nexus-agents 8.19.1 → 8.20.0

package/dist/{chunk-UDYR3ME6.js → chunk-ASUB4LSV.js}

@@ -23,10 +23,10 @@ import {
   toolSuccessStructured,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-XLNP4ODH.js";
+} from "./chunk-FZXMMOBQ.js";
 import {
   VERSION
-} from "./chunk-CKTLFPT3.js";
+} from "./chunk-AWFW6FD4.js";
 import {
   assessPanelIndependence,
   countDistinctModels,
@@ -7205,4 +7205,4 @@ export {
   CONSENSUS_VOTE_TOOL_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-UDYR3ME6.js.map
+//# sourceMappingURL=chunk-ASUB4LSV.js.map

package/dist/chunk-AWFW6FD4.js

@@ -0,0 +1,7 @@
+// src/version.ts
+var VERSION = true ? "8.20.0" : "dev";
+
+export {
+  VERSION
+};
+//# sourceMappingURL=chunk-AWFW6FD4.js.map

package/dist/{chunk-XLNP4ODH.js → chunk-FZXMMOBQ.js}

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-CKTLFPT3.js";
+} from "./chunk-AWFW6FD4.js";
 import {
   emitClawGuardViolation
 } from "./chunk-TCTKOFNL.js";
@@ -2246,4 +2246,4 @@ export {
   VOTING_THRESHOLDS,
   ConsensusMetricsSchema
 };
-//# sourceMappingURL=chunk-XLNP4ODH.js.map
+//# sourceMappingURL=chunk-FZXMMOBQ.js.map

package/dist/{chunk-PY6BGMNJ.js → chunk-PIWFHJSU.js}

@@ -21,7 +21,7 @@ import {
 import {
   DEFAULT_TASK_TTL_MS,
   clampTaskTtl
-} from "./chunk-KRCRVSGX.js";
+} from "./chunk-XSRCJ7FA.js";
 import {
   executeExpert
 } from "./chunk-C7CSLODO.js";
@@ -48,7 +48,7 @@ import {
   simulationDeniedResult,
   toJobSummary,
   writeJobCancelled
-} from "./chunk-UDYR3ME6.js";
+} from "./chunk-ASUB4LSV.js";
 import {
   allOf
 } from "./chunk-OQB3XC5O.js";
