@cleocode/core 2026.10.26 → 2026.10.27-rc.ci.698

package/dist/resources/admission-ledger.js

@@ -76,10 +76,10 @@ import { getLogger } from '../logger.js';
 import { getCleoHome } from '../paths.js';
 import { admissionCapacityBytes, admissionReserveBytes, defaultSingleProcessHeapMb, GIB_PER_WORKER, HEAVY_TOOL_HEAP_MB, heavyToolWorkers, isHeavyTool, isMemoryBoundTool, planHeavyToolEnv, projectSettingOverrides, vitestWorkerCeiling, } from '../tasks/heavy-tool-env.js';
 import { gitHookPath, HOOK_MIN_RUNS, HOOK_PEAK_MARGIN, hookFootprintKey, readHookPeak, scriptFootprint, } from './hook-footprint.js';
-import { pressureScore, ResourceMonitor } from './monitor.js';
+import { classifyPressure, pressureScore, ResourceMonitor } from './monitor.js';
 import { checkMemoryGate, MEMORY_GATE_RETRY_AFTER_MS, } from './pressure-gate.js';
 import { processAncestors, processGroupOf, processGroupsOf } from './run-admission.js';
-import { canonicalForClass, gitHookFor, heavyScriptReason, lightCommandReason, namedTestFileCount, nodeScriptOf, runFootprint, } from './run-class.js';
+import { canonicalForClass, gitHookFor, heavyScriptReason, lightCommandReason, namedTestFileCount, runFootprint, scriptRunOf, } from './run-class.js';
 import { ownProcessStartedAt, systemPidProbe } from './slot-holder.js';
 import { followToolGroups, isProbeableId } from './tool-groups.js';
 import { memoryPressureCause, TOP_MEMORY_COUNT, TOP_MEMORY_FAILED_REUSE_MS, TOP_MEMORY_REUSE_MS, topMemoryConsumers, } from './top-memory.js';
@@ -282,20 +282,26 @@ scriptPeak = (script) => {
     let scope = cls === 'full-build' ? null : runFootprint(argv);
     const sized = cls === 'scoped-build' && scope?.size === 'class';
     // T14050: a node script that hosts a heavy tool (its path names one, or it
-    // loads a compiler or test runner in-process) is never light.
-    const script = sized ? nodeScriptOf(argv) : null;
+    // loads a compiler or test runner in-process) is never light. T14079: so
+    // is a Python or shell script that runs one, or one that cannot be read.
+    const run = sized ? scriptRunOf(argv) : null;
+    const script = run?.script ?? null;
     const scripted = script !== null ? scriptPeak(script) : null;
     const host = script === null
         ? null
         : (heavyScriptReason(script) ??
-            (scripted?.heavyTool ? `it loads ${scripted.heavyTool}` : null));
+            (scripted?.heavyTool
+                ? `it ${run?.runner === 'node' ? 'loads' : 'runs'} ${scripted.heavyTool}`
+                : run?.runner !== 'node' && scripted === null
+                    ? 'it cannot be read'
+                    : null));
     // T13452: a scoped build of a command that runs no heavy tool (`node x.mjs`,
     // `ls`) is charged light. An explicit test run keeps its class plan.
     const light = sized && host === null ? lightCommandReason(argv) : null;
     if (light !== null)
         scope = { size: 'light', reason: light };
     else if (host !== null)
-        scope = { size: 'class', reason: `node ${script} hosts a heavy tool (${host})` };
+        scope = { size: 'class', reason: `${run?.runner} ${script} hosts a heavy tool (${host})` };
     // T13452: a hooked git push/commit keeps the class plan, because whatever
     // the hook runs (tests, a build) rides this admission.
     const probe = scope?.size === 'light' ? gitHookFor(argv) : null;
