nexus-agents 8.56.0 → 8.58.0

package/dist/{chunk-MO6FSEFJ.js → chunk-C4DQ6FON.js}

@@ -25,10 +25,10 @@ import {
   toolSuccessStructured,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-BWP3RTR2.js";
+} from "./chunk-KQNVDSMX.js";
 import {
   VERSION
-} from "./chunk-UURJGJTW.js";
+} from "./chunk-PU2UWCEK.js";
 import {
   UNRESOLVED_MODEL_ID,
   assessPanelIndependence,
@@ -90,7 +90,71 @@ import {
 } from "./chunk-BTYRPZON.js";
 
 // src/mcp/tools/consensus-vote.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
+
+// src/mcp/tools/async-dispatch-input.ts
+import { z } from "zod";
+var DISPATCH_MODES = ["sync", "async"];
+var MODE_ALIAS_REMOVAL_ISSUE = "#6225";
+var DISPATCH_DESCRIPTION = "Async dispatch (#4968). 'sync' (default): run inline and return the result. 'async': return { status: 'pending', jobId } immediately and run in the background; poll get_job_result({ jobId }).";
+var WRONG_KEY_MODE_MESSAGE = '`mode` is not the async switch on this tool; send `dispatch: "async"` (or "sync") instead (#4968).';
+function dispatchModeConflictMessage(dispatch, mode) {
+  return `\`dispatch: "${dispatch}"\` and \`mode: "${mode}"\` disagree; send only \`dispatch\` (\`mode\` is a deprecated alias, removed in ${MODE_ALIAS_REMOVAL_ISSUE}).`;
+}
+function describeDispatch(note) {
+  return note === void 0 ? DISPATCH_DESCRIPTION : `${DISPATCH_DESCRIPTION} ${note}`;
+}
+function dispatchField(note) {
+  return z.enum(DISPATCH_MODES).optional().describe(describeDispatch(note));
+}
+function dispatchFieldDefaultSync(note) {
+  return z.enum(DISPATCH_MODES).default("sync").describe(describeDispatch(note));
+}
+var REJECTED_MODE_KEY = z.never({ error: WRONG_KEY_MODE_MESSAGE }).optional().describe(
+  "Not an input of this tool. The async switch is `dispatch`; `mode: 'async'` is rejected (#4968)."
+);
+function asyncDispatchInput(note) {
+  return { dispatch: dispatchField(note), mode: REJECTED_MODE_KEY };
+}
+function asyncDispatchInputDefaultSync(note) {
+  return { dispatch: dispatchFieldDefaultSync(note), mode: REJECTED_MODE_KEY };
+}
+function modeEnumErrorNamingDispatch(issue) {
+  return isDispatchMode(issue.input) ? WRONG_KEY_MODE_MESSAGE : void 0;
+}
+function isDispatchMode(value) {
+  return value === "sync" || value === "async";
+}
+var DEPRECATED_MODE_ALIAS_INPUT = {
+  dispatch: dispatchField(),
+  mode: z.enum(DISPATCH_MODES).optional().describe(
+    `DEPRECATED alias of \`dispatch\` (removed in the next major, ${MODE_ALIAS_REMOVAL_ISSUE}). Send \`dispatch\` instead; a call that sends only \`mode\` still works and returns a deprecation warning.`
+  )
+};
+function refineDispatchModeAgreement(value, ctx) {
+  if (value.dispatch === void 0 || value.mode === void 0) return;
+  if (value.dispatch === value.mode) return;
+  ctx.addIssue({
+    code: "custom",
+    path: ["dispatch"],
+    message: dispatchModeConflictMessage(value.dispatch, value.mode)
+  });
+}
+function resolveDispatch(input) {
+  return input.dispatch ?? input.mode;
+}
+function deprecatedModeWarning(input) {
+  if (input.mode === void 0 || input.dispatch !== void 0) return void 0;
+  return `\`mode: "${input.mode}"\` is deprecated; send \`dispatch: "${input.mode}"\`. \`mode\` is removed in the next major (${MODE_ALIAS_REMOVAL_ISSUE}).`;
+}
+var WARNINGS_META_KEY = "nexus-agents/warnings";
+function withWarnings(result, warnings) {
+  const present = warnings.filter((w) => w !== void 0);
+  if (present.length === 0) return result;
+  const existing = result._meta?.[WARNINGS_META_KEY];
+  const prior = Array.isArray(existing) ? existing.filter((w) => typeof w === "string") : [];
+  return { ...result, _meta: { ...result._meta, [WARNINGS_META_KEY]: [...prior, ...present] } };
+}
 
 // src/cli/voter-roles.ts
 var VOTER_ROLES = {
@@ -602,7 +666,7 @@ var SIMULATED_VOTE_REASONING = {
 };
 
 // src/cli/voter-response.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 
 // src/consensus/option-tally.ts
 var SUPERMAJORITY_SHARE = 2 / 3;
@@ -662,26 +726,26 @@ var SyntheticVoteError = class extends Error {
   }
   rawOutput;
 };
-var RawFindingSchema = z.object({
-  summary: z.string().min(1).max(500).describe("One-line summary of the issue"),
-  location: z.string().min(1).max(200).describe("path/file.ext:line"),
-  severity: z.enum(["critical", "high", "medium", "low"]).default("medium"),
-  gate: z.object({
-    reread_cited_line: z.enum(["passed", "failed", "skipped"]).default("skipped"),
-    traced_call_path: z.enum(["passed", "failed", "skipped"]).default("skipped"),
-    named_assertion: z.string().default("").describe("Concrete failing assertion \u2014 substantive, not a rubber-stamp word"),
-    ruled_out_language_non_issue: z.enum(["passed", "failed", "skipped"]).default("skipped")
+var RawFindingSchema = z2.object({
+  summary: z2.string().min(1).max(500).describe("One-line summary of the issue"),
+  location: z2.string().min(1).max(200).describe("path/file.ext:line"),
+  severity: z2.enum(["critical", "high", "medium", "low"]).default("medium"),
+  gate: z2.object({
+    reread_cited_line: z2.enum(["passed", "failed", "skipped"]).default("skipped"),
+    traced_call_path: z2.enum(["passed", "failed", "skipped"]).default("skipped"),
+    named_assertion: z2.string().default("").describe("Concrete failing assertion \u2014 substantive, not a rubber-stamp word"),
+    ruled_out_language_non_issue: z2.enum(["passed", "failed", "skipped"]).default("skipped")
   }),
-  claim: z.string().min(1).max(2e3).describe("What is wrong and why it justifies blocking")
+  claim: z2.string().min(1).max(2e3).describe("What is wrong and why it justifies blocking")
 });
-var VoteResponseSchema = z.object({
-  decision: z.enum(["approve", "reject", "abstain"]).describe("Your vote decision"),
-  reasoning: z.string().min(10).max(4e3).describe("Explanation for your vote (10-4000 chars)"),
-  confidence: z.number().min(0).max(1).describe("Confidence level 0-1"),
-  conditions: z.array(z.string()).optional().describe("Optional conditions for approval"),
+var VoteResponseSchema = z2.object({
+  decision: z2.enum(["approve", "reject", "abstain"]).describe("Your vote decision"),
+  reasoning: z2.string().min(10).max(4e3).describe("Explanation for your vote (10-4000 chars)"),
+  confidence: z2.number().min(0).max(1).describe("Confidence level 0-1"),
+  conditions: z2.array(z2.string()).optional().describe("Optional conditions for approval"),
   /** Structured rejection categories for reject→refine→re-vote loops (Issue #1213). */
-  rejectionCategories: z.array(
-    z.enum([
+  rejectionCategories: z2.array(
+    z2.enum([
       "YAGNI",
       "DRY_VIOLATION",
       "OVER_ENGINEERING",
@@ -693,11 +757,11 @@ var VoteResponseSchema = z.object({
   ).optional().describe("Rejection reason categories when decision is reject"),
   /** Top-level structured findings for PR-review mode (#2245 v4 follow-up).
    * Replaces the YAML-in-reasoning encoding that proved lossy. */
-  findings: z.array(RawFindingSchema).optional().describe("Structured findings (PR review only)"),
+  findings: z2.array(RawFindingSchema).optional().describe("Structured findings (PR review only)"),
   /** Chosen option when the proposal declared `options` (#4472). Validated
    * against the declared list by the caller; an unmatched value is dropped
    * rather than recorded, so a parse miss surfaces as absent. */
-  selectedOption: z.string().optional().describe("Which declared option you choose")
+  selectedOption: z2.string().optional().describe("Which declared option you choose")
 });
 var VOTE_JSON_SCHEMA = {
   type: "object",
@@ -1589,9 +1653,9 @@ async function collectRealVotes(options) {
 // src/cli/voter-project.ts
 import { readFileSync, statSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var VOTER_PROJECT_PATTERN = /^[A-Za-z0-9._/@-]{1,200}$/;
-var VoterProjectInputSchema = z2.string().regex(VOTER_PROJECT_PATTERN).optional().describe(
+var VoterProjectInputSchema = z3.string().regex(VOTER_PROJECT_PATTERN).optional().describe(
   "The project the panel is judging (#6110), e.g. `acme/widgets` \u2014 it replaces `nexus-agents` in every voter's system prompt, so a consuming repository is not judged against this one's mission and governance files. When omitted the name is DERIVED from the server's working directory (the `origin` remote as `owner/repo`, else the nearest `package.json` name) and falls back to `nexus-agents`; the response discloses which on `project.source`. Letters, digits and `._/@-` only, at most 200 characters."
 );
 var MAX_ANCESTOR_DEPTH = 64;
@@ -1757,40 +1821,40 @@ function describeVeto(verdict) {
 }
 
 // src/consensus/types-voting-protocol.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var VOTING_ROUND_DEFAULT_TIMEOUT_MS = OPERATION_CLASSES["multi-llm-panel"].guardMs;
-var VotingRoundPhaseSchema = z3.enum(["analysis", "deliberation", "consensus"]);
-var VotingRoundStatusSchema = z3.enum([
+var VotingRoundPhaseSchema = z4.enum(["analysis", "deliberation", "consensus"]);
+var VotingRoundStatusSchema = z4.enum([
   "pending",
   "in_progress",
   "awaiting_votes",
   "completed",
   "aborted"
 ]);
-var AgentFindingSchema = z3.object({
-  agentId: z3.string(),
-  category: z3.enum(["bug", "security", "performance", "style", "design", "documentation", "other"]),
-  severity: z3.enum(["critical", "major", "minor", "suggestion"]),
-  description: z3.string().min(1),
-  location: z3.string().optional().describe("File path and line range if applicable"),
-  suggestion: z3.string().optional().describe("Recommended fix"),
-  confidence: z3.number().min(0).max(1),
-  timestamp: z3.iso.datetime().optional()
+var AgentFindingSchema = z4.object({
+  agentId: z4.string(),
+  category: z4.enum(["bug", "security", "performance", "style", "design", "documentation", "other"]),
+  severity: z4.enum(["critical", "major", "minor", "suggestion"]),
+  description: z4.string().min(1),
+  location: z4.string().optional().describe("File path and line range if applicable"),
+  suggestion: z4.string().optional().describe("Recommended fix"),
+  confidence: z4.number().min(0).max(1),
+  timestamp: z4.iso.datetime().optional()
 });
-var FindingVoteSchema = z3.object({
-  agentId: z3.string(),
-  findingId: z3.string(),
-  agree: z3.boolean(),
-  reasoning: z3.string().optional(),
-  amendedSeverity: z3.enum(["critical", "major", "minor", "suggestion"]).optional()
+var FindingVoteSchema = z4.object({
+  agentId: z4.string(),
+  findingId: z4.string(),
+  agree: z4.boolean(),
+  reasoning: z4.string().optional(),
+  amendedSeverity: z4.enum(["critical", "major", "minor", "suggestion"]).optional()
 });
-var VotingProtocolConfigSchema = z3.object({
-  committeeSize: z3.number().int().min(2).max(7).default(3),
-  maxRounds: z3.number().int().min(1).max(5).default(3),
-  roundTimeoutMs: z3.number().int().positive().default(VOTING_ROUND_DEFAULT_TIMEOUT_MS),
-  agreementThreshold: z3.number().min(0.5).max(1).default(SUPERMAJORITY_THRESHOLD),
-  enableAntiSycophancy: z3.boolean().default(true),
-  sycophancyThreshold: z3.number().min(0).max(1).default(0.8)
+var VotingProtocolConfigSchema = z4.object({
+  committeeSize: z4.number().int().min(2).max(7).default(3),
+  maxRounds: z4.number().int().min(1).max(5).default(3),
+  roundTimeoutMs: z4.number().int().positive().default(VOTING_ROUND_DEFAULT_TIMEOUT_MS),
+  agreementThreshold: z4.number().min(0.5).max(1).default(SUPERMAJORITY_THRESHOLD),
+  enableAntiSycophancy: z4.boolean().default(true),
+  sycophancyThreshold: z4.number().min(0).max(1).default(0.8)
 });
 var DEFAULT_VOTING_PROTOCOL_CONFIG = {
   committeeSize: 3,
@@ -1803,30 +1867,30 @@ var DEFAULT_VOTING_PROTOCOL_CONFIG = {
 };
 
 // src/consensus/types-weighted-voting.ts
-import { z as z4 } from "zod";
-var TaskOutcomeStatusSchema = z4.enum(["success", "failure", "partial", "unknown"]);
-var WeightedAgentRecordSchema = z4.object({
-  agentId: z4.string().min(1),
-  totalTasks: z4.number().int().nonnegative(),
-  successfulTasks: z4.number().int().nonnegative(),
-  failedTasks: z4.number().int().nonnegative(),
-  partialTasks: z4.number().int().nonnegative(),
-  successRate: z4.number().min(0).max(1),
-  weight: z4.number().min(0).max(1),
-  trustScore: z4.number().min(0).max(1),
-  byzantineFlags: z4.number().int().nonnegative(),
-  lastActive: z4.date(),
-  createdAt: z4.date()
+import { z as z5 } from "zod";
+var TaskOutcomeStatusSchema = z5.enum(["success", "failure", "partial", "unknown"]);
+var WeightedAgentRecordSchema = z5.object({
+  agentId: z5.string().min(1),
+  totalTasks: z5.number().int().nonnegative(),
+  successfulTasks: z5.number().int().nonnegative(),
+  failedTasks: z5.number().int().nonnegative(),
+  partialTasks: z5.number().int().nonnegative(),
+  successRate: z5.number().min(0).max(1),
+  weight: z5.number().min(0).max(1),
+  trustScore: z5.number().min(0).max(1),
+  byzantineFlags: z5.number().int().nonnegative(),
+  lastActive: z5.date(),
+  createdAt: z5.date()
 });
-var WeightedVotingConfigSchema = z4.object({
-  minWeight: z4.number().min(0).max(1).default(0.1),
-  maxByzantineFraction: z4.number().min(0).max(0.5).default(0.33),
-  weightDecayFactor: z4.number().min(0.5).max(1).default(0.9),
-  weightRecoveryFactor: z4.number().min(1).max(2).default(1.05),
-  minTrustScore: z4.number().min(0).max(1).default(0.3),
-  byzantineFlagThreshold: z4.number().int().positive().default(3),
-  initialWeight: z4.number().min(0).max(1).default(0.5),
-  quorumThreshold: z4.number().min(0.5).max(1).default(SUPERMAJORITY_THRESHOLD)
+var WeightedVotingConfigSchema = z5.object({
+  minWeight: z5.number().min(0).max(1).default(0.1),
+  maxByzantineFraction: z5.number().min(0).max(0.5).default(0.33),
+  weightDecayFactor: z5.number().min(0.5).max(1).default(0.9),
+  weightRecoveryFactor: z5.number().min(1).max(2).default(1.05),
+  minTrustScore: z5.number().min(0).max(1).default(0.3),
+  byzantineFlagThreshold: z5.number().int().positive().default(3),
+  initialWeight: z5.number().min(0).max(1).default(0.5),
+  quorumThreshold: z5.number().min(0.5).max(1).default(SUPERMAJORITY_THRESHOLD)
 });
 var DEFAULT_WEIGHTED_VOTING_CONFIG = {
   minWeight: 0.1,
@@ -1841,7 +1905,7 @@ var DEFAULT_WEIGHTED_VOTING_CONFIG = {
 };
 
 // src/consensus/higher-order-types.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 function createAgentPairKey(agentA, agentB) {
   return agentA < agentB ? `${agentA}:${agentB}` : `${agentB}:${agentA}`;
 }
@@ -1852,52 +1916,52 @@ function parseAgentPairKey(key) {
   }
   return [parts[0], parts[1]];
 }
-var CorrelationCoefficientSchema = z5.number().min(-1).max(1);
-var IndependentSubsetSchema = z5.object({
-  id: z5.string(),
-  agentIds: z5.array(z5.string()),
-  independenceScore: z5.number().min(0).max(1),
-  pairCoverage: z5.object({
-    observed: z5.number().int().nonnegative(),
-    total: z5.number().int().nonnegative()
+var CorrelationCoefficientSchema = z6.number().min(-1).max(1);
+var IndependentSubsetSchema = z6.object({
+  id: z6.string(),
+  agentIds: z6.array(z6.string()),
+  independenceScore: z6.number().min(0).max(1),
+  pairCoverage: z6.object({
+    observed: z6.number().int().nonnegative(),
+    total: z6.number().int().nonnegative()
   }),
-  observationCount: z5.number().int().nonnegative()
+  observationCount: z6.number().int().nonnegative()
 });
-var VotingObservationSchema = z5.object({
-  proposalId: z5.string(),
-  agentId: z5.string(),
-  decision: z5.enum(["approve", "reject", "abstain"]),
-  confidence: z5.number().min(0).max(1),
-  alignedWithOutcome: z5.boolean(),
-  timestamp: z5.date(),
-  modelKey: z5.string().optional(),
-  observedModel: z5.string().optional()
+var VotingObservationSchema = z6.object({
+  proposalId: z6.string(),
+  agentId: z6.string(),
+  decision: z6.enum(["approve", "reject", "abstain"]),
+  confidence: z6.number().min(0).max(1),
+  alignedWithOutcome: z6.boolean(),
+  timestamp: z6.date(),
+  modelKey: z6.string().optional(),
+  observedModel: z6.string().optional()
 });
-var PairwiseVotingHistorySchema = z5.object({
-  pairKey: z5.string(),
-  jointObservations: z5.number().int().nonnegative(),
-  agreements: z5.number().int().nonnegative(),
-  disagreements: z5.number().int().nonnegative(),
+var PairwiseVotingHistorySchema = z6.object({
+  pairKey: z6.string(),
+  jointObservations: z6.number().int().nonnegative(),
+  agreements: z6.number().int().nonnegative(),
+  disagreements: z6.number().int().nonnegative(),
   correlation: CorrelationCoefficientSchema,
-  lastUpdated: z5.date()
+  lastUpdated: z6.date()
 });
-var HigherOrderVotingConfigSchema = z5.object({
-  minObservationsForCorrelation: z5.number().int().positive().default(10),
-  correlationThreshold: z5.number().min(0).max(1).default(0.3),
+var HigherOrderVotingConfigSchema = z6.object({
+  minObservationsForCorrelation: z6.number().int().positive().default(10),
+  correlationThreshold: z6.number().min(0).max(1).default(0.3),
   /**
    * @deprecated Ignored since 8.x: correlation evidence is lifetime and partitioned by the role's pinned model (#5555); nothing reads this value. Removed in the next major (#5564).
    */
-  correlationMaxAgeMs: z5.number().int().positive().default(864e5),
+  correlationMaxAgeMs: z6.number().int().positive().default(864e5),
   // 24 hours
-  independenceThreshold: z5.number().min(0).max(1).default(0.2),
-  fallbackToSimpleVoting: z5.boolean().default(true),
+  independenceThreshold: z6.number().min(0).max(1).default(0.2),
+  fallbackToSimpleVoting: z6.boolean().default(true),
   /**
    * @deprecated Ignored since 8.x: correlation evidence is lifetime and partitioned by the role's pinned model (#5555); nothing reads this value. Removed in the next major (#5564).
    */
-  observationDecayFactor: z5.number().min(0).max(1).default(0.95),
-  maxObservationsPerAgent: z5.number().int().positive().default(1e3),
-  maxProposals: z5.number().int().positive().default(5e3),
-  maxTrackedPairs: z5.number().int().positive().default(100)
+  observationDecayFactor: z6.number().min(0).max(1).default(0.95),
+  maxObservationsPerAgent: z6.number().int().positive().default(1e3),
+  maxProposals: z6.number().int().positive().default(5e3),
+  maxTrackedPairs: z6.number().int().positive().default(100)
 });
 var DEFAULT_HIGHER_ORDER_CONFIG = {
   minObservationsForCorrelation: 10,
@@ -1911,25 +1975,25 @@ var DEFAULT_HIGHER_ORDER_CONFIG = {
   maxProposals: 5e3,
   maxTrackedPairs: 100
 };
-var HigherOrderVotingResultSchema = z5.object({
-  decision: z5.enum(["approve", "reject", "no_consensus"]),
-  posteriorApproval: z5.number().min(0).max(1),
-  posteriorRejection: z5.number().min(0).max(1),
-  effectiveVoteCount: z5.number().nonnegative(),
-  usedCorrelationData: z5.boolean(),
-  method: z5.enum(["ow", "isp", "simple"]),
-  improvementOverBaseline: z5.number(),
-  independentSubsets: z5.array(IndependentSubsetSchema).optional(),
-  downweightedAgents: z5.array(z5.string()),
-  reasoning: z5.string()
+var HigherOrderVotingResultSchema = z6.object({
+  decision: z6.enum(["approve", "reject", "no_consensus"]),
+  posteriorApproval: z6.number().min(0).max(1),
+  posteriorRejection: z6.number().min(0).max(1),
+  effectiveVoteCount: z6.number().nonnegative(),
+  usedCorrelationData: z6.boolean(),
+  method: z6.enum(["ow", "isp", "simple"]),
+  improvementOverBaseline: z6.number(),
+  independentSubsets: z6.array(IndependentSubsetSchema).optional(),
+  downweightedAgents: z6.array(z6.string()),
+  reasoning: z6.string()
 });
-var CorrelationTrackerStatsSchema = z5.object({
-  totalAgents: z5.number().int().nonnegative(),
-  trackedPairs: z5.number().int().nonnegative(),
-  totalObservations: z5.number().int().nonnegative(),
-  averageCorrelation: z5.number(),
-  independentSubsetCount: z5.number().int().nonnegative(),
-  pairsWithSufficientData: z5.number().int().nonnegative()
+var CorrelationTrackerStatsSchema = z6.object({
+  totalAgents: z6.number().int().nonnegative(),
+  trackedPairs: z6.number().int().nonnegative(),
+  totalObservations: z6.number().int().nonnegative(),
+  averageCorrelation: z6.number(),
+  independentSubsetCount: z6.number().int().nonnegative(),
+  pairsWithSufficientData: z6.number().int().nonnegative()
 });
 
 // src/consensus/higher-order-helpers.ts
@@ -4941,24 +5005,24 @@ function createCorrelationTracker(config) {
 import * as fs from "node:fs";
 
 // src/consensus/correlation-persistence-records.ts
-import { z as z6 } from "zod";
-var PersistedVoteSchema = z6.object({
-  agentId: z6.string(),
-  decision: z6.enum(["approve", "reject", "abstain"]),
-  confidence: z6.number().min(0).max(1),
-  modelKey: z6.string().optional(),
-  observedModel: z6.string().optional()
+import { z as z7 } from "zod";
+var PersistedVoteSchema = z7.object({
+  agentId: z7.string(),
+  decision: z7.enum(["approve", "reject", "abstain"]),
+  confidence: z7.number().min(0).max(1),
+  modelKey: z7.string().optional(),
+  observedModel: z7.string().optional()
 });
-var PersistedProposalSchema = z6.object({
-  proposalId: z6.string(),
-  votes: z6.array(PersistedVoteSchema),
-  outcome: z6.enum(["approved", "rejected"]),
-  timestamp: z6.iso.datetime()
+var PersistedProposalSchema = z7.object({
+  proposalId: z7.string(),
+  votes: z7.array(PersistedVoteSchema),
+  outcome: z7.enum(["approved", "rejected"]),
+  timestamp: z7.iso.datetime()
 });
-var PersistedCorrelationDataSchema = z6.object({
-  version: z6.number().int().positive(),
-  proposals: z6.array(PersistedProposalSchema),
-  savedAt: z6.iso.datetime()
+var PersistedCorrelationDataSchema = z7.object({
+  version: z7.number().int().positive(),
+  proposals: z7.array(PersistedProposalSchema),
+  savedAt: z7.iso.datetime()
 });
 function createPersistedProposal(proposalId, votes, outcome, context) {
   const persistedVotes = [];
@@ -5200,7 +5264,7 @@ function createPersistentCorrelationTracker(config) {
 }
 
 // src/mcp/tools/consensus-vote-types.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/cli/vote-diversity.ts
 function answeringSeats(votes) {
@@ -5244,39 +5308,39 @@ function singleModelPanelWarning(votes) {
 
 // src/audit/vote-record.ts
 import * as crypto from "node:crypto";
-import { z as z7 } from "zod";
-var VoteRecordDecisionSchema = z7.enum(["approved", "rejected", "no_quorum"]);
-var VoteRecordOptionCoverageSchema = z7.object({
+import { z as z8 } from "zod";
+var VoteRecordDecisionSchema = z8.enum(["approved", "rejected", "no_quorum"]);
+var VoteRecordOptionCoverageSchema = z8.object({
   /** Every approving voter, selecting or not — the tally's denominator. */
-  approverCount: z7.number().int().nonnegative(),
+  approverCount: z8.number().int().nonnegative(),
   /** Approvers whose selection matched a declared option. */
-  selectedCount: z7.number().int().nonnegative(),
+  selectedCount: z8.number().int().nonnegative(),
   /** Approvers with no usable selection; their choice is unmeasured. */
-  unattributedApprovals: z7.number().int().nonnegative()
+  unattributedApprovals: z8.number().int().nonnegative()
 }).strict();
-var VoteRecordPanelCoverageSchema = z7.object({
+var VoteRecordPanelCoverageSchema = z8.object({
   /** Voters the panel asked for. */
-  requested: z7.number().int().nonnegative(),
+  requested: z8.number().int().nonnegative(),
   /** Voters that returned a usable vote — the denominator of `voteCounts`. */
-  responded: z7.number().int().nonnegative(),
+  responded: z8.number().int().nonnegative(),
   /** Voters that errored or timed out. */
-  errored: z7.number().int().nonnegative(),
+  errored: z8.number().int().nonnegative(),
   /** The roles behind `errored`, in panel order. */
-  erroredRoles: z7.array(z7.string().min(1).max(100))
+  erroredRoles: z8.array(z8.string().min(1).max(100))
 }).strict();
 var MAX_VOTER_REASONING_CHARS = 2e4;
-var SeatFallbackRecordSchema = z7.object({
+var SeatFallbackRecordSchema = z8.object({
   /** The CLI the seat was assigned to, bare (`claude`, not `cli-claude`). */
-  fromCli: z7.string().min(1).max(100),
+  fromCli: z8.string().min(1).max(100),
   /** The model the assigned adapter had detected, when it had one. */
-  fromModel: z7.string().min(1).max(200).optional(),
+  fromModel: z8.string().min(1).max(200).optional(),
   /** The adapter-layer class of the error that moved the seat. */
-  reason: z7.enum(["rate-limit", "capacity", "auth", "timeout", "sandbox", "unknown"])
+  reason: z8.enum(["rate-limit", "capacity", "auth", "timeout", "sandbox", "unknown"])
 }).strict();
-var VoterSummarySchema = z7.object({
-  role: z7.string().min(1).max(100),
-  decision: z7.enum(["approve", "reject", "abstain"]),
-  confidence: z7.number().min(0).max(1),
+var VoterSummarySchema = z8.object({
+  role: z8.string().min(1).max(100),
+  decision: z8.enum(["approve", "reject", "abstain"]),
+  confidence: z8.number().min(0).max(1),
   /**
    * The voter's stated grounds (#5373, schema 1.6).
    *
@@ -5296,9 +5360,9 @@ var VoterSummarySchema = z7.object({
    * `voters` at all (see `panelCoverage`), so `reasoning: ''` means a live
    * voter returned nothing, which is itself a signal.
    */
-  reasoning: z7.string().max(MAX_VOTER_REASONING_CHARS).optional(),
+  reasoning: z8.string().max(MAX_VOTER_REASONING_CHARS).optional(),
   /** True when `reasoning` was clipped to {@link MAX_VOTER_REASONING_CHARS}. */
-  reasoningTruncated: z7.literal(true).optional(),
+  reasoningTruncated: z8.literal(true).optional(),
   /**
    * True when this seat was recovered by the per-role retry (#6050, schema 1.7).
    *
@@ -5319,7 +5383,7 @@ var VoterSummarySchema = z7.object({
    * seat carries no key, so its entry re-hashes byte-identical and every
    * historical record still verifies.
    */
-  retried: z7.literal(true).optional(),
+  retried: z8.literal(true).optional(),
   /**
    * Registry model id the seat ran on (#6091, schema 1.8).
    *
@@ -5332,7 +5396,7 @@ var VoterSummarySchema = z7.object({
    * Present-only, on the `retried` rule; absent when the result carried no
    * model or only the pending-detection placeholder.
    */
-  model: z7.string().min(1).max(200).optional(),
+  model: z8.string().min(1).max(200).optional(),
   /**
    * True when the seat could not read the artifact (#6094, schema 1.8).
    *
@@ -5342,7 +5406,7 @@ var VoterSummarySchema = z7.object({
    * on the proposal text after failing to read. `literal(true)` and
    * present-only, so every pre-1.8 entry re-hashes byte-identical.
    */
-  unverifiable: z7.literal(true).optional(),
+  unverifiable: z8.literal(true).optional(),
   /**
    * The CLI the round-robin or `NEXUS_VOTER_MODEL_<ROLE>` pin chose for the
    * seat, as a bare name (#6115, schema 1.9). `model` says where a seat
@@ -5353,7 +5417,7 @@ var VoterSummarySchema = z7.object({
    * that said five of them were substitutes. Present-only, on the `model`
    * rule; absent on a result built outside the panel launcher.
    */
-  assignedCli: z7.string().min(1).max(100).optional(),
+  assignedCli: z8.string().min(1).max(100).optional(),
   /**
    * Present only when the seat answered on a different CLI or model than
    * assigned (#6115, schema 1.9): the exact `SeatFallback` shape the live
@@ -5407,33 +5471,33 @@ function projectVoterSummary(v) {
   }
   return out;
 }
-var VoteRecordCountsSchema = z7.object({
-  approve: z7.number().int().nonnegative(),
-  reject: z7.number().int().nonnegative(),
-  abstain: z7.number().int().nonnegative(),
-  total: z7.number().int().nonnegative()
+var VoteRecordCountsSchema = z8.object({
+  approve: z8.number().int().nonnegative(),
+  reject: z8.number().int().nonnegative(),
+  abstain: z8.number().int().nonnegative(),
+  total: z8.number().int().nonnegative()
 }).strict();
-var VoteRecordOptionCountSchema = z7.object({
+var VoteRecordOptionCountSchema = z8.object({
   /** The option label as declared in the proposal (e.g. 'A'). */
-  option: z7.string().min(1),
+  option: z8.string().min(1),
   /** How many voters selected it. */
-  count: z7.number().int().nonnegative()
+  count: z8.number().int().nonnegative()
 }).strict();
 var GIT_SHA_PATTERN = /^[0-9a-f]{40}$/;
-var VoteRecordPrBindingSchema = z7.object({
-  pr: z7.number().int().positive(),
-  headSha: z7.string().regex(GIT_SHA_PATTERN, "expected a full 40-hex lowercase commit sha")
+var VoteRecordPrBindingSchema = z8.object({
+  pr: z8.number().int().positive(),
+  headSha: z8.string().regex(GIT_SHA_PATTERN, "expected a full 40-hex lowercase commit sha")
 }).strict();
 function projectPrBinding(b) {
   return { pr: b.pr, headSha: b.headSha };
 }
-var VoteRecordErrorPolicySchema = z7.enum([
+var VoteRecordErrorPolicySchema = z8.enum([
   "reduce_denominator",
   "count_as_abstain",
   "fail_closed",
   "absolute_quorum"
 ]);
-var VoteRecordSchema = z7.object({
+var VoteRecordSchema = z8.object({
   /**
    * Schema version. '1.1' marked the chain→record-set+sequence model (#3927);
    * '1.2' adds the optional `ratifies` subject-binding field (#3927 item 1);
@@ -5444,7 +5508,7 @@ var VoteRecordSchema = z7.object({
    * Tiers are labels, not ordered numbers: '1.10' follows '1.9' by
    * convention only and nothing compares them.
    */
-  version: z7.enum([
+  version: z8.enum([
     "1.1",
     "1.2",
     "1.3",
@@ -5458,27 +5522,27 @@ var VoteRecordSchema = z7.object({
     "1.11"
   ]),
   /** Unique record id (also usable as a `ratificationVoteRef`). */
-  id: z7.string().min(1),
+  id: z8.string().min(1),
   /**
    * Monotonic sequence number (integer ≥ 0). Assigned as (max existing
    * sequence)+1 at write time. Sorted, the set of sequences must cover
    * 0..maxSeq with no gap (omission detection); DUPLICATE sequences are a
    * benign concurrent-fork signal, not tampering.
    */
-  sequence: z7.number().int().nonnegative(),
+  sequence: z8.number().int().nonnegative(),
   /** ISO-8601 timestamp the vote was recorded. */
-  recordedAt: z7.string().min(1),
+  recordedAt: z8.string().min(1),
   /**
    * SHA-256 of the FULL proposal text. The proposal itself is truncated for
    * the human record (`proposal`), but the hash binds the record to the exact
    * proposal voted on — a later edit of `proposal` that changes meaning is
    * detectable by recomputing this hash from the original.
    */
-  proposalHash: z7.string().length(64),
+  proposalHash: z8.string().length(64),
   /** Truncated proposal text for the human/reviewer record. */
-  proposal: z7.string(),
+  proposal: z8.string(),
   /** The voting strategy used. */
-  strategy: z7.enum([
+  strategy: z8.enum([
     "simple_majority",
     "supermajority",
     "unanimous",
@@ -5489,13 +5553,13 @@ var VoteRecordSchema = z7.object({
   /** The resolved decision. */
   decision: VoteRecordDecisionSchema,
   /** Approval fraction as a percentage (0-100). */
-  approvalPercentage: z7.number().min(0).max(100),
+  approvalPercentage: z8.number().min(0).max(100),
   /** Vote-count breakdown. */
   voteCounts: VoteRecordCountsSchema,
   /** Per-voter {role, decision, confidence} summary. */
-  voters: z7.array(VoterSummarySchema),
+  voters: z8.array(VoterSummarySchema),
   /** Optional correlation/decision id linking to the cost rollup / trace. */
-  correlationId: z7.string().min(1).optional(),
+  correlationId: z8.string().min(1).optional(),
   /**
    * Per-option distribution for a multi-option proposal (#4452, schema 1.3).
    *
@@ -5520,7 +5584,7 @@ var VoteRecordSchema = z7.object({
   //
   // Relaxing is a pure widening: no previously-valid record changes meaning
   // or hash, and no persisted record can currently hold an empty tally.
-  optionTally: z7.array(VoteRecordOptionCountSchema).optional(),
+  optionTally: z8.array(VoteRecordOptionCountSchema).optional(),
   /**
    * Selection coverage for a multi-option vote (#4472, schema 1.4).
    *
@@ -5546,7 +5610,7 @@ var VoteRecordSchema = z7.object({
    * (with `decision === 'approved'` and `strategy === 'higher_order'`). Absent on
    * an ordinary (non-ratification) vote; a 1.1 record never carries it.
    */
-  ratifies: z7.string().min(1).optional(),
+  ratifies: z8.string().min(1).optional(),
   /**
    * The PR this vote RATIFIES, bound to the head the panel saw (#5130 step 1,
    * schema 1.10; panel decision Q1 option A, 5 of 6). Present only on a
@@ -5587,9 +5651,9 @@ var VoteRecordSchema = z7.object({
    * Retained for audit texture but NOT covered by `hash` and NOT verified —
    * the record-set model is position-independent (#3927).
    */
-  previousHash: z7.string().length(64).optional(),
+  previousHash: z8.string().length(64).optional(),
   /** SHA-256 over every field above EXCEPT `previousHash` (and except `hash`). */
-  hash: z7.string().length(64)
+  hash: z8.string().length(64)
 }).strict();
 function foldOptionalFields(base, payload) {
   const withTally = payload.optionTally !== void 0 ? {
@@ -5676,7 +5740,7 @@ function checkUndeclaredOptions(proposal, declaredOptions, allEngagedApproved) {
 
 // src/mcp/tools/consensus-vote-types.ts
 var MAX_PROPOSAL_LENGTH = 4e3;
-var VotingStrategySchema = z8.enum([
+var VotingStrategySchema = z9.enum([
   "simple_majority",
   "supermajority",
   "unanimous",
@@ -5691,18 +5755,18 @@ var HIGHER_ORDER_ESCALATION_POSTERIOR_FLOOR = 0.65;
 function shouldEscalateLowPosterior(strategy, outcome, quickMode, posteriorApproval) {
   return quickMode && outcome === "approved" && isHigherOrderStrategy(strategy) && posteriorApproval !== void 0 && posteriorApproval < HIGHER_ORDER_ESCALATION_POSTERIOR_FLOOR;
 }
-var ErrorPolicySchema = z8.enum([
+var ErrorPolicySchema = z9.enum([
   "reduce_denominator",
   "count_as_abstain",
   "fail_closed",
   "absolute_quorum"
 ]);
-var VoteThresholdSchema = z8.enum(["majority", "supermajority", "unanimous"]);
-var ConsensusVoteInputSchema = z8.object({
-  proposal: z8.string().min(1).max(MAX_PROPOSAL_LENGTH).describe(
+var VoteThresholdSchema = z9.enum(["majority", "supermajority", "unanimous"]);
+var ConsensusVoteInputSchema = z9.object({
+  proposal: z9.string().min(1).max(MAX_PROPOSAL_LENGTH).describe(
     'Proposal text to vote on. If the proposal asks voters to choose among named alternatives, declare them in `options` (#4472) \u2014 otherwise the tally records approve/reject/abstain only, so every voter who engages returns `approve` and a 6-1 split on WHICH option persists as 7-0, 100% (#4452). This is ENFORCED AS A WARNING, not a refusal: a heuristic over the proposal text flags an apparent multi-option proposal with no `options` and says so on `panelWarning` (#5360). The wording says "declare", not "MUST", because the warning is what the code actually holds \u2014 it is tightened back only in the same change that promotes the warning to a refusal.'
   ),
-  options: z8.array(z8.string().min(1).max(200)).min(2).max(10).optional().describe(
+  options: z9.array(z9.string().min(1).max(200)).min(2).max(10).optional().describe(
     "Named alternatives for a multi-option proposal (#4472). When present, the threshold must ALSO be cleared by the leading option, in addition to the ordinary approve/reject bar: `unanimous` requires every approver to have chosen the SAME option, and `supermajority`/`majority` measure the leading option's share of approvers. An approving voter whose selection is absent or matches no declared option stays in the denominator and credits no option, so a degraded response can only lower the leading share, never raise it. Omit for an ordinary yes/no vote \u2014 behaviour is then unchanged."
   ),
   project: VoterProjectInputSchema,
@@ -5715,12 +5779,12 @@ var ConsensusVoteInputSchema = z8.object({
   errorPolicy: ErrorPolicySchema.optional().describe(
     "How to treat voters that errored or timed out (#2630). Default: fail_closed for unanimous only; reduce_denominator for all other strategies incl. higher_order/opinion_wise (#3138 \u2014 a single infra timeout should not void an otherwise-unanimous vote). Opt-in absolute_quorum (#4132): an errored voter \u2014 especially the contrarian (catfish) \u2014 degrades the verdict to no_quorum (recoverable re-run) instead of being dropped from the denominator; never manufactures approved/rejected from an induced error. Regardless of policy, errors > 50% always fails."
   ),
-  quickMode: z8.boolean().optional().default(false).describe("Use 3 agents instead of the full 7-role panel for faster execution"),
-  simulateVotes: z8.boolean().optional().default(false).describe(
+  quickMode: z9.boolean().optional().default(false).describe("Use 3 agents instead of the full 7-role panel for faster execution"),
+  simulateVotes: z9.boolean().optional().default(false).describe(
     "TESTS ONLY \u2014 when true, voters return random decisions. Output must not be used for real decisions. (#2319)"
   ),
   /**
-   * Async-mode dispatch (#3045, Stage 4 of epic #2631). Default `sync` —
+   * Async dispatch (#3045, Stage 4 of epic #2631). Default `sync` —
    * backward-compat invariant. `async` returns `{ status: 'pending', jobId }`
    * immediately; caller polls `get_job_result(jobId)`. Per-tool cap via
    * `NEXUS_JOB_MAX_CONCURRENT_CONSENSUS_VOTE` (default 2 — voting is
@@ -5733,19 +5797,20 @@ var ConsensusVoteInputSchema = z8.object({
    * with whatever voters completed before the abort signal — preserves
    * audit visibility into who voted before the cancel landed.
    *
-   * Kept optional (no `.default()`) so the inferred type doesn't force
-   * `mode: 'sync'` on every existing call site / test fixture.
+   * The key is `dispatch` (#4968); `mode` is the deprecated alias this tool
+   * used to spell it with, resolved as `dispatch ?? mode` by the handler and
+   * rejected when the two disagree (the `superRefine` below). Both optional
+   * (no `.default()`) so the inferred type doesn't force a value onto every
+   * existing call site / test fixture.
    */
-  mode: z8.enum(["sync", "async"]).optional().describe(
-    'Dispatch mode (default: sync). Use "async" for higher-order strategies with 7 voters.'
-  ),
+  ...DEPRECATED_MODE_ALIAS_INPUT,
   /**
    * Idempotency key for async-mode replay-safety (#3042 Stage 1c / epic
    * #2631). When set: identical (key, inputs) returns the existing job;
    * same key with different inputs fails closed with
    * `idempotency_key_collision`. Sync mode ignores this.
    */
-  idempotencyKey: z8.string().min(1).max(256).optional().describe(
+  idempotencyKey: z9.string().min(1).max(256).optional().describe(
     "Replay-safe key for async-mode dispatch (#3042 Stage 1c). Same (key, inputs) returns existing jobId."
   ),
   /**
@@ -5757,7 +5822,7 @@ var ConsensusVoteInputSchema = z8.object({
    * record and require `ratifies === transition.subject` (with decision=approved,
    * strategy=higher_order). Omit on an ordinary vote.
    */
-  ratifies: z8.string().min(1).max(256).optional().describe(
+  ratifies: z9.string().min(1).max(256).optional().describe(
     "Authority-tier ratification subject (#4004) \u2014 the loop/strategy id this vote ratifies for an authority-ladder promotion. Bound into the authentic vote record so the promotion gate can verify it. Omit for ordinary votes."
   ),
   /**
@@ -5773,15 +5838,16 @@ var ConsensusVoteInputSchema = z8.object({
   ratifiesPr: VoteRecordPrBindingSchema.optional().describe(
     "Governor-path PR ratification binding (#5130): pr is the PR number and headSha the full 40-hex head sha the panel reviewed. Bound into the authentic vote record so the committed ledger and the governor gate can verify which PR, at which head, this panel ratified. Omit for ordinary votes."
   )
-});
-var VoteDecisionStatusSchema = z8.enum([
+  // #4968: `dispatch` and the deprecated `mode` alias must agree when both are sent.
+}).superRefine(refineDispatchModeAgreement);
+var VoteDecisionStatusSchema = z9.enum([
   "approved",
   "rejected",
   "pending",
   "timeout",
   "no_quorum"
 ]);
-var ContrarianCheckStatusSchema = z8.enum(["ok", "errored", "skipped"]);
+var ContrarianCheckStatusSchema = z9.enum(["ok", "errored", "skipped"]);
 function toRecordDecision(status) {
   switch (status) {
     case "approved":
@@ -6773,25 +6839,25 @@ import {
   writeFileSync as writeFileSync4,
   chmodSync
 } from "node:fs";
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/mcp/jobs/job-idempotency.ts
 import { createHash as createHash2, randomUUID } from "node:crypto";
 import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var logger7 = createLogger({ component: "job-idempotency" });
-var IdempotencyIndexEntrySchema = z9.object({
-  v: z9.literal(1),
+var IdempotencyIndexEntrySchema = z10.object({
+  v: z10.literal(1),
   /** MCP tool name (e.g. `orchestrate`, `run_workflow`, `consensus_vote`). */
-  tool: z9.string().min(1),
+  tool: z10.string().min(1),
   /** Caller-supplied idempotency key. */
-  key: z9.string().min(1),
+  key: z10.string().min(1),
   /** sha256 of the canonical input JSON. */
-  inputsHash: z9.string().length(64),
+  inputsHash: z10.string().length(64),
   /** Existing jobId for this (tool, key, inputs) tuple. */
-  jobId: z9.string().min(1),
+  jobId: z10.string().min(1),
   /** ISO timestamp of first dispatch. */
-  createdAt: z9.iso.datetime()
+  createdAt: z10.iso.datetime()
 });
 function sha256Hex(input) {
   return createHash2("sha256").update(input).digest("hex");
@@ -6892,28 +6958,28 @@ function readIndexEntry(path2) {
 
 // src/mcp/jobs/job-result-store.ts
 var logger8 = createLogger({ component: "job-result-store" });
-var JobStatusSchema = z10.enum(["pending", "complete", "failed", "cancelled"]);
-var JobResultSchema = z10.object({
+var JobStatusSchema = z11.enum(["pending", "complete", "failed", "cancelled"]);
+var JobResultSchema = z11.object({
   /** Format version. Currently `1` — bump if the shape changes. */
-  v: z10.literal(1),
-  jobId: z10.string().min(1),
+  v: z11.literal(1),
+  jobId: z11.string().min(1),
   /** Tool that was invoked (e.g. `orchestrate`). */
-  toolName: z10.string().min(1),
+  toolName: z11.string().min(1),
   status: JobStatusSchema,
-  createdAt: z10.iso.datetime(),
+  createdAt: z11.iso.datetime(),
   /** Set when the job leaves `pending` — either via `complete` or `failed` or `cancelled`. */
-  completedAt: z10.iso.datetime().optional(),
+  completedAt: z11.iso.datetime().optional(),
   /**
    * Structured payload the synchronous mode would have returned. Present
    * only when `status === 'complete'`. Shape is tool-specific — readers
    * cast to the tool's known output type after status check.
    */
-  result: z10.unknown().optional(),
+  result: z11.unknown().optional(),
   /**
    * Failure message when `status === 'failed'`. Cannot be paired with
    * `result` — the discriminator is `status`.
    */
-  error: z10.string().optional(),
+  error: z11.string().optional(),
   /**
    * Machine-readable reason for a `failed` record that was NOT settled by the
    * process that ran the job (#6224). `abandoned` is written only by
@@ -6922,7 +6988,7 @@ var JobResultSchema = z10.object({
    * the sweep rewrote it rather than deleting it. Absent on every record the
    * job's own process wrote — `error` alone carries those failures.
    */
-  errorKind: z10.literal("abandoned").optional(),
+  errorKind: z11.literal("abandoned").optional(),
   /**
    * Whether the tool's `run` callback accepts `runAsJob`'s `AbortSignal`
    * (#4972).
@@ -6938,7 +7004,7 @@ var JobResultSchema = z10.object({
    * "cancellation can reach this tool", not "the work stopped". Absent means
    * the writer did not report it, which is not the same as `false`.
    */
-  signalAccepted: z10.boolean().optional(),
+  signalAccepted: z11.boolean().optional(),
   /**
    * `VERSION` of the nexus-agents process that WROTE this record (#5008) —
    * i.e. the build that ran the job, not the build that reads it back.
@@ -6959,7 +7025,7 @@ var JobResultSchema = z10.object({
    * `'dev'` — readers MUST run it through {@link isMeasuredBuildVersion}
    * before treating two stamps as comparable.
    */
-  producerVersion: z10.string().optional()
+  producerVersion: z11.string().optional()
 });
 var UNMEASURED_BUILD_VERSION = "dev";
 function isMeasuredBuildVersion(version) {
@@ -7332,8 +7398,8 @@ import * as path from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
 
 // src/context/structured-task-state-types.ts
-import { z as z11 } from "zod";
-var TaskStageSchema = z11.enum([
+import { z as z12 } from "zod";
+var TaskStageSchema = z12.enum([
   "planning",
   "executing",
   "verifying",
@@ -7345,64 +7411,64 @@ var TaskStageSchema = z11.enum([
   // failed run in StructuredTaskState instead of the Stage-1 sidecar.
   "failed"
 ]);
-var TaskDecisionSchema = z11.object({
-  ts: z11.iso.datetime(),
-  decision: z11.string().min(1),
-  rationale: z11.string().min(1)
+var TaskDecisionSchema = z12.object({
+  ts: z12.iso.datetime(),
+  decision: z12.string().min(1),
+  rationale: z12.string().min(1)
 });
-var TaskBlockerSchema = z11.object({
-  ts: z11.iso.datetime(),
-  blocker: z11.string().min(1),
-  resolved: z11.iso.datetime().optional()
+var TaskBlockerSchema = z12.object({
+  ts: z12.iso.datetime(),
+  blocker: z12.string().min(1),
+  resolved: z12.iso.datetime().optional()
 });
-var TaskPositionSchema = z11.object({
-  currentStep: z11.string().min(1),
-  nextStep: z11.string().optional()
+var TaskPositionSchema = z12.object({
+  currentStep: z12.string().min(1),
+  nextStep: z12.string().optional()
 });
-var TaskLedgerSchema = z11.object({
+var TaskLedgerSchema = z12.object({
   /** Verifiable observations: what we have observed/measured/confirmed. */
-  facts: z11.array(z11.string()),
+  facts: z12.array(z12.string()),
   /** Working assumptions: useful guesses we proceed under, marked separately. */
-  guesses: z11.array(z11.string()),
+  guesses: z12.array(z12.string()),
   /** Things we still need to figure out before the plan is sound. */
-  openQuestions: z11.array(z11.string()),
-  updatedAt: z11.iso.datetime()
+  openQuestions: z12.array(z12.string()),
+  updatedAt: z12.iso.datetime()
 });
-var ReflectActionSchema = z11.enum([
+var ReflectActionSchema = z12.enum([
   "continue",
   "revise_plan",
   "escalate_to_human",
   "abort"
 ]);
-var ProgressLedgerEntrySchema = z11.object({
-  ts: z11.iso.datetime(),
+var ProgressLedgerEntrySchema = z12.object({
+  ts: z12.iso.datetime(),
   /** What just happened (the step we are reflecting on). */
-  step: z11.string().min(1),
+  step: z12.string().min(1),
   /** Is the outer Task Ledger plan still right after this step? */
-  planStillValid: z11.boolean(),
+  planStillValid: z12.boolean(),
   /** Are we making progress, or have we stalled? */
-  stuck: z11.boolean(),
+  stuck: z12.boolean(),
   /** What the orchestrator should do next based on this reflection. */
   suggestedAction: ReflectActionSchema,
   /** Why this action was chosen — required so future readers can audit the call. */
-  rationale: z11.string().min(1)
+  rationale: z12.string().min(1)
 });
-var TaskCancellationSchema = z11.object({
-  requestedAt: z11.iso.datetime(),
+var TaskCancellationSchema = z12.object({
+  requestedAt: z12.iso.datetime(),
   /** Optional human-readable note carried back to the caller. */
-  reason: z11.string().max(1e3).optional()
+  reason: z12.string().max(1e3).optional()
 });
 var TASK_RESULT_MAX_BYTES = 1048576;
-var StructuredTaskStateSchema = z11.object({
-  taskId: z11.string().min(1),
+var StructuredTaskStateSchema = z12.object({
+  taskId: z12.string().min(1),
   /**
    * Marks state created by the shared async-job dispatcher (#5622).
    * Optional for backward compatibility; absence does not prove async dispatch.
    */
-  dispatch: z11.literal("async").optional(),
+  dispatch: z12.literal("async").optional(),
   stage: TaskStageSchema,
-  decisions: z11.array(TaskDecisionSchema),
-  blockers: z11.array(TaskBlockerSchema),
+  decisions: z12.array(TaskDecisionSchema),
+  blockers: z12.array(TaskBlockerSchema),
   position: TaskPositionSchema,
   /**
    * Magentic-One Task Ledger (#2278). Mutable single-object outer-loop state:
@@ -7415,7 +7481,7 @@ var StructuredTaskStateSchema = z11.object({
    * Most recent entry's `suggestedAction` is what `reflect()` returns. Optional
    * for the same backward-compat reason as `taskLedger`.
    */
-  progressLedger: z11.array(ProgressLedgerEntrySchema).optional(),
+  progressLedger: z12.array(ProgressLedgerEntrySchema).optional(),
   /**
    * Monotonic version counter (#3043 / epic #2631 Stage 2). Increments by
    * 1 on every write; polling clients use this to detect "I missed a
@@ -7425,7 +7491,7 @@ var StructuredTaskStateSchema = z11.object({
    * state logs (pre-Stage-2) don't carry it; the reducer treats their
    * baseline as v0 and starts counting from there.
    */
-  version: z11.number().int().nonnegative().optional(),
+  version: z12.number().int().nonnegative().optional(),
   /**
    * Tool result payload (#3043 / epic #2631 Stage 2). Set atomically
    * via the `result` log event when `stage === 'complete'`. Carries the
@@ -7441,7 +7507,7 @@ var StructuredTaskStateSchema = z11.object({
    * field, then the sidecar files become legacy that the next cleanup
    * sweep can remove.
    */
-  result: z11.unknown().optional(),
+  result: z12.unknown().optional(),
   /**
    * Cancellation marker (#3043 / epic #2631 Stage 2). Set by `cancel_job`
    * — the running tool checks for this at safe-point boundaries (between
@@ -7458,70 +7524,70 @@ var StructuredTaskStateSchema = z11.object({
    * transition has been recorded. Optional for backward-compat with
    * pre-#3090 logs (the reducer backfills it from the init entry).
    */
-  createdAt: z11.iso.datetime().optional(),
-  updatedAt: z11.iso.datetime()
+  createdAt: z12.iso.datetime().optional(),
+  updatedAt: z12.iso.datetime()
 });
-var StructuredTaskLogEntrySchema = z11.discriminatedUnion("event", [
-  z11.object({
-    event: z11.literal("init"),
-    ts: z11.iso.datetime(),
+var StructuredTaskLogEntrySchema = z12.discriminatedUnion("event", [
+  z12.object({
+    event: z12.literal("init"),
+    ts: z12.iso.datetime(),
     state: StructuredTaskStateSchema
   }),
-  z11.object({
-    event: z11.literal("decision"),
-    ts: z11.iso.datetime(),
+  z12.object({
+    event: z12.literal("decision"),
+    ts: z12.iso.datetime(),
     decision: TaskDecisionSchema
   }),
-  z11.object({
-    event: z11.literal("blocker"),
-    ts: z11.iso.datetime(),
+  z12.object({
+    event: z12.literal("blocker"),
+    ts: z12.iso.datetime(),
     blocker: TaskBlockerSchema
   }),
-  z11.object({
-    event: z11.literal("blocker_resolved"),
-    ts: z11.iso.datetime(),
+  z12.object({
+    event: z12.literal("blocker_resolved"),
+    ts: z12.iso.datetime(),
     /** Index of the blocker in the state's blockers[] array. */
-    blockerIndex: z11.number().int().nonnegative(),
-    resolvedAt: z11.iso.datetime()
+    blockerIndex: z12.number().int().nonnegative(),
+    resolvedAt: z12.iso.datetime()
   }),
-  z11.object({
-    event: z11.literal("stage"),
-    ts: z11.iso.datetime(),
+  z12.object({
+    event: z12.literal("stage"),
+    ts: z12.iso.datetime(),
     stage: TaskStageSchema
   }),
-  z11.object({
-    event: z11.literal("position"),
-    ts: z11.iso.datetime(),
+  z12.object({
+    event: z12.literal("position"),
+    ts: z12.iso.datetime(),
     position: TaskPositionSchema
   }),
   // Magentic-One Task Ledger replacement event — the outer loop revises the
   // entire ledger atomically when replanning. Always replaces, never partial.
-  z11.object({
-    event: z11.literal("task_ledger"),
-    ts: z11.iso.datetime(),
+  z12.object({
+    event: z12.literal("task_ledger"),
+    ts: z12.iso.datetime(),
     ledger: TaskLedgerSchema
   }),
   // Magentic-One Progress Ledger append event — one self-reflection per step.
-  z11.object({
-    event: z11.literal("progress_ledger"),
-    ts: z11.iso.datetime(),
+  z12.object({
+    event: z12.literal("progress_ledger"),
+    ts: z12.iso.datetime(),
     entry: ProgressLedgerEntrySchema
   }),
   // #3043 / epic #2631 Stage 2 — tool result payload set when stage flips
   // to 'complete'. Written by appendResult; replayed into state.result.
   // The payload itself is `unknown` because each tool's result shape is
   // its own; readers cast after a status check.
-  z11.object({
-    event: z11.literal("result"),
-    ts: z11.iso.datetime(),
-    result: z11.unknown()
+  z12.object({
+    event: z12.literal("result"),
+    ts: z12.iso.datetime(),
+    result: z12.unknown()
   }),
   // #3043 / epic #2631 Stage 2 — cancellation marker. Append-only: the
   // reducer ignores a second cancellation event so a malicious or buggy
   // double-cancel can't rewrite the requestedAt timestamp.
-  z11.object({
-    event: z11.literal("cancellation"),
-    ts: z11.iso.datetime(),
+  z12.object({
+    event: z12.literal("cancellation"),
+    ts: z12.iso.datetime(),
     cancellation: TaskCancellationSchema
   })
 ]);
@@ -7842,7 +7908,7 @@ function defaultBusyEnvelope(retryAfterMs, toolName) {
     JSON.stringify({
       status: "busy",
       retryAfterMs,
-      note: `Async-mode concurrency cap reached for ${toolName}. Retry later or use mode: "sync".`
+      note: `Async-mode concurrency cap reached for ${toolName}. Retry later or use dispatch: "sync".`
     })
   );
 }
@@ -8453,26 +8519,30 @@ function createConsensusVoteHandler(deps) {
       if (!simCheck.allowed) return simulationDeniedResult(simCheck.reason);
     }
     const strategy = validationResult.data.strategy ?? "simple_majority";
+    const dispatch = resolveDispatch(validationResult.data);
+    const modeWarning = deprecatedModeWarning(validationResult.data);
     ctx.logger.debug("Starting consensus vote", {
       strategy,
       quickMode: validationResult.data.quickMode,
-      ...validationResult.data.mode !== void 0 ? { mode: validationResult.data.mode } : {}
+      ...dispatch !== void 0 ? { dispatch } : {}
     });
     notifier.info("consensus_vote", {
       event: "vote_start",
       proposalLength: validationResult.data.proposal.length,
       strategy
     });
-    if (validationResult.data.mode === "async") {
+    if (dispatch === "async") {
       const asyncResult = dispatchAsyncConsensusVote(deps, validationResult.data);
       notifier.info("consensus_vote", {
         event: "vote_dispatched_async",
         proposalLength: validationResult.data.proposal.length,
         strategy
       });
-      return asyncResult;
+      return withWarnings(asyncResult, [modeWarning]);
     }
-    return runSyncConsensusVote(deps, notifier, validationResult.data);
+    return withWarnings(await runSyncConsensusVote(deps, notifier, validationResult.data), [
+      modeWarning
+    ]);
   };
 }
 var ASYNC_ENVELOPES = {
@@ -8485,7 +8555,7 @@ var ASYNC_ENVELOPES = {
   busy: (retryAfterMs, toolName) => toolSuccessStructured({
     status: "busy",
     retryAfterMs,
-    note: `Async-mode concurrency cap reached for ${toolName}. Retry later or use mode: "sync".`
+    note: `Async-mode concurrency cap reached for ${toolName}. Retry later or use dispatch: "sync".`
   }),
   replay: (jobId) => toolSuccessStructured({
     status: "replay",
@@ -8497,49 +8567,49 @@ var ASYNC_ENVELOPES = {
 };
 var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
   /** Async-dispatch envelope discriminator — absent on a completed vote. */
-  status: z12.enum(["pending", "busy", "replay"]).optional(),
-  jobId: z12.string().max(200).optional(),
-  pollTool: z12.literal("get_job_result").optional(),
-  note: z12.string().max(500).optional(),
-  retryAfterMs: z12.number().optional(),
-  proposal: z12.string().optional(),
+  status: z13.enum(["pending", "busy", "replay"]).optional(),
+  jobId: z13.string().max(200).optional(),
+  pollTool: z13.literal("get_job_result").optional(),
+  note: z13.string().max(500).optional(),
+  retryAfterMs: z13.number().optional(),
+  proposal: z13.string().optional(),
   strategy: VotingStrategySchema.optional(),
   // Reuses the canonical VoteDecisionStatusSchema (single source) — a hand-listed
   // subset here (was ['approved','rejected','no_quorum']) omitted the reachable
   // 'timeout'/'pending' outcomes and made strict clients reject those votes (#4032).
   decision: VoteDecisionStatusSchema.optional(),
-  approvalPercentage: z12.number().optional(),
-  voteCounts: z12.object({
-    approve: z12.number(),
-    reject: z12.number(),
-    abstain: z12.number(),
-    error: z12.number(),
+  approvalPercentage: z13.number().optional(),
+  voteCounts: z13.object({
+    approve: z13.number(),
+    reject: z13.number(),
+    abstain: z13.number(),
+    error: z13.number(),
     /** #6094: seats that could not read the artifact; always present. */
-    unverifiable: z12.number()
+    unverifiable: z13.number()
   }).optional(),
   // #6111: the quick-mode contrarian check is not a seat, so `voteCounts.error`
   // cannot count it. Present on every completed vote (`skipped` when it did not
   // run); optional here only because the async envelope shares this schema.
   contrarianCheck: ContrarianCheckStatusSchema.optional(),
-  votes: z12.array(
-    z12.object({
-      role: z12.string().max(100),
-      decision: z12.enum(["approve", "reject", "abstain"]),
-      confidence: z12.number(),
-      reasoning: z12.string().max(4e3),
-      simulated: z12.boolean(),
-      error: z12.boolean(),
+  votes: z13.array(
+    z13.object({
+      role: z13.string().max(100),
+      decision: z13.enum(["approve", "reject", "abstain"]),
+      confidence: z13.number(),
+      reasoning: z13.string().max(4e3),
+      simulated: z13.boolean(),
+      error: z13.boolean(),
       /** #6094: present only when the seat could not read the artifact. */
-      unverifiable: z12.literal(true).optional(),
+      unverifiable: z13.literal(true).optional(),
       /** #6115: present only when the seat answered elsewhere than assigned. */
-      fallback: z12.object({
-        fromCli: z12.string().max(100),
-        fromModel: z12.string().max(100).optional(),
-        reason: z12.enum(["rate-limit", "capacity", "auth", "timeout", "sandbox", "unknown"])
+      fallback: z13.object({
+        fromCli: z13.string().max(100),
+        fromModel: z13.string().max(100).optional(),
+        reason: z13.enum(["rate-limit", "capacity", "auth", "timeout", "sandbox", "unknown"])
       }).optional(),
-      modelUsed: z12.string().max(100).optional(),
-      rejectionCategories: z12.array(
-        z12.enum([
+      modelUsed: z13.string().max(100).optional(),
+      rejectionCategories: z13.array(
+        z13.enum([
           "YAGNI",
           "DRY_VIOLATION",
           "OVER_ENGINEERING",
@@ -8552,48 +8622,48 @@ var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
     })
   ).optional(),
   threshold: VoteThresholdSchema.optional(),
-  durationMs: z12.number().optional(),
-  simulateVotes: z12.boolean().optional(),
+  durationMs: z13.number().optional(),
+  simulateVotes: z13.boolean().optional(),
   // #6110: the project the panel judged and how the name was decided. Always
   // on the response; optional here like every field, because the async
   // `pending` envelope shares this schema.
-  project: z12.object({
-    name: z12.string().max(200),
-    source: z12.enum(["input", "derived", "default"])
+  project: z13.object({
+    name: z13.string().max(200),
+    source: z13.enum(["input", "derived", "default"])
   }).optional(),
-  higherOrderMetadata: z12.object({
-    posteriorApproval: z12.number(),
-    posteriorRejection: z12.number(),
-    effectiveVoteCount: z12.number(),
-    method: z12.enum(["ow", "isp", "simple"]),
-    usedCorrelationData: z12.boolean(),
-    improvementOverBaseline: z12.number(),
-    downweightedAgents: z12.array(z12.string().max(100)).max(10),
-    reasoning: z12.string().max(2e3)
+  higherOrderMetadata: z13.object({
+    posteriorApproval: z13.number(),
+    posteriorRejection: z13.number(),
+    effectiveVoteCount: z13.number(),
+    method: z13.enum(["ow", "isp", "simple"]),
+    usedCorrelationData: z13.boolean(),
+    improvementOverBaseline: z13.number(),
+    downweightedAgents: z13.array(z13.string().max(100)).max(10),
+    reasoning: z13.string().max(2e3)
   }).optional(),
   // #3124: explains a `rejected` decision that coexists with a high
   // approvalPercentage (an error-policy short-circuit, e.g. fail_closed).
-  policyReason: z12.string().max(200).optional(),
+  policyReason: z13.string().max(200).optional(),
   // #3991: whether the authentic vote record was persisted at vote time. Post-
   // #3991 it routes through nexusDataPath under governance/, so true is the
   // normal case; false means all-simulated (skipped by design) or write-failed
   // (data dir unwritable) — voteRecordNote carries the actionable reason. Makes
   // a previously WARN-only skip visible to MCP callers.
-  voteRecordPersisted: z12.boolean().optional(),
-  voteRecordNote: z12.string().max(500).optional(),
+  voteRecordPersisted: z13.boolean().optional(),
+  voteRecordNote: z13.string().max(500).optional(),
   // #5130: the persisted record's id, so the caller-commits script can name it.
-  voteRecordId: z12.string().max(200).optional(),
+  voteRecordId: z13.string().max(200).optional(),
   // #3587: set when the panel DEGRADED (some voters errored), so the decision
   // rests on fewer voters than requested. Part of the response since #3587 but
   // omitted from this schema until #4032 — its absence made a strict MCP client
   // reject any degraded-panel vote (`-32602 additional properties`).
-  panelWarning: z12.string().optional(),
+  panelWarning: z13.string().optional(),
   // #6115: distinct answering models and seats that answered elsewhere than
   // assigned. Always on the response (explicit zeros); optional here only
   // because the async `pending` envelope shares this schema.
-  panelDiversity: z12.object({
-    distinctModels: z12.number().int().nonnegative(),
-    fallbacks: z12.number().int().nonnegative()
+  panelDiversity: z13.object({
+    distinctModels: z13.number().int().nonnegative(),
+    fallbacks: z13.number().int().nonnegative()
   }).optional(),
   // #3855: per-decision cost rollup. Same omission as panelWarning (#4032) — it
   // is present on the response whenever cost recording succeeds (common in `api`
@@ -8602,22 +8672,22 @@ var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
   // #4472: declared-option outcome. Present whenever the proposal declared
   // `options`. `unattributedApprovals` is part of the contract, not telemetry:
   // without it a caller cannot tell a real split from unreadable responses.
-  optionOutcome: z12.object({
-    tally: z12.array(z12.object({ option: z12.string(), count: z12.number().int().nonnegative() })),
-    leadingOption: z12.string().optional(),
-    leadingShare: z12.number().min(0).max(1),
-    approverCount: z12.number().int().nonnegative(),
-    selectedCount: z12.number().int().nonnegative(),
-    unattributedApprovals: z12.number().int().nonnegative(),
-    thresholdMet: z12.boolean(),
+  optionOutcome: z13.object({
+    tally: z13.array(z13.object({ option: z13.string(), count: z13.number().int().nonnegative() })),
+    leadingOption: z13.string().optional(),
+    leadingShare: z13.number().min(0).max(1),
+    approverCount: z13.number().int().nonnegative(),
+    selectedCount: z13.number().int().nonnegative(),
+    unattributedApprovals: z13.number().int().nonnegative(),
+    thresholdMet: z13.boolean(),
     // #4529: present only on a veto. Declared here because a strict MCP
     // client rejects any property the advertised schema omits — the same
     // drift that made degraded-panel votes unusable before #4032.
-    vetoReason: z12.string().max(400).optional()
+    vetoReason: z13.string().max(400).optional()
   }).optional()
 };
 var CONSENSUS_VOTE_TOOL_SCHEMA = ConsensusVoteInputSchema.shape;
-var CONSENSUS_VOTE_DESCRIPTION = "Execute multi-model consensus voting on a proposal. Uses 7 roles by default (architect, security, devex, ai_ml, pm, catfish, scope_steward) or 3 with quickMode (architect, security, scope_steward), voting with configurable strategies. higher_order does NOT decide the verdict by correlation-aware aggregation (#4701): approve/reject is a simple tally of the panel, so correlated voters each carry full independent weight. The Bayesian correlation analysis is computed and feeds contrarian escalation only. Choose it for the escalation behaviour, not for a weighted verdict. Supports async mode (mode: 'async') \u2014 returns a jobId to poll via get_job_result. Pass ratifies=<subject> to bind an authority-ladder ratification vote into its authentic record, and ratifiesPr={pr, headSha} to bind a governor-path PR ratification to the head the panel saw (#5130); the result carries voteRecordId for the caller-commits append. If your proposal asks voters to choose among named alternatives, you MUST pass them in `options` (#4472) \u2014 the threshold is then measured over WHICH option won, and the record carries the per-option tally plus selection coverage. WITHOUT `options` the tally is approve/reject/abstain only, so every voter who engages returns `approve` and a 6-1 split on which option persists as 7-0, 100% (#4452).";
+var CONSENSUS_VOTE_DESCRIPTION = "Execute multi-model consensus voting on a proposal. Uses 7 roles by default (architect, security, devex, ai_ml, pm, catfish, scope_steward) or 3 with quickMode (architect, security, scope_steward), voting with configurable strategies. higher_order does NOT decide the verdict by correlation-aware aggregation (#4701): approve/reject is a simple tally of the panel, so correlated voters each carry full independent weight. The Bayesian correlation analysis is computed and feeds contrarian escalation only. Choose it for the escalation behaviour, not for a weighted verdict. Supports async dispatch (dispatch: 'async'; `mode` is a deprecated alias) \u2014 returns a jobId to poll via get_job_result. Pass ratifies=<subject> to bind an authority-ladder ratification vote into its authentic record, and ratifiesPr={pr, headSha} to bind a governor-path PR ratification to the head the panel saw (#5130); the result carries voteRecordId for the caller-commits append. If your proposal asks voters to choose among named alternatives, you MUST pass them in `options` (#4472) \u2014 the threshold is then measured over WHICH option won, and the record carries the per-option tally plus selection coverage. WITHOUT `options` the tally is approve/reject/abstain only, so every voter who engages returns `approve` and a 6-1 split on which option persists as 7-0, 100% (#4452).";
 function registerConsensusVoteTool(server, deps) {
   const logger11 = deps.logger ?? createLogger({ tool: "consensus_vote" });
   const notifier = deps.notifier ?? createMcpNotifier(server);
@@ -8647,6 +8717,15 @@ function registerConsensusVoteTool(server, deps) {
 
 export {
   VOTER_ROLES,
+  dispatchFieldDefaultSync,
+  asyncDispatchInput,
+  asyncDispatchInputDefaultSync,
+  modeEnumErrorNamingDispatch,
+  DEPRECATED_MODE_ALIAS_INPUT,
+  refineDispatchModeAgreement,
+  resolveDispatch,
+  deprecatedModeWarning,
+  withWarnings,
   resolveIdempotency,
   registerIdempotentJob,
   JobStatusSchema,
@@ -8726,6 +8805,7 @@ export {
   createCorrelationTracker,
   seatFallbacks,
   panelDiversityOf,
+  VoteRecordPrBindingSchema,
   VotingStrategySchema,
   ErrorPolicySchema,
   VoteThresholdSchema,
@@ -8747,4 +8827,4 @@ export {
   CONSENSUS_VOTE_TOOL_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-MO6FSEFJ.js.map
+//# sourceMappingURL=chunk-C4DQ6FON.js.map