nexus-agents 2.79.3 → 2.80.0

package/dist/{chunk-SWFJU3W2.js → chunk-6CJIKX6I.js}

@@ -2,31 +2,32 @@ import {
   CUSTOM_API_BASE_URL_ENV,
   PROVIDER_ENV_KEYS,
   validateCustomApiBaseUrl
-} from "./chunk-ZVCED4Z4.js";
+} from "./chunk-JLWKHYIU.js";
 import {
   AdapterModelError,
   BaseAdapter,
   createStream,
   requireApiKey,
   validateApiKeyPresence
-} from "./chunk-PLX6FCFC.js";
+} from "./chunk-YGKPWUJ6.js";
 import {
   getToolMemory
-} from "./chunk-Q5CFPIJ5.js";
+} from "./chunk-OO6MTUDS.js";
 import {
   getDefaultAvailableModelsCache
-} from "./chunk-KT5FIBWS.js";
+} from "./chunk-HBKZ2DJK.js";
 import {
   CUSTOM_API_DEFAULT_MODEL
-} from "./chunk-HYU4GZY6.js";
+} from "./chunk-BSIGP5XF.js";
 import {
   createCliAdapter,
   createCliDetectionCache,
   delay,
   getAvailableClis,
   isCliAvailable,
+  sanitizeOutput,
   withTimeout
-} from "./chunk-D6TM2VHX.js";
+} from "./chunk-ZU2Q3DWE.js";
 import {
   AgentError,
   CACHE_TIMEOUTS,
@@ -69,13 +70,13 @@ import {
   resolveCliAlias,
   resolveVoteTimeout,
   toRateLimitError
-} from "./chunk-WDYCIJWN.js";
+} from "./chunk-YMT6H2HQ.js";
 import {
   ensureLearningDir,
   getNexusDataDir,
   getOutcomesFile,
   nexusDataPath
-} from "./chunk-7BMOZJYS.js";
+} from "./chunk-2JQXC3CK.js";
 
 // src/mcp/tools/consensus-vote.ts
 import { z as z10 } from "zod";
@@ -1596,7 +1597,7 @@ var SECRET_PATTERNS = [
   // password= or token= in output
   /(?:password|token|secret|apikey|api_key)\s*[=:]\s*\S{8,}/i
 ];
