nexus-agents 9.1.1 → 9.3.0

package/dist/{chunk-JU4YPMVT.js → chunk-RKSJ26NV.js}

@@ -21,24 +21,24 @@ import {
   toolSuccess,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-A2UFTOL3.js";
+} from "./chunk-P2LYE2KA.js";
 import {
   getToolMemory
-} from "./chunk-KSZAEQAZ.js";
+} from "./chunk-6JLDPMMU.js";
 import {
   allOf
 } from "./chunk-EZNIYU5T.js";
 import {
   VERSION
-} from "./chunk-7TLUEWRK.js";
+} from "./chunk-Q4L5XROB.js";
 import {
   isGatewayModelAdapter
-} from "./chunk-HK5DNXNV.js";
+} from "./chunk-B3LT4L5R.js";
 import {
   ModelBoundAdapter,
   createEvent,
   getGlobalRegistry
-} from "./chunk-3A24GW2T.js";
+} from "./chunk-NM7YEKQM.js";
 import {
   UNVERIFIABLE_STDERR_RE,
   classifyUnverifiable,
@@ -46,25 +46,25 @@ import {
   getAvailableClis,
   isAbsentSeat,
   markUnverifiable
-} from "./chunk-MW454P5G.js";
+} from "./chunk-Y3OBX752.js";
 import {
   ensureGatewayDiscovered
-} from "./chunk-ZZ63WG24.js";
+} from "./chunk-5T33FILA.js";
 import {
   CLI_TO_MODELSDEV_VENDOR,
   delay,
   getAbortObservation,
   sleep,
   withTimeout
-} from "./chunk-Z5CLWX4M.js";
+} from "./chunk-A34ANV7R.js";
 import {
   getDefaultCliCircuitBreakerRegistry
-} from "./chunk-TMCE755U.js";
+} from "./chunk-OQNKPJPJ.js";
 import {
   sanitizeErrorDetails,
   sanitizeOutput,
   sanitizeStringLeaves
-} from "./chunk-SAK2PAQD.js";
+} from "./chunk-4HUCHMSX.js";
 import {
   AgentError,
   DecisionCostStore,
@@ -121,7 +121,7 @@ import {
   servedCostDetail,
   stepBus,
   voteRecordWriteFailedMessage
-} from "./chunk-TVUPVQXD.js";
+} from "./chunk-4IJII2WG.js";
 import {
   ensureLearningDir,
   getOutcomesFile
@@ -145,7 +145,7 @@ import {
 // src/mcp/tools/consensus-vote.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { basename as basename2 } from "node:path";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // src/cli/voter-roles.ts
 var VOTER_ROLES = {
@@ -1793,6 +1793,123 @@ function warnIfSingleFamily(roleCount, assignedModels, logger12) {
   }
 }
 
+// src/cli/voter-option-reask.ts
+import { z as z2 } from "zod";
+var SelectionSchema = z2.object({
+  selectedOption: z2.string(),
+  decision: z2.literal("approve").optional()
+});
+var SELECTION_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["selectedOption"],
+  properties: { selectedOption: { type: "string" } }
+};
+function reaskRequest(seat, input) {
+  const context = buildVotePrompt(
+    input.proposal,
+    input.options,
+    input.workspace,
+    input.workspaceSha
+  );
+  return {
+    messages: [
+      { role: "system", content: getVoterPrompts(input.project)[seat.role] },
+      {
+        role: "user",
+        content: `${context}
+
+OPTION SELECTION RE-ASK (once only):
+Your original vote: ${JSON.stringify(seat.vote)}
+Your approval is final. Keep that decision and its reasoning unchanged. Only fill the missing option selection.
+Declared options: ${JSON.stringify(input.options)}
+Return only JSON: {"selectedOption": "one exact declared option"}.`
+      }
+    ],
+    maxTokens: 512,
+    temperature: 0.3,
+    timeoutMs: input.timeoutMs,
+    accessMode: VOTER_ACCESS_MODE,
+    signal: seatSignal(input.timeoutMs, input.signal),
+    ...input.workspace !== void 0 && input.workspace.trim() !== "" ? { workDir: input.workspace } : {},
+    responseFormat: { type: "json_schema", schema: SELECTION_JSON_SCHEMA }
+  };
+}
+async function askSelection(seat, input, state) {
+  state.collector.started();
+  let eventId;
+  const call = input.adapter.complete(reaskRequest(seat, input)).then((result) => {
+    if (result.ok) {
+      eventId = state.collector.settled(
+        seat.role,
+        input.adapter,
+        result.value,
+        "option_reask",
+        input.withinRoleRetry
+      );
+      state.usage = foldCompletionUsage(void 0, readVoteUsage(result.value));
+    }
+    return result;
+  });
+  const completed = await withTimeout(
+    unlessCancelled(trackVoterCompletion(call, input.signal), input.signal),
+    input.timeoutMs,
+    "Option selection re-ask timed out"
+  );
+  if (!completed.ok) throw new Error(completed.error);
+  if (!completed.value.ok) throw completed.value.error;
+  try {
+    const text = extractTextFromResponse(completed.value.value.content);
+    const parsed = SelectionSchema.parse(JSON.parse(extractJsonFromResponse(text)));
+    state.collector.classified(eventId, "parsed");
+    return matchDeclaredOption(parsed.selectedOption, input.options ?? []);
+  } catch (error) {
+    state.collector.classified(eventId, "parse_failed");
+    throw error;
+  }
+}
+function needsOptionReask(seat, input) {
+  const declared = input.options;
+  return declared !== void 0 && declared.length > 0 && seat.source === "llm" && seat.vote.decision === "approve" && seat.optionReask === void 0 && matchDeclaredOption(seat.selectedOption, declared) === void 0 && !isCancelled(input.signal);
+}
+async function reaskUnresolvedOption(seat, input) {
+  if (!needsOptionReask(seat, input)) return seat;
+  const start = getTimeProvider().now();
+  const state = { collector: new VoterAttemptCollector() };
+  let selection;
+  try {
+    selection = await askSelection(seat, input, state);
+  } catch (error) {
+    input.logger.warn("Option selection re-ask unresolved", {
+      role: seat.role,
+      error: getErrorMessage(error)
+    });
+  }
+  const resolved = selection !== void 0;
+  input.logger.info("Option selection re-ask completed", { role: seat.role, resolved });
+  const result = {
+    ...seat,
+    ...resolved ? { selectedOption: selection, vote: { ...seat.vote, selectedOption: selection } } : {},
+    optionReask: { resolved },
+    processingTimeMs: seat.processingTimeMs + getTimeProvider().now() - start,
+    attemptUsage: mergeAttemptUsage(seat.attemptUsage, state.usage)
+  };
+  return withVoterAttemptTelemetry(result, () => {
+    const prior = seat.attemptTelemetry;
+    const next = state.collector.snapshot();
+    return {
+      events: [
+        ...prior?.events ?? [],
+        ...next.events.map((event) => ({
+          ...event,
+          outcome: event.outcome === "final" ? "parsed" : event.outcome
+        }))
+      ],
+      observableAttempts: (prior?.observableAttempts ?? 0) + next.observableAttempts
+    };
+  });
+}
+
 // src/cli/voter-agents-deadline.ts
 function computeOverallConsensusDeadlineMs(timeoutMs, maxRetries, roleCount, interDelayMs) {
   const perVoteBudget = timeoutMs * (maxRetries + 1);
@@ -1914,7 +2031,24 @@ function voteBeforeDeadline(input, role, adapter, remaining) {
       }
     }
   );
