nexus-agents 8.55.6 → 8.55.8

package/dist/{chunk-JAFFZUMA.js → chunk-4XRGCSFR.js}

@@ -25,10 +25,10 @@ import {
   toolSuccessStructured,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-ADYNKL6V.js";
+} from "./chunk-MUSPT4J4.js";
 import {
   VERSION
-} from "./chunk-WCTONUCK.js";
+} from "./chunk-ZBZSSNRB.js";
 import {
   UNRESOLVED_MODEL_ID,
   assessPanelIndependence,
@@ -8630,4 +8630,4 @@ export {
   CONSENSUS_VOTE_TOOL_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-JAFFZUMA.js.map
+//# sourceMappingURL=chunk-4XRGCSFR.js.map

package/dist/{chunk-NIAQBK7X.js → chunk-DZHGR5UO.js}

@@ -21,7 +21,7 @@ import {
 import {
   DEFAULT_TASK_TTL_MS,
   clampTaskTtl
-} from "./chunk-ZUZWHGTB.js";
+} from "./chunk-IEF3YTEH.js";
 import {
   executeExpert
 } from "./chunk-QMGMD6JB.js";
@@ -62,7 +62,7 @@ import {
   toJobSummary,
   updateStage,
   writeJobCancelled
-} from "./chunk-JAFFZUMA.js";
+} from "./chunk-4XRGCSFR.js";
 import {
   allOf,
   anyOf
@@ -82,7 +82,7 @@ import {
 } from "./chunk-RNWUIQTZ.js";
 import {
   withPrerequisite
-} from "./chunk-RLJ6SDFZ.js";
+} from "./chunk-WL336Y4R.js";
 import {
   NOOP_NOTIFIER,
   RateLimiter,
@@ -107,7 +107,7 @@ import {
   withAuditTrail,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-ADYNKL6V.js";
+} from "./chunk-MUSPT4J4.js";
 import {
   createAuditTrail,
   createGraphAuditBridge,
@@ -46182,7 +46182,7 @@ function buildVotingInput(plan, config) {
 }
 async function executeSingleVote(plan, config, log) {
   try {
-    const { executeVoting } = await import("./consensus-vote-FGGOXR3Y.js");
+    const { executeVoting } = await import("./consensus-vote-CJKMBM47.js");
     const input = buildVotingInput(plan, config);
     const result = await executeVoting(input, log);
     return parseVotingResult(result);
@@ -47980,7 +47980,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-FGGOXR3Y.js");
+        const { executeVoting } = await import("./consensus-vote-CJKMBM47.js");
         const votingResult = await executeVoting(
           {
             proposal: buildVoteProposal(plan, research),
@@ -48759,8 +48759,9 @@ var PrReviewSanitizationSchema = z103.object({
    * #4140 an over-budget diff is packed to a security-prioritized SUBSET
    * before the panel prompt is built, so on that path the voters read less
    * than this hash covers. That reduction is a DIFFERENT one, disclosed
-   * separately in the hash-covered `summary` (`[partial coverage: n/m files
-   * reviewed, dropped: …]`) and enforced by `applyPartialCoverageGate`.
+   * separately in the hash-covered `coverage` record field (#6190; and,
+   * human-readably, the `[partial coverage: …]` summary stamp) and enforced
+   * by `applyPartialCoverageGate`.
    *
    * Keeping them apart is the point: one hash covering both reductions could
    * not tell an auditor WHICH one moved it. This field isolates the
@@ -48801,6 +48802,35 @@ var PrReviewSanitizationSchema = z103.object({
    */
   tagsRemoved: z103.number().int().nonnegative()
 }).strict();
+var PrReviewBudgetSourceSchema = z103.enum(["registry", "binding-cap-fallback"]);
+var PrReviewPanelCoverageSchema = z103.object({
+  /** `'full'` — the panel was sent the whole diff; `'partial'` — a packed subset. */
+  panelRead: z103.enum(["full", "partial"]),
+  /** Files whose full diff the panel actually reviewed. */
+  reviewedFiles: z103.number().int().nonnegative(),
+  /** Files in the original diff. */
+  totalFiles: z103.number().int().nonnegative(),
+  /**
+   * EVERY path the panel did not fully review — the complete list, never a
+   * prefix of it. The summary stamp lists at most a few of these and says
+   * `N dropped (k listed)`; this field is where the rest live.
+   */
+  droppedFiles: z103.array(z103.string()),
+  /** UTF-8 bytes of the diff text the panel actually read. */
+  reviewedBytes: z103.number().int().nonnegative(),
+  /** UTF-8 bytes of the input diff. */
+  totalBytes: z103.number().int().nonnegative(),
+  /** Where the panel-read budget came from. */
+  budgetSource: PrReviewBudgetSourceSchema,
+  /** The budget derivation (registry) or the fallback reason, verbatim. */
+  budgetDetail: z103.string()
+}).strict();
+var PrReviewBindingBoundsSchema = z103.object({
+  /** `'full'` — the hash covers every byte; `'prefix'` — only the first `boundBytes`. */
+  kind: z103.enum(["full", "prefix"]),
+  /** UTF-8 bytes the hash binds: `min(totalBytes, MAX_REVIEWED_DIFF_BYTES)`. */
+  boundBytes: z103.number().int().nonnegative()
+}).strict();
 var PrReviewRecordSchema = z103.object({
   /**
    * Schema version. '1.1' was the Option-C binding (#3831): the record binds to
@@ -48819,8 +48849,17 @@ var PrReviewRecordSchema = z103.object({
    * at this bump), so no record exists whose hash a version literal would
    * invalidate. Reading a '1.2' record as if it were '1.3' would be the unsafe
    * move — its hash may bind SANITIZED bytes the gate can never reproduce.
-   */
-  version: z103.literal("1.3"),
+   * '1.4' (#6190) marks the boundary at which records began carrying
+   * {@link coverage} and {@link bindingBounds} as structured fields. NOT a clean
+   * break this time: a '1.3' record is still accepted and — because both new
+   * fields are folded into the hash ONLY when present, like `diffProvenance`
+   * and `sanitization` — re-hashes byte-identically (the pinned 1.3 golden in
+   * pr-review-record.test.ts is the guard). This is the vote-record tier
+   * model (`vote-record.ts`, #6179): a 1.3 record differs from a 1.4 one only
+   * in which fields it CAN carry, and reading it as 1.4 is safe because its
+   * hash binds the same raw bytes. Tiers are labels; nothing orders them.
+   */
+  version: z103.enum(["1.3", "1.4"]),
   /**
    * Monotonic sequence number (integer ≥ 0). Assigned as (max existing
    * sequence)+1 at write time. Sorted, the set of sequences must cover
@@ -48876,6 +48915,20 @@ var PrReviewRecordSchema = z103.object({
    * consumer must NOT read that as "nothing was removed".
    */
   sanitization: PrReviewSanitizationSchema.optional(),
+  /**
+   * What the panel READ (#6190). OPTIONAL for the same reason the two above
+   * are: the schema is `.strict()`, a '1.3' record has no such field, and a
+   * producer that does not measure coverage (the local-ledger script) must be
+   * able to decline to say. Absent ⇒ nothing stated; NOT "read everything".
+   */
+  coverage: PrReviewPanelCoverageSchema.optional(),
+  /**
+   * How far the hash BINDS (#6190). Same optionality rule. Written together
+   * with {@link coverage} by the pr_review producer; absent ⇒ nothing stated,
+   * and a consumer that needs the answer recomputes it from the diff length
+   * against `MAX_REVIEWED_DIFF_BYTES` (which the governor gate does).
+   */
+  bindingBounds: PrReviewBindingBoundsSchema.optional(),
   /**
    * ADVISORY hash of the tip record at write time (absent for the first).
    * Retained for audit texture but NOT covered by `hash` and NOT verified —
@@ -48885,6 +48938,21 @@ var PrReviewRecordSchema = z103.object({
   /** SHA-256 over every field above EXCEPT `previousHash` (and except `hash`). */
   hash: z103.string().length(64)
 }).strict();
+function projectPanelCoverage(c) {
+  return {
+    panelRead: c.panelRead,
+    reviewedFiles: c.reviewedFiles,
+    totalFiles: c.totalFiles,
+    droppedFiles: [...c.droppedFiles],
+    reviewedBytes: c.reviewedBytes,
+    totalBytes: c.totalBytes,
+    budgetSource: c.budgetSource,
+    budgetDetail: c.budgetDetail
+  };
+}
+function projectBindingBounds(b) {
+  return { kind: b.kind, boundBytes: b.boundBytes };
+}
 function computePrReviewRecordHash(payload) {
   const canonical = JSON.stringify({
     version: payload.version,
@@ -48937,7 +49005,12 @@ function computePrReviewRecordHash(payload) {
         fieldsModified: payload.sanitization.fieldsModified,
         tagsRemoved: payload.sanitization.tagsRemoved
       }
-    } : {}
+    } : {},
+    // #6190 panel coverage and binding bounds, INSIDE the hash. Present-only on the
+    // same rule as the two blocks above, so a 1.3 record projects
+    // byte-identically (the pinned golden is the guard).
+    ...payload.coverage !== void 0 ? { coverage: projectPanelCoverage(payload.coverage) } : {},
+    ...payload.bindingBounds !== void 0 ? { bindingBounds: projectBindingBounds(payload.bindingBounds) } : {}
   });
   return crypto3.createHash("sha256").update(canonical).digest("hex");
 }
@@ -48949,7 +49022,7 @@ var MAX_SUMMARY_RECORD_CHARS = 500;
 function buildPrReviewRecord(input) {
   const summaryTruncated = input.summary.length > MAX_SUMMARY_RECORD_CHARS ? input.summary.slice(0, MAX_SUMMARY_RECORD_CHARS) + "..." : input.summary;
   const payload = {
-    version: "1.3",
+    version: "1.4",
     sequence: input.sequence ?? 0,
     prNumber: input.prNumber,
     baseSha: input.baseSha,
@@ -48967,6 +49040,8 @@ function buildPrReviewRecord(input) {
     summary: summaryTruncated,
     ...input.diffProvenance !== void 0 ? { diffProvenance: input.diffProvenance } : {},
     ...input.sanitization !== void 0 ? { sanitization: input.sanitization } : {},
+    ...input.coverage !== void 0 ? { coverage: input.coverage } : {},
+    ...input.bindingBounds !== void 0 ? { bindingBounds: input.bindingBounds } : {},
     ...input.correlationId !== void 0 ? { correlationId: input.correlationId } : {},
     ...input.previousHash !== void 0 ? { previousHash: input.previousHash } : {}
   };
@@ -49197,20 +49272,21 @@ function wholeDiffFileCoverage(prDiff) {
     strategy: "budget"
   };
 }
-function packDiffForPanelAndBinding(prDiff, budgets) {
+function packDiffForPanelAndBinding(prDiff, budgets, binding) {
   const totalBytes = byteLen(prDiff);
-  const binding = totalBytes > budgets.bindingCapBytes ? "prefix" : "full";
-  const boundBytes = Math.min(totalBytes, budgets.bindingCapBytes);
+  const bindingKind = binding.totalBytes > budgets.bindingCapBytes ? "prefix" : "full";
+  const boundBytes = Math.min(binding.totalBytes, budgets.bindingCapBytes);
   const panel = packDiffForReview(prDiff, budgets.panelReadBudgetBytes);
   const panelRead = panel.coverage?.partial === true ? "partial" : "full";
-  if (panelRead === "full" && binding === "full") {
+  if (panelRead === "full" && bindingKind === "full") {
     return { coverage: void 0, packedDiff: prDiff, note: "" };
   }
   const fileCoverage = panel.coverage ?? wholeDiffFileCoverage(prDiff);
   const coverage = {
     ...fileCoverage,
     panelRead,
-    binding,
+    binding: bindingKind,
+    bindingSource: binding.source,
     reviewedBytes: byteLen(panel.packedDiff),
     boundBytes,
     totalBytes,
@@ -49231,24 +49307,96 @@ function applyPartialCoverageGate(aggregate, coverage) {
   return aggregate;
 }
 
+// src/mcp/tools/pr-review-sanitization-view.ts
+function sanitizationViewOf(ctx) {
+  const rawDiffBytes = ctx.sanitization.rawFieldBytes["prDiff"];
+  return {
+    rawDiffHash: ctx.sanitization.rawFieldHashes["prDiff"],
+    rawDiffBytes,
+    // #6177: the same UTF-8 test `reviewedDiffWasTruncated` applies to the raw
+    // string, over the length the middleware measured beside the hash — the
+    // raw text itself never reaches the handler (sanitize-before-dispatch).
+    // `undefined` when the length is: a missing number is not "not truncated".
+    rawTruncated: rawDiffBytes === void 0 ? void 0 : rawDiffBytes > MAX_REVIEWED_DIFF_BYTES,
+    commentsRemoved: ctx.sanitization.commentsRemoved,
+    fieldsModified: ctx.sanitization.fieldsModified,
+    tagsRemoved: ctx.sanitization.tagsRemoved
+  };
+}
+function measuredAsHanded(prDiff, source) {
+  return {
+    totalBytes: Buffer.byteLength(prDiff, "utf-8"),
+    truncated: reviewedDiffWasTruncated(prDiff),
+    source
+  };
+}
+function resolveBindingMeasurement(prDiff, sanitization) {
+  if (sanitization === void 0) return measuredAsHanded(prDiff, "input");
+  const { rawDiffBytes, rawTruncated } = sanitization;
+  if (rawDiffBytes === void 0 || rawTruncated === void 0) {
+    return measuredAsHanded(prDiff, "sanitized-fallback");
+  }
+  return { totalBytes: rawDiffBytes, truncated: rawTruncated, source: "raw" };
+}
+function removalsBefore(sanitization) {
+  return {
+    comments: sanitization?.commentsRemoved ?? 0,
+    fields: sanitization?.fieldsModified ?? 0,
+    tags: sanitization?.tagsRemoved ?? 0
+  };
+}
+
 // src/mcp/tools/pr-review-record-producer.ts
 function bytes(n) {
   return n.toLocaleString("en-US");
 }
+function bindingSourceClause(source) {
+  if (source === "raw") return " (raw)";
+  if (source === "sanitized-fallback") return " (sanitized; raw length not supplied)";
+  return "";
+}
 function bindingStamp(coverage) {
-  const binding = coverage.binding === "prefix" ? `binding covers first ${bytes(coverage.boundBytes)} bytes` : `binding covers all ${bytes(coverage.boundBytes)} bytes`;
+  const binding = (coverage.binding === "prefix" ? `binding covers first ${bytes(coverage.boundBytes)} bytes` : `binding covers all ${bytes(coverage.boundBytes)} bytes`) + bindingSourceClause(coverage.bindingSource);
   return `[panel read ${bytes(coverage.reviewedBytes)}/${bytes(coverage.totalBytes)} bytes; ${binding}; budget: ${coverage.budgetSource} (${coverage.budgetDetail})]`;
 }
+var SUMMARY_DROPPED_FILES_LISTED = 3;
+function droppedFilesClause(dropped) {
+  const listed = dropped.slice(0, SUMMARY_DROPPED_FILES_LISTED);
+  const qualifier = listed.length < dropped.length ? ` (${String(listed.length)} listed)` : "";
+  return `${String(dropped.length)} dropped${qualifier}: ${listed.join(", ")}`;
+}
 function coverageStamps(coverage) {
   if (coverage === void 0) return "";
-  const files = coverage.partial ? `[partial coverage: ${String(coverage.reviewedFiles)}/${String(coverage.totalFiles)} files reviewed, dropped: ${coverage.droppedFiles.join(", ")}] ` : "";
+  const files = coverage.partial ? `[partial coverage: ${String(coverage.reviewedFiles)}/${String(coverage.totalFiles)} files reviewed, ${droppedFilesClause(coverage.droppedFiles)}] ` : "";
   return ` ${files}${bindingStamp(coverage)}`;
 }
-function warnIfDiffTruncated(diff, prNumber, logger57) {
-  if (!reviewedDiffWasTruncated(diff)) return;
+function coverageFieldsOf(coverage) {
+  if (coverage === void 0) return void 0;
+  return {
+    coverage: {
+      panelRead: coverage.panelRead,
+      reviewedFiles: coverage.reviewedFiles,
+      totalFiles: coverage.totalFiles,
+      droppedFiles: [...coverage.droppedFiles],
+      reviewedBytes: coverage.reviewedBytes,
+      totalBytes: coverage.totalBytes,
+      budgetSource: coverage.budgetSource,
+      budgetDetail: coverage.budgetDetail
+    },
+    bindingBounds: { kind: coverage.binding, boundBytes: coverage.boundBytes }
+  };
+}
+function warnIfDiffTruncated(binding, prNumber, logger57) {
+  if (binding.source === "sanitized-fallback") {
+    logger57.warn(
+      "Binding bounds measured over the SANITIZED diff: the sanitizer supplied no raw byte length, so a prefix binding can be under-stated (#6177)",
+      { prNumber, sanitizedBytes: binding.totalBytes }
+    );
+  }
+  if (!binding.truncated) return;
   logger57.warn(
     "Reviewed diff exceeds the hash byte cap; content past it is unbound in reviewedDiffHash",
-    { prNumber }
+    { prNumber, measuredOver: binding.source, totalBytes: binding.totalBytes }
   );
 }
 function diffProvenanceOf(source, diff) {
@@ -49274,14 +49422,16 @@ function buildAndPersist(prNumber, baseSha, args) {
   const { input, aggregate, counts, reviewCount, logger: logger57, coverage, diffSource, sanitization } = args;
   const reviewedDiffHash = sanitization?.rawDiffHash ?? computeReviewedDiffHash(input.prDiff);
   const stamps = coverageStamps(coverage);
+  const coverageFields = coverageFieldsOf(coverage);
   const disclosure = sanitizationDisclosureOf(sanitization, input.prDiff);
-  warnIfDiffTruncated(input.prDiff, prNumber, logger57);
+  warnIfDiffTruncated(resolveBindingMeasurement(input.prDiff, sanitization), prNumber, logger57);
   const record = persistPrReviewRecord({
     prNumber,
     baseSha,
     reviewedDiffHash,
     diffProvenance: diffProvenanceOf(diffSource, input.prDiff),
     ...disclosure !== void 0 ? { sanitization: disclosure } : {},
+    ...coverageFields ?? {},
     verdict: aggregate.decision,
     verified: aggregate.verified,
     voteCounts: {
@@ -49364,23 +49514,6 @@ function persistReviewRecord(args) {
   }
 }
 
-// src/mcp/tools/pr-review-sanitization-view.ts
-function sanitizationViewOf(ctx) {
-  return {
-    rawDiffHash: ctx.sanitization.rawFieldHashes["prDiff"],
-    commentsRemoved: ctx.sanitization.commentsRemoved,
-    fieldsModified: ctx.sanitization.fieldsModified,
-    tagsRemoved: ctx.sanitization.tagsRemoved
-  };
-}
-function removalsBefore(sanitization) {
-  return {
-    comments: sanitization?.commentsRemoved ?? 0,
-    fields: sanitization?.fieldsModified ?? 0,
-    tags: sanitization?.tagsRemoved ?? 0
-  };
-}
-
 // src/mcp/tools/pr-review-panel-budget.ts
 var PANEL_PROMPT_OVERHEAD_TOKENS = 16e3;
 function conservativeBytesPerToken() {
@@ -49472,9 +49605,11 @@ function resolvePrReviewPanelBudget(panel, logger57, registry = getDefaultRegist
   }
   return budget;
 }
-function preparePanelProposal(input, panel, removedBefore, logger57, registry = getDefaultRegistry()) {
+function preparePanelProposal(input, panel, sanitization, logger57, registry = getDefaultRegistry()) {
   const budgets = resolvePrReviewPanelBudget(panel, logger57, registry);
-  const { coverage, packedDiff, note } = packDiffForPanelAndBinding(input.prDiff, budgets);
+  const binding = resolveBindingMeasurement(input.prDiff, sanitization);
+  const { coverage, packedDiff, note } = packDiffForPanelAndBinding(input.prDiff, budgets, binding);
+  const removedBefore = removalsBefore(sanitization);
   const body = coverage === void 0 ? input : { ...input, prDiff: packedDiff };
   if (coverage?.partial === true) {
     logger57.warn(
@@ -49484,6 +49619,8 @@ function preparePanelProposal(input, panel, removedBefore, logger57, registry =
     logger57.info("pr_review panel read the whole diff; the audit hash binds a prefix (#6003)", {
       totalBytes: coverage.totalBytes,
       boundBytes: coverage.boundBytes,
+      bindingSource: coverage.bindingSource,
+      bindingTotalBytes: binding.totalBytes,
       budgetSource: coverage.budgetSource
     });
   }
@@ -49492,7 +49629,7 @@ function preparePanelProposal(input, panel, removedBefore, logger57, registry =
 async function preparePanelForReview(input, roles, opts, logger57) {
   const seats = input.simulate ? void 0 : await resolvePanelSeats(roles, opts.gatewayAdapters, logger57);
   const panel = { seats, simulate: input.simulate };
-  const packed = preparePanelProposal(input, panel, removalsBefore(opts.sanitization), logger57);
+  const packed = preparePanelProposal(input, panel, opts.sanitization, logger57);
   return { ...packed, seats };
 }
 
@@ -57042,4 +57179,4 @@ export {
   startPipelineEventBridge,
   shutdownPipelineEventBridge
 };
-//# sourceMappingURL=chunk-NIAQBK7X.js.map
+//# sourceMappingURL=chunk-DZHGR5UO.js.map