nexus-agents 2.117.3 → 2.119.0

package/dist/{chunk-KY6UJGXP.js → chunk-6M4BCY2N.js}

@@ -8,7 +8,7 @@ import {
   checkSqlite,
   defaultConfig,
   initDataDirectories
-} from "./chunk-KU7GX43O.js";
+} from "./chunk-WGVRUD3L.js";
 import {
   probeAllClis
 } from "./chunk-ONSYPTQV.js";
@@ -1987,4 +1987,4 @@ export {
   setupCommand,
   setupCommandAsync
 };
-//# sourceMappingURL=chunk-KY6UJGXP.js.map
+//# sourceMappingURL=chunk-6M4BCY2N.js.map

package/dist/{chunk-KZJHMSH6.js → chunk-I4BPTXSC.js}

@@ -115,7 +115,7 @@ import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-KU7GX43O.js";
+} from "./chunk-WGVRUD3L.js";
 import {
   resolveInsideRoot
 } from "./chunk-NUBSJGQZ.js";
@@ -34224,6 +34224,64 @@ function registerDelegateToModelTool(server, deps) {
   logger56.info("Registered delegate_to_model tool with secure handler and timeout protection");
 }
 
+// src/orchestration/graph/consensus-node.ts
+async function runConsensusGate(voter, input) {
+  try {
+    return await voter(input);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      outcome: "rejected",
+      feedback: `Consensus gate failed closed (voter error): ${message}`,
+      detail: { error: message }
+    };
+  }
+}
+function createConsensusGateNode(options) {
+  return async (state) => {
+    let input;
+    try {
+      input = options.proposalFrom(state);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        [options.verdictKey]: {
+          outcome: "rejected",
+          feedback: `Consensus gate failed closed (proposal extraction error): ${message}`,
+          detail: { error: message }
+        }
+      };
+    }
+    const verdict = await runConsensusGate(options.voter, input);
+    return { [options.verdictKey]: verdict };
+  };
+}
+async function runGraphWithConsensus(options) {
+  const proposalKey = options.proposalKey ?? "proposal";
+  const verdictKey = options.verdictKey ?? "consensusVerdict";
+  const gate = createConsensusGateNode({
+    voter: options.voter,
+    verdictKey,
+    proposalFrom: (state) => {
+      const raw2 = state[proposalKey];
+      return { proposal: typeof raw2 === "string" ? raw2 : "" };
+    }
+  });
+  const compiled = new GraphBuilder().addState(proposalKey, overwrite("")).addState(verdictKey, overwrite(null)).addNode("produce", options.produce).addNode("consensus", gate).addEdge(START, "produce").addEdge("produce", "consensus").addEdge("consensus", END).compile();
+  if (!compiled.ok) {
+    return err(
+      new Error(
+        `runGraphWithConsensus: graph compile failed: ${formatCompileError(compiled.error)}`
+      )
+    );
+  }
+  const execResult = await executeGraph(compiled.value, options.initialState ?? {});
+  if (!execResult.ok) return err(execResult.error);
+  const raw = execResult.value.finalState[verdictKey];
+  const verdict = raw ?? void 0;
+  return ok({ execution: execResult.value, verdict });
+}
+
 // src/mcp/tools/run-graph-workflow-multicli-templates.ts
 var SECURITY_AUDIT_ASSIGNMENTS = [
   { node: "threat_model", preferredCli: "claude" },
@@ -41679,6 +41737,22 @@ function createBudgetGuard(budget) {
   });
   return new BudgetGuard(breaker);
 }
+var DEFAULT_BUDGET_TOLERANCE = 1.5;
+var BUDGET_TOLERANCE_ENV = "NEXUS_BUDGET_TOLERANCE";
+function resolveBudgetTolerance() {
+  const raw = process.env[BUDGET_TOLERANCE_ENV];
+  if (raw === void 0 || raw.trim() === "") return DEFAULT_BUDGET_TOLERANCE;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 1) return DEFAULT_BUDGET_TOLERANCE;
+  return parsed;
+}
+function estimateRelativeBudget(estimateTokens2, tolerance = DEFAULT_BUDGET_TOLERANCE) {
+  if (estimateTokens2 === void 0 || !Number.isFinite(estimateTokens2) || estimateTokens2 <= 0) {
+    return void 0;
+  }
+  if (!Number.isFinite(tolerance) || tolerance < 1) return void 0;
+  return { maxTokens: Math.ceil(estimateTokens2 * tolerance) };
+}
 
 // src/pipeline/agent-executor.ts
 var logger40 = createLogger({ component: "agent-executor" });
