nexus-agents 2.111.1 → 2.113.0

package/dist/{chunk-GJ47JWNS.js → chunk-5KBR7SYI.js}

@@ -1,5 +1,10 @@
 import {
+  DEFAULT_CONSENSUS_CONFIG,
+  DEFAULT_INCREMENTAL_QUORUM_CONFIG,
   NOOP_NOTIFIER,
+  ProposalSchema,
+  VOTING_THRESHOLDS,
+  VoteSchema,
   createMcpNotifier,
   createSecureHandler,
   getToolAnnotations,
@@ -9,7 +14,7 @@ import {
   toolSuccess,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-5P5KCVTX.js";
+} from "./chunk-7E2ZCYKA.js";
 import {
   getToolMemory
 } from "./chunk-P2K5GCLL.js";
@@ -66,7 +71,7 @@ import {
 } from "./chunk-CH7QIDHQ.js";
 
 // src/mcp/tools/consensus-vote.ts
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 
 // src/cli/vote-types.ts
 var VOTER_ROLES = {
@@ -1997,187 +2002,40 @@ async function collectRealVotes(options) {
   });
 }
 
-// src/consensus/types-core.ts
-import { z as z2 } from "zod";
-var ConsensusAlgorithmSchema = z2.enum([
-  "simple_majority",
-  "supermajority",
-  "unanimous",
-  "proof_of_learning",
-  "opinion_wise",
-  "higher_order"
-]);
-var VoteDecisionSchema = z2.enum(["approve", "reject", "abstain"]);
-var ProposalStatusSchema = z2.enum([
-  "pending",
-  "voting",
-  "approved",
-  "rejected",
-  "timeout",
-  "closed"
-]);
-var RejectionCategorySchema = z2.enum([
-  "YAGNI",
-  "DRY_VIOLATION",
-  "OVER_ENGINEERING",
-  "SCOPE_CREEP",
-  "SECURITY_RISK",
-  "MISALIGNED",
-  "INSUFFICIENT_EVIDENCE"
-]);
-var REJECTION_CATEGORIES = RejectionCategorySchema.options;
-var FindingShapeSchema = z2.object({
-  summary: z2.string().min(1).max(500),
-  location: z2.string().min(1).max(200),
-  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(""),
-    ruled_out_language_non_issue: z2.enum(["passed", "failed", "skipped"]).default("skipped")
-  }),
-  claim: z2.string().min(1).max(2e3)
-});
-var VoteSchema = z2.object({
-  decision: VoteDecisionSchema,
-  reasoning: z2.string().min(1).describe("Explanation for the vote"),
-  confidence: z2.number().min(0).max(1).describe("Confidence level 0-1"),
-  conditions: z2.array(z2.string()).optional().describe("Conditions for approval"),
-  /** Structured rejection categories for reject→refine→re-vote loops (Issue #1213). */
-  rejectionCategories: z2.array(RejectionCategorySchema).optional().describe("Rejection reason categories when decision is reject"),
-  /** Pre-verified PR-review findings (#2245 v4 follow-up). Optional;
-   * populated only when the voter emits the structured top-level array. */
-  findings: z2.array(FindingShapeSchema).optional().describe("PR-review findings (pre-verified)"),
-  timestamp: z2.iso.datetime().optional()
-});
-var ProposalSchema = z2.object({
-  id: z2.string().optional().describe("Auto-generated if not provided"),
-  title: z2.string().min(1).max(200).describe("Short proposal title"),
-  description: z2.string().min(1).describe("Detailed proposal description"),
-  algorithm: ConsensusAlgorithmSchema,
-  timeout: z2.number().int().positive().optional().describe("Timeout in milliseconds"),
-  requiredVoters: z2.array(z2.string()).optional().describe("Agent IDs that must vote"),
-  metadata: z2.record(z2.string(), z2.unknown()).optional().describe("Additional context"),
-  createdAt: z2.iso.datetime().optional()
-});
-var ConsensusResultSchema = z2.object({
-  proposalId: z2.string(),
-  proposal: ProposalSchema,
-  outcome: ProposalStatusSchema,
-  votes: z2.map(z2.string(), VoteSchema),
-  voteCounts: z2.object({
-    approve: z2.number().int().nonnegative(),
-    reject: z2.number().int().nonnegative(),
-    abstain: z2.number().int().nonnegative(),
-    total: z2.number().int().nonnegative()
-  }),
-  weightedCounts: z2.object({
-    approve: z2.number().nonnegative(),
-    reject: z2.number().nonnegative(),
-    abstain: z2.number().nonnegative(),
-    totalWeight: z2.number().nonnegative()
-  }).optional(),
-  approvalPercentage: z2.number().min(0).max(100),
-  quorumReached: z2.boolean(),
-  startedAt: z2.iso.datetime(),
-  closedAt: z2.iso.datetime(),
-  durationMs: z2.number().int().nonnegative()
-});
-var AgentPerformanceSchema = z2.object({
-  agentId: z2.string(),
-  totalVotes: z2.number().int().nonnegative(),
-  correctVotes: z2.number().int().nonnegative(),
-  successRate: z2.number().min(0).max(1),
-  lastUpdated: z2.iso.datetime()
-});
-var DEFAULT_INCREMENTAL_QUORUM_CONFIG = {
-  enabled: false,
-  maxExpansionRounds: 2,
-  votersPerExpansion: 2,
-  confidenceThreshold: 0.6,
-  ambiguityBand: 0.15
-};
-var ProposalCacheConfigSchema = z2.object({
-  enabled: z2.boolean().default(false),
-  ttlMs: z2.number().int().positive().default(36e5),
-  // 1 hour
-  maxEntries: z2.number().int().positive().default(500)
-});
-var ConsensusEngineConfigSchema = z2.object({
-  defaultTimeout: z2.number().int().positive().default(3e5),
-  // 5 minutes
-  minVotersForQuorum: z2.number().int().positive().default(2),
-  maxActiveProposals: z2.number().int().positive().default(100),
-  enablePerformanceTracking: z2.boolean().default(true),
-  maxClosedProposals: z2.number().int().positive().default(1e3),
-  // Issue #549
-  proposalCache: ProposalCacheConfigSchema.optional()
-  // Issue #589
-});
-var DEFAULT_CONSENSUS_CONFIG = {
-  defaultTimeout: 3e5,
-  // 5 minutes
-  minVotersForQuorum: 2,
-  maxActiveProposals: 100,
-  enablePerformanceTracking: true,
-  maxClosedProposals: 1e3
-  // Issue #549: Prevent unbounded memory growth
-};
-var VOTING_THRESHOLDS = {
-  simple_majority: 0.5,
-  supermajority: 0.67,
-  unanimous: 1,
-  proof_of_learning: 0.5,
-  // Uses weighted voting
-  opinion_wise: 0.5,
-  // Uses correlation-aware Bayesian aggregation (Issue #333)
-  higher_order: 0.5
-  // Alias for opinion_wise (Issue #514)
-};
-var ConsensusMetricsSchema = z2.object({
-  totalProposals: z2.number().int().nonnegative(),
-  approvedProposals: z2.number().int().nonnegative(),
-  rejectedProposals: z2.number().int().nonnegative(),
-  timedOutProposals: z2.number().int().nonnegative(),
-  averageDurationMs: z2.number().nonnegative(),
-  averageVotesPerProposal: z2.number().nonnegative(),
-  algorithmUsage: z2.record(ConsensusAlgorithmSchema, z2.number().int().nonnegative())
-});
-
 // src/consensus/types-voting-protocol.ts
