nexus-agents 4.15.5 → 4.15.6

package/dist/{chunk-TL57RB6H.js → chunk-QZAMRR2Q.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.15.6" : "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-VLOT7GSQ.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-QZAMRR2Q.js.map

package/dist/{chunk-VPR6LDBO.js → chunk-XED5OLWO.js}

@@ -21,7 +21,7 @@ import {
 import {
   DEFAULT_TASK_TTL_MS,
   clampTaskTtl
-} from "./chunk-TL57RB6H.js";
+} from "./chunk-QZAMRR2Q.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) {
@@ -55780,4 +55850,4 @@ export {
   shutdownFeedbackSubscriber,
   createEventBusBridge
 };
-//# sourceMappingURL=chunk-VPR6LDBO.js.map
+//# sourceMappingURL=chunk-XED5OLWO.js.map