-function sanitizeOutput(text, logger8) {
+function sanitizeOutput2(text, logger8) {
   let sanitized = text;
   for (const pattern of SECRET_PATTERNS) {
     if (pattern.test(sanitized)) {
@@ -1610,7 +1611,7 @@ function sanitizeOutput(text, logger8) {
 }
 function sanitizeToolResult(result, logger8) {
   for (const item of result.content) {
-    item.text = sanitizeOutput(item.text, logger8);
+    item.text = sanitizeOutput2(item.text, logger8);
   }
 }
 function checkInputSize(args, logger8, requestId) {
@@ -2631,9 +2632,10 @@ var SdkAdapter = class extends BaseAdapter {
    */
   toErrorResult(error, code) {
     const message = getErrorMessage(error);
-    const errorObj = error instanceof Error ? error : new Error(message);
+    const safeMessage = sanitizeOutput(message);
+    const errorObj = error instanceof Error ? error : new Error(safeMessage);
     this.logger.error(`SDK adapter error (${this.sdkProviderId})`, errorObj);
-    const modelError = new AdapterModelError(`${this.sdkProviderId} SDK error: ${message}`, {
+    const modelError = new AdapterModelError(`${this.sdkProviderId} SDK error: ${safeMessage}`, {
       code
     });
     return { ok: false, error: modelError };
@@ -5576,6 +5578,16 @@ var ConsensusError = class extends AgentError {
     this.name = "ConsensusError";
   }
 };
+var HYPOTHETICAL_APPROVE = {
+  decision: "approve",
+  confidence: 0.5,
+  reasoning: "hypothetical-cascade-probe"
+};
+var HYPOTHETICAL_REJECT = {
+  decision: "reject",
+  confidence: 0.5,
+  reasoning: "hypothetical-cascade-probe"
+};
 var DEFAULT_PROPOSAL_CACHE_CONFIG = {
   enabled: true,
   ttlMs: 36e5,
@@ -5849,47 +5861,47 @@ var ConsensusEngine = class {
   }
   /**
    * Agreement-based cascading: close early when outcome is mathematically determined.
-   * If approvals already exceed the threshold even if all remaining voters reject,
-   * or rejections make approval impossible, the proposal can be decided early.
+   *
+   * #2822: the prior implementation computed approval rates against
+   * `totalExpected = requiredVoters.length` and compared against
+   * `VOTING_THRESHOLDS[algorithm]` directly. Every voting strategy
+   * (`SimpleMajorityStrategy`, `SupermajorityStrategy`, `UnanimousStrategy`,
+   * `ProofOfLearningStrategy`) uses `approve + reject` as its denominator —
+   * abstains are explicitly excluded. The two diverged whenever abstains
+   * were present, producing wrong-winner cascades (e.g. 5-voter supermajority
+   * with [approve, abstain, abstain, abstain, pending] cascade-rejected even
+   * though the strategy would approve at close).
+   *
+   * The fix delegates to the strategy itself: build a best-case (all pending
+   * voters approve) and worst-case (all pending voters reject) hypothetical
+   * vote map, call `strategy.calculateOutcome` on each, and cascade only
+   * when both extremes yield the same outcome. This guarantees parity with
+   * the strategy's denominator semantics by construction.
    */
   canCascadeEarly(state) {
     const required = state.proposal.requiredVoters;
     if (required === void 0 || required.length === 0) return false;
-    const totalExpected = required.length;
-    const votesCast = state.votes.size;
-    const remaining = totalExpected - votesCast;
-    if (remaining <= 0) return false;
-    const threshold = VOTING_THRESHOLDS[state.proposal.algorithm];
-    let approvals = 0;
-    let rejections = 0;
-    for (const vote of state.votes.values()) {
-      if (vote.decision === "approve") approvals++;
-      else if (vote.decision === "reject") rejections++;
-    }
-    const minApprovalRate = approvals / totalExpected;
-    if (minApprovalRate > threshold) {
-      this.logger.info("Agreement cascade: early approval", {
-        proposalId: state.proposal.id,
-        approvals,
-        totalExpected,
-        threshold,
-        remaining
-      });
-      return true;
-    }
-    const maxPossibleApprovals = approvals + remaining;
-    const maxApprovalRate = maxPossibleApprovals / totalExpected;
-    if (maxApprovalRate < threshold) {
-      this.logger.info("Agreement cascade: early rejection", {
-        proposalId: state.proposal.id,
-        rejections,
-        totalExpected,
-        threshold,
-        remaining
-      });
-      return true;
-    }
-    return false;
+    if (state.votes.size === 0) return false;
+    const pending = required.filter((voter) => !state.votes.has(voter));
+    if (pending.length === 0) return false;
+    const strategy = this.strategyFactory.getStrategy(state.proposal.algorithm);
+    const bestCase = new Map(state.votes);
+    const worstCase = new Map(state.votes);
+    for (const voter of pending) {
+      bestCase.set(voter, HYPOTHETICAL_APPROVE);
+      worstCase.set(voter, HYPOTHETICAL_REJECT);
+    }
+    const bestOutcome = strategy.calculateOutcome(bestCase, state.voteWeights);
+    const worstOutcome = strategy.calculateOutcome(worstCase, state.voteWeights);
+    if (bestOutcome.approved !== worstOutcome.approved) return false;
+    this.logger.info("Agreement cascade: outcome determined", {
+      proposalId: state.proposal.id,
+      outcome: bestOutcome.approved ? "approve" : "reject",
+      votesCast: state.votes.size,
+      pending: pending.length,
+      algorithm: state.proposal.algorithm
+    });
+    return true;
   }
   allRequiredVotersVoted(state) {
     const required = state.proposal.requiredVoters;
@@ -8638,7 +8650,7 @@ async function processVotesWithCascade(engineVotes, opts) {
 var CONTRARIAN_ESCALATION_THRESHOLD = 0.8;
 async function runContrarianCheck(proposal, log) {
   try {
-    const { executeExpert } = await import("./expert-bridge-JKLC57IC.js");
+    const { executeExpert } = await import("./expert-bridge-6ZLD2NWD.js");
     const prompt = [
       "You are a contrarian analyst. Your job is to find reasons this proposal should be REJECTED.",
       "Look for: YAGNI (not needed), MISALIGNED (wrong tech/architecture), SECURITY_RISK, SCOPE_CREEP.",
@@ -9055,4 +9067,4 @@ export {
   CONSENSUS_VOTE_OUTPUT_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-SWFJU3W2.js.map
+//# sourceMappingURL=chunk-6CJIKX6I.js.map