nexus-agents 8.133.5 → 8.134.0

package/dist/{chunk-J466LJ35.js → chunk-GN3OLNPH.js}

@@ -21,7 +21,7 @@ import {
   toolSuccessStructured,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-CPG2YZ44.js";
+} from "./chunk-SBDWDV62.js";
 import {
   getToolMemory
 } from "./chunk-KJI4SNSK.js";
@@ -30,7 +30,7 @@ import {
 } from "./chunk-EZNIYU5T.js";
 import {
   VERSION
-} from "./chunk-DKO2UVFI.js";
+} from "./chunk-LO53UJFH.js";
 import {
   isGatewayModelAdapter
 } from "./chunk-BGHKG77F.js";
@@ -112,6 +112,7 @@ import {
   readVoteRecords,
   recordUsageEvent,
   registerPersistentOutcomeStoreFactory,
+  resolveInsideRoot,
   resolveModelIdentitySync,
   resolveVoteRecordsPath,
   servedCostDetail,
@@ -140,6 +141,7 @@ import {
 
 // src/mcp/tools/consensus-vote.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
+import { basename as basename2 } from "node:path";
 import { z as z15 } from "zod";
 
 // src/mcp/tools/async-dispatch-input.ts
@@ -2400,6 +2402,54 @@ async function collectRealVotes(options) {
   return results;
 }
 
+// src/cli/vote-artifact.ts
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { basename } from "node:path";
+var MAX_VOTE_ARTIFACT_BYTES = 256 * 1024;
+function oversizedArtifact(bytes) {
+  return new Error(
+    `Vote artifact is ${String(bytes)} bytes; cap is ${String(MAX_VOTE_ARTIFACT_BYTES)} bytes`
+  );
+}
+async function readBoundedArtifact(artifactPath) {
+  const file = await open(artifactPath, constants.O_RDONLY | constants.O_NONBLOCK);
+  try {
+    const stat = await file.stat();
+    if (!stat.isFile()) throw new Error("Vote artifact must be a regular file");
+    if (stat.size > MAX_VOTE_ARTIFACT_BYTES) throw oversizedArtifact(stat.size);
+    const buffer = Buffer.alloc(MAX_VOTE_ARTIFACT_BYTES + 1);
+    let size = 0;
+    while (size < buffer.length) {
+      const { bytesRead } = await file.read(buffer, size, buffer.length - size, null);
+      if (bytesRead === 0) break;
+      size += bytesRead;
+    }
+    if (size > MAX_VOTE_ARTIFACT_BYTES) {
+      throw oversizedArtifact(Math.max(size, (await file.stat()).size));
+    }
+    return buffer.subarray(0, size);
+  } finally {
+    await file.close();
+  }
+}
+async function inlineVoteArtifact(proposal, artifactPath, displayName) {
+  if (artifactPath === void 0) return proposal;
+  const bytes = await readBoundedArtifact(artifactPath);
+  if (bytes.length === 0) throw new Error("Vote artifact is empty; an artifact must have content");
+  if (bytes.includes(0)) throw new Error("Vote artifact is binary (contains a NUL byte)");
+  const content = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+  const digest = createHash("sha256").update(bytes).digest("hex");
+  const header = `Artifact: ${displayName ?? basename(artifactPath)} sha256:${digest} ${String(bytes.length)} bytes`;
+  return `${proposal}
+
+${header}
+===== BEGIN ARTIFACT =====
+${content}
+===== END ARTIFACT =====`;
+}
+
 // src/cli/voter-project.ts
 import { readFileSync, statSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
@@ -6154,6 +6204,9 @@ var ConsensusVoteInputSchema = z8.object({
   proposal: z8.string().min(1).max(MAX_PROPOSAL_LENGTH).describe(
     'Proposal text to vote on. If the proposal asks voters to choose among named alternatives, declare them in `options` (#4472) \u2014 otherwise the tally records approve/reject/abstain only, so every voter who engages returns `approve` and a 6-1 split on WHICH option persists as 7-0, 100% (#4452). This is ENFORCED AS A WARNING, not a refusal: a heuristic over the proposal text flags an apparent multi-option proposal with no `options` and says so on `panelWarning` (#5360). The wording says "declare", not "MUST", because the warning is what the code actually holds \u2014 it is tightened back only in the same change that promotes the warning to a refusal.'
   ),
+  artifactPath: z8.string().min(1).max(4096).optional().describe(
+    "UTF-8 artifact file within the repository root (server cwd). Its content is inlined into every seat's proposal with a SHA-256 digest; maximum 256 KiB. Missing, empty, binary (NUL byte), oversized, and escaping paths are rejected. Seats read the inlined text, not the tree."
+  ),
   options: z8.array(z8.string().min(1).max(200)).min(2).max(10).optional().describe(
     "Named alternatives for a multi-option proposal (#4472). When present, the threshold must ALSO be cleared by the leading option, in addition to the ordinary approve/reject bar: `unanimous` requires every approver to have chosen the SAME option, and `supermajority`/`majority` measure the leading option's share of approvers. An approving voter whose selection is absent or matches no declared option stays in the denominator and credits no option, so a degraded response can only lower the leading share, never raise it. Omit for an ordinary yes/no vote \u2014 behaviour is then unchanged."
   ),
@@ -6726,7 +6779,7 @@ function jobIdSchema(description) {
 }
 
 // src/mcp/jobs/job-idempotency.ts
-import { createHash, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
 import { existsSync as existsSync2, readFileSync as readFileSync4, writeFileSync } from "node:fs";
 import { z as z11 } from "zod";
 var logger6 = createLogger({ component: "job-idempotency" });
@@ -6744,7 +6797,7 @@ var IdempotencyIndexEntrySchema = z11.object({
   createdAt: z11.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);
@@ -9320,6 +9373,32 @@ async function runSyncConsensusVote(deps, notifier, args) {
   });
   return toolSuccessStructured({ ...result.value });
 }
+async function prepareVoteArtifact(input) {
+  if (input.artifactPath === void 0) return { ok: true, value: input };
+  const resolved = resolveInsideRoot(input.artifactPath);
+  if (resolved === null) {
+    return {
+      ok: false,
+      error: toolStructuredError({
+        errorCategory: "permission",
+        message: "Path traversal denied: artifactPath must be within the repository root."
+      })
+    };
+  }
+  try {
+    const proposal = await inlineVoteArtifact(
+      input.proposal,
+      resolved,
+      basename2(input.artifactPath)
+    );
+    return { ok: true, value: { ...input, proposal } };
+  } catch (error) {
+    return {
+      ok: false,
+      error: toolStructuredError({ errorCategory: "validation", message: getErrorMessage(error) })
+    };
+  }
+}
 function createConsensusVoteHandler(deps) {
   const notifier = deps.notifier ?? NOOP_NOTIFIER;
   return async (args, ctx) => {
@@ -9334,31 +9413,32 @@ function createConsensusVoteHandler(deps) {
       const simCheck = checkSimulationAllowed("consensus_vote", ctx.logger);
       if (!simCheck.allowed) return simulationDeniedResult(simCheck.reason);
     }
-    const strategy = validationResult.data.strategy ?? "simple_majority";
-    const dispatch = resolveDispatch(validationResult.data);
-    const modeWarning = deprecatedModeWarning(validationResult.data);
+    const prepared = await prepareVoteArtifact(validationResult.data);
+    if (!prepared.ok) return prepared.error;
+    const input = prepared.value;
+    const strategy = input.strategy ?? "simple_majority";
+    const dispatch = resolveDispatch(input);
+    const modeWarning = deprecatedModeWarning(input);
     ctx.logger.debug("Starting consensus vote", {
       strategy,
-      quickMode: validationResult.data.quickMode,
+      quickMode: input.quickMode,
       ...dispatch !== void 0 ? { dispatch } : {}
     });
     notifier.info("consensus_vote", {
       event: "vote_start",
-      proposalLength: validationResult.data.proposal.length,
+      proposalLength: input.proposal.length,
       strategy
     });
     if (dispatch === "async") {
-      const asyncResult = dispatchAsyncConsensusVote(deps, validationResult.data);
+      const asyncResult = dispatchAsyncConsensusVote(deps, input);
       notifier.info("consensus_vote", {
         event: "vote_dispatched_async",
-        proposalLength: validationResult.data.proposal.length,
+        proposalLength: input.proposal.length,
         strategy
       });
       return withWarnings(asyncResult, [modeWarning]);
     }
-    return withWarnings(await runSyncConsensusVote(deps, notifier, validationResult.data), [
-      modeWarning
-    ]);
+    return withWarnings(await runSyncConsensusVote(deps, notifier, input), [modeWarning]);
   };
 }
 var ASYNC_ENVELOPES = {
@@ -9598,6 +9678,7 @@ export {
   resolveAdapter,
   assignPanelSeats,
   collectRealVotes,
+  inlineVoteArtifact,
   VoterProjectInputSchema,
   resolveAndLogVoterProject,
   VotingRoundPhaseSchema,
@@ -9669,4 +9750,4 @@ export {
   CONSENSUS_VOTE_TOOL_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-J466LJ35.js.map
+//# sourceMappingURL=chunk-GN3OLNPH.js.map