nexus-agents 4.15.5 → 4.16.0

package/dist/{chunk-TL57RB6H.js → chunk-2XNL5FUJ.js}

@@ -170,7 +170,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/version.ts
-var VERSION = true ? "4.15.5" : "dev";
+var VERSION = true ? "4.16.0" : "dev";
 
 // src/mcp/task-store.ts
 import { InMemoryTaskStore } from "@modelcontextprotocol/sdk/experimental/tasks";
@@ -1134,7 +1134,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 { initDataDirectories: initDataDirectories2, describeDataDirFix: describeDataDirFix2 } = await import("./setup-data-dir-AER2GI57.js");
+    const { initDataDirectories: initDataDirectories2, describeDataDirFix: describeDataDirFix2 } = await import("./setup-data-dir-LIZTPE42.js");
     const outcome = describeDataDirFix2(initDataDirectories2());
     writeLine2(outcome.line);
     if (outcome.counted) fixCount++;
@@ -1237,4 +1237,4 @@ export {
   startStdioServer,
   closeServer
 };
-//# sourceMappingURL=chunk-TL57RB6H.js.map
+//# sourceMappingURL=chunk-2XNL5FUJ.js.map

package/dist/{chunk-VPR6LDBO.js → chunk-5EB36WJD.js}

@@ -21,7 +21,7 @@ import {
 import {
   DEFAULT_TASK_TTL_MS,
   clampTaskTtl
-} from "./chunk-TL57RB6H.js";
+} from "./chunk-2XNL5FUJ.js";
 import {
   executeExpert
 } from "./chunk-BH5PWPKK.js";
@@ -7905,6 +7905,7 @@ var AegeanResultSchema = z21.object({
   totalRounds: z21.number().int().min(0),
   totalDurationMs: z21.number(),
   tokensUsed: z21.number().int().min(0),
+  unmeasuredTokenContributions: z21.number().int().min(0).default(0),
   rounds: z21.array(AegeanRoundSchema).readonly(),
   terminationReason: z21.enum(["consensus", "max_rounds", "timeout", "byzantine_failure", "error"])
 });
@@ -8118,6 +8119,10 @@ function buildAegeanConfig(options) {
   }
   return parsed.data;
 }
+function tokensFromMetadata(metadata) {
+  if (metadata.tokensMeasured === false) return { tokens: 0, unmeasured: 1 };
+  return { tokens: metadata.tokensUsed, unmeasured: 0 };
+}
 function buildAegeanResult(opts) {
   return {
     consensusValue: opts.consensusValue,
@@ -8125,6 +8130,7 @@ function buildAegeanResult(opts) {
     totalRounds: opts.rounds.length,
     totalDurationMs: getTimeProvider().now() - opts.startTime,
     tokensUsed: opts.tokensUsed,
+    unmeasuredTokenContributions: opts.unmeasuredTokenContributions,
     rounds: opts.rounds,
     terminationReason: opts.terminationReason
   };
@@ -8148,20 +8154,21 @@ function determineIterationAction(opts) {
     return { type: "early_termination" };
   return { type: "continue" };
 }
-function determinePreRoundAction(cancelled, rounds, startTime, tokensUsed) {
+function determinePreRoundAction(cancelled, rounds, startTime, tokensUsed, unmeasuredTokenContributions) {
   if (cancelled) {
     return buildAegeanResult({
       rounds,
       consensusValue: null,
       terminationReason: "error",
       startTime,
-      tokensUsed
+      tokensUsed,
+      unmeasuredTokenContributions
     });
   }
   return null;
 }
-function createIterationContext(rounds, startTime, totalTokensUsed) {
-  return { rounds, startTime, tokensUsed: totalTokensUsed };
+function createIterationContext(rounds, startTime, totalTokensUsed, unmeasuredTokenContributions) {
+  return { rounds, startTime, tokensUsed: totalTokensUsed, unmeasuredTokenContributions };
 }
 function processIterationAction(opts) {
   const { action, round, sessionId, ctx, emitIterationEvent, onEarlyTermination } = opts;
@@ -8173,7 +8180,8 @@ function processIterationAction(opts) {
         consensusValue: action.value,
         terminationReason: "consensus",
         startTime: ctx.startTime,
-        tokensUsed: ctx.tokensUsed
+        tokensUsed: ctx.tokensUsed,
+        unmeasuredTokenContributions: ctx.unmeasuredTokenContributions
       });
     case "early_termination":
       if (onEarlyTermination) onEarlyTermination(round);
@@ -8183,7 +8191,8 @@ function processIterationAction(opts) {
         consensusValue: null,
         terminationReason: "max_rounds",
         startTime: ctx.startTime,
-        tokensUsed: ctx.tokensUsed
+        tokensUsed: ctx.tokensUsed,
+        unmeasuredTokenContributions: ctx.unmeasuredTokenContributions
       });
     case "continue":
       emitIterationEvent(round, "in_progress", sessionId);
@@ -8194,12 +8203,13 @@ function processIterationAction(opts) {
         consensusValue: null,
         terminationReason: "error",
         startTime: ctx.startTime,
-        tokensUsed: ctx.tokensUsed
+        tokensUsed: ctx.tokensUsed,
+        unmeasuredTokenContributions: ctx.unmeasuredTokenContributions
       });
   }
 }