@@ -41725,12 +41799,21 @@ function recordOutcome(args) {
 }
 async function runExpert(guard, expertType, prompt, executionId) {
   if (guard.isExhausted()) {
+    emitPipelineStageEvent("dev-pipeline", "budget", "failed", {
+      reason: "budget_exceeded",
+      expertType,
+      ...executionId !== void 0 ? { executionId } : {}
+    });
+    logger40.warn("Budget exhausted \u2014 expert call skipped (#3262/#3395)", {
+      expertType,
+      ...executionId !== void 0 ? { executionId } : {}
+    });
     return {
       success: false,
       text: "",
       expertType,
       durationMs: 0,
-      error: "Budget exhausted \u2014 expert call skipped (#3395)"
+      error: "Budget exhausted \u2014 expert call skipped (estimate-relative cap, #3262/#3395)"
     };
   }
   const result = await executeExpert(expertType, prompt);
@@ -42934,6 +43017,14 @@ ${priorArt}` : research;
   };
 }
 function createVoteStageWrapper(stages) {
+  const voter = async (input) => {
+    const vote = await stages.vote(input.proposal, input.context ?? "");
+    return {
+      outcome: isApproved(vote) ? "approved" : "rejected",
+      feedback: isApproved(vote) ? "" : getVoteFeedback(vote),
+      detail: { vote }
+    };
+  };
   return {
     id: "vote",
     name: "Vote",
@@ -42941,19 +43032,14 @@ function createVoteStageWrapper(stages) {
       const start = getTimeProvider().now();
       const plan = typeof ctx.state[PIPELINE_STATE_KEYS.PLAN] === "string" ? ctx.state[PIPELINE_STATE_KEYS.PLAN] : "";
       const research = typeof ctx.state[PIPELINE_STATE_KEYS.RESEARCH] === "string" ? ctx.state[PIPELINE_STATE_KEYS.RESEARCH] : "";
-      try {
-        const vote = await stages.vote(plan, research);
-        const ms = getTimeProvider().now() - start;
-        const feedback = isApproved(vote) ? "" : getVoteFeedback(vote);
-        return {
-          stateKey: PIPELINE_STATE_KEYS.VOTE_RESULT,
-          value: { vote, feedback },
-          durationMs: ms,
-          success: isApproved(vote)
-        };
-      } catch (e) {
-        return failOutput(PIPELINE_STATE_KEYS.VOTE_RESULT, getErrorMessage(e), getTimeProvider().now() - start);
-      }
+      const verdict = await runConsensusGate(voter, { proposal: plan, context: research });
+      const vote = verdict.detail?.["vote"];
+      return {
+        stateKey: PIPELINE_STATE_KEYS.VOTE_RESULT,
+        value: { vote, feedback: verdict.feedback },
+        durationMs: getTimeProvider().now() - start,
+        success: verdict.outcome === "approved"
+      };
     }
   };
 }
@@ -44776,6 +44862,31 @@ ${task}`;
     throw err2;
   }
 }
+var OUTPUT_TOKEN_RATIO = 0.6;
+var DEFAULT_STAGE_COUNT = 6;
+function resolveRunBudget(task, templateId, logger56) {
+  if (process.env["NEXUS_BUDGET_ENFORCE"] !== "1") return void 0;
+  const effectiveId = templateId ?? classifyTask(task).pipelineType;
+  const template = getTemplate(effectiveId) ?? getTemplate("general");
+  const stageCount = template?.stages.length ?? DEFAULT_STAGE_COUNT;
+  const perCall = Math.round(
+    createSharedTaskAnalyzer().estimateTokens(task) * (1 + OUTPUT_TOKEN_RATIO)
+  );
+  const budget = estimateRelativeBudget(perCall * stageCount, resolveBudgetTolerance());
+  if (budget === void 0) {
+    logger56.warn("Budget enforcement on but no usable token estimate \u2014 running unguarded (#3262)", {
+      perCall,
+      stageCount
+    });
+  } else {
+    logger56.info("Estimate-relative token budget enforced (#3262)", {
+      template: effectiveId,
+      stageCount,
+      maxTokens: budget.maxTokens
+    });
+  }
+  return budget;
+}
 function selectStageRegistry(template, task, agentStages) {
   const effectiveTemplate = template ?? classifyTask(task).pipelineType;
   if (effectiveTemplate === "greenfield") {
@@ -44804,7 +44915,8 @@ async function runPipelineHandler(args, logger56) {
     const agentStages = createAgentStages({
       simulateVotes: input.simulateVotes,
       votingStrategy: input.votingStrategy,
-      quickMode: input.quickMode
+      quickMode: input.quickMode,
+      budget: resolveRunBudget(task, input.template, logger56)
     });
     const stages = selectStageRegistry(input.template, task, agentStages);
     const result = await runAdaptiveOrchestrator(task, {
@@ -48806,6 +48918,9 @@ export {
   analyzeTask,
   selectModel,
   registerDelegateToModelTool,
+  runConsensusGate,
+  createConsensusGateNode,
+  runGraphWithConsensus,
   getGraphWorkflowList,
   getGraphRegistry,
   ListExpertsInputSchema,
@@ -48959,4 +49074,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-KZJHMSH6.js.map
+//# sourceMappingURL=chunk-I4BPTXSC.js.map