-  return result.then((vote) => withVoterAttemptTelemetry(vote, () => collector.snapshot()));
+  return result.then(
+    (vote) => withVoterAttemptTelemetry(vote, () => vote.attemptTelemetry ?? collector.snapshot())
+  );
+}
+function finishOptionSelection(vote, input, context) {
+  const settings = input.voteOptions;
+  return reaskUnresolvedOption(vote, {
+    adapter: context.adapter,
+    proposal: input.proposal,
+    logger: input.logger,
+    timeoutMs: Math.min(settings.timeoutMs, Math.max(1, context.deadlineAtMs - Date.now())),
+    options: settings.declaredOptions,
+    project: settings.project,
+    workspace: settings.workspace,
+    workspaceSha: settings.workspaceSha,
+    signal: input.signal,
+    withinRoleRetry: vote.retried === true || settings.withinRoleRetry === true || settings.attemptKind === "role_retry"
+  });
 }
 async function launchRoleVote(role, index, input, voteOnAdapter, deadlineAtMs) {
   const staggerWaitMs = Math.min(input.interDelay, Math.max(0, deadlineAtMs - Date.now()));
@@ -1946,8 +2080,7 @@ async function launchRoleVote(role, index, input, voteOnAdapter, deadlineAtMs) {
   const fallback = crossCliFallback(adapter, assignedKey, primary.error ?? "");
   return stamp(preserveVoterAttemptTelemetry(recovered, { ...recovered, fallback }));
 }
-function createTimedVoteLauncher(input, deadlineAtMs) {
-  const serialize = createKeyedSerializer();
+function createTimedVoteLauncher(input, deadlineAtMs, serialize) {
   const voteOnAdapter = (role, adapter, fallback) => {
     const cli = adapterCliKey(adapter);
     const enqueuedAt = Date.now();
@@ -1981,10 +2114,23 @@ function createTimedVoteLauncher(input, deadlineAtMs) {
   };
   return voteOnAdapter;
 }
+async function reaskUnresolvedOptions(votes, input, deadlineAtMs) {
+  const serialize = createKeyedSerializer();
+  return Promise.all(
+    votes.map((vote) => {
+      const adapter = vote.timing?.attempts.at(-1)?.fallback === true ? input.fallbackAdapter : input.roleAdapters.get(vote.role) ?? input.fallbackAdapter;
+      return serialize(
+        adapterCliKey(adapter),
+        () => finishOptionSelection(vote, input, { adapter, deadlineAtMs })
+      );
+    })
+  );
+}
 async function launchVotesWithOverallDeadline(input) {
   const { roles, logger: logger12, overallDeadlineMs } = input;
   const deadlineAtMs = input.deadlineAtMs ?? Date.now() + overallDeadlineMs;
-  const voteOnAdapter = createTimedVoteLauncher(input, deadlineAtMs);
+  const serialize = createKeyedSerializer();
+  const voteOnAdapter = createTimedVoteLauncher(input, deadlineAtMs, serialize);
   const wrapped = roles.map(
     (role, index) => launchRoleVote(role, index, input, voteOnAdapter, deadlineAtMs).then((result) => {
       input.onVoteCollected?.(result);
@@ -2333,7 +2479,7 @@ async function assignPanelSeats(fallbackAdapter, options, logger12) {
 async function collectPanelPasses(input, deadline, nonRetryableRoles, backoffMs) {
   const { overallDeadlineMs, deadlineAtMs } = deadline;
   const first = await launchStaggeredVotes(input, overallDeadlineMs, deadlineAtMs);
-  return retryErroredRoles(
+  const final = await retryErroredRoles(
     first,
     (roles) => launchStaggeredVotes(
       { ...input, roles, voteOptions: { ...input.voteOptions, attemptKind: "role_retry" } },
@@ -2344,6 +2490,7 @@ async function collectPanelPasses(input, deadline, nonRetryableRoles, backoffMs)
     backoffMs,
     { signal: input.signal, deadlineAtMs, nonRetryableRoles }
   );
+  return reaskUnresolvedOptions(final, input, deadlineAtMs);
 }
 async function collectRealVotes(options) {
   const logger12 = options.logger ?? defaultLogger;
@@ -2442,9 +2589,9 @@ ${content}
 // 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;
@@ -2609,40 +2756,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,
@@ -2655,30 +2802,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,
@@ -2693,7 +2840,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}`;
 }
@@ -2704,43 +2851,43 @@ 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),
-  independenceThreshold: z5.number().min(0).max(1).default(0.2),
-  fallbackToSimpleVoting: z5.boolean().default(true),
-  maxObservationsPerAgent: z5.number().int().positive().default(1e3),
-  maxProposals: z5.number().int().positive().default(5e3),
-  maxTrackedPairs: z5.number().int().positive().default(100)
+var HigherOrderVotingConfigSchema = z6.object({
+  minObservationsForCorrelation: z6.number().int().positive().default(10),
+  correlationThreshold: z6.number().min(0).max(1).default(0.3),
+  independenceThreshold: z6.number().min(0).max(1).default(0.2),
+  fallbackToSimpleVoting: z6.boolean().default(true),
+  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,
@@ -2751,25 +2898,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
@@ -5677,24 +5824,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 = [];
@@ -5936,10 +6083,10 @@ function createPersistentCorrelationTracker(config) {
 }
 
 // src/mcp/tools/consensus-vote-types.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/mcp/tools/async-dispatch-input.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var DISPATCH_MODES = ["sync", "async"];
 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).';
@@ -5947,12 +6094,12 @@ function describeDispatch(note) {
   return note === void 0 ? DISPATCH_DESCRIPTION : `${DISPATCH_DESCRIPTION} ${note}`;
 }
 function dispatchField(note) {
-  return z7.enum(DISPATCH_MODES).optional().describe(describeDispatch(note));
+  return z8.enum(DISPATCH_MODES).optional().describe(describeDispatch(note));
 }
 function dispatchFieldDefaultSync(note) {
-  return z7.enum(DISPATCH_MODES).default("sync").describe(describeDispatch(note));
+  return z8.enum(DISPATCH_MODES).default("sync").describe(describeDispatch(note));
 }
-var REJECTED_MODE_KEY = z7.never({ error: WRONG_KEY_MODE_MESSAGE }).optional().describe(
+var REJECTED_MODE_KEY = z8.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) {
@@ -6095,7 +6242,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", "higher_order", "opinion_wise"],
   {
     error: (issue) => issue.input === "proof_of_learning" ? RETIRED_CONSENSUS_STRATEGY_MESSAGE : void 0
@@ -6108,21 +6255,21 @@ 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.'
   ),
-  artifactPath: z8.string().min(1).max(4096).optional().describe(
+  artifactPath: z9.string().min(1).max(4096).optional().describe(
     "UTF-8 artifact file within the repository root (server cwd). Its content is inlined into every seat's proposal with a SHA-256 digest; maximum 256 KiB. Missing, empty, binary (NUL byte), oversized, and escaping paths are rejected. Seats read the inlined text, not the tree."
   ),
-  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,
@@ -6135,8 +6282,8 @@ 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)"
   ),
   /**
@@ -6178,7 +6325,7 @@ var ConsensusVoteInputSchema = z8.object({
    * 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."
   ),
   /**
@@ -6190,7 +6337,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."
   ),
   /**
@@ -6207,14 +6354,14 @@ var ConsensusVoteInputSchema = z8.object({
     "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([
+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":
@@ -6494,7 +6641,7 @@ function logPartialProposal(bounded, log) {
 }
 async function runContrarianCheck(proposal, options, log, opts) {
   try {
-    const { executeExpert } = await import("./expert-bridge-S4LEWNOQ.js");
+    const { executeExpert } = await import("./expert-bridge-E6HHFKGF.js");
     const bounded = boundArtifactForReview(proposal, CONTRARIAN_PROPOSAL_BUDGET, "proposal");
     logPartialProposal(bounded, log);
     const result = await executeExpert(
@@ -6678,20 +6825,20 @@ async function withFileLock(lockPath, body, options = {}) {
 }
 
 // src/mcp/jobs/job-cancelled-partial-schema.ts
-import { z as z9 } from "zod";
-var CancelledPartialSchema = z9.strictObject({
-  partialVotes: z9.array(z9.unknown()),
-  seatsCast: z9.number().int().nonnegative(),
-  panelSize: z9.number().int().nonnegative()
+import { z as z10 } from "zod";
+var CancelledPartialSchema = z10.strictObject({
+  partialVotes: z10.array(z10.unknown()),
+  seatsCast: z10.number().int().nonnegative(),
+  panelSize: z10.number().int().nonnegative()
 });
 
 // src/mcp/jobs/job-result-store.ts
 import { existsSync as existsSync4, readdirSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2, chmodSync, mkdirSync as mkdirSync2 } from "node:fs";
 import { dirname as dirname2 } from "node:path";
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // src/mcp/jobs/job-id.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var JOB_ID_MAX_LENGTH = 128;
 var JOB_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
 function isValidJobId(jobId) {
@@ -6703,26 +6850,26 @@ function assertValidJobId(jobId) {
   }
 }
 function jobIdSchema(description) {
-  return z10.string().min(1).max(JOB_ID_MAX_LENGTH).regex(JOB_ID_PATTERN, 'jobId must contain only letters, digits, "_" and "-"').describe(description);
+  return z11.string().min(1).max(JOB_ID_MAX_LENGTH).regex(JOB_ID_PATTERN, 'jobId must contain only letters, digits, "_" and "-"').describe(description);
 }
 
 // src/mcp/jobs/job-idempotency.ts
 import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
 import { existsSync as existsSync2, readFileSync as readFileSync4, writeFileSync } from "node:fs";
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var logger6 = createLogger({ component: "job-idempotency" });
-var IdempotencyIndexEntrySchema = z11.object({
-  v: z11.literal(1),
+var IdempotencyIndexEntrySchema = z12.object({
+  v: z12.literal(1),
   /** MCP tool name (e.g. `orchestrate`, `run_workflow`, `consensus_vote`). */
-  tool: z11.string().min(1),
+  tool: z12.string().min(1),
   /** Caller-supplied idempotency key. */
-  key: z11.string().min(1),
+  key: z12.string().min(1),
   /** sha256 of the canonical input JSON. */
-  inputsHash: z11.string().length(64),
+  inputsHash: z12.string().length(64),
   /** Existing jobId for this (tool, key, inputs) tuple. */
-  jobId: z11.string().min(1),
+  jobId: z12.string().min(1),
   /** ISO timestamp of first dispatch. */
-  createdAt: z11.iso.datetime()
+  createdAt: z12.iso.datetime()
 });
 function sha256Hex(input) {
   return createHash2("sha256").update(input).digest("hex");
@@ -6949,14 +7096,14 @@ function syncAlternateCandidates(jobId, primaryPath, record, logger12, persistFn
 }
 
 // src/mcp/jobs/job-failure-detail.ts
-import { z as z12 } from "zod";
-var JobFailureDetailSchema = z12.object({
+import { z as z13 } from "zod";
+var JobFailureDetailSchema = z13.object({
   /** Identifier of the failing adapter (e.g. 'claude', 'codex', 'api:anthropic'). */
-  adapter: z12.string().min(1),
+  adapter: z13.string().min(1),
   /** Transport mechanism where the failure occurred (e.g. 'subprocess', 'mcp', 'stdio'). */
-  transport: z12.string().min(1),
+  transport: z13.string().min(1),
   /** Normalized failure category (e.g. 'rate_limited', 'timeout', 'capacity_exhausted'). */
-  category: z12.string().min(1)
+  category: z13.string().min(1)
 });
 function isRecord(value) {
   return typeof value === "object" && value !== null;
@@ -7028,28 +7175,28 @@ function validateAndSanitizeFailureDetail(detail) {
 
 // src/mcp/jobs/job-result-store.ts
 var logger7 = createLogger({ component: "job-result-store" });
-var JobStatusSchema = z13.enum(["pending", "complete", "failed", "cancelled"]);
-var JobResultSchema = z13.object({
+var JobStatusSchema = z14.enum(["pending", "complete", "failed", "cancelled"]);
+var JobResultSchema = z14.object({
   /** Format version. Currently `1` — bump if the shape changes. */
-  v: z13.literal(1),
-  jobId: z13.string().min(1),
+  v: z14.literal(1),
+  jobId: z14.string().min(1),
   /** Tool that was invoked (e.g. `orchestrate`). */
-  toolName: z13.string().min(1),
+  toolName: z14.string().min(1),
   status: JobStatusSchema,
-  createdAt: z13.iso.datetime(),
+  createdAt: z14.iso.datetime(),
   /** Set when the job leaves `pending` — either via `complete` or `failed` or `cancelled`. */
-  completedAt: z13.iso.datetime().optional(),
+  completedAt: z14.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: z13.unknown().optional(),
+  result: z14.unknown().optional(),
   /**
    * Failure message when `status === 'failed'`. Cannot be paired with
    * `result` — the discriminator is `status`.
    */
-  error: z13.string().optional(),
+  error: z14.string().optional(),
   /**
    * Structured failure detail when `status === 'failed'` (#4375).
    * Holds normalized adapter, transport, and category information without
@@ -7064,7 +7211,7 @@ var JobResultSchema = z13.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: z13.literal("abandoned").optional(),
+  errorKind: z14.literal("abandoned").optional(),
   /**
    * Whether the tool's `run` callback accepts `runAsJob`'s `AbortSignal`
    * (#4972).
@@ -7080,7 +7227,7 @@ var JobResultSchema = z13.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: z13.boolean().optional(),
+  signalAccepted: z14.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.
@@ -7101,7 +7248,7 @@ var JobResultSchema = z13.object({
    * `'dev'` — readers MUST run it through {@link isMeasuredBuildVersion}
    * before treating two stamps as comparable.
    */
-  producerVersion: z13.string().optional(),
+  producerVersion: z14.string().optional(),
   /**
    * When the job body last heartbeat — `runAsJob`'s `progress()` callback,
    * `heartbeatJob`, or a pipeline-bus event the body emitted (#6162). Present
@@ -7113,7 +7260,7 @@ var JobResultSchema = z13.object({
    * `run-as-job.ts` fails a body that stops heartbeating as wedged, measuring
    * silence from this stamp (or from job start when there is none).
    */
-  lastProgressAt: z13.iso.datetime().optional(),
+  lastProgressAt: z14.iso.datetime().optional(),
   /**
    * What a cancelled vote had collected when `cancel_job` fired (#6735).
    * Present only on a `cancelled` record, and only when the body settled after
@@ -8072,8 +8219,8 @@ import * as path from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
 
 // src/context/structured-task-state-types.ts
-import { z as z14 } from "zod";
-var TaskStageSchema = z14.enum([
+import { z as z15 } from "zod";
+var TaskStageSchema = z15.enum([
   "planning",
   "executing",
   "verifying",
@@ -8085,59 +8232,59 @@ var TaskStageSchema = z14.enum([
   // failed run in StructuredTaskState instead of the Stage-1 sidecar.
   "failed"
 ]);
-var TaskDecisionSchema = z14.object({
-  ts: z14.iso.datetime(),
-  decision: z14.string().min(1),
-  rationale: z14.string().min(1)
+var TaskDecisionSchema = z15.object({
+  ts: z15.iso.datetime(),
+  decision: z15.string().min(1),
+  rationale: z15.string().min(1)
 });
-var TaskBlockerSchema = z14.object({
-  ts: z14.iso.datetime(),
-  blocker: z14.string().min(1),
-  resolved: z14.iso.datetime().optional()
+var TaskBlockerSchema = z15.object({
+  ts: z15.iso.datetime(),
+  blocker: z15.string().min(1),
+  resolved: z15.iso.datetime().optional()
 });
-var TaskPositionSchema = z14.object({
-  currentStep: z14.string().min(1),
-  nextStep: z14.string().optional()
+var TaskPositionSchema = z15.object({
+  currentStep: z15.string().min(1),
+  nextStep: z15.string().optional()
 });
-var TaskLedgerSchema = z14.object({
+var TaskLedgerSchema = z15.object({
   /** Verifiable observations: what we have observed/measured/confirmed. */
-  facts: z14.array(z14.string()),
+  facts: z15.array(z15.string()),
   /** Working assumptions: useful guesses we proceed under, marked separately. */
-  guesses: z14.array(z14.string()),
+  guesses: z15.array(z15.string()),
   /** Things we still need to figure out before the plan is sound. */
-  openQuestions: z14.array(z14.string()),
-  updatedAt: z14.iso.datetime()
+  openQuestions: z15.array(z15.string()),
+  updatedAt: z15.iso.datetime()
 });
-var ReflectActionSchema = z14.enum(["continue", "revise_plan", "escalate_to_human", "abort"]);
-var ProgressLedgerEntrySchema = z14.object({
-  ts: z14.iso.datetime(),
+var ReflectActionSchema = z15.enum(["continue", "revise_plan", "escalate_to_human", "abort"]);
+var ProgressLedgerEntrySchema = z15.object({
+  ts: z15.iso.datetime(),
   /** What just happened (the step we are reflecting on). */
-  step: z14.string().min(1),
+  step: z15.string().min(1),
   /** Is the outer Task Ledger plan still right after this step? */
-  planStillValid: z14.boolean(),
+  planStillValid: z15.boolean(),
   /** Are we making progress, or have we stalled? */
-  stuck: z14.boolean(),
+  stuck: z15.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: z14.string().min(1)
+  rationale: z15.string().min(1)
 });
-var TaskCancellationSchema = z14.object({
-  requestedAt: z14.iso.datetime(),
+var TaskCancellationSchema = z15.object({
+  requestedAt: z15.iso.datetime(),
   /** Optional human-readable note carried back to the caller. */
-  reason: z14.string().max(1e3).optional()
+  reason: z15.string().max(1e3).optional()
 });
 var TASK_RESULT_MAX_BYTES = 1048576;
-var StructuredTaskStateSchema = z14.object({
-  taskId: z14.string().min(1),
+var StructuredTaskStateSchema = z15.object({
+  taskId: z15.string().min(1),
   /**
    * Marks state created by the shared async-job dispatcher (#5622).
    * Optional for backward compatibility; absence does not prove async dispatch.
    */
-  dispatch: z14.literal("async").optional(),
+  dispatch: z15.literal("async").optional(),
   stage: TaskStageSchema,
-  decisions: z14.array(TaskDecisionSchema),
-  blockers: z14.array(TaskBlockerSchema),
+  decisions: z15.array(TaskDecisionSchema),
+  blockers: z15.array(TaskBlockerSchema),
   position: TaskPositionSchema,
   /**
    * Magentic-One Task Ledger (#2278). Mutable single-object outer-loop state:
@@ -8150,7 +8297,7 @@ var StructuredTaskStateSchema = z14.object({
    * Most recent entry's `suggestedAction` is what `reflect()` returns. Optional
    * for the same backward-compat reason as `taskLedger`.
    */
-  progressLedger: z14.array(ProgressLedgerEntrySchema).optional(),
+  progressLedger: z15.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
@@ -8160,7 +8307,7 @@ var StructuredTaskStateSchema = z14.object({
    * state logs (pre-Stage-2) don't carry it; the reducer treats their
    * baseline as v0 and starts counting from there.
    */
-  version: z14.number().int().nonnegative().optional(),
+  version: z15.number().int().nonnegative().optional(),
   /**
    * Tool result payload (#3043 / epic #2631 Stage 2). Set atomically
    * via the `result` log event when `stage === 'complete'`. Carries the
@@ -8176,7 +8323,7 @@ var StructuredTaskStateSchema = z14.object({
    * field, then the sidecar files become legacy that the next cleanup
    * sweep can remove.
    */
-  result: z14.unknown().optional(),
+  result: z15.unknown().optional(),
   /**
    * Cancellation marker (#3043 / epic #2631 Stage 2). Set by `cancel_job`
    * — the running tool checks for this at safe-point boundaries (between
@@ -8193,70 +8340,70 @@ var StructuredTaskStateSchema = z14.object({
    * transition has been recorded. Optional for backward-compat with
    * pre-#3090 logs (the reducer backfills it from the init entry).
    */
-  createdAt: z14.iso.datetime().optional(),
-  updatedAt: z14.iso.datetime()
+  createdAt: z15.iso.datetime().optional(),
+  updatedAt: z15.iso.datetime()
 });
-var StructuredTaskLogEntrySchema = z14.discriminatedUnion("event", [
-  z14.object({
-    event: z14.literal("init"),
-    ts: z14.iso.datetime(),
+var StructuredTaskLogEntrySchema = z15.discriminatedUnion("event", [
+  z15.object({
+    event: z15.literal("init"),
+    ts: z15.iso.datetime(),
     state: StructuredTaskStateSchema
   }),
-  z14.object({
-    event: z14.literal("decision"),
-    ts: z14.iso.datetime(),
+  z15.object({
+    event: z15.literal("decision"),
+    ts: z15.iso.datetime(),
     decision: TaskDecisionSchema
   }),
-  z14.object({
-    event: z14.literal("blocker"),
-    ts: z14.iso.datetime(),
+  z15.object({
+    event: z15.literal("blocker"),
+    ts: z15.iso.datetime(),
     blocker: TaskBlockerSchema
   }),
-  z14.object({
-    event: z14.literal("blocker_resolved"),
-    ts: z14.iso.datetime(),
+  z15.object({
+    event: z15.literal("blocker_resolved"),
+    ts: z15.iso.datetime(),
     /** Index of the blocker in the state's blockers[] array. */
-    blockerIndex: z14.number().int().nonnegative(),
-    resolvedAt: z14.iso.datetime()
+    blockerIndex: z15.number().int().nonnegative(),
+    resolvedAt: z15.iso.datetime()
   }),
-  z14.object({
-    event: z14.literal("stage"),
-    ts: z14.iso.datetime(),
+  z15.object({
+    event: z15.literal("stage"),
+    ts: z15.iso.datetime(),
     stage: TaskStageSchema
   }),
-  z14.object({
-    event: z14.literal("position"),
-    ts: z14.iso.datetime(),
+  z15.object({
+    event: z15.literal("position"),
+    ts: z15.iso.datetime(),
     position: TaskPositionSchema
   }),
   // Magentic-One Task Ledger replacement event — the outer loop revises the
   // entire ledger atomically when replanning. Always replaces, never partial.
-  z14.object({
-    event: z14.literal("task_ledger"),
-    ts: z14.iso.datetime(),
+  z15.object({
+    event: z15.literal("task_ledger"),
+    ts: z15.iso.datetime(),
     ledger: TaskLedgerSchema
   }),
   // Magentic-One Progress Ledger append event — one self-reflection per step.
-  z14.object({
-    event: z14.literal("progress_ledger"),
-    ts: z14.iso.datetime(),
+  z15.object({
+    event: z15.literal("progress_ledger"),
+    ts: z15.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.
-  z14.object({
-    event: z14.literal("result"),
-    ts: z14.iso.datetime(),
-    result: z14.unknown()
+  z15.object({
+    event: z15.literal("result"),
+    ts: z15.iso.datetime(),
+    result: z15.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.
-  z14.object({
-    event: z14.literal("cancellation"),
-    ts: z14.iso.datetime(),
+  z15.object({
+    event: z15.literal("cancellation"),
+    ts: z15.iso.datetime(),
     cancellation: TaskCancellationSchema
   })
 ]);
@@ -9300,7 +9447,7 @@ async function runSyncConsensusVote(deps, notifier, args) {
     approvalPercentage: result.value.approvalPercentage,
     voteCount: result.value.votes.length
   });
-  return structuredToolSuccess(z15.object(CONSENSUS_VOTE_OUTPUT_SCHEMA), { ...result.value });
+  return structuredToolSuccess(z16.object(CONSENSUS_VOTE_OUTPUT_SCHEMA), { ...result.value });
 }
 async function prepareVoteArtifact(input) {
   if (input.artifactPath === void 0) return { ok: true, value: input };
@@ -9370,18 +9517,18 @@ function createConsensusVoteHandler(deps) {
   };
 }
 var ASYNC_ENVELOPES = {
-  pending: (jobId) => structuredToolSuccess(z15.object(CONSENSUS_VOTE_OUTPUT_SCHEMA), {
+  pending: (jobId) => structuredToolSuccess(z16.object(CONSENSUS_VOTE_OUTPUT_SCHEMA), {
     status: "pending",
     jobId,
     pollTool: "get_job_result",
     note: 'Poll via get_job_result({ jobId }) until status !== "pending".'
   }),
-  busy: (retryAfterMs, toolName) => structuredToolSuccess(z15.object(CONSENSUS_VOTE_OUTPUT_SCHEMA), {
+  busy: (retryAfterMs, toolName) => structuredToolSuccess(z16.object(CONSENSUS_VOTE_OUTPUT_SCHEMA), {
     status: "busy",
     retryAfterMs,
     note: `Async-mode concurrency cap reached for ${toolName}. Retry later or use dispatch: "sync".`
   }),
-  replay: (jobId) => structuredToolSuccess(z15.object(CONSENSUS_VOTE_OUTPUT_SCHEMA), {
+  replay: (jobId) => structuredToolSuccess(z16.object(CONSENSUS_VOTE_OUTPUT_SCHEMA), {
     status: "replay",
     jobId,
     pollTool: "get_job_result",
@@ -9391,56 +9538,56 @@ var ASYNC_ENVELOPES = {
 };
 var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
   /** Async-dispatch envelope discriminator — absent on a completed vote. */
-  status: z15.enum(["pending", "busy", "replay"]).optional(),
-  jobId: z15.string().max(200).optional(),
-  pollTool: z15.literal("get_job_result").optional(),
-  note: z15.string().max(500).optional(),
-  retryAfterMs: z15.number().optional(),
-  proposal: z15.string().optional(),
+  status: z16.enum(["pending", "busy", "replay"]).optional(),
+  jobId: z16.string().max(200).optional(),
+  pollTool: z16.literal("get_job_result").optional(),
+  note: z16.string().max(500).optional(),
+  retryAfterMs: z16.number().optional(),
+  proposal: z16.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: z15.number().optional(),
-  voteCounts: z15.object({
-    approve: z15.number(),
-    reject: z15.number(),
-    abstain: z15.number(),
-    error: z15.number(),
+  approvalPercentage: z16.number().optional(),
+  voteCounts: z16.object({
+    approve: z16.number(),
+    reject: z16.number(),
+    abstain: z16.number(),
+    error: z16.number(),
     /** #6094: seats that could not read the artifact; always present. */
-    unverifiable: z15.number()
+    unverifiable: z16.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: z15.array(
-    z15.object({
-      role: z15.string().max(100),
-      decision: z15.enum(["approve", "reject", "abstain"]),
-      confidence: z15.number(),
-      reasoning: z15.string().max(4e3),
-      simulated: z15.boolean(),
-      error: z15.boolean(),
-      retried: z15.boolean().optional(),
-      retriedFrom: z15.object({
-        source: z15.enum(["error", "unverifiable"]),
-        error: z15.string().optional(),
-        errorTruncated: z15.literal(true).optional()
+  votes: z16.array(
+    z16.object({
+      role: z16.string().max(100),
+      decision: z16.enum(["approve", "reject", "abstain"]),
+      confidence: z16.number(),
+      reasoning: z16.string().max(4e3),
+      simulated: z16.boolean(),
+      error: z16.boolean(),
+      retried: z16.boolean().optional(),
+      retriedFrom: z16.object({
+        source: z16.enum(["error", "unverifiable"]),
+        error: z16.string().optional(),
+        errorTruncated: z16.literal(true).optional()
       }).optional(),
       /** #6094: present only when the seat could not read the artifact. */
-      unverifiable: z15.literal(true).optional(),
+      unverifiable: z16.literal(true).optional(),
       /** #6115: present only when the seat answered elsewhere than assigned. */
-      fallback: z15.object({
-        fromCli: z15.string().max(100),
-        fromModel: z15.string().max(100).optional(),
-        reason: z15.enum(["rate-limit", "capacity", "auth", "timeout", "sandbox", "unknown"])
+      fallback: z16.object({
+        fromCli: z16.string().max(100),
+        fromModel: z16.string().max(100).optional(),
+        reason: z16.enum(["rate-limit", "capacity", "auth", "timeout", "sandbox", "unknown"])
       }).optional(),
-      modelUsed: z15.string().max(100).optional(),
-      assignedModel: z15.string().max(100).optional(),
-      rejectionCategories: z15.array(
-        z15.enum([
+      modelUsed: z16.string().max(100).optional(),
+      assignedModel: z16.string().max(100).optional(),
+      rejectionCategories: z16.array(
+        z16.enum([
           "YAGNI",
           "DRY_VIOLATION",
           "OVER_ENGINEERING",
@@ -9453,64 +9600,64 @@ var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
     })
   ).optional(),
   threshold: VoteThresholdSchema.optional(),
-  durationMs: z15.number().optional(),
-  simulateVotes: z15.boolean().optional(),
+  durationMs: z16.number().optional(),
+  simulateVotes: z16.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: z15.object({
-    name: z15.string().max(200),
-    source: z15.enum(["input", "derived", "default"])
+  project: z16.object({
+    name: z16.string().max(200),
+    source: z16.enum(["input", "derived", "default"])
   }).optional(),
   // #6258: the working directory the panel's seats were pointed at. Absent
   // when no live seat ran (simulated panel) and on the async envelope.
-  workspace: z15.string().max(4096).optional(),
-  higherOrderMetadata: z15.object({
-    posteriorApproval: z15.number(),
-    posteriorRejection: z15.number(),
-    effectiveVoteCount: z15.number(),
-    method: z15.enum(["ow", "isp", "simple"]),
-    appliedToDecision: z15.boolean(),
-    usedCorrelationData: z15.boolean(),
-    improvementOverBaseline: z15.number(),
-    downweightedAgents: z15.array(z15.string().max(100)).max(10),
-    reasoning: z15.string().max(2e3)
+  workspace: z16.string().max(4096).optional(),
+  higherOrderMetadata: z16.object({
+    posteriorApproval: z16.number(),
+    posteriorRejection: z16.number(),
+    effectiveVoteCount: z16.number(),
+    method: z16.enum(["ow", "isp", "simple"]),
+    appliedToDecision: z16.boolean(),
+    usedCorrelationData: z16.boolean(),
+    improvementOverBaseline: z16.number(),
+    downweightedAgents: z16.array(z16.string().max(100)).max(10),
+    reasoning: z16.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: z15.string().max(200).optional(),
+  policyReason: z16.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: z15.boolean().optional(),
-  voteRecordNote: z15.string().max(500).optional(),
+  voteRecordPersisted: z16.boolean().optional(),
+  voteRecordNote: z16.string().max(500).optional(),
   // #5130: the persisted record's id, so the caller-commits script can name it.
-  voteRecordId: z15.string().max(200).optional(),
+  voteRecordId: z16.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: z15.string().optional(),
+  panelWarning: z16.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: z15.object({
-    distinctModels: z15.number().int().nonnegative(),
+  panelDiversity: z16.object({
+    distinctModels: z16.number().int().nonnegative(),
     // #6606: distinct vendor families among the answering seats, and the
     // answering seats whose model names no recognised vendor.
-    distinctFamilies: z15.number().int().nonnegative(),
-    unclassifiedSeats: z15.number().int().nonnegative(),
+    distinctFamilies: z16.number().int().nonnegative(),
+    unclassifiedSeats: z16.number().int().nonnegative(),
     // #6660: answering seats whose model never resolved. Always set by
     // panelDiversityOf; optional so the published schema widens additively.
-    unresolvedSeats: z15.number().int().nonnegative().optional(),
-    fallbacks: z15.number().int().nonnegative()
+    unresolvedSeats: z16.number().int().nonnegative().optional(),
+    fallbacks: z16.number().int().nonnegative()
   }).optional(),
   // Assigned roster includes errored and abstaining seats. Absent when no
   // assignment resolved, including a zero-seat roster.
-  assignedDistinctModels: z15.number().int().nonnegative().optional(),
-  assignedDistinctFamilies: z15.number().int().nonnegative().optional(),
+  assignedDistinctModels: z16.number().int().nonnegative().optional(),
+  assignedDistinctFamilies: z16.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`
   // billing mode). Shared schema lives with the type (single source of truth).
@@ -9518,18 +9665,18 @@ 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: z15.object({
-    tally: z15.array(z15.object({ option: z15.string(), count: z15.number().int().nonnegative() })),
-    leadingOption: z15.string().optional(),
-    leadingShare: z15.number().min(0).max(1),
-    approverCount: z15.number().int().nonnegative(),
-    selectedCount: z15.number().int().nonnegative(),
-    unattributedApprovals: z15.number().int().nonnegative(),
-    thresholdMet: z15.boolean(),
+  optionOutcome: z16.object({
+    tally: z16.array(z16.object({ option: z16.string(), count: z16.number().int().nonnegative() })),
+    leadingOption: z16.string().optional(),
+    leadingShare: z16.number().min(0).max(1),
+    approverCount: z16.number().int().nonnegative(),
+    selectedCount: z16.number().int().nonnegative(),
+    unattributedApprovals: z16.number().int().nonnegative(),
+    thresholdMet: z16.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: z15.string().max(400).optional()
+    vetoReason: z16.string().max(400).optional()
   }).optional()
 };
 var CONSENSUS_VOTE_TOOL_SCHEMA = ConsensusVoteInputSchema.shape;
@@ -9630,6 +9777,7 @@ export {
   createOWVoting,
   HigherOrderVotingStrategy,
   createHigherOrderVotingStrategy,
+  evaluateThreshold,
   determineFinalStatus,
   mapOutcomeToDecision,
   SimpleMajorityStrategy,
@@ -9676,4 +9824,4 @@ export {
   CONSENSUS_VOTE_TOOL_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-JU4YPMVT.js.map
+//# sourceMappingURL=chunk-RKSJ26NV.js.map