mandrel 2.54.0 → 2.55.0

package/.agents/scripts/lib/orchestration/plan-persist/run-plan-persist.js

@@ -38,7 +38,7 @@
  */
 
 import { rm } from 'node:fs/promises';
-import { getLimits, PROJECT_ROOT } from '../../config-resolver.js';
+import { getLimits, getPaths, PROJECT_ROOT } from '../../config-resolver.js';
 import { gitSpawn } from '../../git-utils.js';
 import { Logger } from '../../Logger.js';
 import { sweepTempRetention } from '../../temp-retention.js';
@@ -88,6 +88,7 @@ import {
   PLAN_SUMMARY_COMMENT_TYPE,
 } from './summary.js';
 import { closeSupersededTickets } from './supersede-ops.js';
+import { predictWaveSerialisation } from './wave-serialisation.js';
 
 /** Checkpoint schema version written on each Story's story-plan-state. */
 const PLAN_CHECKPOINT_SCHEMA_VERSION_V2 = 2;
@@ -212,6 +213,7 @@ async function runSupersedePhase(args) {
       reason: `phase-error: ${err.message}`,
       closed: [],
       planned: [],
+      epicRollup: { closed: [], pending: [] },
       skipped: [],
       failed: (args.sourceTicketIds ?? []).map((ticket) => ({
         ticket,
@@ -831,6 +833,17 @@ export async function runPlanPersist({
     })),
   );
 
+  // Story #5265: the table says which Stories share an order; the dispatcher
+  // decides which of those actually run together, and it decides on the
+  // evidence-widened footprint. Run its own predicate over the assembled
+  // bodies — the exact artifact the tick will read back off GitHub — so the
+  // comment names the serialisation instead of promising parallelism the
+  // next tick refuses. `tempRoot` is threaded for the same reason the tick
+  // threads it: the scrape must ignore this project's scratch root.
+  const waveCollisions = predictWaveSerialisation(waveTable, stories, {
+    tempRoot: getPaths(config).tempRoot,
+  });
+
   // Story #4541: `readPlanMetrics` is declared `(epicId, config)` but was
   // called with `config` first, so the ledger path resolver received the
   // config object as an `epicId` and threw its guard on every single run —
@@ -860,6 +873,7 @@ export async function runPlanPersist({
     // collisions the conflict passes found belong on the same surface, or the
     // promise is the only half anyone reads.
     conflictFindings: assembledConflicts,
+    waveCollisions,
   });
 
   if (!dryRun) {
@@ -890,6 +904,10 @@ export async function runPlanPersist({
     stories,
     created,
     sourceTicketIds,
+    // Story #5280 — closing a source ticket is a child state change, so the
+    // phase re-derives the container above it. It needs the config the rollup
+    // reads its board and operator handle from.
+    config,
     dryRun,
     closeSuperseded,
   });
@@ -915,6 +933,11 @@ export async function runPlanPersist({
     reachability,
     freshness,
     waveTable,
+    // Story #5265 AC-2/AC-4: both halves of what persist concluded but used
+    // to keep to itself — the `refactors-existing` declarations it rewrote,
+    // and the same-order pairs the dispatcher will serialize.
+    assumptionNormalizations: validated.normalizations ?? [],
+    waveCollisions,
     supersede,
     epic: containerEpic,
   };

package/.agents/scripts/lib/orchestration/plan-persist/story-ops.js

@@ -1098,6 +1098,11 @@ export async function createStoryIssues({ provider, stories, opts = {} }) {
       id,
       title: story.title,
       url: result.url,
+      // Kept, not discarded (Story #5280). `createIssue` hands back the
+      // database id, which is the only identifier the native sub-issue write
+      // accepts — and dropping it here is what made the Epic linker re-read
+      // every Story this run had just created to recover it.
+      internalId: result.internalId,
       // True when the provider's retry probe adopted an issue a lost-response
       // first attempt had already filed — pre-existing either way.
       adopted: result.adopted === true,

package/.agents/scripts/lib/orchestration/plan-persist/summary.js

@@ -14,6 +14,7 @@
  */
 
 import { computeStoryWaves } from '../dependency-analyzer.js';
+import { renderPredictedSerialisationLines } from './wave-serialisation.js';
 
 /**
  * Structured-comment type for the persist summary.
@@ -129,6 +130,7 @@ export function buildPlanSummaryCommentBody({
   planMetricsLine = null,
   stories = null,
   conflictFindings = null,
+  waveCollisions = null,
   // legacy unused knobs kept so older test call sites don't crash mid-migration
   single = null,
   amend = null,
@@ -180,6 +182,7 @@ export function buildPlanSummaryCommentBody({
     '#### Delivery order (`depends_on`)',
     '',
     ...renderWaveTableLines(waveTable),
+    ...renderPredictedSerialisationLines(waveCollisions),
     ...renderSharedEditorLines(conflictFindings),
     '',
     `_Deliver with \`${deliverCommand}\` — \`/mandrel-deliver\` resolves the dependency graph from live state, so edges may point at Stories from earlier plan runs._`,

package/.agents/scripts/lib/orchestration/plan-persist/supersede-ops.js

@@ -50,6 +50,7 @@ import {
   concurrentMap,
   FANOUT_CONCURRENCY,
 } from '../../util/concurrent-map.js';
+import { rollUpEpicForStory } from '../epic-rollup.js';
 import { upsertStructuredComment } from '../ticketing.js';
 
 /** Structured-comment type marking a source issue as superseded. */
@@ -444,6 +445,9 @@ async function closeOneSupersededTicket({
  *   slug is the only identifier that means anything before the writes land.
  * @property {Array<{ ticket: number, reason: string }>} skipped
  * @property {Array<{ ticket: number, reason: string }>} failed
+ * @property {{ closed: number[], pending: number[] }} epicRollup Container
+ *   Epics this phase's closes resolved. Empty on a dry run and on a phase that
+ *   closed nothing.
  */
 
 function emptyReport(overrides) {
@@ -455,10 +459,53 @@ function emptyReport(overrides) {
     planned: [],
     skipped: [],
     failed: [],
+    epicRollup: { closed: [], pending: [] },
     ...overrides,
   };
 }
 
+/**
+ * Re-derive the container Epic above every ticket this phase just closed.
+ *
+ * Closing a source ticket is a child state change like any other, and it was
+ * the one edge with no rollup behind it. Superseding a cohort therefore left
+ * its container open indefinitely: every child was closed, so no delivery
+ * would ever run and no land tail would ever fire the derivation. The Epic sat
+ * open above finished work until someone noticed.
+ *
+ * Runs **after** the closes land, never alongside them: the rollup reads each
+ * child's state back, so racing it against the writes it is meant to observe
+ * would derive from a tree half of which has not been written yet.
+ *
+ * Sequential, sharing one `skipEpicIds` set, because siblings share a
+ * container — without it the second ticket re-derives, and re-closes, the Epic
+ * the first already closed. `rollUpEpicForStory` never throws, so no guard is
+ * needed here beyond the phase-level one the caller already holds.
+ *
+ * @param {{ closedIds: number[], provider: object, config?: object }} opts
+ * @returns {Promise<{ closed: number[], pending: number[] }>}
+ */
+async function rollUpContainersFor({ closedIds, provider, config }) {
+  const seen = new Set();
+  const closed = new Set();
+  const pending = new Set();
+  for (const storyId of closedIds) {
+    const outcome = await rollUpEpicForStory({
+      storyId,
+      provider,
+      config,
+      skipEpicIds: seen,
+    });
+    for (const epic of outcome.epics) seen.add(epic.epicId);
+    for (const epicId of outcome.closed) closed.add(epicId);
+    for (const epicId of outcome.pending) pending.add(epicId);
+  }
+  // A container reported pending by one ticket's rollup and closed by a later
+  // one is closed: the last answer saw the whole cohort.
+  for (const epicId of closed) pending.delete(epicId);
+  return { closed: [...closed], pending: [...pending] };
+}
+
 /**
  * Comment on and close every superseded source ticket.
  *
@@ -471,6 +518,7 @@ function emptyReport(overrides) {
  * @param {Array<{ slug: string, supersedes: Array<{ id: number, note: string|null }> }>} args.stories
  * @param {Array<{ slug: string, id: number, title: string }>} args.created
  * @param {number[]} args.sourceTicketIds
+ * @param {object} [args.config] Resolved `.agentrc.json`, for the Epic rollup.
  * @param {boolean} [args.dryRun=false]
  * @param {boolean} [args.closeSuperseded=true]
  * @returns {Promise<SupersedeReport>}
@@ -480,6 +528,7 @@ export async function closeSupersededTickets({
   stories,
   created,
   sourceTicketIds,
+  config,
   dryRun = false,
   closeSuperseded = true,
 }) {
@@ -532,6 +581,14 @@ export async function closeSupersededTickets({
     recordSupersedeOutcome(report, units[index], result);
   });
 
+  if (report.closed.length > 0) {
+    report.epicRollup = await rollUpContainersFor({
+      closedIds: report.closed,
+      provider,
+      config,
+    });
+  }
+
   logSupersedeReport(report);
   return report;
 }
@@ -613,4 +670,10 @@ function logSupersedeReport(report) {
         'close it by hand.',
     );
   }
+  if (report.epicRollup.closed.length > 0) {
+    Logger.info(
+      `[plan-persist] container Epic(s) closed by the supersede rollup: ` +
+        `${report.epicRollup.closed.map((id) => `#${id}`).join(', ')}.`,
+    );
+  }
 }

package/.agents/scripts/lib/orchestration/plan-persist/wave-serialisation.js

@@ -0,0 +1,110 @@
+/**
+ * wave-serialisation.js — what the dispatcher will actually do with the wave
+ * table plan-persist prints (Story #5265).
+ *
+ * Kept out of `summary.js` because it answers a different question. The
+ * summary module renders receipts persist already computed; this one runs the
+ * *runtime's* collision predicate over the assembled Story bodies to work out
+ * which of the table's promises the next tick will refuse to keep.
+ *
+ * @module lib/orchestration/plan-persist/wave-serialisation
+ */
+
+import {
+  detectCollision,
+  OVERLAP_SOURCES,
+  renderScrapeAttribution,
+} from '../../wave-runner/footprint.js';
+
+/**
+ * Predict which same-wave pairs the dispatch guard will actually refuse to
+ * co-dispatch (Story #5265).
+ *
+ * The wave table answers a `depends_on` question, and the runtime answers a
+ * different one: `stories-wave-tick.js` withholds on {@link detectCollision},
+ * whose footprint is the declared `changes[]` **plus** every path scraped out
+ * of the Story's title, spec and serialized body — and that body carries
+ * `## Verify`, so two Stories that merely run the same gate script share a
+ * path neither will edit. The table therefore promised parallelism the very
+ * next tick refused, with nothing anywhere reconciling the two.
+ *
+ * This runs the runtime's own exported predicate — not a reimplementation of
+ * it — pairwise within each wave, so the prediction cannot drift from the
+ * behaviour it predicts.
+ *
+ * @param {ReturnType<typeof buildWaveTable>} waveTable
+ * @param {Array<{ slug: string, title?: string, body?: string, spec?: string, changes?: Array }>} stories
+ * @param {{ tempRoot?: string }} [options]
+ * @returns {Array<{ wave: number, slugs: [string, string], paths: string[], source: string, attribution: object[] }>}
+ */
+export function predictWaveSerialisation(waveTable, stories, options = {}) {
+  const bySlug = new Map(
+    (Array.isArray(stories) ? stories : []).map((s) => [s.slug, s]),
+  );
+  const out = [];
+  for (const { wave, stories: members } of Array.isArray(waveTable)
+    ? waveTable
+    : []) {
+    for (let i = 0; i < members.length; i += 1) {
+      for (let j = i + 1; j < members.length; j += 1) {
+        const a = bySlug.get(members[i].slug);
+        const b = bySlug.get(members[j].slug);
+        if (!a || !b) continue;
+        const collision = detectCollision(a, b, options);
+        if (collision) {
+          out.push({
+            wave,
+            slugs: [members[i].slug, members[j].slug],
+            ...collision,
+          });
+        }
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * Render the predicted serialisation beside the wave table (Story #5265).
+ *
+ * Same shape as {@link renderSharedEditorLines} on purpose: both are caveats
+ * against the same promise, and an operator should read them the same way.
+ * The difference is what they know — the shared-editor pass names paths two
+ * Stories both *write*, this one names every pair the dispatcher will refuse
+ * to run together whatever the reason, including the pairs whose only shared
+ * path was scraped out of a `## Verify` line.
+ *
+ * @param {ReturnType<typeof predictWaveSerialisation>} collisions
+ * @returns {string[]}
+ */
+export function renderPredictedSerialisationLines(collisions) {
+  const list = Array.isArray(collisions) ? collisions : [];
+  if (list.length === 0) return [];
+  const rows = list.map((c) => {
+    const scraped = renderScrapeAttribution(c.attribution);
+    return `| \`${c.slugs[0]}\` + \`${c.slugs[1]}\` | ${c.paths
+      .map((p) => `\`${p}\``)
+      .join(', ')} | ${c.source} | ${scraped ? `\`${scraped}\`` : '—'} |`;
+  });
+  const scrapedOnly = list.filter(
+    (c) => c.source === OVERLAP_SOURCES.SCRAPED,
+  ).length;
+  return [
+    '',
+    `#### ⚠️ Predicted serialisation (${list.length} same-order pair(s))`,
+    '',
+    '| Stories | Colliding paths | Overlap source | Scraped from |',
+    '| --- | --- | --- | --- |',
+    ...rows,
+    '',
+    '_The dispatcher compares the **evidence-widened** footprint — declared ' +
+      '`changes[]` plus every path named in the title, `## Spec` and the rest ' +
+      'of the body — so these pairs are shown in one order above but will be ' +
+      `dispatched one at a time. ${scrapedOnly} pair(s) collide only on ` +
+      'scraped paths; the "Scraped from" column names the field each such ' +
+      'path was read out of, so a shared `## Verify` command is ' +
+      'distinguishable from a genuine unpredicted edit target. The guard is ' +
+      'deliberately not narrowed to `changes[]`: the declaration is a lower ' +
+      'bound (Story #4875) and under-serialising is the worse failure._',
+  ];
+}

package/.agents/scripts/lib/orchestration/planning/memory-pool-advisory.js

@@ -34,13 +34,31 @@
  * simply stays silent and only the age arm can speak, until the next pass
  * writes a baseline.
  *
+ * **The index byte arm (Story #5285).** Age and growth both measure the
+ * *pool*; neither measures the one artifact a session actually loads. The
+ * harness reads `MEMORY.md` into every session under a hard byte cap and
+ * **truncates** past it, so an index over that cap loses its tail entries
+ * silently — the pointers are on disk, indexed, and unreachable. That is a
+ * loss in progress, not a hygiene forecast, so this arm is independent of the
+ * other two: it fires on a fresh, zero-growth pool whose index has simply
+ * outgrown the cap. It measures the index file's size, never the pool's, and
+ * a pass that rewrites long index lines short clears it without pruning a
+ * single entry.
+ *
+ * **A future-dated stamp is no stamp.** `lastConsolidatedAt` ahead of `now`
+ * cannot describe a pass that happened — it is a clock skew, a hand-edit, or
+ * a timezone bug. Scored as-is it yields a negative age that silences the age
+ * arm *forever*, which is the loudest possible failure for an advisory whose
+ * only job is to speak up. It reads as unstamped instead, so the
+ * never-consolidated reason fires and the next real pass overwrites it.
+ *
  * Detection is filesystem-only — no child processes, no `gh` probes, no
  * network. Every failure path fails soft to "no pool, no recommendation": the
  * advisory can degrade the nudge, never a plan.
  *
  * Test seams: `cwd`, `env`, `fsImpl` (node:fs-compatible `statSync` /
- * `readdirSync` / `readFileSync`), `now`, and the two thresholds
- * (`staleAfterDays`, `growthDelta`).
+ * `readdirSync` / `readFileSync`), `now`, and the three thresholds
+ * (`staleAfterDays`, `growthDelta`, `indexByteCeiling`).
  *
  * `buildMemoryPoolAdvisory` is the **only** export: the helpers below have no
  * caller outside this module, and exporting one solely for a test would add a
@@ -59,6 +77,16 @@ const STALE_AFTER_DAYS = 30;
 /** Recommend a pass once this many entries were written since the last one. */
 const GROWTH_DELTA = 25;
 
+/**
+ * Recommend a pass once `MEMORY.md` exceeds this many bytes.
+ *
+ * 24576 (24 KiB) is the harness's own index cap — the point past which it
+ * truncates the file it loads into a session, making every entry after the
+ * cut unreachable. The default is the cap itself rather than a margin under
+ * it: the arm reports a loss that has already started, not one approaching.
+ */
+const INDEX_BYTE_CEILING = 24_576;
+
 /** Stamp file written by `/memory-consolidate` after its operator gate. */
 const STAMP_FILENAME = '.consolidation-stamp.json';
 
@@ -109,6 +137,28 @@ function resolveMemoryPoolDir({ cwd, env = process.env, homedir } = {}) {
   );
 }
 
+/**
+ * Run one filesystem probe, falling back on any failure.
+ *
+ * Every read here is fail-soft by design — the advisory may degrade its nudge
+ * but never a plan — so all four probes had the same try/catch shape wrapped
+ * around one expression. One helper states the rule once; a new probe cannot
+ * forget it, and a `catch` that ever needs to do more than fall back would
+ * have to be written out, which is the signal it deserves.
+ *
+ * @template T
+ * @param {() => T} read
+ * @param {T|null} [fallback]
+ * @returns {T|null}
+ */
+function probe(read, fallback = null) {
+  try {
+    return read();
+  } catch {
+    return fallback;
+  }
+}
+
 /**
  * The growth baseline a stamp records: its entry count, or `null` when it
  * records none. `null` is *unmeasured*, never zero — a zero baseline would
@@ -125,8 +175,11 @@ function readBaseline(count) {
  * Read the consolidation stamp.
  *
  * `at` is the ISO timestamp of the last pass, or `null` when there was none:
- * a missing, unreadable, unparseable or date-less stamp is indistinguishable
- * from "never consolidated" — all four mean the same thing to the advisory.
+ * a missing, unreadable, unparseable, date-less or **future-dated** stamp is
+ * indistinguishable from "never consolidated" — all five mean the same thing
+ * to the advisory. A future date is the one that has to be caught here rather
+ * than downstream: it is arithmetically valid, so the age arm would score it
+ * as a negative age and stay silent for as long as the clock stays behind it.
  * A stamp whose date is unusable carries no baseline either, so `baseline`
  * follows it to `null` rather than describing a pass that cannot be dated.
  *
@@ -135,23 +188,40 @@ function readBaseline(count) {
  * only) and on a malformed count, which reads as *unmeasured growth*, never
  * as zero growth: a `0` baseline would score the whole pool as new.
  *
+ * @param {{ poolDir: string, fsImpl: object, now: Date|string|number }} args
  * @returns {{ at: string|null, baseline: number|null }}
  */
-function readStamp({ poolDir, fsImpl }) {
-  const unstamped = { at: null, baseline: null };
-  try {
-    const raw = fsImpl.readFileSync(path.join(poolDir, STAMP_FILENAME), 'utf8');
-    const parsed = JSON.parse(raw);
-    const at = parsed.lastConsolidatedAt;
-    // `Date.parse` rejects the empty string as NaN, so this one test covers
-    // both an absent date and an unusable one.
-    if (typeof at !== 'string' || Number.isNaN(Date.parse(at))) {
-      return unstamped;
-    }
-    return { at, baseline: readBaseline(parsed.entryCount) };
-  } catch {
-    return unstamped;
+function readStamp({ poolDir, fsImpl, now }) {
+  const parsed = probe(() =>
+    JSON.parse(fsImpl.readFileSync(path.join(poolDir, STAMP_FILENAME), 'utf8')),
+  );
+  const at = parsed?.lastConsolidatedAt;
+  // `Date.parse` rejects the empty string as NaN, so one test covers both an
+  // absent date and an unusable one; `> now` covers the future-dated stamp.
+  // Equality is not the future, so a stamp written this instant still counts.
+  const at_ms = typeof at === 'string' ? Date.parse(at) : Number.NaN;
+  if (Number.isNaN(at_ms) || at_ms > new Date(now).getTime()) {
+    return { at: null, baseline: null };
   }
+  return { at, baseline: readBaseline(parsed.entryCount) };
+}
+
+/**
+ * The index file's size in bytes.
+ *
+ * `null` when it cannot be stat'd — an absent or unreadable `MEMORY.md`
+ * leaves the byte arm silent rather than guessing a size, on the same
+ * fail-soft rule every other probe here follows. Stat'd rather than read:
+ * the arm needs the length, never the content, and this module deliberately
+ * never reads a memory's text.
+ *
+ * @returns {number|null}
+ */
+function readIndexBytes({ poolDir, fsImpl }) {
+  const size = probe(
+    () => fsImpl.statSync(path.join(poolDir, INDEX_FILENAME)).size,
+  );
+  return Number.isFinite(size) ? size : null;
 }
 
 /**
@@ -160,13 +230,13 @@ function readStamp({ poolDir, fsImpl }) {
  * @returns {number|null} `null` when the directory cannot be listed
  */
 function countEntries({ poolDir, fsImpl }) {
-  try {
-    return fsImpl
-      .readdirSync(poolDir)
-      .filter((name) => name.endsWith('.md') && name !== INDEX_FILENAME).length;
-  } catch {
-    return null;
-  }
+  return probe(
+    () =>
+      fsImpl
+        .readdirSync(poolDir)
+        .filter((name) => name.endsWith('.md') && name !== INDEX_FILENAME)
+        .length,
+  );
 }
 
 /**
@@ -176,7 +246,8 @@ function countEntries({ poolDir, fsImpl }) {
  * and not others, which is the failure mode a per-branch object literal has.
  *
  * @param {object} fields
- * @returns {{ present: boolean, entryCount: number, lastConsolidatedAt: string|null,
+ * @returns {{ present: boolean, entryCount: number, indexBytes: number|null,
+ *            lastConsolidatedAt: string|null,
  *            entriesSinceConsolidation: number|null, recommend: boolean,
  *            reasons: string[] }}
  */
@@ -184,6 +255,7 @@ function envelope(fields) {
   return {
     present: false,
     entryCount: 0,
+    indexBytes: null,
     lastConsolidatedAt: null,
     entriesSinceConsolidation: null,
     recommend: false,
@@ -197,14 +269,23 @@ function envelope(fields) {
  * the quiet verdict; the caller turns it into `recommend` and supplies the
  * standing-down sentence, so every arm lives in one place.
  *
- * The two arms are independent and both are reported when both fire.
+ * The three arms are independent and every one that fires is reported.
  *
  * @param {{ stamp: { at: string|null, baseline: number|null },
- *           growth: number|null, now: Date|string|number,
- *           staleAfterDays: number, growthDelta: number }} args
+ *           growth: number|null, indexBytes: number|null,
+ *           now: Date|string|number, staleAfterDays: number,
+ *           growthDelta: number, indexByteCeiling: number }} args
  * @returns {string[]}
  */
-function collectReasons({ stamp, growth, now, staleAfterDays, growthDelta }) {
+function collectReasons({
+  stamp,
+  growth,
+  indexBytes,
+  now,
+  staleAfterDays,
+  growthDelta,
+  indexByteCeiling,
+}) {
   const reasons = [];
 
   if (stamp.at === null) {
@@ -229,6 +310,13 @@ function collectReasons({ stamp, growth, now, staleAfterDays, growthDelta }) {
     );
   }
 
+  // `indexBytes === null` is an unreadable index, not a small one.
+  if (indexBytes !== null && indexBytes > indexByteCeiling) {
+    reasons.push(
+      `${INDEX_FILENAME} is ${indexBytes} bytes, ${indexBytes - indexByteCeiling} over the ${indexByteCeiling}-byte index ceiling — the index is truncated at the cap, so every entry listed after the cut is invisible to every session`,
+    );
+  }
+
   return reasons;
 }
 
@@ -241,9 +329,9 @@ function collectReasons({ stamp, growth, now, staleAfterDays, growthDelta }) {
  */
 function quietReason({ growth, growthDelta }) {
   if (growth === null) {
-    return 'memory pool is within the freshness threshold; growth is unmeasured until the next /memory-consolidate stamps an entry count';
+    return 'memory pool is within the freshness and index-size thresholds; growth is unmeasured until the next /memory-consolidate stamps an entry count';
   }
-  return `memory pool is within both thresholds — ${growth} entries written since the last consolidation (under the ${growthDelta}-entry growth delta)`;
+  return `memory pool is within every threshold — ${growth} entries written since the last consolidation (under the ${growthDelta}-entry growth delta)`;
 }
 
 /**
@@ -261,7 +349,9 @@ function quietReason({ growth, growthDelta }) {
  * @param {Date|string|number} [opts.now]
  * @param {number} [opts.staleAfterDays]
  * @param {number} [opts.growthDelta]
- * @returns {{ present: boolean, entryCount: number, lastConsolidatedAt: string|null,
+ * @param {number} [opts.indexByteCeiling]
+ * @returns {{ present: boolean, entryCount: number, indexBytes: number|null,
+ *            lastConsolidatedAt: string|null,
  *            entriesSinceConsolidation: number|null, recommend: boolean,
  *            reasons: string[] }}
  */
@@ -273,6 +363,7 @@ export function buildMemoryPoolAdvisory({
   now = new Date(),
   staleAfterDays = STALE_AFTER_DAYS,
   growthDelta = GROWTH_DELTA,
+  indexByteCeiling = INDEX_BYTE_CEILING,
 } = {}) {
   const absent = (reason) => envelope({ reasons: [reason] });
 
@@ -283,12 +374,7 @@ export function buildMemoryPoolAdvisory({
     );
   }
 
-  let isDir = false;
-  try {
-    isDir = fsImpl.statSync(poolDir).isDirectory();
-  } catch {
-    isDir = false;
-  }
+  const isDir = probe(() => fsImpl.statSync(poolDir).isDirectory(), false);
   if (!isDir) {
     return absent(`no memory pool at ${poolDir} — nothing to consolidate`);
   }
@@ -298,14 +384,16 @@ export function buildMemoryPoolAdvisory({
     return absent(`memory pool at ${poolDir} could not be listed`);
   }
 
-  const stamp = readStamp({ poolDir, fsImpl });
+  const stamp = readStamp({ poolDir, fsImpl, now });
   // Reported raw: a pruning pass can leave this negative, and saying the pool
   // shrank by 7 is more use to the operator than clamping it to zero.
   const growth = stamp.baseline === null ? null : entryCount - stamp.baseline;
+  const indexBytes = readIndexBytes({ poolDir, fsImpl });
 
   const found = {
     present: true,
     entryCount,
+    indexBytes,
     lastConsolidatedAt: stamp.at,
     entriesSinceConsolidation: growth,
   };
@@ -321,9 +409,11 @@ export function buildMemoryPoolAdvisory({
   const reasons = collectReasons({
     stamp,
     growth,
+    indexBytes,
     now,
     staleAfterDays,
     growthDelta,
+    indexByteCeiling,
   });
 
   return envelope({