npm - mandrel - Versions diffs - 2.67.0 → 2.68.0 - Mend

mandrel 2.67.0 → 2.68.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (60) hide show

package/.agents/scripts/lib/observability/source-classifier.js CHANGED Viewed

@@ -75,6 +75,7 @@ const FRAMEWORK_SCRIPT_BASENAMES = Object.freeze([
   'single-story-confirm-merge.js',
   'single-story-init.js',
   'stories-wave-tick.js',
+  'story-review-compute.js',
   'sync-agentrc.js',
   'sync-claude-agents.js',
   'sync-claude-commands.js',

package/.agents/scripts/lib/orchestration/code-review.js CHANGED Viewed

@@ -103,10 +103,13 @@ function resolveScopeEnvelope(opts, config) {
  *   createReviewProviderFn?: typeof createReviewProvider,
  *   upsertCommentFn?: typeof upsertStructuredComment,
  *   renderFindingsFn?: typeof renderFindings,
+ *   deferPost?: boolean,
  * }} opts
  * @returns {Promise<{
  *   status: 'ok'|'no-changes'|'invalid',
  *   severity: { critical: number, high: number, medium: number, suggestion: number },
+ *   findings?: Array<object>,
+ *   providerName?: string,
  *   report?: string,
  *   posted: boolean,
  *   postedCommentId: number|null,
@@ -196,9 +199,10 @@ async function resolvePromptMessages(reviewProvider, reviewInput, logger) {
 }
 /**
- * Posting failure is non-fatal and surfaces as `posted: false`.
+ * Posting failure is non-fatal and surfaces as `posted: false`. Also posts a
+ * `deferPost` review's held report.
  */
-async function postReviewComment({
+export async function postReviewComment({
   upsertCommentFn,
   provider,
   commentTargetId,
@@ -230,6 +234,12 @@ async function postReviewComment({
   }
 }
+/** A `deferPost` review holds its report for the caller to post. */
+async function postUnlessDeferred(opts, post) {
+  if (opts.deferPost) return { posted: false, postedCommentId: null };
+  return postReviewComment(post);
+}
 /**
  * Which review provider(s) raised the critical findings. A chain reports its
  * own per-entry attribution; any other provider owns every critical.
@@ -309,7 +319,7 @@ async function executeReviewPipeline({ opts, config, envelope }) {
     degradations,
   });
-  const { posted, postedCommentId } = await postReviewComment({
+  const { posted, postedCommentId } = await postUnlessDeferred(opts, {
     upsertCommentFn,
     provider,
     commentTargetId,
@@ -320,6 +330,8 @@ async function executeReviewPipeline({ opts, config, envelope }) {
   return {
     status: 'ok',
     severity,
+    findings,
+    providerName,
     report,
     posted,
     postedCommentId,

package/.agents/scripts/lib/orchestration/merge-poll.js CHANGED Viewed

@@ -26,6 +26,11 @@ export function pollIntervalMs(checksStatus, intervalSeconds) {
 }
 export const DEFAULT_MAX_BUDGET_SECONDS = 3600;
+/** CI never reddens in the first minute, so only green or red polls on. */
+export function probeSettlesAsyncWait(checksStatus) {
+  return checksStatus !== 'success' && checksStatus !== 'failure';
+}
 /** Bounds every `gh` spawn so a hang degrades to the probe-error path. */
 export const MERGE_WAIT_GH_TIMEOUT_MS = 60_000;

package/.agents/scripts/lib/orchestration/review-deposit.js ADDED Viewed

@@ -0,0 +1,219 @@
+/**
+ * review-deposit.js — the held Story-scope review a worker computes at push
+ * time, and its identity.
+ *
+ * The identity is the **diff digest**: a sha256 of the exact
+ * `git diff --no-color <base>...<head>` text the review provider is handed.
+ * A clean base-sync merge moves HEAD without changing that text, while any
+ * commit that changes the diff changes it — so close adopts a deposit, and
+ * posts a held result, on digest equality, never on SHA equality.
+ *
+ * The file lives beside the terminal envelope; nothing deletes it but the
+ * Story temp purge. A mismatched deposit is simply not adopted.
+ */
+import { createHash } from 'node:crypto';
+import nodeFs from 'node:fs';
+import path from 'node:path';
+import { storyReviewDepositPath } from '../config/temp-paths.js';
+import { resolveSharedBaseRef } from './review-base-ref.js';
+const DEPOSIT_KIND = 'story-review-deposit';
+/**
+ * @param {{ cwd: string, ref: string, gitSpawnFn: Function }} args
+ * @returns {string|null} the commit `ref` points at.
+ */
+export function resolveRefSha({ cwd, ref, gitSpawnFn }) {
+  try {
+    const probe = gitSpawnFn(
+      cwd,
+      'rev-parse',
+      '--verify',
+      '--quiet',
+      `${ref}^{commit}`,
+    );
+    const sha = probe?.status === 0 ? String(probe.stdout ?? '').trim() : '';
+    return sha.length > 0 ? sha : null;
+  } catch {
+    return null;
+  }
+}
+/**
+ * sha256 of the three-dot diff text, spawned exactly as the review provider
+ * spawns it. `null` when the diff cannot be read — an unknown identity that
+ * never matches anything.
+ *
+ * @param {{ cwd: string, baseRef: string|null, headRef: string|null,
+ *   gitSpawnFn: Function }} args
+ * @returns {string|null}
+ */
+export function computeReviewDiffDigest({ cwd, baseRef, headRef, gitSpawnFn }) {
+  if (!baseRef || !headRef) return null;
+  try {
+    const diff = gitSpawnFn(
+      cwd,
+      'diff',
+      '--no-color',
+      `${baseRef}...${headRef}`,
+    );
+    if (diff?.status !== 0) return null;
+    return createHash('sha256')
+      .update(String(diff.stdout ?? ''), 'utf8')
+      .digest('hex');
+  } catch {
+    return null;
+  }
+}
+/**
+ * Flatten a computed review `result` into the deposit record.
+ *
+ * @param {{ storyId: number, headSha: string, baseRef: string,
+ *   diffDigest: string, result: object, createdAt?: string }} args
+ * @returns {object}
+ */
+export function buildReviewDeposit({
+  storyId,
+  headSha,
+  baseRef,
+  diffDigest,
+  result,
+  createdAt = new Date().toISOString(),
+}) {
+  return {
+    kind: DEPOSIT_KIND,
+    storyId,
+    headSha,
+    baseRef,
+    diffDigest,
+    createdAt,
+    provider: result.providerName ?? null,
+    severity: result.severity,
+    halted: !!result.halted,
+    criticalByProvider: result.criticalByProvider ?? {},
+    findings: Array.isArray(result.findings) ? result.findings : [],
+    report: result.report ?? '',
+    degraded: !!result.degraded,
+    degradations: Array.isArray(result.degradations) ? result.degradations : [],
+    blockerReason: result.blockerReason ?? null,
+  };
+}
+/**
+ * The deposit as `computeStoryScopeReview`'s `{ result }` shape, ready for
+ * `settleStoryScopeReview` to post.
+ *
+ * @param {object} deposit
+ * @returns {{ result: object }}
+ */
+export function depositAsComputedReview(deposit) {
+  return {
+    result: {
+      status: 'ok',
+      severity: deposit.severity,
+      findings: deposit.findings,
+      providerName: deposit.provider,
+      report: deposit.report,
+      posted: false,
+      postedCommentId: null,
+      halted: deposit.halted,
+      criticalByProvider: deposit.criticalByProvider,
+      degraded: deposit.degraded,
+      degradations: deposit.degradations,
+      blockerReason: deposit.blockerReason,
+    },
+  };
+}
+/**
+ * Atomic write (pid-scoped tmp + rename): close may read it mid-write.
+ *
+ * @param {object} deposit
+ * @param {{ config?: object, fsImpl?: typeof nodeFs }} [deps]
+ * @returns {string} the path written.
+ */
+export function writeReviewDeposit(deposit, { config, fsImpl = nodeFs } = {}) {
+  const target = storyReviewDepositPath(deposit.storyId, config);
+  fsImpl.mkdirSync(path.dirname(target), { recursive: true });
+  const tmpPath = `${target}.${process.pid}.tmp`;
+  fsImpl.writeFileSync(
+    tmpPath,
+    `${JSON.stringify(deposit, null, 2)}\n`,
+    'utf8',
+  );
+  fsImpl.renameSync(tmpPath, target);
+  return target;
+}
+/**
+ * @param {unknown} record
+ * @param {number} storyId
+ * @returns {boolean}
+ */
+function isDeposit(record, storyId) {
+  return (
+    record?.kind === DEPOSIT_KIND &&
+    record.storyId === storyId &&
+    typeof record.diffDigest === 'string' &&
+    record.diffDigest.length > 0 &&
+    typeof record.report === 'string' &&
+    typeof record.severity === 'object' &&
+    record.severity !== null
+  );
+}
+/**
+ * @param {number} storyId
+ * @param {{ config?: object, fsImpl?: typeof nodeFs }} [deps]
+ * @returns {object|null} the Story's deposit, or `null` when absent or
+ *   malformed.
+ */
+function readReviewDeposit(storyId, { config, fsImpl = nodeFs } = {}) {
+  try {
+    const raw = fsImpl.readFileSync(
+      storyReviewDepositPath(storyId, config),
+      'utf8',
+    );
+    const record = JSON.parse(raw);
+    return isDeposit(record, storyId) ? record : null;
+  } catch {
+    return null;
+  }
+}
+/**
+ * Close's held-review start point: the base ref, the diff digest of
+ * `origin/<base>...<sha>`, and the worker deposit when its digest matches.
+ *
+ * @param {{ cwd: string, storyId: number|string, sha: string,
+ *   baseBranch: string, gitSpawnFn: Function, config?: object,
+ *   readDepositFn?: typeof readReviewDeposit }} args
+ * @returns {{ baseRef: string|null, diffDigest: string|null,
+ *   deposit: object|null }}
+ */
+export function probeHeldReviewDiff({
+  cwd,
+  storyId,
+  sha,
+  baseBranch,
+  gitSpawnFn,
+  config,
+  readDepositFn = readReviewDeposit,
+}) {
+  const base = resolveSharedBaseRef({ baseBranch, cwd, gitSpawnFn });
+  const baseRef = base.resolved ? base.ref : null;
+  const diffDigest = computeReviewDiffDigest({
+    cwd,
+    baseRef,
+    headRef: sha,
+    gitSpawnFn,
+  });
+  const deposit = diffDigest
+    ? readDepositFn(Number(storyId), { config })
+    : null;
+  const matches = deposit?.diffDigest === diffDigest;
+  return { baseRef, diffDigest, deposit: matches ? deposit : null };
+}

package/.agents/scripts/lib/orchestration/review-providers/code-review.js CHANGED Viewed

@@ -15,7 +15,7 @@
  * @typedef {import('./types.js').ReviewProvider} ReviewProvider
  */
-import { spawnCapture } from '../../child-exec.js';
+import { spawnCaptureAsync } from '../../child-exec.js';
 import { gitSpawn } from '../../git-utils.js';
 import { PROJECT_ROOT } from '../../project-root.js';
 import { parseProviderFindings } from './parse-findings.js';
@@ -62,14 +62,15 @@ function buildPrompt(input, diff) {
 }
 /**
- * The prompt rides stdin so no shell ever quotes it.
+ * The prompt rides stdin so no shell ever quotes it. Asynchronous: the
+ * review overlaps close's gate children, whose output must keep draining.
  *
  * @param {string} prompt
- * @param {Function} [run] - `spawnSync`-shaped seam for tests.
- * @returns {{ status: number, stdout: string, stderr: string }}
+ * @param {Function} [run] - `(file, args, options)` seam for tests.
+ * @returns {Promise<{ status: number, stdout: string, stderr: string }>}
  */
 function invokeClaude(prompt, run) {
-  return spawnCapture('claude', [...CLAUDE_ARGS], {
+  return spawnCaptureAsync('claude', [...CLAUDE_ARGS], {
     cwd: PROJECT_ROOT,
     input: prompt,
     shell: process.platform === 'win32',
@@ -144,7 +145,7 @@ function assertInput(input) {
  *   gitSpawnFn?: typeof gitSpawn,
  *   spawnFn?: Function,
  *   logger?: { info?: Function, warn?: Function },
- * }} [deps] - `spawnFn` replaces `spawnSync` for the `claude` call.
+ * }} [deps] - `spawnFn` replaces the async runner for the `claude` call.
  * @returns {ReviewProvider}
  */
 export function createCodeReviewProviderForRegistry(deps = {}) {
@@ -183,7 +184,10 @@ export function createCodeReviewProviderForRegistry(deps = {}) {
       logger?.info?.(
         `[code-review] Invoking claude --print --effort low for Story #${ticketId} (${baseRef}...${headRef})...`,
       );
-      const result = invokeClaude(buildPrompt(input, diff.stdout), spawnFn);
+      const result = await invokeClaude(
+        buildPrompt(input, diff.stdout),
+        spawnFn,
+      );
       if (result.status !== 0) {
         logger?.warn?.(
           `[code-review] claude exited ${result.status}; emitting advisory.`,

package/.agents/scripts/lib/orchestration/single-story-close/phases/close-validation.js CHANGED Viewed

@@ -12,12 +12,14 @@ import { buildDefaultGates as defaultBuildDefaultGates } from '../../../close-va
 import { runCloseValidation as defaultRunCloseValidation } from '../../../close-validation/runner.js';
 import { LOCK_WAIT_EXPIRED_EXIT_CODE } from '../../../full-suite-lock.js';
 import { parseLockWaitOutcome } from '../../../full-suite-queue.js';
+import { parseSuiteTimings } from '../../../supervised-suite.js';
 import { createGateLogSink as defaultCreateGateLogSink } from '../gate-log.js';
 import { runPreGateSteps as defaultRunPreGateSteps } from './pre-gate-steps.js';
 /**
  * Pre-gate self-heal steps, then the gates (throws on first failure). The
  * steps commit in the worktree before scoring, so the gates see their output.
+ * `onPreGateStepsDone` (must not throw) runs once the tree is final.
  *
  * @param {{
  *   cwd: string,
@@ -34,10 +36,12 @@ import { runPreGateSteps as defaultRunPreGateSteps } from './pre-gate-steps.js';
  *   runBaselineUpwardWriteback?: Function,
  *   runContextBudgetWriteback?: Function,
  *   createGateLogSink?: typeof defaultCreateGateLogSink,
+ *   onPreGateStepsDone?: () => void,
  * }} args
  * @returns {Promise<{
  *   gates: Record<string, 'passed'|'skipped'>|null,
- *   lockWait: { waitedSeconds: number, expired: boolean }|null,
+ *   lockWait: { waitedSeconds: number, expired: boolean, holder?: object }|null,
+ *   suiteTimings: { lockWaitMs: number, hostWaitMs: number|null, testRunMs: number }|null,
  *   pending: boolean,
  * }>} `pending` (with `gates: null`) when a lock wait expired; any other
  *   failure throws with `err.closeGate` naming the gate.
@@ -57,6 +61,7 @@ export async function runCloseValidationPhase({
   runBaselineUpwardWriteback,
   runContextBudgetWriteback,
   createGateLogSink = defaultCreateGateLogSink,
+  onPreGateStepsDone,
 }) {
   await runPreGateSteps({
     cwd,
@@ -70,6 +75,7 @@ export async function runCloseValidationPhase({
     runBaselineUpwardWriteback,
     runContextBudgetWriteback,
   });
+  onPreGateStepsDone?.();
   progress(
     'VALIDATE',
@@ -101,7 +107,6 @@ export async function runCloseValidationPhase({
       baseBranch,
       storyBranch,
       config,
-      deferOnLockExpiry: true,
     });
   } finally {
     // The sink is async-buffered; settle it before anything reads it, on
@@ -116,6 +121,7 @@ export async function runCloseValidationPhase({
   return {
     gates: gateOutcomes(gateList, validation),
     lockWait,
+    suiteTimings: lockWaits.suiteTimings(),
     pending: false,
   };
 }
@@ -129,7 +135,7 @@ export async function runCloseValidationPhase({
  *   gateLog: { replay: () => void },
  *   progress: (tag: string, msg: string) => void,
  * }} args
- * @returns {{ gates: null, lockWait: object, pending: true }}
+ * @returns {{ gates: null, lockWait: object, suiteTimings: null, pending: true }}
  */
 function settleFailedValidation({ validation, lockWait, gateLog, progress }) {
   const [first] = validation.failed;
@@ -139,7 +145,7 @@ function settleFailedValidation({ validation, lockWait, gateLog, progress }) {
       'VALIDATE',
       `⏸ ${gate.name} deferred: the full-suite lock wait expired after ${lockWait.waitedSeconds}s. Nothing was spawned; close will report pending.`,
     );
-    return { gates: null, lockWait, pending: true };
+    return { gates: null, lockWait, suiteTimings: null, pending: true };
   }
   gateLog.replay();
   const err = new Error(
@@ -151,27 +157,40 @@ function settleFailedValidation({ validation, lockWait, gateLog, progress }) {
 }
 /**
- * Parsed from the gate log because it is the one place that sees waits both
+ * Parsed from the gate log: the one place that sees waits and timings both
  * in-process and in gate children.
  *
  * @param {{ sink: (m: string) => void, progress: (tag: string, msg: string) => void }} args
- * @returns {{ log: (m: string) => void, summary: () => { waitedSeconds: number, expired: boolean }|null }}
+ * @returns {{ log: (m: string) => void, summary: () => { waitedSeconds: number, expired: boolean, holder?: object }|null, suiteTimings: () => object|null }}
  */
 function trackLockWaits({ sink, progress }) {
   let tally = null;
+  let timings = null;
   return {
     log(line) {
       sink(line);
+      timings = parseSuiteTimings(line) ?? timings;
       if (!String(line).includes('[full-suite-lock]')) return;
       progress('LOCK', line);
       const outcome = parseLockWaitOutcome(line);
       if (!outcome) return;
-      tally = {
-        waitedSeconds: (tally?.waitedSeconds ?? 0) + outcome.waitedSeconds,
-        expired: Boolean(tally?.expired) || outcome.expired,
-      };
+      tally = mergeLockWait(tally, outcome);
     },
     summary: () => tally,
+    suiteTimings: () => timings,
+  };
+}
+/**
+ * @param {{ waitedSeconds: number, expired: boolean, holder?: object }|null} tally
+ * @param {{ waitedSeconds: number, expired: boolean, holder?: object }} outcome
+ */
+function mergeLockWait(tally, outcome) {
+  const holder = outcome.holder ?? tally?.holder;
+  return {
+    waitedSeconds: (tally?.waitedSeconds ?? 0) + outcome.waitedSeconds,
+    expired: Boolean(tally?.expired) || outcome.expired,
+    ...(holder ? { holder } : {}),
   };
 }

package/.agents/scripts/lib/orchestration/single-story-close/phases/code-review.js CHANGED Viewed

@@ -49,29 +49,6 @@ export function buildStoryReviewCrossRefBody({
   );
 }
-async function invokeStoryReviewCore({
-  storyId,
-  storyBranch,
-  baseRef,
-  prNumber,
-  provider,
-  runCodeReviewFn,
-  gitSpawnFn,
-  progress,
-}) {
-  return runStoryReviewCore({
-    storyId,
-    baseRef,
-    headRef: storyBranch,
-    commentTargetId: prNumber,
-    provider,
-    progress,
-    progressTag: 'REVIEW',
-    runCodeReviewFn,
-    gitSpawnFn,
-  });
-}
 async function postStoryReviewCrossRef({
   provider,
   storyId,
@@ -115,7 +92,122 @@ async function postStoryReviewCrossRef({
 }
 /**
- * Skips on an unparseable PR number or an unresolvable base (recording a
+ * Run the review against `headRef`; `deferPost` holds the report unposted.
+ *
+ * @returns {Promise<{ outcome: object }|{ result: object }>} a final
+ *   `outcome` (unresolvable base), or the `result` to settle.
+ */
+export async function computeStoryScopeReview({
+  cwd,
+  storyId,
+  headRef,
+  baseBranch,
+  commentTargetId = null,
+  deferPost = false,
+  provider,
+  runCodeReviewFn,
+  gitSpawnFn,
+  progress,
+}) {
+  const base = resolveSharedBaseRef({ baseBranch, cwd, gitSpawnFn });
+  if (!base.resolved) {
+    return {
+      outcome: unresolvedBaseReviewOutcome({
+        storyId,
+        baseBranch,
+        remoteRef: base.remoteRef,
+        progress,
+      }),
+    };
+  }
+  const target = deferPost
+    ? 'held until the PR exists'
+    : `→ PR #${commentTargetId}`;
+  progress(
+    'REVIEW',
+    `Running Story-scope code review for Story #${storyId} (${base.ref}...${headRef}) ${target}...`,
+  );
+  const result = await runStoryReviewCore({
+    storyId,
+    baseRef: base.ref,
+    headRef,
+    commentTargetId,
+    provider,
+    progress,
+    progressTag: 'REVIEW',
+    runCodeReviewFn: deferPost
+      ? (opts) => runCodeReviewFn({ ...opts, deferPost: true })
+      : runCodeReviewFn,
+    gitSpawnFn,
+  });
+  return { result };
+}
+/**
+ * Settle a computed review on the PR: post a held report via `postReportFn`,
+ * report the tally, cross-reference the Story.
+ *
+ * @returns {Promise<object>} the review outcome.
+ */
+export async function settleStoryScopeReview({
+  computed,
+  storyId,
+  prUrl,
+  prNumber,
+  provider,
+  progress,
+  postReportFn = null,
+}) {
+  if (computed.outcome) return computed.outcome;
+  const posting = postReportFn
+    ? await postReportFn({
+        provider,
+        commentTargetId: prNumber,
+        report: computed.result.report,
+        logger: {
+          info: (m) => progress('REVIEW', m),
+          warn: (m) => progress('REVIEW', `⚠️ ${m}`),
+        },
+      })
+    : {};
+  const result = { ...computed.result, ...posting };
+  const sev = result.severity ?? {
+    critical: 0,
+    high: 0,
+    medium: 0,
+    suggestion: 0,
+  };
+  const outcome = formatReviewOutcomeLines({
+    severity: sev,
+    degradations: result.degradations,
+    prNumber,
+    posted: result.posted,
+  });
+  for (const line of outcome) progress('REVIEW', line);
+  const crossRefPosted = await postStoryReviewCrossRef({
+    provider,
+    storyId,
+    prUrl,
+    prNumber,
+    result,
+    severity: sev,
+    progress,
+  });
+  return {
+    halted: !!result.halted,
+    severity: sev,
+    criticalByProvider: result.criticalByProvider,
+    posted: result.posted,
+    postedCommentId: result.postedCommentId ?? null,
+    ...degradationEnvelope(result.degradations),
+    crossRefPosted,
+  };
+}
+/**
+ * The serial review, posting to the PR. Skips on an unparseable PR number or an unresolvable base (recording a
  * degradation); a runner throw propagates and fails the close.
  *
  * @param {{
@@ -161,64 +253,23 @@ export async function runStoryScopeReview({
     );
     return { halted: false, skipped: true };
   }
-  const base = resolveSharedBaseRef({ baseBranch, cwd, gitSpawnFn });
-  if (!base.resolved) {
-    return unresolvedBaseReviewOutcome({
-      storyId,
-      baseBranch,
-      remoteRef: base.remoteRef,
-      progress,
-    });
-  }
-  progress(
-    'REVIEW',
-    `Running Story-scope code review for Story #${storyId} (${base.ref}...${storyBranch}) → PR #${prNumber}...`,
-  );
-  const result = await invokeStoryReviewCore({
+  const computed = await computeStoryScopeReview({
+    cwd,
     storyId,
-    storyBranch,
-    baseRef: base.ref,
-    prNumber,
+    headRef: storyBranch,
+    baseBranch,
+    commentTargetId: prNumber,
     provider,
     runCodeReviewFn,
     gitSpawnFn,
     progress,
   });
-  const sev = result.severity ?? {
-    critical: 0,
-    high: 0,
-    medium: 0,
-    suggestion: 0,
-  };
-  const outcome = formatReviewOutcomeLines({
-    severity: sev,
-    degradations: result.degradations,
-    prNumber,
-    posted: result.posted,
-  });
-  for (const line of outcome) progress('REVIEW', line);
-  const crossRefPosted = await postStoryReviewCrossRef({
-    provider,
+  return settleStoryScopeReview({
+    computed,
     storyId,
     prUrl,
     prNumber,
-    result,
-    severity: sev,
+    provider,
     progress,
   });
-  return {
-    halted: !!result.halted,
-    severity: sev,
-    criticalByProvider: result.criticalByProvider,
-    posted: result.posted,
-    postedCommentId: result.postedCommentId ?? null,
-    ...degradationEnvelope(result.degradations),
-    crossRefPosted,
-  };
 }