-function buildLoopResult(rounds, consensusValue, terminationReason, startTime, tokensUsed) {
-  return buildAegeanResult({ rounds, consensusValue, terminationReason, startTime, tokensUsed });
+function buildLoopResult(opts) {
+  return buildAegeanResult(opts);
 }
 function validateAegeanSetup(opts) {
   const minAgents = 3 * opts.byzantineTolerance + 1;
@@ -8231,6 +8241,10 @@ function buildSessionTaskResult(taskId, result, startTime) {
     metadata: {
       durationMs: getTimeProvider().now() - startTime,
       tokensUsed: result.tokensUsed,
+      // The count becomes the disclosure the rest of the tree already reads
+      // (#4734): a total assembled from contributors that reported nothing is
+      // a lower bound, and must not be handed on as a measurement (#4743).
+      tokensMeasured: result.unmeasuredTokenContributions === 0,
       toolsUsed: [],
       model: "aegean-protocol"
     }
@@ -8292,19 +8306,41 @@ var AegeanProtocol = class {
     const startTime = getTimeProvider().now();
     const rounds = [];
     let totalTokensUsed = 0;
+    let unmeasuredTokenContributions = 0;
     for (let round = 0; round < this.config.maxRounds; round++) {
-      const preAction = determinePreRoundAction(this.cancelled, rounds, startTime, totalTokensUsed);
+      const preAction = determinePreRoundAction(
+        this.cancelled,
+        rounds,
+        startTime,
+        totalTokensUsed,
+        unmeasuredTokenContributions
+      );
       if (preAction) return ok(preAction);
       const roundResult = await this.executeRound(round, config, agents);
       if (!roundResult.ok) return err(roundResult.error);
-      const { roundData, tokensUsed } = roundResult.value;
+      const { roundData, tokensUsed, unmeasured } = roundResult.value;
       rounds.push(roundData);
       totalTokensUsed += tokensUsed;
-      const ctx = createIterationContext(rounds, startTime, totalTokensUsed);
+      unmeasuredTokenContributions += unmeasured;
+      const ctx = createIterationContext(
+        rounds,
+        startTime,
+        totalTokensUsed,
+        unmeasuredTokenContributions
+      );
       const iterAction = this.handleIterationAction(round, roundData, config, ctx);
       if (iterAction) return ok(iterAction);
     }
-    return ok(buildLoopResult(rounds, null, "max_rounds", startTime, totalTokensUsed));
+    return ok(
+      buildLoopResult({
+        rounds,
+        consensusValue: null,
+        terminationReason: "max_rounds",
+        startTime,
+        tokensUsed: totalTokensUsed,
+        unmeasuredTokenContributions
+      })
+    );
   }
   /** Handles post-round iteration actions. */
   handleIterationAction(round, roundData, config, ctx) {
@@ -8346,16 +8382,36 @@ var AegeanProtocol = class {
     if (leader === void 0) {
       return err(new AgentError(`Leader agent not found: ${leaderId}`));
     }
-    this.logger.debug("Starting round", { roundNumber, leaderId });
-    emitAegeanRoundStarted(this.eventBus, {
-      round: roundNumber,
-      maxRounds: this.config.maxRounds,
+    this.announceRoundStart(roundNumber, leaderId, config.sessionId);
+    const gathered = await this.gatherRound(leader, leaderId, config, agents, roundNumber);
+    if (!gathered.ok) return err(gathered.error);
+    const { proposal, votes, tokensUsed, unmeasured } = gathered.value;
+    const quorumStatus = this.evaluateQuorum(
+      votes,
+      config.experts.length,
+      roundNumber,
+      config.sessionId
+    );
+    const roundData = createRoundData({
+      roundNumber,
       leaderId,
-      sessionId: config.sessionId
+      proposal,
+      votes,
+      quorumStatus,
+      startTime: roundStart
     });
+    this.logger.debug("Round complete", { roundNumber, ...quorumStatus });
+    return ok({ roundData, tokensUsed, unmeasured });
+  }
+  /** Phases 1 and 2 of a round: the leader's proposal, then the votes on it. */
+  async gatherRound(leader, leaderId, config, agents, roundNumber) {
     const proposalResult = await this.generateProposal(leader, leaderId, config.task, roundNumber);
     if (!proposalResult.ok) return err(proposalResult.error);
-    const { proposal, tokensUsed: proposalTokens } = proposalResult.value;
+    const {
+      proposal,
+      tokensUsed: proposalTokens,
+      unmeasured: proposalUnmeasured
+    } = proposalResult.value;
     const votesResult = await this.collectVotes({
       experts: config.experts,
       agents,
@@ -8365,31 +8421,23 @@ var AegeanProtocol = class {
       sessionId: config.sessionId
     });
     if (!votesResult.ok) return err(votesResult.error);
-    const { votes, tokensUsed: voteTokens } = votesResult.value;
-    const quorumStatus = this.evaluateQuorum(
-      votes,
-      config.experts.length,
-      roundNumber,
-      config.sessionId
-    );
-    const roundData = createRoundData({
-      roundNumber,
-      leaderId,
+    const { votes, tokensUsed: voteTokens, unmeasured: voteUnmeasured } = votesResult.value;
+    return ok({
       proposal,
       votes,
-      quorumStatus,
-      startTime: roundStart
+      tokensUsed: proposalTokens + voteTokens,
+      unmeasured: proposalUnmeasured + voteUnmeasured
     });
-    this.logger.debug("Round complete", { roundNumber, ...quorumStatus });
-    return ok({ roundData, tokensUsed: proposalTokens + voteTokens });
   }
   /** Generates a proposal from the leader. */
   async generateProposal(leader, leaderId, task, round) {
     const result = await leader.execute(createProposalTask(task, round));
     if (!result.ok) return err(result.error);
+    const { tokens, unmeasured } = tokensFromMetadata(result.value.metadata);
     return ok({
       proposal: createProposal(round, leaderId, result.value.output),
-      tokensUsed: result.value.metadata.tokensUsed
+      tokensUsed: tokens,
+      unmeasured
     });
   }
   /** Collects votes from all agents. */
@@ -8397,27 +8445,16 @@ var AegeanProtocol = class {
     const { experts, agents, proposal, leaderId, roundNumber, sessionId } = opts;
     const votes = [];
     let totalTokens = 0;
+    let totalUnmeasured = 0;
     const quorumSize = calculateQuorumSize(experts.length, this.config.byzantineTolerance);
     const voterIds = experts.filter((id) => id !== leaderId);
-    const votePromises = voterIds.map(async (agentId) => {
-      const agent = agents.get(agentId);
-      if (agent === void 0) {
-        return { agentId, vote: createTimeoutVote(agentId, proposal.proposalId), tokens: 0 };
-      }
-      const voteResult = await this.getAgentVote(agent, agentId, proposal);
-      if (!voteResult.ok) {
-        return {
-          agentId,
-          vote: createTimeoutVote(agentId, proposal.proposalId),
-          tokens: 0
-        };
-      }
-      return { agentId, vote: voteResult.value.vote, tokens: voteResult.value.tokensUsed };
-    });
-    const results = await Promise.all(votePromises);
-    for (const { vote, tokens } of results) {
+    const results = await Promise.all(
+      voterIds.map((agentId) => this.voteOrTimeout(agents.get(agentId), agentId, proposal))
+    );
+    for (const { vote, tokens, unmeasured } of results) {
       votes.push(vote);
       totalTokens += tokens;
+      totalUnmeasured += unmeasured;
       emitAegeanVoteCollected(this.eventBus, {
         round: roundNumber,
         voterId: vote.agentId,
@@ -8427,22 +8464,55 @@ var AegeanProtocol = class {
       });
     }
     votes.push(createLeaderVote(leaderId, proposal.proposalId));
-    return ok({ votes, tokensUsed: totalTokens });
+    return ok({ votes, tokensUsed: totalTokens, unmeasured: totalUnmeasured });
+  }
+  /** Logs and emits the round-started event (Issue #216). */
+  announceRoundStart(roundNumber, leaderId, sessionId) {
+    this.logger.debug("Starting round", { roundNumber, leaderId });
+    emitAegeanRoundStarted(this.eventBus, {
+      round: roundNumber,
+      maxRounds: this.config.maxRounds,
+      leaderId,
+      sessionId
+    });
+  }
+  /**
+   * One voter's contribution, or a timeout vote when the agent is missing or
+   * errored. A timeout contributes no tokens by a different route than an
+   * unmeasured one — nothing executed — so it is not counted as unmeasured.
+   */
+  async voteOrTimeout(agent, agentId, proposal) {
+    const timedOut = {
+      agentId,
+      vote: createTimeoutVote(agentId, proposal.proposalId),
+      tokens: 0,
+      unmeasured: 0
+    };
+    if (agent === void 0) return timedOut;
+    const voteResult = await this.getAgentVote(agent, agentId, proposal);
+    if (!voteResult.ok) return timedOut;
+    return {
+      agentId,
+      vote: voteResult.value.vote,
+      tokens: voteResult.value.tokensUsed,
+      unmeasured: voteResult.value.unmeasured
+    };
   }
   /** Gets a vote from an agent. */
   async getAgentVote(agent, agentId, proposal) {
     const result = await agent.execute(createVoteTask(proposal, agentId));
     if (!result.ok) {
-      return ok({ vote: createTimeoutVote(agentId, proposal.proposalId), tokensUsed: 0 });
+      return ok({
+        vote: createTimeoutVote(agentId, proposal.proposalId),
+        tokensUsed: 0,
+        unmeasured: 0
+      });
     }
-    return ok(
-      createVoteFromOutput(
-        agentId,
-        proposal.proposalId,
-        result.value.output,
-        result.value.metadata.tokensUsed
-      )
-    );
+    const { tokens, unmeasured } = tokensFromMetadata(result.value.metadata);
+    return ok({
+      ...createVoteFromOutput(agentId, proposal.proposalId, result.value.output, tokens),
+      unmeasured
+    });
   }
   /** Evaluates quorum status from votes. */
   evaluateQuorum(votes, totalAgents, roundNumber, sessionId) {
@@ -45527,6 +45597,12 @@ function getVoteFeedback(result) {
 }
 var MAX_VOTE_ITERATIONS = 3;
 var MAX_QA_ITERATIONS = 3;
+function resolveIterationLimits(options) {
+  return {
+    vote: options?.maxVoteIterations ?? MAX_VOTE_ITERATIONS,
+    qa: options?.maxQaIterations ?? MAX_QA_ITERATIONS
+  };
+}
 async function runDevPipeline(task, stages, options) {
   const sid = options?.sessionId;
   const prior = sid !== void 0 ? loadCheckpointState(sid) : null;
@@ -45556,13 +45632,11 @@ async function runDevPipelineInner(task, stages, options, sid, prior) {
     logger42.info("Harness mode \u2014 returning tasks for external implementation");
     return buildHarnessResult(planResult, tasks);
   }
-  const result = await runImplSecurityPhase(
-    planResult,
-    tasks,
-    stages,
+  const result = await runImplSecurityPhase(planResult, tasks, stages, {
     sid,
-    options?.qualityGate ?? "off"
-  );
+    qualityGateMode: options?.qualityGate ?? "off",
+    limits: resolveIterationLimits(options)
+  });
   applyPipelineHindsight(bm, task, sid, result);
   return result;
 }
@@ -45776,7 +45850,10 @@ async function runPlanningPhase(task, stages, prior, options) {
     saveStageCheckpoint(sid, "research", { type: "research", text: research.text });
   }
   const planContext = await assemblePlanContext(research.text, task, sid, bm);
-  const planResult = await runPlanOrResume(prior, task, planContext, stages, sid);
+  const planResult = await runPlanOrResume(prior, task, planContext, stages, {
+    sid,
+    limits: resolveIterationLimits(options)
+  });
   if (sid !== void 0) {
     saveStageCheckpoint(sid, "plan", {
       type: "plan",
@@ -45807,8 +45884,9 @@ function buildHarnessResult(planResult, tasks) {
     securityRan: false
   };
 }
-async function runImplSecurityPhase(planResult, tasks, stages, sid, qualityGateMode) {
-  const implResult = await implementQaLoop(tasks, stages);
+async function runImplSecurityPhase(planResult, tasks, stages, run) {
+  const { sid, qualityGateMode, limits } = run;
+  const implResult = await implementQaLoop(tasks, stages, limits);
   if (sid !== void 0)
     saveStageCheckpoint(sid, "implement", { type: "implement", tasks: implResult.completedTasks });
   const qaGate = await runQualityGateStage(stages, qualityGateMode);
@@ -45866,7 +45944,8 @@ async function runQualityGateStage(stages, mode) {
     }
   );
 }
-async function runPlanOrResume(prior, task, research, stages, sessionId) {
+async function runPlanOrResume(prior, task, research, stages, run) {
+  const { sid: sessionId, limits } = run;
   if (prior?.plan !== void 0) {
     logger42.info("Resuming from checkpoint", { stage: "plan", sessionId });
     return {
@@ -45877,7 +45956,7 @@ async function runPlanOrResume(prior, task, research, stages, sessionId) {
       caveats: prior.voteCaveats ?? []
     };
   }
-  return planVoteLoop(task, research, stages, sessionId);
+  return planVoteLoop(task, research, stages, sessionId, limits);
 }
 async function runOrResumeDecompose(prior, plan, stages, meta) {
   if (prior?.tasks !== void 0) {
@@ -45901,10 +45980,10 @@ function extractConditionalMeta(vote) {
   }
   return { conditional: false, conditions: [], caveats: [] };
 }
-async function planVoteLoop(task, research, stages, sessionId) {
+async function planVoteLoop(task, research, stages, sessionId, limits) {
   let feedback;
   let plan = "";
-  for (let i = 1; i <= MAX_VOTE_ITERATIONS; i++) {
+  for (let i = 1; i <= limits.vote; i++) {
     plan = await withStep(
       { name: `plan (i=${String(i)})`, kind: "pipeline.stage", attrs: { iteration: i } },
       () => stages.plan(task, research, feedback)
@@ -45941,9 +46020,9 @@ async function planVoteLoop(task, research, stages, sessionId) {
     });
   }
   logger42.warn("Max vote iterations reached, proceeding with last plan", { sessionId });
-  return { plan, iterations: MAX_VOTE_ITERATIONS, conditional: false, conditions: [], caveats: [] };
+  return { plan, iterations: limits.vote, conditional: false, conditions: [], caveats: [] };
 }
-async function implementSingleTask(task, stages) {
+async function implementSingleTask(task, stages, limits) {
   let currentTask = { ...task, status: "in_progress" };
   const qaResult = await runQaLoop(
     async (feedback) => {
@@ -45965,7 +46044,7 @@ async function implementSingleTask(task, stages) {
       const review = await stages.qaReview(currentTask, impl);
       return { verdict: review.verdict, feedback: review.feedback, issues: review.issues };
     },
-    MAX_QA_ITERATIONS
+    limits.qa
   );
   const finalTask = {
     id: task.id,
@@ -45981,15 +46060,15 @@ async function implementSingleTask(task, stages) {
   return { iterations: qaResult.iterations, task: finalTask };
 }
 var MAX_IMPL_CONCURRENCY = 4;
-async function implementQaLoop(tasks, stages) {
+async function implementQaLoop(tasks, stages, limits) {
   if (tasks.length === 0) return { totalIterations: 0, completedTasks: [] };
-  const taskFns = tasks.map((task) => () => implementSingleTaskSafe(task, stages));
+  const taskFns = tasks.map((task) => () => implementSingleTaskSafe(task, stages, limits));
   const results = await executeWithConcurrency(taskFns, MAX_IMPL_CONCURRENCY);
   return aggregateImplResults(results);
 }
-async function implementSingleTaskSafe(task, stages) {
+async function implementSingleTaskSafe(task, stages, limits) {
   try {
-    return await implementSingleTask(task, stages);
+    return await implementSingleTask(task, stages, limits);
   } catch (error) {
     const reason = error instanceof Error ? error : new Error(String(error));
     logger42.error("Task implementation failed", reason, {});
@@ -51097,6 +51176,10 @@ function buildPipelineOptions(input, trustTier, auditLogger) {
     ...input.dryRun ? { dryRun: true } : {},
     ...input.mode === "harness" ? { mode: "harness" } : {},
     ...input.qualityGate !== "off" ? { qualityGate: input.qualityGate } : {},
+    // #4939: both were advertised, bounds-checked and defaulted since the tool
+    // shipped, and neither was ever read off `parsed.data`.
+    maxVoteIterations: input.maxVoteIterations,
+    maxQaIterations: input.maxQaIterations,
     ...trustTier !== void 0 ? { trustTier } : {},
     // #3710: thread the server's durable audit logger so the consensus→execute
     // policy gate persists decisions to the shared hash chain.
@@ -55780,4 +55863,4 @@ export {
   shutdownFeedbackSubscriber,
   createEventBusBridge
 };
-//# sourceMappingURL=chunk-VPR6LDBO.js.map
+//# sourceMappingURL=chunk-5EB36WJD.js.map