-import { z as z3 } from "zod";
-var VotingRoundPhaseSchema = z3.enum(["analysis", "deliberation", "consensus"]);
-var VotingRoundStatusSchema = z3.enum([
+import { z as z2 } from "zod";
+var VotingRoundPhaseSchema = z2.enum(["analysis", "deliberation", "consensus"]);
+var VotingRoundStatusSchema = z2.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 = z2.object({
+  agentId: z2.string(),
+  category: z2.enum(["bug", "security", "performance", "style", "design", "documentation", "other"]),
+  severity: z2.enum(["critical", "major", "minor", "suggestion"]),
+  description: z2.string().min(1),
+  location: z2.string().optional().describe("File path and line range if applicable"),
+  suggestion: z2.string().optional().describe("Recommended fix"),
+  confidence: z2.number().min(0).max(1),
+  timestamp: z2.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 = z2.object({
+  agentId: z2.string(),
+  findingId: z2.string(),
+  agree: z2.boolean(),
+  reasoning: z2.string().optional(),
+  amendedSeverity: z2.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(6e4),
-  agreementThreshold: z3.number().min(0.5).max(1).default(0.67),
-  enableAntiSycophancy: z3.boolean().default(true),
-  sycophancyThreshold: z3.number().min(0).max(1).default(0.8)
+var VotingProtocolConfigSchema = z2.object({
+  committeeSize: z2.number().int().min(2).max(7).default(3),
+  maxRounds: z2.number().int().min(1).max(5).default(3),
+  roundTimeoutMs: z2.number().int().positive().default(6e4),
+  agreementThreshold: z2.number().min(0.5).max(1).default(0.67),
+  enableAntiSycophancy: z2.boolean().default(true),
+  sycophancyThreshold: z2.number().min(0).max(1).default(0.8)
 });
 var DEFAULT_VOTING_PROTOCOL_CONFIG = {
   committeeSize: 3,
@@ -2189,30 +2047,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 z3 } from "zod";
+var TaskOutcomeStatusSchema = z3.enum(["success", "failure", "partial", "unknown"]);
+var WeightedAgentRecordSchema = z3.object({
+  agentId: z3.string().min(1),
+  totalTasks: z3.number().int().nonnegative(),
+  successfulTasks: z3.number().int().nonnegative(),
+  failedTasks: z3.number().int().nonnegative(),
+  partialTasks: z3.number().int().nonnegative(),
+  successRate: z3.number().min(0).max(1),
+  weight: z3.number().min(0).max(1),
+  trustScore: z3.number().min(0).max(1),
+  byzantineFlags: z3.number().int().nonnegative(),
+  lastActive: z3.date(),
+  createdAt: z3.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(0.67)
+var WeightedVotingConfigSchema = z3.object({
+  minWeight: z3.number().min(0).max(1).default(0.1),
+  maxByzantineFraction: z3.number().min(0).max(0.5).default(0.33),
+  weightDecayFactor: z3.number().min(0.5).max(1).default(0.9),
+  weightRecoveryFactor: z3.number().min(1).max(2).default(1.05),
+  minTrustScore: z3.number().min(0).max(1).default(0.3),
+  byzantineFlagThreshold: z3.number().int().positive().default(3),
+  initialWeight: z3.number().min(0).max(1).default(0.5),
+  quorumThreshold: z3.number().min(0.5).max(1).default(0.67)
 });
 var DEFAULT_WEIGHTED_VOTING_CONFIG = {
   minWeight: 0.1,
@@ -2226,7 +2084,7 @@ var DEFAULT_WEIGHTED_VOTING_CONFIG = {
 };
 
 // src/consensus/higher-order-types.ts
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 function createAgentPairKey(agentA, agentB) {
   return agentA < agentB ? `${agentA}:${agentB}` : `${agentB}:${agentA}`;
 }
@@ -2237,40 +2095,40 @@ 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),
-  observationCount: z5.number().int().nonnegative()
+var CorrelationCoefficientSchema = z4.number().min(-1).max(1);
+var IndependentSubsetSchema = z4.object({
+  id: z4.string(),
+  agentIds: z4.array(z4.string()),
+  independenceScore: z4.number().min(0).max(1),
+  observationCount: z4.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()
+var VotingObservationSchema = z4.object({
+  proposalId: z4.string(),
+  agentId: z4.string(),
+  decision: z4.enum(["approve", "reject", "abstain"]),
+  confidence: z4.number().min(0).max(1),
+  alignedWithOutcome: z4.boolean(),
+  timestamp: z4.date()
 });
-var PairwiseVotingHistorySchema = z5.object({
-  pairKey: z5.string(),
-  jointObservations: z5.number().int().nonnegative(),
-  agreements: z5.number().int().nonnegative(),
-  disagreements: z5.number().int().nonnegative(),
+var PairwiseVotingHistorySchema = z4.object({
+  pairKey: z4.string(),
+  jointObservations: z4.number().int().nonnegative(),
+  agreements: z4.number().int().nonnegative(),
+  disagreements: z4.number().int().nonnegative(),
   correlation: CorrelationCoefficientSchema,
-  lastUpdated: z5.date()
+  lastUpdated: z4.date()
 });
-var HigherOrderVotingConfigSchema = z5.object({
-  minObservationsForCorrelation: z5.number().int().positive().default(10),
-  correlationThreshold: z5.number().min(0).max(1).default(0.3),
-  correlationMaxAgeMs: z5.number().int().positive().default(864e5),
+var HigherOrderVotingConfigSchema = z4.object({
+  minObservationsForCorrelation: z4.number().int().positive().default(10),
+  correlationThreshold: z4.number().min(0).max(1).default(0.3),
+  correlationMaxAgeMs: z4.number().int().positive().default(864e5),
   // 24 hours
-  independenceThreshold: z5.number().min(0).max(1).default(0.2),
-  fallbackToSimpleVoting: z5.boolean().default(true),
-  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)
+  independenceThreshold: z4.number().min(0).max(1).default(0.2),
+  fallbackToSimpleVoting: z4.boolean().default(true),
+  observationDecayFactor: z4.number().min(0).max(1).default(0.95),
+  maxObservationsPerAgent: z4.number().int().positive().default(1e3),
+  maxProposals: z4.number().int().positive().default(5e3),
+  maxTrackedPairs: z4.number().int().positive().default(100)
 });
 var DEFAULT_HIGHER_ORDER_CONFIG = {
   minObservationsForCorrelation: 10,
@@ -2284,25 +2142,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 = z4.object({
+  decision: z4.enum(["approve", "reject", "no_consensus"]),
+  posteriorApproval: z4.number().min(0).max(1),
+  posteriorRejection: z4.number().min(0).max(1),
+  effectiveVoteCount: z4.number().nonnegative(),
+  usedCorrelationData: z4.boolean(),
+  method: z4.enum(["ow", "isp", "simple"]),
+  improvementOverBaseline: z4.number(),
+  independentSubsets: z4.array(IndependentSubsetSchema).optional(),
+  downweightedAgents: z4.array(z4.string()),
+  reasoning: z4.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 = z4.object({
+  totalAgents: z4.number().int().nonnegative(),
+  trackedPairs: z4.number().int().nonnegative(),
+  totalObservations: z4.number().int().nonnegative(),
+  averageCorrelation: z4.number(),
+  independentSubsetCount: z4.number().int().nonnegative(),
+  pairsWithSufficientData: z4.number().int().nonnegative()
 });
 
 // src/consensus/higher-order-helpers.ts
@@ -4990,7 +4848,7 @@ function createCorrelationTracker(config) {
 
 // src/consensus/correlation-persistence.ts
 import * as fs from "fs";
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 var logger6 = createLogger({ component: "correlation-persistence" });
 var VOTING_SUBDIR = "voting";
 var CORRELATIONS_FILE = "correlations.json";
@@ -4998,21 +4856,21 @@ var CORRELATIONS_JSONL_FILE = "correlations.jsonl";
 var FILE_MODE = 384;
 var DIR_MODE = 448;
 var SCHEMA_VERSION = 2;
-var PersistedVoteSchema = z6.object({
-  agentId: z6.string(),
-  decision: z6.enum(["approve", "reject", "abstain"]),
-  confidence: z6.number().min(0).max(1)
+var PersistedVoteSchema = z5.object({
+  agentId: z5.string(),
+  decision: z5.enum(["approve", "reject", "abstain"]),
+  confidence: z5.number().min(0).max(1)
 });
-var PersistedProposalSchema = z6.object({
-  proposalId: z6.string(),
-  votes: z6.array(PersistedVoteSchema),
-  outcome: z6.enum(["approved", "rejected"]),
-  timestamp: z6.iso.datetime()
+var PersistedProposalSchema = z5.object({
+  proposalId: z5.string(),
+  votes: z5.array(PersistedVoteSchema),
+  outcome: z5.enum(["approved", "rejected"]),
+  timestamp: z5.iso.datetime()
 });
-var PersistedCorrelationDataSchema = z6.object({
-  version: z6.number().int().positive(),
-  proposals: z6.array(PersistedProposalSchema),
-  savedAt: z6.iso.datetime()
+var PersistedCorrelationDataSchema = z5.object({
+  version: z5.number().int().positive(),
+  proposals: z5.array(PersistedProposalSchema),
+  savedAt: z5.iso.datetime()
 });
 function getCorrelationDataPath() {
   return nexusDataPath(VOTING_SUBDIR, CORRELATIONS_FILE);
@@ -5213,9 +5071,9 @@ function createPersistedProposal(proposalId, votes, outcome) {
 }
 
 // src/mcp/tools/consensus-vote-types.ts
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 var MAX_PROPOSAL_LENGTH = 4e3;
-var VotingStrategySchema = z7.enum([
+var VotingStrategySchema = z6.enum([
   "simple_majority",
   "supermajority",
   "unanimous",
@@ -5226,8 +5084,8 @@ var VotingStrategySchema = z7.enum([
 function isHigherOrderStrategy(strategy) {
   return strategy === "higher_order" || strategy === "opinion_wise";
 }
-var ErrorPolicySchema = z7.enum(["reduce_denominator", "count_as_abstain", "fail_closed"]);
-var VoteThresholdSchema = z7.enum(["majority", "supermajority", "unanimous"]);
+var ErrorPolicySchema = z6.enum(["reduce_denominator", "count_as_abstain", "fail_closed"]);
+var VoteThresholdSchema = z6.enum(["majority", "supermajority", "unanimous"]);
 var ERROR_FLOOR_FRACTION = 0.5;
 function getDefaultErrorPolicy(strategy) {
   if (strategy === "unanimous") {
@@ -5235,8 +5093,8 @@ function getDefaultErrorPolicy(strategy) {
   }
   return "reduce_denominator";
 }
-var ConsensusVoteInputSchema = z7.object({
-  proposal: z7.string().min(1).max(MAX_PROPOSAL_LENGTH).describe("Proposal text to vote on"),
+var ConsensusVoteInputSchema = z6.object({
+  proposal: z6.string().min(1).max(MAX_PROPOSAL_LENGTH).describe("Proposal text to vote on"),
   threshold: VoteThresholdSchema.optional().describe(
     "Voting threshold (legacy): majority, supermajority, unanimous. Use strategy instead."
   ),
@@ -5246,8 +5104,8 @@ var ConsensusVoteInputSchema = z7.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). Regardless of policy, errors > 50% always fails."
   ),
-  quickMode: z7.boolean().optional().default(false).describe("Use 3 agents instead of the full 7-role panel for faster execution"),
-  simulateVotes: z7.boolean().optional().default(false).describe(
+  quickMode: z6.boolean().optional().default(false).describe("Use 3 agents instead of the full 7-role panel for faster execution"),
+  simulateVotes: z6.boolean().optional().default(false).describe(
     "TESTS ONLY \u2014 when true, voters return random decisions. Output must not be used for real decisions. (#2319)"
   ),
   /**
@@ -5267,7 +5125,7 @@ var ConsensusVoteInputSchema = z7.object({
    * Kept optional (no `.default()`) so the inferred type doesn't force
    * `mode: 'sync'` on every existing call site / test fixture.
    */
-  mode: z7.enum(["sync", "async"]).optional().describe(
+  mode: z6.enum(["sync", "async"]).optional().describe(
     'Dispatch mode (default: sync). Use "async" for higher-order strategies with 7 voters.'
   ),
   /**
@@ -5276,7 +5134,7 @@ var ConsensusVoteInputSchema = z7.object({
    * same key with different inputs fails closed with
    * `idempotency_key_collision`. Sync mode ignores this.
    */
-  idempotencyKey: z7.string().min(1).max(256).optional().describe(
+  idempotencyKey: z6.string().min(1).max(256).optional().describe(
     "Replay-safe key for async-mode dispatch (#3042 Stage 1c). Same (key, inputs) returns existing jobId."
   )
 });
@@ -5621,30 +5479,30 @@ function warnIfSimulatedOutsideTests(toolName, logger11) {
 
 // src/mcp/jobs/job-result-store.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync, writeFileSync as writeFileSync3 } from "fs";
-import { z as z8 } from "zod";
+import { z as z7 } from "zod";
 var logger8 = createLogger({ component: "job-result-store" });
-var JobStatusSchema = z8.enum(["pending", "complete", "failed", "cancelled"]);
-var JobResultSchema = z8.object({
+var JobStatusSchema = z7.enum(["pending", "complete", "failed", "cancelled"]);
+var JobResultSchema = z7.object({
   /** Format version. Currently `1` — bump if the shape changes. */
-  v: z8.literal(1),
-  jobId: z8.string().min(1),
+  v: z7.literal(1),
+  jobId: z7.string().min(1),
   /** Tool that was invoked (e.g. `orchestrate`). */
-  toolName: z8.string().min(1),
+  toolName: z7.string().min(1),
   status: JobStatusSchema,
-  createdAt: z8.iso.datetime(),
+  createdAt: z7.iso.datetime(),
   /** Set when the job leaves `pending` — either via `complete` or `failed` or `cancelled`. */
-  completedAt: z8.iso.datetime().optional(),
+  completedAt: z7.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: z8.unknown().optional(),
+  result: z7.unknown().optional(),
   /**
    * Failure message when `status === 'failed'`. Cannot be paired with
    * `result` — the discriminator is `status`.
    */
-  error: z8.string().optional()
+  error: z7.string().optional()
 });
 function jobResultPath(jobId) {
   return nexusDataPathEnsure("jobs", `result-${jobId}.json`);
@@ -5761,20 +5619,20 @@ function listJobs() {
 // src/mcp/jobs/job-idempotency.ts
 import { createHash, randomUUID as randomUUID2 } from "crypto";
 import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 var logger9 = createLogger({ component: "job-idempotency" });
-var IdempotencyIndexEntrySchema = z9.object({
-  v: z9.literal(1),
+var IdempotencyIndexEntrySchema = z8.object({
+  v: z8.literal(1),
   /** MCP tool name (e.g. `orchestrate`, `run_workflow`, `consensus_vote`). */
-  tool: z9.string().min(1),
+  tool: z8.string().min(1),
   /** Caller-supplied idempotency key. */
-  key: z9.string().min(1),
+  key: z8.string().min(1),
   /** sha256 of the canonical input JSON. */
-  inputsHash: z9.string().length(64),
+  inputsHash: z8.string().length(64),
   /** Existing jobId for this (tool, key, inputs) tuple. */
-  jobId: z9.string().min(1),
+  jobId: z8.string().min(1),
   /** ISO timestamp of first dispatch. */
-  createdAt: z9.iso.datetime()
+  createdAt: z8.iso.datetime()
 });
 function sha256Hex(input) {
   return createHash("sha256").update(input).digest("hex");
@@ -6432,27 +6290,27 @@ function createConsensusVoteHandler(deps) {
   };
 }
 var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
-  proposal: z10.string(),
+  proposal: z9.string(),
   strategy: VotingStrategySchema,
-  decision: z10.enum(["approved", "rejected", "no_quorum"]),
-  approvalPercentage: z10.number(),
-  voteCounts: z10.object({
-    approve: z10.number(),
-    reject: z10.number(),
-    abstain: z10.number(),
-    error: z10.number()
+  decision: z9.enum(["approved", "rejected", "no_quorum"]),
+  approvalPercentage: z9.number(),
+  voteCounts: z9.object({
+    approve: z9.number(),
+    reject: z9.number(),
+    abstain: z9.number(),
+    error: z9.number()
   }),
-  votes: z10.array(
-    z10.object({
-      role: z10.string().max(100),
-      decision: z10.enum(["approve", "reject", "abstain"]),
-      confidence: z10.number(),
-      reasoning: z10.string().max(4e3),
-      simulated: z10.boolean(),
-      error: z10.boolean(),
-      modelUsed: z10.string().max(100).optional(),
-      rejectionCategories: z10.array(
-        z10.enum([
+  votes: z9.array(
+    z9.object({
+      role: z9.string().max(100),
+      decision: z9.enum(["approve", "reject", "abstain"]),
+      confidence: z9.number(),
+      reasoning: z9.string().max(4e3),
+      simulated: z9.boolean(),
+      error: z9.boolean(),
+      modelUsed: z9.string().max(100).optional(),
+      rejectionCategories: z9.array(
+        z9.enum([
           "YAGNI",
           "DRY_VIOLATION",
           "OVER_ENGINEERING",
@@ -6465,34 +6323,34 @@ var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
     })
   ),
   threshold: VoteThresholdSchema.optional(),
-  durationMs: z10.number(),
-  simulateVotes: z10.boolean(),
-  higherOrderMetadata: z10.object({
-    posteriorApproval: z10.number(),
-    posteriorRejection: z10.number(),
-    effectiveVoteCount: z10.number(),
-    method: z10.enum(["ow", "isp", "simple"]),
-    usedCorrelationData: z10.boolean(),
-    improvementOverBaseline: z10.number(),
-    downweightedAgents: z10.array(z10.string().max(100)).max(10),
-    reasoning: z10.string().max(2e3)
+  durationMs: z9.number(),
+  simulateVotes: z9.boolean(),
+  higherOrderMetadata: z9.object({
+    posteriorApproval: z9.number(),
+    posteriorRejection: z9.number(),
+    effectiveVoteCount: z9.number(),
+    method: z9.enum(["ow", "isp", "simple"]),
+    usedCorrelationData: z9.boolean(),
+    improvementOverBaseline: z9.number(),
+    downweightedAgents: z9.array(z9.string().max(100)).max(10),
+    reasoning: z9.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: z10.string().max(200).optional()
+  policyReason: z9.string().max(200).optional()
 };
 function registerConsensusVoteTool(server, deps) {
   const logger11 = deps.logger ?? createLogger({ tool: "consensus_vote" });
   const notifier = deps.notifier ?? createMcpNotifier(server);
   const depsWithNotifier = { ...deps, notifier };
   const toolSchema = {
-    proposal: z10.string().min(1).max(MAX_PROPOSAL_LENGTH).describe("Proposal text to vote on"),
-    threshold: z10.enum(["majority", "supermajority", "unanimous"]).optional().describe("Voting threshold (legacy). Use strategy instead."),
+    proposal: z9.string().min(1).max(MAX_PROPOSAL_LENGTH).describe("Proposal text to vote on"),
+    threshold: z9.enum(["majority", "supermajority", "unanimous"]).optional().describe("Voting threshold (legacy). Use strategy instead."),
     strategy: VotingStrategySchema.optional().describe(
       "Voting strategy: simple_majority (default), supermajority, unanimous, proof_of_learning, or higher_order"
     ),
-    quickMode: z10.boolean().optional().default(false).describe("Use 3 agents instead of 7"),
-    simulateVotes: z10.boolean().optional().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
+    quickMode: z9.boolean().optional().default(false).describe("Use 3 agents instead of 7"),
+    simulateVotes: z9.boolean().optional().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
   };
   const description = "Execute multi-model consensus voting on a proposal. Uses 7 specialized agent roles (architect, security, devex, ai_ml, pm, catfish, scope_steward) to vote on proposals with configurable strategies. Supports higher_order strategy for Bayesian-optimal aggregation with correlation awareness (Issue #514).";
   const secureHandler = createSecureHandler(createConsensusVoteHandler(depsWithNotifier), {
@@ -6546,18 +6404,6 @@ export {
   VOTER_ROLES,
   NoAdapterError,
   collectRealVotes,
-  ConsensusAlgorithmSchema,
-  ProposalStatusSchema,
-  RejectionCategorySchema,
-  REJECTION_CATEGORIES,
-  VoteSchema,
-  ProposalSchema,
-  ConsensusResultSchema,
-  AgentPerformanceSchema,
-  ConsensusEngineConfigSchema,
-  DEFAULT_CONSENSUS_CONFIG,
-  VOTING_THRESHOLDS,
-  ConsensusMetricsSchema,
   VotingRoundPhaseSchema,
   VotingRoundStatusSchema,
   AgentFindingSchema,
@@ -6611,4 +6457,4 @@ export {
   CONSENSUS_VOTE_OUTPUT_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-GJ47JWNS.js.map
+//# sourceMappingURL=chunk-5KBR7SYI.js.map