@@ -67,7 +67,7 @@ import {
 } from "./chunk-ZUK5BG3Q.js";
 import {
   withPrerequisite
-} from "./chunk-DRD2GXBT.js";
+} from "./chunk-W5M6VFDH.js";
 import {
   NOOP_NOTIFIER,
   RateLimiter,
@@ -92,7 +92,7 @@ import {
   withAuditTrail,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-XLNP4ODH.js";
+} from "./chunk-FZXMMOBQ.js";
 import {
   createAuditTrail,
   createGraphAuditBridge,
@@ -45808,6 +45808,149 @@ function checkpointToResult(state) {
   return result;
 }
 
+// src/pipeline/iterative-consensus.ts
+var defaultLogger3 = createLogger({ component: "iterative-consensus" });
+var DEFAULT_MAX_ITERATIONS = 3;
+var DEFAULT_MAX_NO_QUORUM_RETRIES = 2;
+var DEFAULT_MAX_PROPOSAL_LENGTH = 4e3;
+var DEFAULT_STRATEGY = "higher_order";
+var DEFAULT_PREFIX = "pipeline";
+async function voteWithQuorumRecovery(state) {
+  const outcome = await retryNoQuorumVote(
+    () => executeSingleVote(state.plan, state.config, state.log),
+    state.maxNoQuorumRetries,
+    (attempt, vote) => {
+      state.log.warn("Vote reached no_quorum \u2014 re-running the missing voice (bounded)", {
+        attempt,
+        maxNoQuorumRetries: state.maxNoQuorumRetries,
+        reason: vote.reason
+      });
+      emitPipelineStageEvent(state.prefix, "vote", "started");
+    }
+  );
+  return outcome.vote;
+}
+async function retryNoQuorumVote(executeVote, maxRetries = DEFAULT_MAX_NO_QUORUM_RETRIES, onRetry) {
+  let vote = await executeVote();
+  let retries = 0;
+  while (vote.kind === "no_quorum" && retries < maxRetries) {
+    retries++;
+    onRetry?.(retries, vote);
+    vote = await executeVote();
+  }
+  return { vote, retries };
+}
+async function runOneIteration(state, iteration) {
+  state.log.info("Consensus iteration", { iteration });
+  emitPipelineStageEvent(state.prefix, "vote", "started");
+  state.lastVote = await voteWithQuorumRecovery(state);
+  const iterMs = getTimeProvider().now() - state.globalStart;
+  const accepted = isVoteAccepted(state.lastVote);
+  emitPipelineStageEvent(state.prefix, "vote", accepted ? "completed" : "failed", {
+    durationMs: iterMs
+  });
+  if (accepted) {
+    return { result: { vote: state.lastVote, iterations: iteration, durationMs: iterMs } };
+  }
+  if (state.lastVote.kind === "no_quorum") {
+    const terminalVote = {
+      kind: "no_quorum",
+      reason: `vote could not reach quorum after ${String(state.maxNoQuorumRetries)} re-run(s): ${state.lastVote.reason}`,
+      approvalPercentage: state.lastVote.approvalPercentage
+    };
+    return { terminal: { vote: terminalVote, iterations: iteration, durationMs: iterMs } };
+  }
+  return {};
+}
+async function runIterativeConsensus(initialPlan, revisePlan, config) {
+  const maxIter = config?.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+  const state = {
+    plan: initialPlan,
+    lastVote: void 0,
+    config,
+    log: config?.logger ?? defaultLogger3,
+    prefix: config?.pipelinePrefix ?? DEFAULT_PREFIX,
+    globalStart: getTimeProvider().now(),
+    maxNoQuorumRetries: config?.maxNoQuorumRetries ?? DEFAULT_MAX_NO_QUORUM_RETRIES
+  };
+  return runConsensusLoop(state, maxIter, revisePlan);
+}
+async function runConsensusLoop(state, maxIter, revisePlan) {
+  for (let i = 0; i < maxIter; i++) {
+    const outcome = await runOneIteration(state, i + 1);
+    const done = outcome.result ?? outcome.terminal;
+    if (done !== void 0) return done;
+    await maybeRevise(state, i, maxIter, revisePlan);
+  }
+  return buildExhaustedResult(state, maxIter);
+}
+function isVoteAccepted(vote) {
+  return vote.kind === "approved" || vote.kind === "conditional_go";
+}
+function extractFeedback2(vote) {
+  if (vote === void 0) return "";
+  return vote.kind === "rejected" ? vote.feedback : "";
+}
+async function maybeRevise(state, iteration, maxIter, revisePlan) {
+  if (iteration >= maxIter - 1) return;
+  state.log.info("Vote rejected, revising plan", { iteration: iteration + 1 });
+  state.plan = await revisePlan(state.plan, extractFeedback2(state.lastVote));
+}
+function buildExhaustedResult(state, maxIter) {
+  const totalMs = getTimeProvider().now() - state.globalStart;
+  const fallback = {
+    kind: "rejected",
+    feedback: "No votes executed",
+    approvalPercentage: 0
+  };
+  return { vote: state.lastVote ?? fallback, iterations: maxIter, durationMs: totalMs };
+}
+function buildVotingInput(plan, config) {
+  const c = config ?? {};
+  const maxLen = c.maxProposalLength ?? DEFAULT_MAX_PROPOSAL_LENGTH;
+  return {
+    proposal: plan.slice(0, maxLen),
+    strategy: c.strategy ?? DEFAULT_STRATEGY,
+    simulateVotes: c.simulateVotes ?? false,
+    quickMode: c.quickMode ?? false,
+    // #4138: this reusable helper opts into absolute_quorum by default.
+    errorPolicy: c.errorPolicy ?? "absolute_quorum"
+  };
+}
+async function executeSingleVote(plan, config, log) {
+  try {
+    const { executeVoting } = await import("./consensus-vote-X4XXWGDD.js");
+    const input = buildVotingInput(plan, config);
+    const result = await executeVoting(input, log);
+    return parseVotingResult(result);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    log.warn("Vote execution failed, treating as rejected", { error: msg });
+    return {
+      kind: "rejected",
+      feedback: `Vote infrastructure failed \u2014 no consensus produced: ${msg}`,
+      approvalPercentage: 0
+    };
+  }
+}
+function parseVotingResult(result) {
+  const total = Math.max(1, result.result.voteCounts.approve + result.result.voteCounts.reject);
+  const pct = result.result.voteCounts.approve / total * 100;
+  const decision = result.decision ?? (result.result.outcome === "approved" ? "approved" : "rejected");
+  if (decision === "approved") {
+    return { kind: "approved", approvalPercentage: pct };
+  }
+  if (decision === "no_quorum") {
+    return {
+      kind: "no_quorum",
+      reason: "vote could not reach quorum (a voice was missing)",
+      approvalPercentage: pct
+    };
+  }
+  const feedback = result.votes.filter((v) => v.vote.decision !== "approve").map((v) => v.vote.reasoning).join("\n");
+  return { kind: "rejected", feedback, approvalPercentage: pct };
+}
+
 // src/orchestration/qa-loop.ts
 var logger40 = createLogger({ component: "qa-loop" });
 var DEFAULT_MAX_QA_ITERATIONS = 3;
@@ -45882,6 +46025,11 @@ async function runDevPipelineInner(task, stages, options, sid, prior) {
     logger41.info("Dry run \u2014 stopping after plan+vote");
     return buildDryRunResult(planResult);
   }
+  if (planResult.planStatus !== void 0) {
+    const result2 = buildPlanFailureResult(planResult);
+    applyPipelineHindsight(bm, task, sid, result2);
+    return result2;
+  }
   enforceConsensusExecutePolicy(sid, trustTier, auditLogger);
   const tasks = await runOrResumeDecompose(prior, planResult.plan, stages, {
     conditional: planResult.conditional,
@@ -46083,7 +46231,25 @@ function buildDryRunResult(planResult) {
     // "the security gate rejected this"; `securityRan: false` says it never ran.
     securityPassed: false,
     securityRan: false,
-    ...planResult.plan.trim() === "" ? { planStatus: "empty" } : {}
+    ...planResult.planStatus !== void 0 ? { planStatus: planResult.planStatus } : {},
+    ...planResult.planVoteReason !== void 0 ? { planVoteReason: planResult.planVoteReason } : {},
+    ...planResult.planVoteApprovalPercentage !== void 0 ? { planVoteApprovalPercentage: planResult.planVoteApprovalPercentage } : {},
+    ...planResult.planVoteFeedback !== void 0 ? { planVoteFeedback: planResult.planVoteFeedback } : {}
+  };
+}
+function buildPlanFailureResult(planResult) {
+  return {
+    completed: false,
+    plan: planResult.plan,
+    tasks: [],
+    voteIterations: planResult.iterations,
+    qaIterations: 0,
+    securityPassed: false,
+    securityRan: false,
+    planStatus: planResult.planStatus ?? "unapproved",
+    ...planResult.planVoteReason !== void 0 ? { planVoteReason: planResult.planVoteReason } : {},
+    ...planResult.planVoteApprovalPercentage !== void 0 ? { planVoteApprovalPercentage: planResult.planVoteApprovalPercentage } : {},
+    ...planResult.planVoteFeedback !== void 0 ? { planVoteFeedback: planResult.planVoteFeedback } : {}
   };
 }
 async function resolveResearch(prior, task, stages, options) {
@@ -46115,7 +46281,7 @@ async function runPlanningPhase(task, stages, prior, options) {
     sid,
     limits: resolveIterationLimits(options)
   });
-  if (sid !== void 0) {
+  if (sid !== void 0 && planResult.planStatus === void 0) {
     saveStageCheckpoint(sid, "plan", {
       type: "plan",
       text: planResult.plan,
@@ -46123,7 +46289,7 @@ async function runPlanningPhase(task, stages, prior, options) {
     });
     saveStageCheckpoint(sid, "vote", {
       type: "vote",
-      approved: planResult.conditional || planResult.iterations > 0,
+      approved: true,
       conditional: planResult.conditional,
       conditions: planResult.conditions,
       caveats: planResult.caveats,
@@ -46239,6 +46405,7 @@ function extractConditionalMeta(vote) {
 async function planVoteLoop(task, research, stages, sessionId, limits) {
   let feedback;
   let plan = "";
+  let lastRejected;
   for (let i = 1; i <= limits.vote; i++) {
     plan = await withStep(
       { name: `plan (i=${String(i)})`, attrs: { iteration: i } },
@@ -46246,37 +46413,100 @@ async function planVoteLoop(task, research, stages, sessionId, limits) {
     );
     if (plan.trim() === "") {
       logger41.warn("Planner returned no plan \u2014 stopping before vote", { iteration: i, sessionId });
-      return { plan: "", iterations: i, conditional: false, conditions: [], caveats: [] };
-    }
-    const vote = await withStep(
-      { name: `vote (i=${String(i)})`, attrs: { iteration: i } },
-      async (ctx) => {
-        const r = await stages.vote(plan, research);
-        ctx.setSummary(
-          `${String(Math.round(r.approvalPercentage))}% ${isApproved(r) ? "approved" : "rejected"}`
-        );
-        return r;
+      return {
+        plan: "",
+        iterations: i,
+        conditional: false,
+        conditions: [],
+        caveats: [],
+        planStatus: "empty"
+      };
+    }
+    const voteOutcome = await retryNoQuorumVote(
+      () => runPlanVote(plan, research, stages, i),
+      DEFAULT_MAX_NO_QUORUM_RETRIES,
+      (attempt, vote2) => {
+        logQuorumRetry(attempt, vote2, sessionId);
       }
     );
-    if (isApproved(vote)) {
-      const meta = extractConditionalMeta(vote);
-      logger41.info("Plan approved", {
-        iteration: i,
-        approval: vote.approvalPercentage,
-        sessionId,
-        ...meta
-      });
-      return { plan, iterations: i, ...meta };
+    const vote = voteOutcome.vote;
+    if (vote.kind === "approved" || vote.kind === "conditional_go") {
+      return buildApprovedPlanResult(plan, i, vote, sessionId);
+    }
+    if (vote.kind === "no_quorum") {
+      return buildNoQuorumPlanResult(plan, i, vote, voteOutcome.retries);
     }
-    feedback = getVoteFeedback(vote);
+    lastRejected = vote;
+    feedback = vote.feedback;
     logger41.warn("Plan rejected, iterating", {
       iteration: i,
       feedback: feedback.slice(0, 200),
       sessionId
     });
   }
-  logger41.warn("Max vote iterations reached, proceeding with last plan", { sessionId });
-  return { plan, iterations: limits.vote, conditional: false, conditions: [], caveats: [] };
+  return buildUnapprovedPlanResult(plan, limits.vote, lastRejected, sessionId);
+}
+function buildApprovedPlanResult(plan, iterations, vote, sessionId) {
+  const meta = extractConditionalMeta(vote);
+  logger41.info("Plan approved", {
+    iteration: iterations,
+    approval: vote.approvalPercentage,
+    sessionId,
+    ...meta
+  });
+  return { plan, iterations, ...meta };
+}
+async function runPlanVote(plan, research, stages, iteration) {
+  return withStep({ name: `vote (i=${String(iteration)})`, attrs: { iteration } }, async (ctx) => {
+    const result = await stages.vote(plan, research);
+    const label = result.kind === "no_quorum" ? "no_quorum" : isApproved(result) ? "approved" : "rejected";
+    ctx.setSummary(`${String(Math.round(result.approvalPercentage))}% ${label}`);
+    return result;
+  });
+}
+function logQuorumRetry(attempt, vote, sessionId) {
+  logger41.warn("Plan vote reached no_quorum \u2014 re-running the same plan", {
+    attempt,
+    maxNoQuorumRetries: DEFAULT_MAX_NO_QUORUM_RETRIES,
+    reason: vote.reason,
+    sessionId
+  });
+}
+function buildNoQuorumPlanResult(plan, iterations, vote, retries) {
+  logger41.warn("Plan vote could not reach quorum \u2014 stopping", {
+    retries,
+    reason: vote.reason
+  });
+  return {
+    plan,
+    iterations,
+    conditional: false,
+    conditions: [],
+    caveats: [],
+    planStatus: "no_quorum",
+    planVoteReason: vote.reason,
+    planVoteApprovalPercentage: vote.approvalPercentage
+  };
+}
+function buildUnapprovedPlanResult(plan, iterations, vote, sessionId) {
+  const feedback = vote?.feedback ?? "No plan vote was run";
+  const approvalPercentage = vote?.approvalPercentage ?? 0;
+  logger41.warn("Max vote iterations reached without plan approval \u2014 stopping", {
+    sessionId,
+    iterations,
+    approvalPercentage,
+    feedback: feedback.slice(0, 200)
+  });
+  return {
+    plan,
+    iterations,
+    conditional: false,
+    conditions: [],
+    caveats: [],
+    planStatus: "unapproved",
+    planVoteApprovalPercentage: approvalPercentage,
+    planVoteFeedback: feedback
+  };
 }
 async function implementSingleTask(task, stages, limits) {
   let currentTask = { ...task, status: "in_progress" };
@@ -47461,13 +47691,15 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-QOWW7RVO.js");
+        const { executeVoting } = await import("./consensus-vote-X4XXWGDD.js");
         const votingResult = await executeVoting(
           {
             proposal: buildVoteProposal(plan, research),
             strategy,
             simulateVotes: config.simulateVotes ?? false,
-            quickMode: config.quickMode ?? false
+            quickMode: config.quickMode ?? false,
+            // #5506: plan approval requires the requested panel, not only survivors.
+            errorPolicy: "absolute_quorum"
           },
           logger45
         );
@@ -50439,6 +50671,37 @@ function classifyDispatchError(err2) {
   return err2 instanceof MetaDispatchError && err2.code === "no_executor" ? "business" : "internal";
 }
 
+// src/mcp/tools/run-tool-incomplete.ts
+var FAILURE_PREFIX = "Engine reported failure:";
+function describePlanFailure(record) {
+  if (record["planStatus"] === "empty") {
+    return `${FAILURE_PREFIX} the planner returned no plan, so nothing was built`;
+  }
+  if (record["planStatus"] === "unapproved") {
+    const iterations = typeof record["voteIterations"] === "number" ? String(record["voteIterations"]) : "an unknown number of";
+    return `${FAILURE_PREFIX} the panel did not approve the plan after ${iterations} iterations`;
+  }
+  if (record["planStatus"] === "no_quorum") {
+    const reason = typeof record["planVoteReason"] === "string" ? record["planVoteReason"] : "no reason was recorded";
+    return `${FAILURE_PREFIX} the plan vote could not reach quorum: ${reason}`;
+  }
+  return void 0;
+}
+function describeIncompletePipeline(record) {
+  const planFailure = describePlanFailure(record);
+  if (planFailure !== void 0) return planFailure;
+  if (record["securityRan"] === true) {
+    return `${FAILURE_PREFIX} the security gate rejected the change`;
+  }
+  if (record["securityRan"] === false) {
+    if (typeof record["securityNote"] === "string") {
+      return `${FAILURE_PREFIX} the security scan did not run (${record["securityNote"]}); the change is blocked until it does`;
+    }
+    return `${FAILURE_PREFIX} the run stopped before the security gate, which never ran`;
+  }
+  return `${FAILURE_PREFIX} the dev pipeline did not complete`;
+}
+
 // src/orchestration/meta-orchestrator.ts
 import { randomUUID as randomUUID14 } from "node:crypto";
 
@@ -51395,6 +51658,9 @@ function buildStructuredOutput(result, simulated) {
     // here, so they never reached the MCP surface.
     ...result.securityRan !== void 0 ? { securityRan: result.securityRan } : {},
     ...result.planStatus !== void 0 ? { planStatus: result.planStatus } : {},
+    ...result.planVoteReason !== void 0 ? { planVoteReason: result.planVoteReason } : {},
+    ...result.planVoteApprovalPercentage !== void 0 ? { planVoteApprovalPercentage: result.planVoteApprovalPercentage } : {},
+    ...result.planVoteFeedback !== void 0 ? { planVoteFeedback: result.planVoteFeedback } : {},
     // #4993 added `dryRun` to DevPipelineResult for exactly the reason above —
     // it says `completed: false` was the request, not a fault — and then did
     // not list it here either. Same omission, same function, under the comment
@@ -51895,27 +52161,11 @@ function detectEngineFailure(result) {
     return { message: `Engine reported failure: ${detail}` };
   }
   if (record["completed"] === false) {
-    if (record["dryRun"] === true && record["planStatus"] !== "empty") return null;
+    if (record["dryRun"] === true && record["planStatus"] === void 0) return null;
     return { message: describeIncompletePipeline(record), detail: record };
   }
   return null;
 }
-function describeIncompletePipeline(record) {
-  const prefix = "Engine reported failure:";
-  if (record["planStatus"] === "empty") {
-    return `${prefix} the planner returned no plan, so nothing was built`;
-  }
-  if (record["securityRan"] === true) {
-    return `${prefix} the security gate rejected the change`;
-  }
-  if (record["securityRan"] === false) {
-    if (typeof record["securityNote"] === "string") {
-      return `${prefix} the security scan did not run (${record["securityNote"]}); the change is blocked until it does`;
-    }
-    return `${prefix} the run stopped before the security gate, which never ran`;
-  }
-  return `${prefix} the dev pipeline did not complete`;
-}
 async function executeRunBody(input, logger57, trustTier, gatewayAdapters) {
   try {
     const exec2 = await executeGoal(input, {
@@ -56074,6 +56324,7 @@ export {
   loadCheckpointState,
   cleanupCheckpoint2 as cleanupCheckpoint,
   checkpointToResult,
+  runIterativeConsensus,
   runDevPipeline,
   flushPipelineMemory,
   createAgentStages,
@@ -56125,4 +56376,4 @@ export {
   shutdownFeedbackSubscriber,
   createEventBusBridge
 };
-//# sourceMappingURL=chunk-PY6BGMNJ.js.map
+//# sourceMappingURL=chunk-PIWFHJSU.js.map