nexus-agents 2.131.1 → 2.132.0

package/dist/{chunk-DEL26PXS.js → chunk-I2SW34K6.js}

@@ -1,3 +1,6 @@
+import {
+  computeCostUSD
+} from "./chunk-TGGR6ST5.js";
 import {
   DEFAULT_CONSENSUS_CONFIG,
   DEFAULT_INCREMENTAL_QUORUM_CONFIG,
@@ -15,24 +18,25 @@ import {
   toolSuccess,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-4SNH5EMQ.js";
+} from "./chunk-4CLBJ2NA.js";
 import {
   getToolMemory
-} from "./chunk-NINNWQ42.js";
+} from "./chunk-GYDO2WOR.js";
 import {
   createEvent,
   getGlobalRegistry
-} from "./chunk-BDERGLIX.js";
+} from "./chunk-XIFOAZ5B.js";
 import {
   authRemediation,
   delay,
   getAvailableClis,
   withTimeout
-} from "./chunk-2QFUW2SP.js";
+} from "./chunk-VZCQRLXT.js";
 import {
   AgentError,
   CLI_NAMES,
   DEFAULT_CLI,
+  DecisionCostStore,
   OPERATION_CLASSES,
   OutcomeStore,
   TaskOutcomeSchema,
@@ -54,16 +58,17 @@ import {
   registerPersistentOutcomeStoreFactory,
   resolveClassGuardMs,
   resolveVoteTimeout
-} from "./chunk-4KBG4ICZ.js";
+} from "./chunk-QJIHSQZX.js";
 import {
   ensureLearningDir,
+  findRepoRoot,
   getOutcomesFile,
   nexusDataPath,
   nexusDataPathEnsure
-} from "./chunk-ZGLIHPGJ.js";
+} from "./chunk-RUSP5PJR.js";
 
 // src/mcp/tools/consensus-vote.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/cli/vote-types.ts
 var VOTER_ROLES = {
@@ -303,6 +308,7 @@ var SyntheticVoteError = class extends Error {
     this.rawOutput = rawOutput;
     this.name = "SyntheticVoteError";
   }
+  rawOutput;
 };
 var RawFindingSchema = z.object({
   summary: z.string().min(1).max(500).describe("One-line summary of the issue"),
@@ -677,6 +683,9 @@ function buildVoteRequest(role, proposal, timeoutMs, withResponseFormat) {
 function isStructuredOutputUnsupported(errorMessage) {
   return /support tool use/i.test(errorMessage);
 }
+function readTokenCount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
 async function runVoteCompletion(role, proposal, adapter, timeoutMs, withResponseFormat) {
   const request = buildVoteRequest(role, proposal, timeoutMs, withResponseFormat);
   const timeoutResult = await withTimeout(
@@ -687,7 +696,12 @@ async function runVoteCompletion(role, proposal, adapter, timeoutMs, withRespons
   if (!timeoutResult.ok) return { ok: false, error: timeoutResult.error };
   const response = timeoutResult.value;
   if (!response.ok) return { ok: false, error: response.error.message };
-  return { ok: true, output: extractTextFromResponse(response.value.content) };
+  const reported = response.value.usage;
+  const usage = {
+    inputTokens: readTokenCount(reported?.inputTokens),
+    outputTokens: readTokenCount(reported?.outputTokens)
+  };
+  return { ok: true, output: extractTextFromResponse(response.value.content), usage };
 }
 async function executeSingleVoteAttempt(role, proposal, adapter, timeoutMs) {
   let completion = await runVoteCompletion(role, proposal, adapter, timeoutMs, true);
@@ -697,7 +711,7 @@ async function executeSingleVoteAttempt(role, proposal, adapter, timeoutMs) {
   if (!completion.ok) return { ok: false, error: completion.error };
   try {
     const vote = parseVoteResponse(completion.output, role);
-    return { ok: true, vote, output: completion.output };
+    return { ok: true, vote, output: completion.output, usage: completion.usage };
   } catch (error) {
     if (error instanceof SyntheticVoteError) {
       return { ok: false, error: `Vote parsing failed: ${error.message}` };
@@ -726,7 +740,7 @@ async function executeWithRetries(opts) {
         attemptMs,
         succeeded: true
       });
-      return { vote: result.vote, ok: true };
+      return { vote: result.vote, usage: result.usage, ok: true };
     }
     lastError = result.error;
     const rateLimited = isRateLimitError(lastError);
@@ -842,6 +856,18 @@ function computeOverallConsensusDeadlineMs(timeoutMs, maxRetries, roleCount, int
 }
 var DEFAULT_INTER_AGENT_DELAY_MS = 2e3;
 var defaultLogger = createLogger({ component: "voter-agents" });
+function buildLlmVoteResult(role, vote, usage, adapter, processingTimeMs) {
+  return {
+    role,
+    vote,
+    processingTimeMs,
+    source: "llm",
+    cli: adapter.providerId,
+    model: adapter.modelId,
+    ...usage.inputTokens !== void 0 ? { inputTokens: usage.inputTokens } : {},
+    ...usage.outputTokens !== void 0 ? { outputTokens: usage.outputTokens } : {}
+  };
+}
 async function executeAgentVote(role, proposal, adapter, logger10, options) {
   const start = getTimeProvider().now();
   const timeoutMs = options?.timeoutMs ?? resolveVoteTimeout();
@@ -859,7 +885,7 @@ async function executeAgentVote(role, proposal, adapter, logger10, options) {
   const processingTimeMs = getTimeProvider().now() - start;
   if (result.ok) {
     logger10.info("Vote completed", { role, model: adapter.modelId, decision: result.vote.decision });
-    return { role, vote: result.vote, processingTimeMs, source: "llm", cli: adapter.providerId };
+    return buildLlmVoteResult(role, result.vote, result.usage, adapter, processingTimeMs);
   }
   logger10.error("Vote execution failed after all retries", void 0, {
     role,
@@ -4179,7 +4205,7 @@ 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).`;
 }
-function buildResponse(input, result) {
+function buildResponse(input, result, costSummary) {
   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;
@@ -4199,6 +4225,10 @@ function buildResponse(input, result) {
     durationMs: result.totalTimeMs,
     simulateVotes: result.simulateVotes
   };
+  applyOptionalResponseFields(response, input, result, errorCount, costSummary);
+  return response;
+}
+function applyOptionalResponseFields(response, input, result, errorCount, costSummary) {
   if (input.threshold !== void 0) {
     response.threshold = input.threshold;
   }
@@ -4212,7 +4242,9 @@ function buildResponse(input, result) {
   if (isHigherOrderStrategy(result.strategy) && result.higherOrderResult) {
     response.higherOrderMetadata = toHigherOrderMetadata(result.higherOrderResult);
   }
-  return response;
+  if (costSummary !== void 0) {
+    response.costSummary = costSummary;
+  }
 }
 function toHigherOrderMetadata(r) {
   return {
@@ -4264,8 +4296,178 @@ function applyErrorPolicy(votes, policy) {
   };
 }
 
+// src/audit/vote-record-store.ts
+import { appendFileSync as appendFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2 } from "fs";
+import { dirname, join } from "path";
+
+// src/audit/vote-record.ts
+import * as crypto from "crypto";
+import { z as z7 } from "zod";
+var VoteRecordDecisionSchema = z7.enum(["approved", "rejected", "no_quorum"]);
+var VoterSummarySchema = z7.object({
+  role: z7.string().min(1).max(100),
+  decision: z7.enum(["approve", "reject", "abstain"]),
+  confidence: z7.number().min(0).max(1)
+}).strict();
+var VoteRecordCountsSchema = z7.object({
+  approve: z7.number().int().nonnegative(),
+  reject: z7.number().int().nonnegative(),
+  abstain: z7.number().int().nonnegative(),
+  total: z7.number().int().nonnegative()
+}).strict();
+var VoteRecordSchema = z7.object({
+  /** Schema version for forward migrations. */
+  version: z7.literal("1.0"),
+  /** Unique record id (also usable as a `ratificationVoteRef`). */
+  id: z7.string().min(1),
+  /** ISO-8601 timestamp the vote was recorded. */
+  recordedAt: z7.string().min(1),
+  /**
+   * SHA-256 of the FULL proposal text. The proposal itself is truncated for
+   * the human record (`proposal`), but the hash binds the record to the exact
+   * proposal voted on — a later edit of `proposal` that changes meaning is
+   * detectable by recomputing this hash from the original.
+   */
+  proposalHash: z7.string().length(64),
+  /** Truncated proposal text for the human/reviewer record. */
+  proposal: z7.string(),
+  /** The voting strategy used. */
+  strategy: z7.enum([
+    "simple_majority",
+    "supermajority",
+    "unanimous",
+    "higher_order",
+    "opinion_wise",
+    "proof_of_learning"
+  ]),
+  /** The resolved decision. */
+  decision: VoteRecordDecisionSchema,
+  /** Approval fraction as a percentage (0-100). */
+  approvalPercentage: z7.number().min(0).max(100),
+  /** Vote-count breakdown. */
+  voteCounts: VoteRecordCountsSchema,
+  /** Per-voter {role, decision, confidence} summary. */
+  voters: z7.array(VoterSummarySchema),
+  /** Optional correlation/decision id linking to the cost rollup / trace. */
+  correlationId: z7.string().min(1).optional(),
+  /** Hash of the previous record in the chain (absent for the first). */
+  previousHash: z7.string().length(64).optional(),
+  /** SHA-256 over every field above + previousHash. */
+  hash: z7.string().length(64)
+}).strict();
+function computeVoteRecordHash(payload) {
+  const canonical = JSON.stringify({
+    version: payload.version,
+    id: payload.id,
+    recordedAt: payload.recordedAt,
+    proposalHash: payload.proposalHash,
+    proposal: payload.proposal,
+    strategy: payload.strategy,
+    decision: payload.decision,
+    approvalPercentage: payload.approvalPercentage,
+    voteCounts: payload.voteCounts,
+    voters: payload.voters.map((v) => ({
+      role: v.role,
+      decision: v.decision,
+      confidence: v.confidence
+    })),
+    correlationId: payload.correlationId ?? null,
+    previousHash: payload.previousHash ?? null
+  });
+  return crypto.createHash("sha256").update(canonical).digest("hex");
+}
+function hashProposal(proposal) {
+  return crypto.createHash("sha256").update(proposal).digest("hex");
+}
+
+// src/audit/vote-record-store.ts
+var VOTE_RECORDS_REL_PATH = "governance/vote-records.jsonl";
+var MAX_PROPOSAL_RECORD_CHARS = 500;
+function outcomeToDecision(result) {
+  if (result.outcome === "approved") return "approved";
+  if (!result.quorumReached && result.outcome !== "rejected") return "no_quorum";
+  return "rejected";
+}
+function toVoterSummaries(votes) {
+  const summaries = [];
+  for (const v of votes) {
+    if (v.source === "error") continue;
+    const vote = v.vote;
+    summaries.push({ role: v.role, decision: vote.decision, confidence: vote.confidence });
+  }
+  return summaries;
+}
+function buildVoteRecord(input) {
+  const proposalTruncated = input.proposal.length > MAX_PROPOSAL_RECORD_CHARS ? input.proposal.slice(0, MAX_PROPOSAL_RECORD_CHARS) + "..." : input.proposal;
+  const payload = {
+    version: "1.0",
+    id: input.id,
+    recordedAt: input.recordedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    proposalHash: hashProposal(input.proposal),
+    proposal: proposalTruncated,
+    strategy: input.strategy,
+    decision: outcomeToDecision(input.result),
+    approvalPercentage: input.result.approvalPercentage,
+    voteCounts: {
+      approve: input.result.voteCounts.approve,
+      reject: input.result.voteCounts.reject,
+      abstain: input.result.voteCounts.abstain,
+      total: input.result.voteCounts.total
+    },
+    voters: toVoterSummaries(input.votes),
+    ...input.correlationId !== void 0 ? { correlationId: input.correlationId } : {},
+    ...input.previousHash !== void 0 ? { previousHash: input.previousHash } : {}
+  };
+  return { ...payload, hash: computeVoteRecordHash(payload) };
+}
+function readLastHash(filePath, logger10) {
+  if (!existsSync2(filePath)) return void 0;
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim() !== "");
+    const last = lines[lines.length - 1];
+    if (last === void 0) return void 0;
+    const parsed = VoteRecordSchema.safeParse(JSON.parse(last));
+    return parsed.success ? parsed.data.hash : void 0;
+  } catch (error) {
+    logger10.warn("Failed to read prior vote record hash", { error: getErrorMessage(error) });
+    return void 0;
+  }
+}
+function resolveVoteRecordsPath() {
+  const root = findRepoRoot(process.cwd());
+  if (root === null) return void 0;
+  return join(root, VOTE_RECORDS_REL_PATH);
+}
+function persistVoteRecord(opts) {
+  const logger10 = opts.logger ?? createLogger({ component: "vote-record-store" });
+  const filePath = opts.filePath ?? resolveVoteRecordsPath();
+  if (filePath === void 0) {
+    logger10.debug("No committable repo root; skipping authentic vote record persist");
+    return void 0;
+  }
+  try {
+    mkdirSync2(dirname(filePath), { recursive: true });
+    const previousHash = readLastHash(filePath, logger10);
+    const record = buildVoteRecord({ ...opts, previousHash });
+    appendFileSync2(filePath, JSON.stringify(record) + "\n", "utf-8");
+    logger10.info("Persisted authentic vote record", {
+      id: record.id,
+      decision: record.decision,
+      path: filePath
+    });
+    return record;
+  } catch (error) {
+    logger10.warn("Failed to persist authentic vote record", {
+      error: getErrorMessage(error),
+      path: filePath
+    });
+    return void 0;
+  }
+}
+
 // src/orchestration/outcomes/outcome-store-persistence.ts
-import { appendFileSync as appendFileSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+import { appendFileSync as appendFileSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync3 } from "fs";
 var PersistentOutcomeStore = class extends OutcomeStore {
   filePath;
   logger;
@@ -4316,14 +4518,14 @@ var PersistentOutcomeStore = class extends OutcomeStore {
     }
   }
   hydrate() {
-    if (!existsSync2(this.filePath)) {
+    if (!existsSync3(this.filePath)) {
       this.logger.debug("No outcomes file found, starting fresh", {
         path: this.filePath
       });
       return;
     }
     try {
-      const content = readFileSync2(this.filePath, "utf-8");
+      const content = readFileSync3(this.filePath, "utf-8");
       const lines = content.split("\n").filter((line) => line.trim().length > 0);
       let loaded = 0;
       let skipped = 0;
@@ -4375,7 +4577,7 @@ var PersistentOutcomeStore = class extends OutcomeStore {
   }
   persistLine(outcome) {
     try {
-      appendFileSync2(this.filePath, JSON.stringify(outcome) + "\n", "utf-8");
+      appendFileSync3(this.filePath, JSON.stringify(outcome) + "\n", "utf-8");
     } catch (error) {
       const msg = getErrorMessage(error);
       this.logger.warn("Failed to persist outcome to disk", {
@@ -4418,6 +4620,34 @@ function recordVoteSuccess(proposal, strategy, outcome, duration, votes) {
     recordVoteOutcomes(votes);
   }
 }
+var VOTE_RECORD_STRATEGIES = /* @__PURE__ */ new Set([
+  "simple_majority",
+  "supermajority",
+  "unanimous",
+  "higher_order",
+  "opinion_wise",
+  "proof_of_learning"
+]);
+function toRecordStrategy(strategy) {
+  return VOTE_RECORD_STRATEGIES.has(strategy) ? strategy : "simple_majority";
+}
+function recordAuthenticVote(args) {
+  const allSimulated = args.votes.length > 0 && args.votes.every((v) => v.source === "simulation");
+  if (allSimulated) {
+    logger6.debug("Skipping authentic vote record \u2014 all votes simulated");
+    return void 0;
+  }
+  const id = `vote-${String(getTimeProvider().now())}-${getRandomProvider().random().toString(36).slice(2, 9)}`;
+  return persistVoteRecord({
+    id,
+    proposal: args.proposal,
+    strategy: toRecordStrategy(args.strategy),
+    result: args.result,
+    votes: args.votes,
+    ...args.correlationId !== void 0 ? { correlationId: args.correlationId } : {},
+    logger: logger6
+  });
+}
 function recordVoteError(proposal, errorMessage) {
   try {
     const memory = getToolMemory();
@@ -4461,6 +4691,75 @@ function recordVoteOutcomes(votes) {
   }
 }
 
+// src/mcp/tools/decision-cost-recording.ts
+function resolveBillingMode() {
+  return process.env["NEXUS_BILLING_MODE"] === "api" ? "api" : "plan";
+}
+function votesToCostInputs(votes) {
+  return votes.map((v) => {
+    const hasTokens = v.inputTokens !== void 0 || v.outputTokens !== void 0;
+    const input = {
+      role: v.role,
+      model: v.model,
+      ...v.inputTokens !== void 0 ? { inputTokens: v.inputTokens } : {},
+      ...v.outputTokens !== void 0 ? { outputTokens: v.outputTokens } : {},
+      ...hasTokens && v.model !== void 0 ? { costUsd: computeCostUSD(v.model, v.inputTokens ?? 0, v.outputTokens ?? 0) } : {}
+    };
+    return input;
+  });
+}
+var defaultLogger2 = createLogger({ component: "decision-cost-recording" });
+var droppedCostRecordCount = 0;
+var WARN_BURST = 5;
+var WARN_PERIOD = 1e3;
+var WARN_MAX_SILENCE_MS = 6e4;
+var warnCountSinceReset = 0;
+var lastWarnAtMs = 0;
+var warnClockOverrideMs = null;
+function warnNowMs() {
+  return warnClockOverrideMs ?? Date.now();
+}
+function shouldWarnForDrop(dropIndex) {
+  const now = warnNowMs();
+  const countTrigger = dropIndex <= WARN_BURST || (dropIndex - WARN_BURST) % WARN_PERIOD === 0;
+  const timeTrigger = dropIndex > WARN_BURST && now - lastWarnAtMs >= WARN_MAX_SILENCE_MS;
+  if (countTrigger || timeTrigger) {
+    lastWarnAtMs = now;
+    return true;
+  }
+  return false;
+}
+function recordDecisionCost(options) {
+  const billingMode = options.billingMode ?? resolveBillingMode();
+  const voters = votesToCostInputs(options.votes);
+  const store = options.store ?? new DecisionCostStore();
+  const logger10 = options.logger ?? defaultLogger2;
+  const timestamp = new Date(getTimeProvider().now()).toISOString();
+  const { record, persisted } = store.record({
+    decisionId: options.decisionId,
+    gate: options.gate,
+    voters,
+    billingMode,
+    timestamp
+  });
+  if (!persisted) {
+    droppedCostRecordCount += 1;
+    if (shouldWarnForDrop(droppedCostRecordCount)) {
+      const suppressedSinceLastWarn = droppedCostRecordCount - warnCountSinceReset - 1;
+      warnCountSinceReset += 1;
+      logger10.warn("Decision-cost rollup dropped (failed to persist) \u2014 billing telemetry lost", {
+        decisionId: options.decisionId,
+        gate: options.gate,
+        totalCostUsd: record.summary.totalCostUsd,
+        totalTokens: record.summary.totalTokens,
+        droppedCostRecordCount,
+        suppressedSinceLastWarn
+      });
+    }
+  }
+  return record.summary;
+}
+
 // src/mcp/tools/consensus-vote-signals.ts
 function rejectionRulesFrom(result) {
   const rules = /* @__PURE__ */ new Set();
@@ -4502,31 +4801,31 @@ function warnIfSimulatedOutsideTests(toolName, logger10) {
 }
 
 // src/mcp/jobs/job-result-store.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync, writeFileSync as writeFileSync3, chmodSync } from "fs";
-import { z as z7 } from "zod";
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync, writeFileSync as writeFileSync3, chmodSync } from "fs";
+import { z as z8 } from "zod";
 var logger7 = createLogger({ component: "job-result-store" });
-var JobStatusSchema = z7.enum(["pending", "complete", "failed", "cancelled"]);
-var JobResultSchema = z7.object({
+var JobStatusSchema = z8.enum(["pending", "complete", "failed", "cancelled"]);
+var JobResultSchema = z8.object({
   /** Format version. Currently `1` — bump if the shape changes. */
-  v: z7.literal(1),
-  jobId: z7.string().min(1),
+  v: z8.literal(1),
+  jobId: z8.string().min(1),
   /** Tool that was invoked (e.g. `orchestrate`). */
-  toolName: z7.string().min(1),
+  toolName: z8.string().min(1),
   status: JobStatusSchema,
-  createdAt: z7.iso.datetime(),
+  createdAt: z8.iso.datetime(),
   /** Set when the job leaves `pending` — either via `complete` or `failed` or `cancelled`. */
-  completedAt: z7.iso.datetime().optional(),
+  completedAt: z8.iso.datetime().optional(),
   /**
    * Structured payload the synchronous mode would have returned. Present
    * only when `status === 'complete'`. Shape is tool-specific — readers
    * cast to the tool's known output type after status check.
    */
-  result: z7.unknown().optional(),
+  result: z8.unknown().optional(),
   /**
    * Failure message when `status === 'failed'`. Cannot be paired with
    * `result` — the discriminator is `status`.
    */
-  error: z7.string().optional()
+  error: z8.string().optional()
 });
 function jobResultPath(jobId) {
   return nexusDataPathEnsure("jobs", `result-${jobId}.json`);
@@ -4537,7 +4836,7 @@ function persistJobRecord(path, record) {
 }
 function writeJobPending(jobId, toolName) {
   const path = jobResultPath(jobId);
-  if (existsSync3(path)) {
+  if (existsSync4(path)) {
     logger7.debug("Job result file already exists \u2014 leaving in place", { jobId });
     return;
   }
@@ -4592,9 +4891,9 @@ function writeJobCancelled(jobId, toolName, reason) {
 }
 function readJobResult(jobId) {
   const path = nexusDataPath("jobs", `result-${jobId}.json`);
-  if (!existsSync3(path)) return null;
+  if (!existsSync4(path)) return null;
   try {
-    const raw = JSON.parse(readFileSync3(path, "utf-8"));
+    const raw = JSON.parse(readFileSync4(path, "utf-8"));
     const parsed = JobResultSchema.safeParse(raw);
     if (!parsed.success) {
       logger7.warn("Job result file failed schema check", { jobId, path });
@@ -4622,7 +4921,7 @@ function toJobSummary(record) {
 }
 function listJobs() {
   const dir = nexusDataPath("jobs");
-  if (!existsSync3(dir)) return [];
+  if (!existsSync4(dir)) return [];
   let entries;
   try {
     entries = readdirSync(dir);
@@ -4647,25 +4946,25 @@ function listJobs() {
 }
 
 // src/mcp/jobs/job-idempotency.ts
-import { createHash, randomUUID } from "crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { z as z8 } from "zod";
+import { createHash as createHash2, randomUUID } from "crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { z as z9 } from "zod";
 var logger8 = createLogger({ component: "job-idempotency" });
-var IdempotencyIndexEntrySchema = z8.object({
-  v: z8.literal(1),
+var IdempotencyIndexEntrySchema = z9.object({
+  v: z9.literal(1),
   /** MCP tool name (e.g. `orchestrate`, `run_workflow`, `consensus_vote`). */
-  tool: z8.string().min(1),
+  tool: z9.string().min(1),
   /** Caller-supplied idempotency key. */
-  key: z8.string().min(1),
+  key: z9.string().min(1),
   /** sha256 of the canonical input JSON. */
-  inputsHash: z8.string().length(64),
+  inputsHash: z9.string().length(64),
   /** Existing jobId for this (tool, key, inputs) tuple. */
-  jobId: z8.string().min(1),
+  jobId: z9.string().min(1),
   /** ISO timestamp of first dispatch. */
-  createdAt: z8.iso.datetime()
+  createdAt: z9.iso.datetime()
 });
 function sha256Hex(input) {
-  return createHash("sha256").update(input).digest("hex");
+  return createHash2("sha256").update(input).digest("hex");
 }
 function canonicalJsonStringify(value) {
   if (value === null || typeof value !== "object") return JSON.stringify(value);
@@ -4690,7 +4989,7 @@ function resolveIdempotency(tool, idempotencyKey, inputs, randomFallback = rando
   }
   const incomingInputsHash = computeInputsHash(inputs);
   const path = indexFilePathReadOnly(tool, idempotencyKey);
-  if (existsSync4(path)) {
+  if (existsSync5(path)) {
     const entry = readIndexEntry(path);
     if (entry !== null) {
       if (entry.inputsHash === incomingInputsHash) {
@@ -4710,7 +5009,7 @@ function resolveIdempotency(tool, idempotencyKey, inputs, randomFallback = rando
 }
 function registerIdempotentJob(params) {
   const path = indexFilePath(params.tool, params.idempotencyKey);
-  if (existsSync4(path)) {
+  if (existsSync5(path)) {
     logger8.debug("Idempotency index entry already present; skipping write", {
       tool: params.tool,
       jobId: params.jobId
@@ -4745,7 +5044,7 @@ function shortCircuitOrFreshJobId(params) {
 }
 function readIndexEntry(path) {
   try {
-    const raw = JSON.parse(readFileSync4(path, "utf-8"));
+    const raw = JSON.parse(readFileSync5(path, "utf-8"));
     const parsed = IdempotencyIndexEntrySchema.safeParse(raw);
     if (!parsed.success) {
       logger8.warn("Idempotency index file failed schema check", { path });
@@ -5153,7 +5452,7 @@ async function processVotesWithCascade(engineVotes, opts) {
 var CONTRARIAN_ESCALATION_THRESHOLD = 0.8;
 async function runContrarianCheck(proposal, log) {
   try {
-    const { executeExpert } = await import("./expert-bridge-BW55FRAH.js");
+    const { executeExpert } = await import("./expert-bridge-MINXBC73.js");
     const prompt = [
       "You are a contrarian analyst. Your job is to find reasons this proposal should be REJECTED.",
       "Look for: YAGNI (not needed), MISALIGNED (wrong tech/architecture), SECURITY_RISK, SCOPE_CREEP.",
@@ -5309,6 +5608,24 @@ function finalizeVotingResult(args) {
   if (args.higherOrderResult !== void 0) result.higherOrderResult = args.higherOrderResult;
   return result;
 }
+function recordVoteSideEffects(proposal, strategy, result, logger10) {
+  const decisionId = `consensus-${String(getTimeProvider().now())}-${randomUUID2().slice(0, 8)}`;
+  recordAuthenticVote({
+    proposal,
+    strategy,
+    result: result.result,
+    votes: result.votes,
+    correlationId: decisionId
+  });
+  try {
+    return recordDecisionCost({ decisionId, gate: "consensus_vote", votes: result.votes });
+  } catch (costError) {
+    logger10.warn("Per-decision cost rollup failed (non-fatal)", {
+      error: getErrorMessage(costError)
+    });
+    return void 0;
+  }
+}
 async function handleConsensusVote(deps, args) {
   const logger10 = deps.logger ?? createLogger({ tool: "consensus_vote" });
   if (args.simulateVotes) warnIfSimulatedOutsideTests("consensus_vote", logger10);
@@ -5332,8 +5649,9 @@ async function handleConsensusVote(deps, args) {
       result.totalTimeMs,
       result.votes
     );
+    const costSummary = recordVoteSideEffects(args.proposal, strategy, result, logger10);
     emitVoteRejectedSignal(result.result, getPipelineEventBus(), logger10);
-    return { ok: true, value: buildResponse(args, result) };
+    return { ok: true, value: buildResponse(args, result, costSummary) };
   } catch (error) {
     const message = getErrorMessage(error);
     const cause = error instanceof Error ? error : new Error(message);
@@ -5414,27 +5732,27 @@ function createConsensusVoteHandler(deps) {
   };
 }
 var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
-  proposal: z9.string(),
+  proposal: z10.string(),
   strategy: VotingStrategySchema,
-  decision: z9.enum(["approved", "rejected", "no_quorum"]),
-  approvalPercentage: z9.number(),
-  voteCounts: z9.object({
-    approve: z9.number(),
-    reject: z9.number(),
-    abstain: z9.number(),
-    error: z9.number()
+  decision: z10.enum(["approved", "rejected", "no_quorum"]),
+  approvalPercentage: z10.number(),
+  voteCounts: z10.object({
+    approve: z10.number(),
+    reject: z10.number(),
+    abstain: z10.number(),
+    error: z10.number()
   }),
-  votes: z9.array(
-    z9.object({
-      role: z9.string().max(100),
-      decision: z9.enum(["approve", "reject", "abstain"]),
-      confidence: z9.number(),
-      reasoning: z9.string().max(4e3),
-      simulated: z9.boolean(),
-      error: z9.boolean(),
-      modelUsed: z9.string().max(100).optional(),
-      rejectionCategories: z9.array(
-        z9.enum([
+  votes: z10.array(
+    z10.object({
+      role: z10.string().max(100),
+      decision: z10.enum(["approve", "reject", "abstain"]),
+      confidence: z10.number(),
+      reasoning: z10.string().max(4e3),
+      simulated: z10.boolean(),
+      error: z10.boolean(),
+      modelUsed: z10.string().max(100).optional(),
+      rejectionCategories: z10.array(
+        z10.enum([
           "YAGNI",
           "DRY_VIOLATION",
           "OVER_ENGINEERING",
@@ -5447,34 +5765,34 @@ var CONSENSUS_VOTE_OUTPUT_SCHEMA = {
     })
   ),
   threshold: VoteThresholdSchema.optional(),
-  durationMs: z9.number(),
-  simulateVotes: z9.boolean(),
-  higherOrderMetadata: z9.object({
-    posteriorApproval: z9.number(),
-    posteriorRejection: z9.number(),
-    effectiveVoteCount: z9.number(),
-    method: z9.enum(["ow", "isp", "simple"]),
-    usedCorrelationData: z9.boolean(),
-    improvementOverBaseline: z9.number(),
-    downweightedAgents: z9.array(z9.string().max(100)).max(10),
-    reasoning: z9.string().max(2e3)
+  durationMs: z10.number(),
+  simulateVotes: z10.boolean(),
+  higherOrderMetadata: z10.object({
+    posteriorApproval: z10.number(),
+    posteriorRejection: z10.number(),
+    effectiveVoteCount: z10.number(),
+    method: z10.enum(["ow", "isp", "simple"]),
+    usedCorrelationData: z10.boolean(),
+    improvementOverBaseline: z10.number(),
+    downweightedAgents: z10.array(z10.string().max(100)).max(10),
+    reasoning: z10.string().max(2e3)
   }).optional(),
   // #3124: explains a `rejected` decision that coexists with a high
   // approvalPercentage (an error-policy short-circuit, e.g. fail_closed).
-  policyReason: z9.string().max(200).optional()
+  policyReason: z10.string().max(200).optional()
 };
 function registerConsensusVoteTool(server, deps) {
   const logger10 = deps.logger ?? createLogger({ tool: "consensus_vote" });
   const notifier = deps.notifier ?? createMcpNotifier(server);
   const depsWithNotifier = { ...deps, notifier };
   const toolSchema = {
-    proposal: z9.string().min(1).max(MAX_PROPOSAL_LENGTH).describe("Proposal text to vote on"),
-    threshold: z9.enum(["majority", "supermajority", "unanimous"]).optional().describe("Voting threshold (legacy). Use strategy instead."),
+    proposal: z10.string().min(1).max(MAX_PROPOSAL_LENGTH).describe("Proposal text to vote on"),
+    threshold: z10.enum(["majority", "supermajority", "unanimous"]).optional().describe("Voting threshold (legacy). Use strategy instead."),
     strategy: VotingStrategySchema.optional().describe(
       "Voting strategy: simple_majority (default), supermajority, unanimous, proof_of_learning, or higher_order"
     ),
-    quickMode: z9.boolean().optional().default(false).describe("Use 3 agents instead of 7"),
-    simulateVotes: z9.boolean().optional().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
+    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)")
   };
   const description = "Execute multi-model consensus voting on a proposal. Uses 7 specialized agent roles (architect, security, devex, ai_ml, pm, catfish, scope_steward) to vote on proposals with configurable strategies. Supports higher_order strategy for Bayesian-optimal aggregation with correlation awareness (Issue #514).";
   const secureHandler = createSecureHandler(createConsensusVoteHandler(depsWithNotifier), {
@@ -5565,6 +5883,7 @@ export {
   ErrorPolicySchema,
   VoteThresholdSchema,
   ConsensusVoteInputSchema,
+  recordDecisionCost,
   warnIfSimulatedOutsideTests,
   resetCorrelationTracker,
   createPolicyFailedResult,
@@ -5573,4 +5892,4 @@ export {
   CONSENSUS_VOTE_OUTPUT_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-DEL26PXS.js.map
+//# sourceMappingURL=chunk-I2SW34K6.js.map