@@ -468,6 +474,10 @@ function isCachedPressure(v) {
         (c.lightShare === undefined ||
             (typeof c.lightShare === 'string' && SHARES.has(c.lightShare))) &&
         typeof c.sampledAtMs === 'number' &&
+        (c.backoff === undefined || typeof c.backoff === 'boolean') &&
+        (c.memAvailableBytes === undefined ||
+            c.memAvailableBytes === null ||
+            typeof c.memAvailableBytes === 'number') &&
         (c.reading === null || (typeof c.reading === 'object' && c.reading !== null)));
 }
 function readLedgerDoc(dir, strictRead = false) {
@@ -831,6 +841,53 @@ export function budgetShare(sample, gateRefuses) {
     return 'full';
 }
 const NOTHING_HELD = { used: 0, reserved: 0, running: 0, heavy: 0, exclusive: 0 };
+/**
+ * The run a latched-below-refuse pass may start (T14088): the first waiting
+ * run in queue order whose charge fits the reclaimable memory, or `null`.
+ *
+ * @param entries - the ledger.
+ * @param reclaimableBytes - the reading's available or reclaimable bytes.
+ * @param capacityBytes - the machine budget.
+ * @param nowMs - the clock.
+ */
+function firstFittingWaiter(entries, reclaimableBytes, capacityBytes, nowMs) {
+    if (typeof reclaimableBytes !== 'number' || !(reclaimableBytes > 0))
+        return null;
+    return (entries
+        .filter((e) => e.state === 'waiting' && charged(e, capacityBytes) <= reclaimableBytes)
+        .sort(queueOrder(nowMs))[0] ?? null);
+}
+/**
+ * Whether a memory-gate reading is latched shut while pressure sits at or
+ * below the refuse line, waiting for the resume line (T14088).
+ *
+ * @param reading - the gate's refusing reading, or `null` while it admits.
+ */
+export function isLatchedBelowRefuse(reading) {
+    return reading?.latched === true && reading.score <= reading.refuseAbove;
+}
+/**
+ * The idle rule (T14088, T14098): with nothing of CLEO's admitted, the
+ * pressure that keeps the budget closed is someone else's, so the first of
+ * `candidates` in queue order whose charge fits the reclaimable memory starts
+ * (never a whole-suite run into a nearly full swap). It holds the budget
+ * alone until it releases; nothing else starts beside it.
+ *
+ * @param entries - the ledger.
+ * @param ctx - the pass context (capacity, clock, reclaimable memory).
+ * @param candidates - the waiters the rule may start.
+ */
+function admitOneWhenIdle(entries, ctx, candidates) {
+    const idle = (ctx.foreign?.count ?? 0) === 0 && !entries.some((e) => e.state === 'admitted');
+    if (!idle)
+        return [...entries];
+    const fitting = firstFittingWaiter(candidates, ctx.reclaimableBytes, ctx.capacityBytes, ctx.nowMs);
+    if (fitting === null)
+        return [...entries];
+    const opened = schedulePass(entries.filter((e) => e.state !== 'waiting' || e.id === fitting.id), { ...ctx, share: 'one', lightShare: 'one', latchedBelowRefuse: false, backoff: false });
+    const started = opened.find((e) => e.id === fitting.id && e.state === 'admitted');
+    return entries.map((e) => e.id === started?.id ? { ...started, admittedBy: 'idle' } : e);
+}
 function charged(entry, capacityBytes) {
     return Math.min(Math.max(0, entry.footprintBytes), capacityBytes);
 }
@@ -851,7 +908,7 @@ export function shareBudgetBytes(share, capacityBytes) {
             : 0;
 }
 /** {@link LedgerBudget} from a ledger doc's cached pressure verdict. */
-function ledgerBudget(pressure, capacityBytes) {
+function ledgerBudget(pressure, capacityBytes, entries = null) {
     const share = pressure?.share ?? 'full';
     const lightShare = pressure?.lightShare ?? share;
     const lightBudgetBytes = shareBudgetBytes(lightShare, capacityBytes);
@@ -862,9 +919,31 @@ function ledgerBudget(pressure, capacityBytes) {
         lightBudgetBytes,
         heavyBudgetBytes: Math.min(lightBudgetBytes, shareBudgetBytes(share, capacityBytes)),
         sampledAtMs: pressure?.sampledAtMs ?? null,
-        cause: pressure?.reading ? gateCause(pressure.reading) : null,
+        cause: pressure?.reading ? latchCause(pressure.reading, entries, capacityBytes) : null,
     };
 }
+/**
+ * {@link gateCause}, and when CLEO holds nothing while the latch waits below
+ * the refuse line, that the memory is outside CLEO and one run at a time
+ * still starts (T14088).
+ *
+ * @param reading - the gate's refusing reading.
+ * @param entries - the ledger, when known.
+ */
+function latchCause(reading, entries, capacityBytes = admissionCapacityBytes(), nowMs = Date.now()) {
+    const cause = gateCause(reading);
+    const cleoHoldsNothing = entries !== null && !entries.some((e) => e.state === 'admitted');
+    if (!cleoHoldsNothing || !isLatchedBelowRefuse(reading))
+        return cause;
+    const reclaimable = reading.memAvailableBytes;
+    const fitting = firstFittingWaiter(entries ?? [], reclaimable, capacityBytes, nowMs);
+    const reclaim = reclaimable === null ? 'unknown' : gib(reclaimable);
+    return (`${cause}. CLEO holds nothing, so the latch is held by memory outside CLEO (the largest users above); ` +
+        `one run at a time that fits the reclaimable memory is still admitted, in queue order, until pressure resumes ` +
+        (fitting === null
+            ? `(largest fitting run: none; reclaimable ${reclaim})`
+            : `(next run that fits: ${fitting.label} ${gib(charged(fitting, capacityBytes))}; reclaimable ${reclaim})`));
+}
 /** The memory gate's refusal in words, with its cause (T13914). */
 function gateCause(reading) {
     return (`memory pressure ${reading.score} (refused above ${reading.refuseAbove}, resumes at ` +
@@ -879,14 +958,17 @@ function gateCause(reading) {
  * @returns the shares and the light/heavy budgets they leave.
  */
 export function readLedgerBudget(dir = admissionDir(), capacityBytes = admissionCapacityBytes()) {
-    return ledgerBudget(readLedgerDoc(dir).pressure, capacityBytes);
+    const doc = readLedgerDoc(dir);
+    return ledgerBudget(doc.pressure, capacityBytes, doc.entries);
 }
 /**
  * The budget a waiting entry is held to, in words: the capacity when no share
  * narrows it, else the narrowed budget with its share and the capacity, e.g.
  * `24 GiB light budget (light share half from memory pressure; capacity 48 GiB)`.
+ * When `usedBytes` is above it, the phrase says the budget was narrowed after
+ * those runs were admitted (T13967), so "48 GiB of 24 GiB" is not a puzzle.
  */
-function budgetPhrase(entry, budget) {
+function budgetPhrase(entry, budget, usedBytes = 0) {
     const heavy = isHeavy(entry);
     const share = heavy ? budget.share : budget.lightShare;
     const bytes = heavy ? budget.heavyBudgetBytes : budget.lightBudgetBytes;
@@ -894,8 +976,9 @@ function budgetPhrase(entry, budget) {
         return gib(budget.capacityBytes);
     const kind = heavy ? 'heavy' : 'light';
     const cause = heavy ? 'memory or CPU pressure' : 'memory pressure';
+    const narrowed = usedBytes > bytes ? '; narrowed after the running jobs were admitted, so they hold more' : '';
     return (`${gib(bytes)} ${kind} budget (${kind} share ${share}` +
-        `${share === 'one' ? ', one heavy run at a time' : ''} from ${cause}; capacity ${gib(budget.capacityBytes)})`);
+        `${share === 'one' ? ', one heavy run at a time' : ''} from ${cause}; capacity ${gib(budget.capacityBytes)}${narrowed})`);
 }
 /**
  * One scheduling pass: admit every waiting entry the budget and the queue
@@ -925,7 +1008,9 @@ function budgetPhrase(entry, budget) {
  *   the budget, and over the capacity too.
  * - Up to {@link TINY_LANE_SLOTS} tiny runs are admitted from a reserve outside
  *   the pressure share, wherever they wait, while the capacity has room for
- *   them (T13587): their bytes do not count against the share budget, and
+ *   them, or, when holders admitted before the share narrowed hold more than
+ *   the narrowed budget, past the capacity unless an exclusive run holds the
+ *   machine (T13587, T13967): their bytes do not count against the share budget, and
  *   other runs never use the reserve. Like the tiny lane, the reserve closes
  *   while the oldest non-tiny run waits past {@link TINY_LANE_WINDOWS}
  *   reservation windows or needs the whole capacity (T13591). The memory gate
@@ -942,8 +1027,30 @@ function budgetPhrase(entry, budget) {
  */
 export function schedulePass(entries, ctx) {
     const lightShare = ctx.lightShare ?? ctx.share;
-    if (ctx.share === 'none' && lightShare === 'none')
-        return [...entries];
+    if (ctx.share === 'none' && lightShare === 'none') {
+        // T14088: latched below the refuse line with nothing of CLEO's running: the
+        // pressure is someone else's, so the idle rule admits one run. Above the
+        // refuse line nothing starts.
+        if (ctx.latchedBelowRefuse !== true)
+            return [...entries];
+        return admitOneWhenIdle(entries, ctx, entries);
+    }
+    if (ctx.backoff === true) {
+        // T14098: pressure cannot pause a never-paused run later, so at backoff it
+        // starts only by the same idle rule. A nested one (its ancestors admitted)
+        // is never held: CLEO is never idle for it. Non-tiny runs queued behind
+        // the first one that fits keep their place, so a stream of pausable runs
+        // cannot starve it; the rest are scheduled as usual.
+        const held = entries.filter((e) => e.state === 'waiting' && e.neverPause === true && e.parentId === undefined);
+        if (held.length > 0) {
+            const heldIds = new Set(held.map((e) => e.id));
+            const head = firstFittingWaiter(held, ctx.reclaimableBytes, ctx.capacityBytes, ctx.nowMs);
+            const order = queueOrder(ctx.nowMs);
+            const waitsBehind = (e) => head !== null && e.state === 'waiting' && !isTiny(e) && order(head, e) < 0;
+            const scheduled = new Map(schedulePass(entries.filter((e) => !heldIds.has(e.id) && !waitsBehind(e)), { ...ctx, backoff: false }).map((e) => [e.id, e]));
+            return admitOneWhenIdle(entries.map((e) => scheduled.get(e.id) ?? e), ctx, held);
+        }
+    }
     const reservationMs = ctx.reservationMs ?? LEDGER_RESERVATION_MS;
     const bytesFor = (share) => shareBudgetBytes(share, ctx.capacityBytes);
     // Light runs see the memory budget. Heavy runs see the narrower of it and
@@ -959,14 +1066,22 @@ export function schedulePass(entries, ctx) {
     // T13367: admitted tiny runs, for the tiny lane past a blocked head.
     let tinyRunning = 0;
     // T13587: up to TINY_LANE_SLOTS tiny runs sit in a reserve outside the
-    // pressure share (never beyond the capacity). Their bytes are not `used`, so
-    // a holder that fills a halved budget exactly cannot starve a formatter.
+    // pressure share. Their bytes are not `used`, so a holder that fills a
+    // halved budget exactly cannot starve a formatter.
     let reserved = 0;
     let reservedBytes = 0;
     const reserveTakes = (e, cost) => isTiny(e) &&
         e.exclusive !== true &&
         reserved < TINY_LANE_SLOTS &&
         used + reservedBytes + cost <= ctx.capacityBytes;
+    // T13967: holders admitted before memory pressure narrowed the light share
+    // can hold the whole capacity, more than the narrowed budget allows; a
+    // two-file formatter must not wait behind them. Only then may a waiting
+    // tiny run take the reserve past the capacity (at most TINY_LANE_SLOTS
+    // gigabytes), and never beside an exclusive run. At a full share the
+    // capacity bounds the reserve as before (T13367), and the memory gate
+    // (`none`) still admits nothing.
+    const narrowedOverfull = () => lightBudget < ctx.capacityBytes && used > lightBudget && exclusiveRunning === 0;
     const reservedIds = new Set();
     for (const e of entries) {
         if (e.state === 'admitted') {
@@ -1083,7 +1198,10 @@ export function schedulePass(entries, ctx) {
         const cost = charged(w, ctx.capacityBytes);
         // T13587: the tiny reserve admits a tiny run wherever it waits; the memory
         // gate (`none`) still admits nothing.
-        if (reserveOpen && lightShare !== 'none' && reserveTakes(w, cost)) {
+        if (reserveOpen &&
+            lightShare !== 'none' &&
+            (reserveTakes(w, cost) ||
+                (isTiny(w) && w.exclusive !== true && reserved < TINY_LANE_SLOTS && narrowedOverfull()))) {
             admit.add(w.id);
             reserved++;
             reservedBytes += cost;
@@ -1503,11 +1621,19 @@ async function sampleShare(opts, cached, nowMs, probeFor = null) {
     const reading = gate.refuse && gate.reading !== null
         ? withTopConsumers(gate.reading, cached, nowMs, opts, probeFor)
         : null;
+    const backoff = classifyPressure(sample).state === 'backoff';
     return {
         share,
         lightShare,
         reading,
-        sampled: { share, lightShare, reading, sampledAtMs: nowMs },
+        sampled: {
+            share,
+            lightShare,
+            reading,
+            sampledAtMs: nowMs,
+            backoff,
+            memAvailableBytes: sample.memAvailableBytes,
+        },
     };
 }
 /**
@@ -1596,9 +1722,18 @@ function foreignLoad(foreign, capacityBytes) {
 function reapAndSchedule(doc, dead, ctx, sampled) {
     const live = doc.entries.filter((e) => dead.entries.get(e.id) !== e.heartbeatAtMs);
     const foreign = doc.foreign.filter((f) => !dead.foreign.has(JSON.stringify(f)));
+    const cached = sampled ?? doc.pressure;
+    const reading = cached?.reading;
+    const latchedBelowRefuse = isLatchedBelowRefuse(reading);
     return {
         ...doc,
-        entries: schedulePass(live, { ...ctx, foreign: foreignLoad(foreign, ctx.capacityBytes) }),
+        entries: schedulePass(live, {
+            ...ctx,
+            foreign: foreignLoad(foreign, ctx.capacityBytes),
+            latchedBelowRefuse,
+            reclaimableBytes: reading?.memAvailableBytes ?? cached?.memAvailableBytes ?? null,
+            backoff: cached?.backoff === true,
+        }),
         foreign,
         pressure: sampled ?? doc.pressure,
     };
@@ -1658,13 +1793,40 @@ async function admitInner(req, opts) {
     // that grant is a heavy run's or covers the request. Under a light or
     // single-process grant a bigger run queues for itself (T13452), naming the
     // parent: schedulePass never makes it wait on its own ancestors.
-    const parent = enclosingGrant(readLedger(dir), pid, env, opts.facts);
+    // T12994: note whether a `ps` probe failed, so a nested run whose first
+    // detection could not see its parent re-checks on every queue poll instead
+    // of waiting on its own parent until it times out.
+    const baseFacts = opts.facts ?? systemProcessFacts;
+    let factsFailed = false;
+    const facts = {
+        ancestorsOf: (p) => {
+            const a = baseFacts.ancestorsOf(p);
+            if (a === null)
+                factsFailed = true;
+            return a;
+        },
+        groupOf: (p) => {
+            const g = baseFacts.groupOf(p);
+            if (g === null)
+                factsFailed = true;
+            return g;
+        },
+        startedAt: (p) => {
+            const at = baseFacts.startedAt(p);
+            if (at === null)
+                factsFailed = true;
+            return at;
+        },
+    };
+    const rides = (p) => isHeavy(p) || p.footprintBytes >= req.footprintBytes;
+    const parent = enclosingGrant(readLedger(dir), pid, env, facts);
     if (parent !== null &&
-        (isHeavy(parent) || parent.footprintBytes >= req.footprintBytes) &&
+        rides(parent) &&
         !opts.signal?.aborted &&
         (!opts.wait || timeoutMs <= 0 || now() - t0 < timeoutMs)) {
         return { admitted: true, grant: passThrough(admissionToken(parent), true, null) };
     }
+    let parentUnknown = parent === null && factsFailed;
     const entry = {
         id: newId(pid, t0),
         nonce: randomBytes(12).toString('hex'),
@@ -1686,6 +1848,7 @@ async function admitInner(req, opts) {
         ...(req.footprintReason !== undefined ? { footprintReason: req.footprintReason } : {}),
         ...(req.exclusive === true ? { exclusive: true } : {}),
         ...(req.urgent === true ? { priority: 'urgent' } : {}),
+        ...(req.neverPause === true ? { neverPause: true } : {}),
     };
     const deadline = t0 + timeoutMs;
     const stop = new AbortController();
@@ -1763,13 +1926,16 @@ async function admitInner(req, opts) {
         const exclusiveHolder = entry.exclusive === true
             ? doc.entries.find((e) => e.state === 'admitted' && e.exclusive === true && e.id !== entry.id)
             : undefined;
+        const hold = neverPauseHold(doc, entry);
         const reason = reading !== null
-            ? gateCause(reading)
-            : exclusiveHolder !== undefined
-                ? `another full build holds the machine-wide full-build slot (${exclusiveHolder.label} pid ` +
-                    `${exclusiveHolder.pid}); one runs at a time, whatever its size${ahead > 0 ? `; ${ahead} waiting ahead` : ''}`
-                : `machine budget in use: ${gib(load.bytes)} of ${budgetPhrase(entry, ledgerBudget(doc.pressure, capacityBytes))} by ${load.runs} run(s); ` +
-                    `this run needs ${gib(charged(entry, capacityBytes))}${ahead > 0 ? `; ${ahead} waiting ahead` : ''}`;
+            ? latchCause(reading, doc.entries, capacityBytes, nowMs)
+            : hold !== null
+                ? `${hold}${ahead > 0 ? `; ${ahead} waiting ahead` : ''}`
+                : exclusiveHolder !== undefined
+                    ? `another full build holds the machine-wide full-build slot (${exclusiveHolder.label} pid ` +
+                        `${exclusiveHolder.pid}); one runs at a time, whatever its size${ahead > 0 ? `; ${ahead} waiting ahead` : ''}`
+                    : `machine budget in use: ${gib(load.bytes)} of ${budgetPhrase(entry, ledgerBudget(doc.pressure, capacityBytes), load.bytes)} by ${load.runs} run(s); ` +
+                        `this run needs ${gib(charged(entry, capacityBytes))}${ahead > 0 ? `; ${ahead} waiting ahead` : ''}`;
         return {
             reason,
             retryAfterMs: reading !== null ? MEMORY_GATE_RETRY_AFTER_MS : 2_000,
@@ -1792,6 +1958,10 @@ async function admitInner(req, opts) {
                 return { admitted: true, grant: holdGrant(raced, dir, now() - t0, opts) };
             return { admitted: false, refusal: refusal(first.doc, first.reading) };
         }
+        // T14098: say at once which rule holds a never-paused run at backoff.
+        const hold = first.reading === null ? neverPauseHold(first.doc, first.mine ?? entry) : null;
+        if (hold !== null)
+            opts.notice?.(`waiting: ${hold}`);
         let lastPassAt = now();
         let lastReportAt = t0;
         let lastKeepAliveAt = Number.NEGATIVE_INFINITY;
@@ -1823,6 +1993,21 @@ async function admitInner(req, opts) {
                 checkQueue();
                 return { admitted: true, grant: holdGrant(mine, dir, now() - t0, opts) };
             }
+            if (parentUnknown) {
+                // T12994: the first detection could not see the process tree; try again.
+                factsFailed = false;
+                const found = enclosingGrant(seen.entries, pid, env, facts);
+                parentUnknown = found === null && factsFailed;
+                if (found !== null && rides(found)) {
+                    const raced = await leave();
+                    checkQueue();
+                    if (raced !== null) {
+                        return { admitted: true, grant: holdGrant(raced, dir, now() - t0, opts) };
+                    }
+                    opts.memoryPressure?.admitted(now() - t0, null);
+                    return { admitted: true, grant: passThrough(admissionToken(found), true, null) };
+                }
+            }
             if (seen.pressure !== null && isFresh(seen.pressure, now()))
                 reading = seen.pressure.reading;
             if (passDue(mine === undefined, now() - lastPassAt, seen.pressure, now(), opts)) {
@@ -1894,6 +2079,20 @@ function describeLoad(doc, nowMs, probe) {
     }
     return lines;
 }
+/**
+ * Why a never-paused waiter is held at backoff (T14098), naming the rule, or
+ * `null` when that rule does not hold it.
+ */
+function neverPauseHold(doc, mine) {
+    if (mine.neverPause !== true || mine.parentId !== undefined || doc.pressure?.backoff !== true) {
+        return null;
+    }
+    const admitted = doc.entries.filter((e) => e.state === 'admitted').length + doc.foreign.length;
+    const reclaimable = doc.pressure.memAvailableBytes;
+    return (`machine at backoff; this run is never paused, so it starts only when no CLEO run is admitted ` +
+        `and its charge fits the reclaimable memory, one at a time in queue order (${admitted} CLEO run(s) admitted; ` +
+        `reclaimable ${typeof reclaimable === 'number' ? gib(reclaimable) : 'unknown'})`);
+}
 /**
  * The holder report a long waiter prints. When the memory gate closed the
  * budget, it names the cause (the host's largest memory users, CLEO or not)
@@ -1904,12 +2103,15 @@ function holderReport(doc, mine, pid, waitedMs, capacityBytes, nowMs, timeoutMs,
     const used = budgetLoad(doc, capacityBytes).bytes;
     const ahead = waitingAhead(doc.entries, mine, nowMs);
     const lines = [
-        `still waiting after ${age(waitedMs)} for the machine budget (${gib(used)} of ${budgetPhrase(mine, ledgerBudget(doc.pressure, capacityBytes))} in use, ` +
+        `still waiting after ${age(waitedMs)} for the machine budget (${gib(used)} of ${budgetPhrase(mine, ledgerBudget(doc.pressure, capacityBytes), used)} in use, ` +
             `queue position ${ahead + 1}${mine.priority === 'urgent' ? ' (urgent)' : ''}, ${ahead} waiting ahead). Holders: ${describeLoad(doc, nowMs, probe).join(' | ') || 'none'}.`,
     ];
     const reading = doc.pressure?.reading ?? null;
+    const hold = reading === null ? neverPauseHold(doc, mine) : null;
+    if (hold !== null)
+        lines.push(`Held by the backoff rule: ${hold}.`);
     if (reading !== null) {
-        lines.push(`The budget is closed by ${gateCause(reading)}. Admission resumes by itself; this wait ` +
+        lines.push(`The budget is closed by ${latchCause(reading, doc.entries, capacityBytes, nowMs)}. Admission resumes by itself; this wait ` +
             `gives up in ${age(Math.max(0, timeoutMs - waitedMs))}.`);
     }
     const table = holders.length > 0 ? processTable() : null;
@@ -2002,6 +2204,7 @@ function holdGrant(entry, dir, waitedMs, opts) {
         ungoverned: null,
         waitedMs,
         footprintBytes: entry.footprintBytes,
+        ...(entry.admittedBy !== undefined ? { admittedBy: entry.admittedBy } : {}),
         recordChild: (child) => {
             void update((e) => ({ ...e, child }));
         },