nexus-agents 2.150.3 → 2.151.0

package/dist/{chunk-DFK6H3KT.js → chunk-O6PPXOH6.js}

@@ -42,7 +42,7 @@ import {
 } from "./chunk-DHVMSIT5.js";
 
 // src/version.ts
-var VERSION = true ? "2.150.3" : "dev";
+var VERSION = true ? "2.151.0" : "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-PPHPJCSN.js");
+    const { runSetup } = await import("./setup-command-JERVOJ5Z.js");
     const setupResult = runSetup({
       skipMcp: true,
       skipRules: true,
@@ -2245,4 +2245,4 @@ export {
   startStdioServer,
   closeServer
 };
-//# sourceMappingURL=chunk-DFK6H3KT.js.map
+//# sourceMappingURL=chunk-O6PPXOH6.js.map

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

@@ -550,16 +550,63 @@ Respond with a JSON object containing:
 
 ${VOTE_PROMPT_EXAMPLES}`;
 }
+function stepInString(state, ch) {
+  if (ch === "\\") state.escaped = true;
+  else if (ch === '"') state.inString = false;
+}
+function stepStructural(state, ch) {
+  if (ch === '"') state.inString = true;
+  else if (ch === "{") state.closers.push("}");
+  else if (ch === "[") state.closers.push("]");
+  else if (ch === "}" || ch === "]") {
+    if (state.closers.pop() === void 0) return "unbalanced";
+    if (state.closers.length === 0) return "complete";
+  }
+  return "continue";
+}
+function stepJsonScan(state, ch) {
+  if (state.escaped) {
+    state.escaped = false;
+    return "continue";
+  }
+  if (state.inString) {
+    stepInString(state, ch);
+    return "continue";
+  }
+  return stepStructural(state, ch);
+}
+function repairTruncatedObject(fragment, state) {
+  let repaired = state.inString ? `${fragment}"` : fragment;
+  for (let i = state.closers.length - 1; i >= 0; i--) {
+    const closer = state.closers[i];
+    if (closer !== void 0) repaired += closer;
+  }
+  return repaired;
+}
+function extractFirstJsonObject(text) {
+  const start = text.indexOf("{");
+  if (start === -1) return void 0;
+  const state = { closers: [], inString: false, escaped: false };
+  for (let i = start; i < text.length; i++) {
+    const result = stepJsonScan(state, text[i]);
+    if (result === "complete") return text.slice(start, i + 1);
+    if (result === "unbalanced") return void 0;
+  }
+  return state.closers.length > 0 ? repairTruncatedObject(text.slice(start), state) : void 0;
+}
 function extractJsonFromResponse(text) {
-  const codeBlockMatch = /```(?:json)?\s*([\s\S]*?)```/i.exec(text);
-  if (codeBlockMatch?.[1] !== void 0) {
-    return codeBlockMatch[1].trim();
+  const jsonFence = /```json\s*([\s\S]*?)```/i.exec(text);
+  if (jsonFence?.[1] !== void 0) {
+    return extractFirstJsonObject(jsonFence[1]) ?? jsonFence[1].trim();
   }
-  const jsonMatch = /\{[\s\S]*\}/i.exec(text);
-  if (jsonMatch?.[0] !== void 0) {
-    return jsonMatch[0];
+  for (const match of text.matchAll(/```[a-zA-Z0-9]*\s*([\s\S]*?)```/g)) {
+    const inner = match[1];
+    if (inner?.trimStart().startsWith("{") === true) {
+      const obj = extractFirstJsonObject(inner);
+      if (obj !== void 0) return obj;
+    }
   }
-  return text.trim();
+  return extractFirstJsonObject(text) ?? text.trim();
 }
 function createFallbackVote(output, _role, reason) {
   const lower = output.toLowerCase();
@@ -581,6 +628,30 @@ function createFallbackVote(output, _role, reason) {
     // Mark as synthetic
   };
 }
+var REASONING_MAX_CHARS = 4e3;
+var CLAIM_MAX_CHARS = 2e3;
+var TRUNCATION_MARKER = " \u2026[truncated]";
+function clampWithMarker(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, Math.max(0, max - TRUNCATION_MARKER.length)) + TRUNCATION_MARKER;
+}
+function clampOversizeVoteStrings(parsed) {
+  if (typeof parsed !== "object" || parsed === null) return parsed;
+  const obj = { ...parsed };
+  if (typeof obj["reasoning"] === "string") {
+    obj["reasoning"] = clampWithMarker(obj["reasoning"], REASONING_MAX_CHARS);
+  }
+  if (Array.isArray(obj["findings"])) {
+    obj["findings"] = obj["findings"].map((finding) => {
+      if (typeof finding === "object" && finding !== null && typeof finding["claim"] === "string") {
+        const f = finding;
+        return { ...f, claim: clampWithMarker(f["claim"], CLAIM_MAX_CHARS) };
+      }
+      return finding;
+    });
+  }
+  return obj;
+}
 function buildParsedVote(data) {
   return {
     decision: data.decision,
@@ -597,7 +668,7 @@ function parseVoteResponse(output, role, options) {
   try {
     const jsonStr = extractJsonFromResponse(output);
     const parsed = JSON.parse(jsonStr);
-    const validated = VoteResponseSchema.safeParse(parsed);
+    const validated = VoteResponseSchema.safeParse(clampOversizeVoteStrings(parsed));
     if (validated.success) {
       return buildParsedVote(validated.data);
     }
@@ -721,8 +792,12 @@ function buildVoteRequest(role, proposal, timeoutMs, withResponseFormat) {
       { role: "system", content: VOTER_SYSTEM_PROMPTS[role] },
       { role: "user", content: buildVotePrompt(proposal) }
     ],
-    // 2000 (#2245): JSON envelope + reasoning + YAML findings exceed the old 500.
-    maxTokens: 2e3,
+    // 4000 (#4131): headroom so a findings-bearing verdict (JSON envelope +
+    // reasoning + structured findings) isn't cut mid-JSON by the token cap and
+    // silently dropped. Was 2000 (#2245, up from 500); large contrarian findings
+    // still overflowed it. Non-findings votes stop at natural completion, so the
+    // higher cap adds no cost for them.
+    maxTokens: 4e3,
     temperature: 0.3,
     // Low temperature for consistent evaluations
     // Thread the vote budget so the CLI timeout doesn't fire first (#3304); pass
@@ -4230,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) {
@@ -4248,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(
@@ -4331,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,
@@ -4359,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) {
@@ -4415,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(
@@ -5750,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;
@@ -5762,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) {
@@ -5785,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);
@@ -5832,6 +5981,7 @@ async function executeVoting(input, logger10, opts) {
       input,
       strategy,
       algorithm,
+      roles,
       votes,
       errorPolicy,
       reason: policyDecision.reason ?? "error policy short-circuit",
@@ -5850,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,
@@ -5870,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, {
@@ -5891,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;
@@ -6108,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(
@@ -6212,9 +6374,10 @@ export {
   warnIfSimulatedOutsideTests,
   resetCorrelationTracker,
   createPolicyFailedResult,
+  maybeEscalateContrarian,
   executeVoting,
   runConsensusForGoal,
   CONSENSUS_VOTE_OUTPUT_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-SF3AM3SY.js.map
+//# sourceMappingURL=chunk-UIL37D2V.js.map