nexus-agents 3.3.2 → 3.4.0

package/dist/{chunk-VSFWQHRX.js → chunk-CFK4VK2M.js}

@@ -21,7 +21,7 @@ import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-LVFYELQU.js";
+} from "./chunk-FHTU4BSP.js";
 import {
   executeExpert
 } from "./chunk-H3B6BSBZ.js";
@@ -45,7 +45,7 @@ import {
   simulationDeniedResult,
   toJobSummary,
   writeJobCancelled
-} from "./chunk-RAYKASM4.js";
+} from "./chunk-XL6T3HTN.js";
 import {
   normalizeTopicToCanonical,
   synthesizeResearch
@@ -59,7 +59,7 @@ import {
 } from "./chunk-G2C4WNK7.js";
 import {
   withPrerequisite
-} from "./chunk-3T3TZZKG.js";
+} from "./chunk-JEV6RUUH.js";
 import {
   NOOP_NOTIFIER,
   RateLimiter,
@@ -82,7 +82,7 @@ import {
   withAuditTrail,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-UNDYHLRR.js";
+} from "./chunk-2KVTXC7Y.js";
 import {
   createAuditTrail,
   createGraphAuditBridge,
@@ -45787,7 +45787,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-UF73LBG6.js");
+        const { executeVoting } = await import("./consensus-vote-EIEPPKAD.js");
         const votingResult = await executeVoting(
           {
             proposal: buildVoteProposal(plan, research),
@@ -54166,4 +54166,4 @@ export {
   shutdownFeedbackSubscriber,
   createEventBusBridge
 };
-//# sourceMappingURL=chunk-VSFWQHRX.js.map
+//# sourceMappingURL=chunk-CFK4VK2M.js.map

package/dist/{chunk-LVFYELQU.js → chunk-FHTU4BSP.js}

@@ -49,7 +49,7 @@ import {
 } from "./chunk-OQLFRJCW.js";
 
 // src/version.ts
-var VERSION = true ? "3.3.2" : "dev";
+var VERSION = true ? "3.4.0" : "dev";
 
 // src/config/schemas-core.ts
 import { z } from "zod";
@@ -2253,7 +2253,7 @@ async function runDoctorFix(result) {
   writeLine2("\u2500".repeat(40));
   let fixCount = 0;
   if (!result.dataDirectory.rootExists || result.dataDirectory.subdirectories.some((d) => !d.exists || !d.writable)) {
-    const { runSetup } = await import("./setup-command-COUBH2NS.js");
+    const { runSetup } = await import("./setup-command-CYZO22RO.js");
     const setupResult = runSetup({
       skipMcp: true,
       skipRules: true,
@@ -2366,4 +2366,4 @@ export {
   startStdioServer,
   closeServer
 };
-//# sourceMappingURL=chunk-LVFYELQU.js.map
+//# sourceMappingURL=chunk-FHTU4BSP.js.map

package/dist/{chunk-3T3TZZKG.js → chunk-JEV6RUUH.js}

@@ -7,7 +7,7 @@ import {
   toolStructuredError,
   toolSuccessStructured,
   wrapToolWithTimeout
-} from "./chunk-UNDYHLRR.js";
+} from "./chunk-2KVTXC7Y.js";
 import {
   JsonlStore,
   SECURITY_KEYWORDS,
@@ -2132,4 +2132,4 @@ export {
   runImprovementReview,
   registerImprovementReviewTool
 };
-//# sourceMappingURL=chunk-3T3TZZKG.js.map
+//# sourceMappingURL=chunk-JEV6RUUH.js.map

package/dist/{chunk-RA5L4BVA.js → chunk-QAEBYGSP.js}

@@ -8,7 +8,7 @@ import {
   checkSqlite,
   defaultConfig,
   initDataDirectories
-} from "./chunk-LVFYELQU.js";
+} from "./chunk-FHTU4BSP.js";
 import {
   BUILT_IN_EXPERTS
 } from "./chunk-YPNQPT2F.js";
@@ -2001,4 +2001,4 @@ export {
   setupCommand,
   setupCommandAsync
 };
-//# sourceMappingURL=chunk-RA5L4BVA.js.map
+//# sourceMappingURL=chunk-QAEBYGSP.js.map

package/dist/{chunk-RAYKASM4.js → chunk-XL6T3HTN.js}

@@ -18,7 +18,7 @@ import {
   toolSuccess,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-UNDYHLRR.js";
+} from "./chunk-2KVTXC7Y.js";
 import {
   createEvent,
   getGlobalRegistry
@@ -369,6 +369,57 @@ var SIMULATED_VOTE_REASONING = {
 
 // src/cli/voter-response.ts
 import { z } from "zod";
+
+// src/consensus/option-tally.ts
+var SUPERMAJORITY_SHARE = 2 / 3;
+var MAJORITY_SHARE = 0.5;
+function matchDeclaredOption(raw, declaredOptions) {
+  if (raw === void 0) return void 0;
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "") return void 0;
+  return declaredOptions.find((option) => option.trim().toLowerCase() === normalized);
+}
+function tallyOptions(votes, declaredOptions) {
+  const approvers = votes.filter((v) => v.decision === "approve");
+  const counts = /* @__PURE__ */ new Map();
+  let selectedCount = 0;
+  for (const vote of approvers) {
+    const matched = matchDeclaredOption(vote.selectedOption, declaredOptions);
+    if (matched === void 0) continue;
+    selectedCount += 1;
+    counts.set(matched, (counts.get(matched) ?? 0) + 1);
+  }
+  const tally = [...counts.entries()].map(([option, count]) => ({ option, count })).sort((a, b) => b.count !== a.count ? b.count - a.count : a.option.localeCompare(b.option));
+  const leader = tally[0];
+  const approverCount = approvers.length;
+  const leadingCount = leader?.count ?? 0;
+  return {
+    tally,
+    ...leader !== void 0 ? { leadingOption: leader.option } : {},
+    leadingCount,
+    approverCount,
+    selectedCount,
+    unattributedApprovals: approverCount - selectedCount,
+    leadingShare: approverCount > 0 ? leadingCount / approverCount : 0
+  };
+}
+function evaluateOptionThreshold(tally, threshold) {
+  const approved = clears(tally, threshold);
+  return { ...tally, threshold, approved };
+}
+function clears(tally, threshold) {
+  if (tally.approverCount === 0 || tally.leadingCount === 0) return false;
+  switch (threshold) {
+    case "unanimous":
+      return tally.leadingCount === tally.approverCount;
+    case "supermajority":
+      return tally.leadingShare >= SUPERMAJORITY_SHARE;
+    case "majority":
+      return tally.leadingShare > MAJORITY_SHARE;
+  }
+}
+
+// src/cli/voter-response.ts
 var SyntheticVoteError = class extends Error {
   constructor(reason, rawOutput) {
     super(`Vote response parsing failed: ${reason}`);
@@ -408,7 +459,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: z.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")
 });
 var VOTE_JSON_SCHEMA = {
   type: "object",
@@ -437,6 +492,12 @@ var VOTE_JSON_SCHEMA = {
       items: { type: "string" },
       description: "Optional conditions for approval"
     },
+    // #4472: without this, `additionalProperties: false` makes it impossible
+    // for a structured-output voter to emit a selection at all.
+    selectedOption: {
+      type: "string",
+      description: "Which declared option you choose (multi-option proposals only)"
+    },
     rejectionCategories: {
       type: "array",
       items: {
@@ -544,12 +605,12 @@ Example PR-review request_changes response with structured findings:
     }
   ]
 }`;
-function buildVotePrompt(proposal) {
+function buildVotePrompt(proposal, options) {
   return `Evaluate the following proposal and provide your vote.
 
 PROPOSAL:
 ${proposal}
-
+${buildOptionsBlock(options)}
 In addition to your role-specific criteria, assess these workflow-test dimensions:
 - Testability: Can the proposed changes be verified with automated tests?
 - Workflow integration: Does this fit into existing CI/make/test workflows?
@@ -562,9 +623,21 @@ Respond with a JSON object containing:
 - conditions: Optional array of conditions for approval
 - rejectionCategories: Required when rejecting. Array of categories from: YAGNI, DRY_VIOLATION, OVER_ENGINEERING, SCOPE_CREEP, SECURITY_RISK, MISALIGNED, INSUFFICIENT_EVIDENCE
 - findings: PR-REVIEW MODE ONLY. Optional top-level array of structured findings \u2014 see "PR-review mode" in the system prompt. OMIT this field entirely when reviewing a non-diff proposal or when approving a diff.
-
+${buildSelectionFieldDoc(options)}
 ${VOTE_PROMPT_EXAMPLES}`;
 }
+function buildOptionsBlock(options) {
+  if (options === void 0 || options.length === 0) return "";
+  const list = options.map((o) => `- ${o}`).join("\n");
+  return `
+OPTIONS \u2014 choose exactly ONE of these and name it verbatim in \`selectedOption\`:
+${list}
+`;
+}
+function buildSelectionFieldDoc(options) {
+  if (options === void 0 || options.length === 0) return "";
+  return "- selectedOption: REQUIRED. Exactly one option from the OPTIONS list above, copied verbatim. Do not invent an option, combine two, or leave it blank \u2014 your selection is what the threshold is measured over.";
+}
 function stepInString(state, ch) {
   if (ch === "\\") state.escaped = true;
   else if (ch === '"') state.inString = false;
@@ -647,7 +720,8 @@ function clampOversizeVoteStrings(parsed) {
   }
   return obj;
 }
-function buildParsedVote(data) {
+function buildParsedVote(data, options) {
+  const selectedOption = options === void 0 ? void 0 : matchDeclaredOption(data.selectedOption, options);
   return {
     decision: data.decision,
     reasoning: data.reasoning,
@@ -655,16 +729,17 @@ function buildParsedVote(data) {
     ...data.conditions !== void 0 ? { conditions: data.conditions } : {},
     ...data.rejectionCategories !== void 0 ? { rejectionCategories: data.rejectionCategories } : {},
     ...data.findings !== void 0 ? { findings: data.findings } : {},
+    ...selectedOption !== void 0 ? { selectedOption } : {},
     source: "parsed"
   };
 }
-function parseVoteResponse(output, _role) {
+function parseVoteResponse(output, _role, options) {
   try {
     const jsonStr = extractJsonFromResponse(output);
     const parsed = JSON.parse(jsonStr);
     const validated = VoteResponseSchema.safeParse(clampOversizeVoteStrings(parsed));
     if (validated.success) {
-      return buildParsedVote(validated.data);
+      return buildParsedVote(validated.data, options);
     }
     const reason = `Validation failed: ${validated.error.issues.map((e) => e.message).join(", ")}`;
     throw new SyntheticVoteError(reason, output);
@@ -773,11 +848,11 @@ function extractTextFromResponse(content) {
   }
   return String(content);
 }
-function buildVoteRequest(role, proposal, timeoutMs, withResponseFormat) {
+function buildVoteRequest(role, proposal, timeoutMs, withResponseFormat, options) {
   const base = {
     messages: [
       { role: "system", content: VOTER_SYSTEM_PROMPTS[role] },
-      { role: "user", content: buildVotePrompt(proposal) }
+      { role: "user", content: buildVotePrompt(proposal, options) }
     ],
     // 4000 (#4131): headroom so a findings-bearing verdict (JSON envelope +
     // reasoning + structured findings) isn't cut mid-JSON by the token cap and
@@ -800,8 +875,15 @@ function isStructuredOutputUnsupported(errorMessage) {
 function readTokenCount(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-async function runVoteCompletion(role, proposal, adapter, timeoutMs, withResponseFormat) {
-  const request = buildVoteRequest(role, proposal, timeoutMs, withResponseFormat);
+async function runVoteCompletion({
+  role,
+  proposal,
+  adapter,
+  timeoutMs,
+  withResponseFormat,
+  options
+}) {
+  const request = buildVoteRequest(role, proposal, timeoutMs, withResponseFormat, options);
   const timeoutResult = await withTimeout(
     adapter.complete(request),
     timeoutMs,
@@ -821,14 +903,15 @@ async function runVoteCompletion(role, proposal, adapter, timeoutMs, withRespons
   };
   return { ok: true, output: extractTextFromResponse(response.value.content), usage };
 }
-async function executeSingleVoteAttempt(role, proposal, adapter, timeoutMs) {
-  let completion = await runVoteCompletion(role, proposal, adapter, timeoutMs, true);
+async function executeSingleVoteAttempt(role, proposal, adapter, timeoutMs, options) {
+  const completionArgs = { role, proposal, adapter, timeoutMs, options };
+  let completion = await runVoteCompletion({ ...completionArgs, withResponseFormat: true });
   if (!completion.ok && isStructuredOutputUnsupported(completion.error)) {
-    completion = await runVoteCompletion(role, proposal, adapter, timeoutMs, false);
+    completion = await runVoteCompletion({ ...completionArgs, withResponseFormat: false });
   }
   if (!completion.ok) return { ok: false, error: completion.error };
   try {
-    const vote = parseVoteResponse(completion.output, role);
+    const vote = parseVoteResponse(completion.output, role, options);
     return { ok: true, vote, output: completion.output, usage: completion.usage };
   } catch (error) {
     if (error instanceof SyntheticVoteError) {
@@ -838,7 +921,7 @@ async function executeSingleVoteAttempt(role, proposal, adapter, timeoutMs) {
   }
 }
 async function executeWithRetries(opts) {
-  const { role, proposal, adapter, logger: logger10, timeoutMs, maxRetries } = opts;
+  const { role, proposal, adapter, logger: logger10, timeoutMs, maxRetries, options } = opts;
   let lastError = "";
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     if (attempt > 0) {
@@ -849,7 +932,7 @@ async function executeWithRetries(opts) {
       await delay(delayMs);
     }
     const attemptStart = Date.now();
-    const result = await executeSingleVoteAttempt(role, proposal, adapter, timeoutMs);
+    const result = await executeSingleVoteAttempt(role, proposal, adapter, timeoutMs, options);
     const attemptMs = Date.now() - attemptStart;
     if (result.ok) {
       logger10.info("Vote attempt timing", {
@@ -982,17 +1065,27 @@ function buildLlmVoteResult(role, vote, usage, adapter, processingTimeMs) {
     source: "llm",
     cli: adapter.providerId,
     model: adapter.modelId,
+    // #4472: surface the voter's choice at the result level, where the tally
+    // and the record read it. Absent when no options were declared or the
+    // selection matched none of them.
+    ...vote.selectedOption !== void 0 ? { selectedOption: vote.selectedOption } : {},
     ...usage.inputTokens !== void 0 ? { inputTokens: usage.inputTokens } : {},
     ...usage.outputTokens !== void 0 ? { outputTokens: usage.outputTokens } : {},
     ...usage.cachedInputTokens !== void 0 ? { cachedInputTokens: usage.cachedInputTokens } : {},
     ...usage.cacheCreationInputTokens !== void 0 ? { cacheCreationInputTokens: usage.cacheCreationInputTokens } : {}
   };
 }
+function resolveVoteExecution(options) {
+  return {
+    timeoutMs: options?.timeoutMs ?? resolveVoteTimeout(),
+    maxRetries: options?.maxRetries ?? VOTE_TIMEOUTS.maxRetries,
+    allowSimulation: options?.allowSimulation ?? false,
+    declaredOptions: options?.declaredOptions
+  };
+}
 async function executeAgentVote(role, proposal, adapter, logger10, options) {
   const start = getTimeProvider().now();
-  const timeoutMs = options?.timeoutMs ?? resolveVoteTimeout();
-  const maxRetries = options?.maxRetries ?? VOTE_TIMEOUTS.maxRetries;
-  const allowSimulation = options?.allowSimulation ?? false;
+  const { timeoutMs, maxRetries, allowSimulation, declaredOptions } = resolveVoteExecution(options);
   logger10.info("Executing vote", { role, model: adapter.modelId, provider: adapter.providerId });
   const result = await executeWithRetries({
     role,
@@ -1000,7 +1093,8 @@ async function executeAgentVote(role, proposal, adapter, logger10, options) {
     adapter,
     logger: logger10,
     timeoutMs,
-    maxRetries
+    maxRetries,
+    options: declaredOptions
   });
   const processingTimeMs = getTimeProvider().now() - start;
   if (result.ok) {
@@ -1191,7 +1285,14 @@ async function collectRealVotes(options) {
   }
   const roleAdapters = options.adapter !== void 0 ? assignUniformAdapter(roles, adapterResult.adapter) : await resolveDiverseAdapters(roles, logger10, adapterResult.adapter, options.gatewayAdapters);
   warnIfCodexConcurrencyExceeded(roleAdapters, logger10);
-  const voteOptions = { timeoutMs, maxRetries, allowSimulation: allowSimulation ?? false };
+  const voteOptions = {
+    timeoutMs,
+    maxRetries,
+    allowSimulation: allowSimulation ?? false,
+    // #4472: reaches executeAgentVote, which puts the declared options in the
+    // prompt and resolves each voter's selection against them.
+    declaredOptions: options.declaredOptions
+  };
   const interDelay = options.interAgentDelayMs ?? DEFAULT_INTER_AGENT_DELAY_MS;
   return launchStaggeredVotes({
     roles,
@@ -1204,6 +1305,43 @@ async function collectRealVotes(options) {
   });
 }
 
+// src/mcp/tools/consensus-vote-option-gate.ts
+var STRATEGY_TO_OPTION_THRESHOLD = {
+  unanimous: "unanimous",
+  supermajority: "supermajority",
+  simple_majority: "majority",
+  // higher_order and proof_of_learning aggregate differently; they are gated at
+  // the majority bar so a declared-option split still cannot pass unnoticed.
+  higher_order: "majority",
+  proof_of_learning: "majority",
+  opinion_wise: "majority"
+};
+function optionThresholdFor(strategy, legacyThreshold) {
+  if (legacyThreshold === "unanimous") return "unanimous";
+  if (legacyThreshold === "supermajority") return "supermajority";
+  return STRATEGY_TO_OPTION_THRESHOLD[strategy] ?? "majority";
+}
+function evaluateOptionGate(votes, declaredOptions, threshold, approvedByStrategy) {
+  const tally = tallyOptions(
+    votes.map((v) => ({
+      decision: v.vote.decision,
+      ...v.selectedOption !== void 0 ? { selectedOption: v.selectedOption } : {}
+    })),
+    declaredOptions
+  );
+  const verdict = evaluateOptionThreshold(tally, threshold);
+  if (!approvedByStrategy || verdict.approved) {
+    return { verdict, vetoed: false };
+  }
+  return { verdict, vetoed: true, reason: describeVeto(verdict) };
+}
+function describeVeto(verdict) {
+  const pct = (verdict.leadingShare * 100).toFixed(1);
+  const leader = verdict.leadingOption !== void 0 ? `leading option "${verdict.leadingOption}" held ${String(verdict.leadingCount)}/${String(verdict.approverCount)} approvers (${pct}%)` : "no voter selected a declared option";
+  const coverage = verdict.unattributedApprovals > 0 ? ` ${String(verdict.unattributedApprovals)} of ${String(verdict.approverCount)} approvers recorded no usable selection, which lowers the leading share; their choice is unmeasured, not counted as dissent.` : "";
+  return `Approvals cleared the ${verdict.threshold} bar, but the option split did not: ${leader}.${coverage}`;
+}
+
 // src/consensus/types-voting-protocol.ts
 import { z as z2 } from "zod";
 var VOTING_ROUND_DEFAULT_TIMEOUT_MS = OPERATION_CLASSES["multi-llm-panel"].guardMs;
@@ -4322,7 +4460,10 @@ function getDefaultErrorPolicy(strategy) {
 }
 var ConsensusVoteInputSchema = z6.object({
   proposal: z6.string().min(1).max(MAX_PROPOSAL_LENGTH).describe(
-    "Proposal text to vote on. IMPORTANT (#4452): the tally records approve/reject/abstain ONLY. If your proposal asks voters to choose among named options (A/B/C), every voter who engages returns `approve`, so the result records as unanimous even when the panel disagreed about WHICH option \u2014 a 6-1 split persists as 7-0, 100%. Threshold semantics invert too: `unanimous` becomes trivially easy to clear, because everyone approves while choosing different things. Prefer a single yes/no question; if you must offer options, read each voter's `reasoning` to recover the real split and do NOT report the recorded percentage as agreement."
+    "Proposal text to vote on. If the proposal asks voters to choose among named alternatives, you MUST declare them in `options` (#4472). Without `options` 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)."
+  ),
+  options: z6.array(z6.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."
   ),
   threshold: VoteThresholdSchema.optional().describe(
     "Voting threshold (legacy): majority, supermajority, unanimous. Use strategy instead."
@@ -4500,6 +4641,18 @@ function buildResponse(input, result, costSummary, voteRecord) {
   if (voteRecord !== void 0 && !voteRecord.persisted) {
     response.voteRecordNote = voteRecord.detail;
   }
+  if (result.optionGate !== void 0) {
+    const g = result.optionGate;
+    response.optionOutcome = {
+      tally: g.tally.map((t) => ({ option: t.option, count: t.count })),
+      ...g.leadingOption !== void 0 ? { leadingOption: g.leadingOption } : {},
+      leadingShare: g.leadingShare,
+      approverCount: g.approverCount,
+      selectedCount: g.selectedCount,
+      unattributedApprovals: g.unattributedApprovals,
+      thresholdMet: g.approved
+    };
+  }
   applyOptionalResponseFields(response, input, result, errorCount, costSummary);
   applyAbsoluteQuorumTelemetry(response, input, decision, degradeReason);
   return response;
@@ -4580,6 +4733,14 @@ import { dirname, isAbsolute, relative, resolve, sep } from "path";
 import * as crypto from "crypto";
 import { z as z7 } from "zod";
 var VoteRecordDecisionSchema = z7.enum(["approved", "rejected", "no_quorum"]);
+var VoteRecordOptionCoverageSchema = z7.object({
+  /** Every approving voter, selecting or not — the tally's denominator. */
+  approverCount: z7.number().int().nonnegative(),
+  /** Approvers whose selection matched a declared option. */
+  selectedCount: z7.number().int().nonnegative(),
+  /** Approvers with no usable selection; their choice is unmeasured. */
+  unattributedApprovals: z7.number().int().nonnegative()
+}).strict();
 var VoterSummarySchema = z7.object({
   role: z7.string().min(1).max(100),
   decision: z7.enum(["approve", "reject", "abstain"]),
@@ -4605,7 +4766,7 @@ var VoteRecordSchema = z7.object({
    * `ratifies` is folded into the self-hash ONLY when present (see
    * {@link computeVoteRecordHash}).
    */
-  version: z7.enum(["1.1", "1.2", "1.3"]),
+  version: z7.enum(["1.1", "1.2", "1.3", "1.4"]),
   /** Unique record id (also usable as a `ratificationVoteRef`). */
   id: z7.string().min(1),
   /**
@@ -4659,6 +4820,16 @@ var VoteRecordSchema = z7.object({
    * choosing different things.
    */
   optionTally: z7.array(VoteRecordOptionCountSchema).min(1).optional(),
+  /**
+   * Selection coverage for a multi-option vote (#4472, schema 1.4).
+   *
+   * `optionTally` alone cannot distinguish dissent from absence: `4 pick X
+   * + 3 unreadable` and a genuine 4/3 split both leave a leading share of
+   * 57%. Recording how many approvers produced no usable selection is what
+   * makes a partial measurement legible AS partial — the condition every
+   * voter attached to adopting the "credit no option" rule.
+   */
+  optionCoverage: VoteRecordOptionCoverageSchema.optional(),
   /**
    * The loop/strategy subject this vote RATIFIES (#3927 item 1). Present only on
    * a ratification vote; set at vote time and bound into the self-hash (so it is
@@ -4708,8 +4879,16 @@ function computeVoteRecordHash(payload) {
     ...base,
     optionTally: payload.optionTally.map((o) => ({ option: o.option, count: o.count }))
   } : base;
+  const withCoverage = payload.optionCoverage !== void 0 ? {
+    ...withTally,
+    optionCoverage: {
+      approverCount: payload.optionCoverage.approverCount,
+      selectedCount: payload.optionCoverage.selectedCount,
+      unattributedApprovals: payload.optionCoverage.unattributedApprovals
+    }
+  } : withTally;
   const canonical = JSON.stringify(
-    payload.ratifies !== void 0 ? { ...withTally, ratifies: payload.ratifies } : withTally
+    payload.ratifies !== void 0 ? { ...withCoverage, ratifies: payload.ratifies } : withCoverage
   );
   return crypto.createHash("sha256").update(canonical).digest("hex");
 }
@@ -4741,6 +4920,26 @@ function toVoterSummaries(votes) {
   }
   return summaries;
 }
+function deriveOptionFields(votes) {
+  const optionTally = tallySelectedOptions(votes);
+  return {
+    optionTally,
+    optionCoverage: optionTally === void 0 ? void 0 : coverageOf(votes)
+  };
+}
+function recordVersion(optionTally, optionCoverage) {
+  if (optionCoverage !== void 0) return "1.4";
+  return optionTally !== void 0 ? "1.3" : "1.2";
+}
+function coverageOf(votes) {
+  const approvers = votes.filter((v) => v.vote.decision === "approve");
+  const selectedCount = approvers.filter((v) => v.selectedOption !== void 0).length;
+  return {
+    approverCount: approvers.length,
+    selectedCount,
+    unattributedApprovals: approvers.length - selectedCount
+  };
+}
 function tallySelectedOptions(votes) {
   const counts = /* @__PURE__ */ new Map();
   for (const v of votes) {
@@ -4752,9 +4951,9 @@ function tallySelectedOptions(votes) {
 }
 function buildVoteRecord(input) {
   const proposalTruncated = input.proposal.length > MAX_PROPOSAL_RECORD_CHARS ? input.proposal.slice(0, MAX_PROPOSAL_RECORD_CHARS) + "..." : input.proposal;
-  const optionTally = tallySelectedOptions(input.votes);
+  const { optionTally, optionCoverage } = deriveOptionFields(input.votes);
   const payload = {
-    version: optionTally !== void 0 ? "1.3" : "1.2",
+    version: recordVersion(optionTally, optionCoverage),
     id: input.id,
     sequence: input.sequence ?? 0,
     recordedAt: input.recordedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
@@ -4773,6 +4972,7 @@ function buildVoteRecord(input) {
     ...input.correlationId !== void 0 ? { correlationId: input.correlationId } : {},
     ...input.ratifies !== void 0 ? { ratifies: input.ratifies } : {},
     ...optionTally !== void 0 ? { optionTally } : {},
+    ...optionCoverage !== void 0 ? { optionCoverage } : {},
     ...input.previousHash !== void 0 ? { previousHash: input.previousHash } : {}
   };
   return { ...payload, hash: computeVoteRecordHash(payload) };
@@ -6060,9 +6260,26 @@ async function maybeEscalateContrarian(input, outcome, ctx, logger10, opts) {
 async function executeVoting(input, logger10, opts) {
   const result = await executeVotingInner(input, logger10, opts);
   const errorCount = result.votes.filter((v) => v.source === "error").length;
+  applyOptionGate(input, result);
   result.decision = resolveVoteDecision(input, result, errorCount).decision;
   return result;
 }
+function applyOptionGate(input, result) {
+  const declaredOptions = input.options;
+  if (declaredOptions === void 0 || declaredOptions.length === 0) return;
+  const outcome = evaluateOptionGate(
+    result.votes,
+    declaredOptions,
+    optionThresholdFor(result.strategy, input.threshold),
+    result.result.outcome === "approved"
+  );
+  result.optionGate = outcome.verdict;
+  if (!outcome.vetoed) return;
+  result.result.outcome = "rejected";
+  if (result.policyReason === void 0 && outcome.reason !== void 0) {
+    result.policyReason = outcome.reason;
+  }
+}
 async function executeVotingInner(input, logger10, opts) {
   const strategy = resolveStrategy(input);
   const algorithm = strategyToAlgorithm(strategy);
@@ -6080,7 +6297,8 @@ async function executeVotingInner(input, logger10, opts) {
     proposal: input.proposal,
     simulate: input.simulateVotes,
     ...opts?.voteTimeoutMs !== void 0 && { timeoutMs: opts.voteTimeoutMs },
-    ...opts?.gatewayAdapters !== void 0 && { gatewayAdapters: opts.gatewayAdapters }
+    ...opts?.gatewayAdapters !== void 0 && { gatewayAdapters: opts.gatewayAdapters },
+    declaredOptions: input.options
   });
   const policyDecision = applyErrorPolicy(votes, errorPolicy);
   if (policyDecision.shortCircuit) {
@@ -6379,7 +6597,19 @@ var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
   // #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).
-  costSummary: DecisionCostSummarySchema.optional()
+  costSummary: DecisionCostSummarySchema.optional(),
+  // #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: z10.object({
+    tally: z10.array(z10.object({ option: z10.string(), count: z10.number().int().nonnegative() })),
+    leadingOption: z10.string().optional(),
+    leadingShare: z10.number().min(0).max(1),
+    approverCount: z10.number().int().nonnegative(),
+    selectedCount: z10.number().int().nonnegative(),
+    unattributedApprovals: z10.number().int().nonnegative(),
+    thresholdMet: z10.boolean()
+  }).optional()
 };
 var CONSENSUS_VOTE_TOOL_SCHEMA = {
   proposal: z10.string().min(1).max(MAX_PROPOSAL_LENGTH).describe("Proposal text to vote on"),
@@ -6503,4 +6733,4 @@ export {
   CONSENSUS_VOTE_OUTPUT_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-RAYKASM4.js.map
+//# sourceMappingURL=chunk-XL6T3HTN.js.map