nexus-agents 2.150.4 → 2.151.1

package/dist/{chunk-4ELTYI33.js → chunk-QL4Q3HUO.js}

@@ -8,7 +8,7 @@ import {
   checkSqlite,
   defaultConfig,
   initDataDirectories
-} from "./chunk-UIUTDHRX.js";
+} from "./chunk-SJFARLAQ.js";
 import {
   BUILT_IN_EXPERTS
 } from "./chunk-ZM4O442V.js";
@@ -2000,4 +2000,4 @@ export {
   setupCommand,
   setupCommandAsync
 };
-//# sourceMappingURL=chunk-4ELTYI33.js.map
+//# sourceMappingURL=chunk-QL4Q3HUO.js.map

package/dist/{chunk-UIUTDHRX.js → chunk-SJFARLAQ.js}

@@ -42,7 +42,7 @@ import {
 } from "./chunk-DHVMSIT5.js";
 
 // src/version.ts
-var VERSION = true ? "2.150.4" : "dev";
+var VERSION = true ? "2.151.1" : "dev";
 
 // src/config/schemas-core.ts
 import { z } from "zod";
@@ -2132,7 +2132,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-OL2A2GCI.js");
+    const { runSetup } = await import("./setup-command-IQ7WFZIM.js");
     const setupResult = runSetup({
       skipMcp: true,
       skipRules: true,
@@ -2245,4 +2245,4 @@ export {
   startStdioServer,
   closeServer
 };
-//# sourceMappingURL=chunk-UIUTDHRX.js.map
+//# sourceMappingURL=chunk-SJFARLAQ.js.map

package/dist/{chunk-CB234Y3O.js → chunk-UIL37D2V.js}

@@ -4305,7 +4305,12 @@ 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 = z6.enum(["reduce_denominator", "count_as_abstain", "fail_closed"]);
+var ErrorPolicySchema = z6.enum([
+  "reduce_denominator",
+  "count_as_abstain",
+  "fail_closed",
+  "absolute_quorum"
+]);
 var VoteThresholdSchema = z6.enum(["majority", "supermajority", "unanimous"]);
 var ERROR_FLOOR_FRACTION = 0.5;
 function getDefaultErrorPolicy(strategy) {
@@ -4323,7 +4328,7 @@ var ConsensusVoteInputSchema = z6.object({
     "Voting strategy: simple_majority (default), supermajority, unanimous, proof_of_learning, or higher_order (Bayesian-optimal)"
   ),
   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."
+    "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: 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(
@@ -4406,12 +4411,69 @@ function panelDegradationWarning(errorCount, total) {
   if (errorCount <= 0 || errorCount >= total) return void 0;
   return `Panel degraded: ${String(errorCount)} of ${String(total)} voters errored; decision rests on ${String(total - errorCount)} voter(s).`;
 }
+var degradedPanelCount = 0;
+function absoluteQuorumFraction(strategy) {
+  switch (strategy) {
+    case "supermajority":
+      return 2 / 3;
+    case "unanimous":
+      return 1;
+    default:
+      return 0.5;
+  }
+}
+function absoluteQuorumDegradeReason(result, errorCount) {
+  const contrarianVote = result.votes.find((v) => v.role === "catfish");
+  const contrarianOk = contrarianVote !== void 0 && contrarianVote.source !== "error";
+  const contrarianDegraded = result.contrarianRequested === true && !contrarianOk;
+  if (errorCount === 0 && !contrarianDegraded) return void 0;
+  const erroredRoles = result.votes.filter((v) => v.source === "error").map((v) => v.role);
+  const named = contrarianDegraded && !erroredRoles.includes("catfish") ? [...erroredRoles, "catfish"] : erroredRoles;
+  const list = named.length > 0 ? named.join(", ") : "contrarian";
+  return `no_quorum: re-run \u2014 voter(s) [${list}] errored (absolute_quorum)`;
+}
+function computeAbsoluteQuorumDecision(result, errorCount, allErrors) {
+  const degradeReason = absoluteQuorumDegradeReason(result, errorCount);
+  if (degradeReason !== void 0) return { decision: "no_quorum", degradeReason };
+  const panel = result.panelSize ?? result.votes.length;
+  const needed = Math.ceil(absoluteQuorumFraction(result.strategy) * panel);
+  const approveCount = result.votes.filter(
+    (v) => v.source !== "error" && v.vote.decision === "approve"
+  ).length;
+  if (result.result.outcome === "approved" && approveCount >= needed) {
+    return { decision: "approved" };
+  }
+  if (result.result.outcome === "rejected" && !allErrors) {
+    return { decision: "rejected" };
+  }
+  return {
+    decision: "no_quorum",
+    degradeReason: `no_quorum: absolute quorum not met (${String(approveCount)}/${String(needed)} approvals over ${String(panel)}-voter panel, absolute_quorum)`
+  };
+}
+function resolveVoteDecision(input, result, errorCount) {
+  const allErrors = errorCount === result.votes.length && errorCount > 0;
+  if (result.policyReason !== void 0 || !result.result.quorumReached && allErrors) {
+    return { decision: "no_quorum" };
+  }
+  if (input.errorPolicy === "absolute_quorum") {
+    return computeAbsoluteQuorumDecision(result, errorCount, allErrors);
+  }
+  return { decision: mapOutcomeToDecision(result.result.outcome) };
+}
+function applyAbsoluteQuorumTelemetry(response, input, decision, degradeReason) {
+  if (input.errorPolicy === "absolute_quorum" && decision === "no_quorum") {
+    degradedPanelCount++;
+  }
+  if (degradeReason !== void 0) {
+    response.policyReason ??= degradeReason;
+    response.panelWarning ??= degradeReason;
+  }
+}
 function buildResponse(input, result, costSummary, voteRecord) {
   const proposalTruncated = input.proposal.length > 200 ? input.proposal.slice(0, 200) + "..." : input.proposal;
   const errorCount = result.votes.filter((v) => v.source === "error").length;
-  const allErrors = errorCount === result.votes.length && errorCount > 0;
-  const errorVoidedVote = result.policyReason !== void 0;
-  const decision = errorVoidedVote || !result.result.quorumReached && allErrors ? "no_quorum" : mapOutcomeToDecision(result.result.outcome);
+  const { decision, degradeReason } = resolveVoteDecision(input, result, errorCount);
   const response = {
     proposal: proposalTruncated,
     strategy: result.strategy,
@@ -4434,6 +4496,7 @@ function buildResponse(input, result, costSummary, voteRecord) {
     response.voteRecordNote = voteRecord.detail;
   }
   applyOptionalResponseFields(response, input, result, errorCount, costSummary);
+  applyAbsoluteQuorumTelemetry(response, input, decision, degradeReason);
   return response;
 }
 function applyOptionalResponseFields(response, input, result, errorCount, costSummary) {
@@ -4490,7 +4553,7 @@ function applyErrorPolicy(votes, policy) {
       engineVotes: []
     };
   }
-  if (policy === "count_as_abstain") {
+  if (policy === "count_as_abstain" || policy === "absolute_quorum") {
     return {
       shortCircuit: false,
       engineVotes: votes.map(
@@ -5825,9 +5888,10 @@ async function runContrarianCheck(proposal, log) {
       '{"decision":"approve","confidence":0.0-1.0,"reasoning":"why it is acceptable"}'
     ].join("\n");
     const result = await executeExpert("architecture", prompt);
-    if (!result.success) return { shouldEscalate: false, reason: "", confidence: 0 };
+    if (!result.success) return { shouldEscalate: false, reason: "", confidence: 0, errored: true };
     const jsonMatch = result.text.match(/\{[\s\S]*\}/);
-    if (jsonMatch === null) return { shouldEscalate: false, reason: "", confidence: 0 };
+    if (jsonMatch === null)
+      return { shouldEscalate: false, reason: "", confidence: 0, errored: false };
     const parsed = JSON.parse(jsonMatch[0]);
     const isRejection = parsed.decision === "reject";
     const confidence = typeof parsed.confidence === "number" ? parsed.confidence : 0;
@@ -5837,13 +5901,13 @@ async function runContrarianCheck(proposal, log) {
         confidence,
         reasoning: reasoning.slice(0, 200)
       });
-      return { shouldEscalate: true, reason: reasoning, confidence };
+      return { shouldEscalate: true, reason: reasoning, confidence, errored: false };
     }
-    return { shouldEscalate: false, reason: "", confidence };
+    return { shouldEscalate: false, reason: "", confidence, errored: false };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     log.warn("Contrarian check failed; defaulting to no escalation", { error: message });
-    return { shouldEscalate: false, reason: "", confidence: 0 };
+    return { shouldEscalate: false, reason: "", confidence: 0, errored: true };
   }
 }
 function buildPolicyShortCircuitResult(args) {
@@ -5860,27 +5924,37 @@ function buildPolicyShortCircuitResult(args) {
     totalTimeMs,
     simulateVotes: args.input.simulateVotes,
     strategy: args.strategy,
+    // #4132: thread the requested panel shape so the absolute_quorum predicate
+    // in buildResponse has PANEL_SIZE + contrarian-presence even on a short-circuit.
+    panelSize: args.roles.length,
+    contrarianRequested: args.roles.includes("catfish"),
     // #3124: surface WHY a high-approval result is still 'rejected' so callers
     // don't mistake a fail-closed policy short-circuit for a genuine rejection.
     policyReason: args.reason
   };
 }
 async function maybeEscalateContrarian(input, outcome, ctx, logger10, opts) {
-  if (!input.quickMode || outcome !== "approved" || input.simulateVotes) return void 0;
+  if (!input.quickMode || outcome !== "approved" || input.simulateVotes) return {};
   if (shouldEscalateLowPosterior(ctx.strategy, outcome, input.quickMode, ctx.posteriorApproval)) {
     logger10.warn("Posterior-confidence escalation: re-running with full vote (#3174)", {
       strategy: ctx.strategy,
       posteriorApproval: ctx.posteriorApproval
     });
-    return executeVoting({ ...input, quickMode: false }, logger10, opts);
+    return { escalated: await executeVoting({ ...input, quickMode: false }, logger10, opts) };
   }
   const escalation = await runContrarianCheck(input.proposal, logger10);
-  if (!escalation.shouldEscalate) return void 0;
+  if (escalation.errored && input.errorPolicy === "absolute_quorum") {
+    logger10.warn("Contrarian check errored under absolute_quorum \u2014 degrading to no_quorum (#4132)");
+    return {
+      degradeReason: "no_quorum: re-run \u2014 contrarian check errored (absolute_quorum quick-mode)"
+    };
+  }
+  if (!escalation.shouldEscalate) return {};
   logger10.warn("Contrarian escalation: re-running with full vote", {
     reason: escalation.reason,
     confidence: escalation.confidence
   });
-  return executeVoting({ ...input, quickMode: false }, logger10, opts);
+  return { escalated: await executeVoting({ ...input, quickMode: false }, logger10, opts) };
 }
 async function executeVoting(input, logger10, opts) {
   const strategy = resolveStrategy(input);
@@ -5907,6 +5981,7 @@ async function executeVoting(input, logger10, opts) {
       input,
       strategy,
       algorithm,
+      roles,
       votes,
       errorPolicy,
       reason: policyDecision.reason ?? "error policy short-circuit",
@@ -5925,18 +6000,19 @@ async function executeVoting(input, logger10, opts) {
     }
   );
   recordVotesToTracker(votes, outcome, logger10);
-  const escalated = await maybeEscalateContrarian(
+  const escalation = await maybeEscalateContrarian(
     input,
     outcome,
     { strategy, posteriorApproval: higherOrderResult?.posteriorApproval },
     logger10,
     opts
   );
-  if (escalated !== void 0) return escalated;
-  return finalizeVotingResult({
+  if (escalation.escalated !== void 0) return escalation.escalated;
+  const finalized = finalizeVotingResult({
     input,
     strategy,
     algorithm,
+    roles,
     engineResult,
     higherOrderResult,
     votes,
@@ -5945,6 +6021,11 @@ async function executeVoting(input, logger10, opts) {
     startTime,
     logger: logger10
   });
+  return applyContrarianDegrade(finalized, escalation.degradeReason);
+}
+function applyContrarianDegrade(result, degradeReason) {
+  if (degradeReason === void 0 || result.policyReason !== void 0) return result;
+  return { ...result, policyReason: degradeReason };
 }
 async function runConsensusForGoal(goal, logger10 = createLogger({ tool: "consensus_vote" }), gatewayAdapters) {
   return executeVoting(ConsensusVoteInputSchema.parse({ proposal: goal }), logger10, {
@@ -5966,7 +6047,10 @@ function finalizeVotingResult(args) {
     votes: args.votes,
     totalTimeMs,
     simulateVotes: args.input.simulateVotes,
-    strategy: args.strategy
+    strategy: args.strategy,
+    // #4132: PANEL_SIZE + contrarian-presence for the absolute_quorum predicate.
+    panelSize: args.roles.length,
+    contrarianRequested: args.roles.includes("catfish")
   };
   if (args.higherOrderResult !== void 0) result.higherOrderResult = args.higherOrderResult;
   return result;
@@ -6183,6 +6267,9 @@ var CONSENSUS_VOTE_TOOL_SCHEMA = {
   strategy: VotingStrategySchema.optional().describe(
     "Voting strategy: simple_majority (default), supermajority, unanimous, proof_of_learning, or higher_order"
   ),
+  errorPolicy: ErrorPolicySchema.optional().describe(
+    "How to treat errored/timed-out voters (#2630): reduce_denominator (default non-strict) | count_as_abstain | fail_closed (default unanimous) | absolute_quorum (#4132 opt-in \u2014 an errored voter, esp. the contrarian, degrades the verdict to no_quorum instead of being dropped; never manufactures approved/rejected from an induced error). Errors > 50% always fails."
+  ),
   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)"),
   ratifies: z10.string().min(1).max(256).optional().describe(
@@ -6287,9 +6374,10 @@ export {
   warnIfSimulatedOutsideTests,
   resetCorrelationTracker,
   createPolicyFailedResult,
+  maybeEscalateContrarian,
   executeVoting,
   runConsensusForGoal,
   CONSENSUS_VOTE_OUTPUT_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-CB234Y3O.js.map
+//# sourceMappingURL=chunk-UIL37D2V.js.map