bantamkit-mcp 0.35.6 → 0.35.8

package/dist/mcp/pyargs.js

@@ -7,12 +7,12 @@
  * ship a server whose recovery behaviour differs from the reference's on every mistyped
  * argument, and that is a product difference, not a cosmetic one.
  *
- * WHAT THE URL IS. `https://errors.pydantic.dev/2.13/v/<type>` names an entry in pydantic's
- * public error catalogue. This runtime has no pydantic; the URL is part of the sentence the
- * reference emits, reproduced because the sentence is the contract. `2.13` is therefore a
- * PIN on the reference, not a claim about this process — and it is compared against the
- * live server by `tools/conformance/suites/wire.mjs`, so the day the Python side bumps to
- * 2.14 the suite goes red here instead of the two runtimes drifting apart quietly.
+ * WHY THERE IS NO URL (job65/#185). pydantic ends each error with `For further information
+ * visit https://errors.pydantic.dev/<major.minor>/v/<type>`, naming whichever pydantic pip
+ * resolved. This port used to reproduce it with `2.13` hard-coded, and the reference printed
+ * `2.14` the day PyPI resolved 2.14 — the refusal texts differed by install date. The
+ * reference now sets `PYDANTIC_ERRORS_INCLUDE_URL=0` at import (`bantamkit.mcpserver`), so
+ * neither runtime prints the line; `tools/conformance/suites/wire.mjs` compares the two.
  *
  * EVERY RULE BELOW WAS MEASURED, not read off pydantic's documentation. The probes are in
  * `scratchpad/job38-n7/probe{4,7,8,9}.py` and each drove the real stdio server:
@@ -54,6 +54,15 @@ const opt = (name, kind, bound = {}) => ({
  * register a tool.
  */
 export const OFFSET_MAXIMUM = 9007199254740991n;
+/**
+ * `assets/tools/skill_audit.json` `budget.maximum` — the same `Number.MAX_SAFE_INTEGER` as
+ * `OFFSET_MAXIMUM`, spelled as its own constant because it is tied to a different asset
+ * and would stay where it is if the other ever moved. Bound on the reference as
+ * `Annotated[int, Field(le=SKILL_BUDGET_MAXIMUM)]` (#133, job65): until then the manifest
+ * advertised a ceiling neither runtime enforced, and `budget: 2**53` was audited as if it
+ * were a number a catalogue could be measured against.
+ */
+export const SKILL_BUDGET_MAXIMUM = 9007199254740991n;
 /**
  * One model per handler, mirroring `build_server`'s closures signature for signature.
  *
@@ -107,9 +116,10 @@ export const ARG_MODELS = {
     bantamkit_status: { model: 'bantamkit_statusArguments', fields: [] },
     // `reserve: int | None = None` on the reference, so it is the same lax `int` as `k`:
     // `'2'`, `True` and `3.0` validate, `'2.5'` is `int_parsing`, `2.5` is `int_from_float`,
-    // and an explicit `null` is the default. The manifest's `minimum: 0` is advisory to the
-    // client; nothing here floors it — a negative value reaches `MemoryStore.compact`, whose
-    // `max(0, min(reserve, budget // 2))` is the only clamp on either side (6b966e5).
+    // and an explicit `null` is the default. Nothing here floors it — a negative value
+    // reaches `MemoryStore.compact`, whose `max(0, min(reserve, budget // 2))` is the only
+    // clamp on either side (6b966e5) — and since #133 (job65) the manifest no longer
+    // advertises a `minimum` it does not enforce: the clamp is stated in the description.
     memory_compact: { model: 'memory_compactArguments', fields: [opt('reserve', 'int')] },
     // `bantamkit_read(path: str, part: str | None = None, offset: int | None = None,
     // limit: int | None = None)` on the reference (job43). `path` and `part` are the strict
@@ -127,16 +137,19 @@ export const ARG_MODELS = {
         model: 'bantamkit_readArguments',
         fields: [req('path', 'str'), opt('part', 'str'), opt('offset', 'int', { le: OFFSET_MAXIMUM }), opt('limit', 'int')],
     },
-    // `skill_audit(root: str, enabled: list[str] | None = None, usage: dict[str, int] | None =
-    // None, check: str | None = None, budget: int | None = None)` on the reference (job44).
-    // `usage` is the only `dict[str, int]` on the surface and the reason `dictInt` exists:
-    // pydantic validates a typed dict's VALUES, so `{'a': 'x'}` is `usage.a` / `int_parsing`
-    // where `handoff_patch`'s `dict[str, Any]` takes anything. `budget` carries no `le`,
-    // because the reference binds none — the manifest's `maximum` is advisory to the client,
-    // and the handler's own refusal is the negative one. `versions` is the only
-    // `dict[str, str]`, and the reason `dictStr` exists beside it: a `str` field is STRICT even
-    // in lax mode, so `{'a': 1}` is `versions.a` / `string_type` where the same value under
-    // `usage` would validate.
+    // `skill_audit(root: str, enabled: list[str] | None = None, usage: dict[str,
+    // Annotated[int, Field(ge=0)]] | None = None, check: str | None = None, budget:
+    // Annotated[int, Field(le=SKILL_BUDGET_MAXIMUM)] | None = None)` on the reference (job44;
+    // the two bounds since #133, job65). `usage` is the only `dict[str, int]` on the surface
+    // and the reason `dictInt` exists: pydantic validates a typed dict's VALUES, so `{'a':
+    // 'x'}` is `usage.a` / `int_parsing` and `{'a': -1}` is `usage.a` /
+    // `greater_than_equal`, where `handoff_patch`'s `dict[str, Any]` takes anything. `budget`'s
+    // ceiling is the manifest's `maximum`, bound the way `bantamkit_read`'s `offset` is;
+    // its floor is still the handler's own refusal (`budget must not be negative`), which
+    // the manifest's `minimum: 0` describes and this table does not pre-empt. `versions` is
+    // the only `dict[str, str]`, and the reason `dictStr` exists beside it: a `str` field is
+    // STRICT even in lax mode, so `{'a': 1}` is `versions.a` / `string_type` where the same
+    // value under `usage` would validate.
     // `dry_run: bool | None = None` on the reference (job45 row 5). LAX bool, and every arm
     // below was MEASURED against the real stdio server, not read off pydantic's docs
     // (`scratchpad` probe, 33 inputs): `0`/`1` and `0.0`/`1.0` coerce; any OTHER integral
@@ -176,9 +189,9 @@ export const ARG_MODELS = {
         fields: [
             req('root', 'str'),
             opt('enabled', 'listStr'),
-            opt('usage', 'dictInt'),
+            opt('usage', 'dictInt', { ge: 0n }),
             opt('check', 'str'),
-            opt('budget', 'int'),
+            opt('budget', 'int', { le: SKILL_BUDGET_MAXIMUM }),
             opt('versions', 'dictStr'),
         ],
     },
@@ -297,7 +310,7 @@ function checkField(spec, value) {
             const bad = [];
             const coerced = new Map();
             for (const [key, item] of value.v) {
-                const checked = checkInt(`${spec.name}.${key}`, item);
+                const checked = checkBoundedInt(spec, `${spec.name}.${key}`, item);
                 if ('value' in checked)
                     coerced.set(key, checked.value);
                 else
@@ -382,24 +395,37 @@ function checkField(spec, value) {
             return wrongType();
         }
         case 'int': {
-            const checked = checkInt(spec.name, value);
-            if (!('value' in checked))
-                return [checked];
-            // `less_than_equal` names the ORIGINAL input, as every constraint error does.
-            if (spec.le !== undefined && checked.value.t === 'int' && checked.value.v > spec.le) {
-                return [
-                    {
-                        loc: spec.name,
-                        type: 'less_than_equal',
-                        msg: `Input should be less than or equal to ${spec.le}`,
-                        input: value,
-                    },
-                ];
-            }
-            return checked;
+            const checked = checkBoundedInt(spec, spec.name, value);
+            return 'value' in checked ? checked : [checked];
         }
     }
 }
+/**
+ * The lax int parse, then the field's `ge`/`le` bounds on what it parsed.
+ *
+ * A constraint frame names the ORIGINAL input, as every pydantic constraint error does:
+ * `usage: {'a': '-1'}` is `greater_than_equal` with `input_value='-1', input_type=str`, the
+ * string the client sent and not the `-1` it parsed to. Measured against pydantic 2.13 on
+ * `dict[str, Annotated[int, Field(ge=0)]]` and `Annotated[int, Field(le=2**53-1)]`,
+ * 2026-10-15 (job65 J65-13 note, §3), and compared over stdio by `suites/wire.mjs`.
+ */
+function checkBoundedInt(spec, loc, value) {
+    const checked = checkInt(loc, value);
+    if (!('value' in checked) || checked.value.t !== 'int')
+        return checked;
+    if (spec.ge !== undefined && checked.value.v < spec.ge) {
+        return {
+            loc,
+            type: 'greater_than_equal',
+            msg: `Input should be greater than or equal to ${spec.ge}`,
+            input: value,
+        };
+    }
+    if (spec.le !== undefined && checked.value.v > spec.le) {
+        return { loc, type: 'less_than_equal', msg: `Input should be less than or equal to ${spec.le}`, input: value };
+    }
+    return checked;
+}
 function checkInt(loc, value) {
     const tooBig = () => ({
         loc,
@@ -550,6 +576,52 @@ export class PyValidationFailure extends Error {
         this.name = 'PyValidationFailure';
     }
 }
+/**
+ * A LONE SURROGATE IN ANY STRING ARGUMENT IS REFUSED BY NAME (job65/#160), before any other
+ * check. JSON can spell `\ud800` on its own; no UTF-8 file or frame can carry it. This port
+ * used to accept it and write U+FFFD ("saved", data silently altered); the reference never
+ * answered at all, because the SDK's frame parser rejects the escape and drops the request.
+ * Both now answer `Error executing tool <name>: argument '<path>' holds a lone surrogate
+ * (U+XXXX), which is not text; nothing was done` — the reference from its stdio reader
+ * (`bantamkit.mcpstdio`), this port from here. `<path>` is the top-level argument, then
+ * `[i]` for a list item and `.key` for a dict member; the first in document order wins.
+ * Keys are not inspected: an unknown key is ignored by both sides anyway.
+ */
+const LONE_SURROGATE = /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;
+export function loneSurrogateArgument(args) {
+    const walk = (value, where) => {
+        if (value.t === 'str') {
+            const found = LONE_SURROGATE.exec(value.v);
+            if (found === null)
+                return null;
+            const unit = found[0].charCodeAt(0).toString(16).toUpperCase().padStart(4, '0');
+            return `argument '${where}' holds a lone surrogate (U+${unit}), which is not text; nothing was done`;
+        }
+        if (value.t === 'list') {
+            for (let i = 0; i < value.v.length; i += 1) {
+                const hit = walk(value.v[i], `${where}[${i}]`);
+                if (hit !== null)
+                    return hit;
+            }
+        }
+        if (value.t === 'dict') {
+            for (const [key, item] of value.v) {
+                const hit = walk(item, `${where}.${key}`);
+                if (hit !== null)
+                    return hit;
+            }
+        }
+        return null;
+    };
+    if (args.t !== 'dict')
+        return null;
+    for (const [key, item] of args.v) {
+        const hit = walk(item, key);
+        if (hit !== null)
+            return hit;
+    }
+    return null;
+}
 /**
  * `model.model_validate(arguments)` for one tool, or the exact `ValidationError` text.
  *
@@ -564,6 +636,9 @@ export class PyValidationFailure extends Error {
  * its `input_value` and not the string the wire held.
  */
 export function validateArguments(model, args) {
+    const lone = loneSurrogateArgument(args);
+    if (lone !== null)
+        throw new Error(lone);
     const unwrapped = preParseJson(model, args);
     const supplied = unwrapped.t === 'dict' ? unwrapped.v : new Map();
     const errors = [];
@@ -589,8 +664,7 @@ export function validateArguments(model, args) {
     const head = `${count} validation error${count === 1 ? '' : 's'} for ${model.model}`;
     const body = errors
         .map((e) => `${e.loc}\n  ${e.msg} [type=${e.type}, input_value=${truncateRepr(reprValue(e.input))}, ` +
-        `input_type=${pyTypeName(e.input)}]\n    For further information visit ` +
-        `https://errors.pydantic.dev/2.13/v/${e.type}`)
+        `input_type=${pyTypeName(e.input)}]`)
         .join('\n');
     throw new PyValidationFailure(`${head}\n${body}`);
 }

package/dist/mcp/server.js

@@ -174,41 +174,32 @@ function rpcError(code, message, data) {
 const asDict = (value) => (value.t === 'dict' ? value.v : new Map());
 const asText = (value) => (value && value.t === 'str' ? value.v : '');
 /**
- * `work_plan`'s `nodes` as `workplan.plan` takes them.
+ * `work_plan`'s `nodes` as `workplan.plan` takes them: the decoded objects, UNCHANGED.
  *
  * The reference's model is `list[dict[str, Any]]`, so pydantic guarantees a list of dicts
- * and NOTHING about what is inside one; `workplan.plan` then reads `node["id"]`,
- * `node.get("depends_on") or []` and `node.get("priority", 0)` off raw Python objects. This
- * reproduces those three reads and their defaults.
+ * and NOTHING about what is inside one; what is inside is checked by `workplan.plan` itself
+ * on both sides against the item schema `assets/tools/work_plan.json` advertises (#127,
+ * job65). Until that check existed THIS function was where the port diverged: it coerced a
+ * string `depends_on` to `[]`, a non-numeric `priority` to 0 and a numeric id to its
+ * `str()`, so `[{id: 'a', depends_on: 'b'}, {id: 'b', ...}]` was planned with `a` beside
+ * `b` here and `b` before `a` there. Nothing is reinterpreted here any more: `toJs` hands
+ * the planner the same value `json.loads` hands the reference, and a node that contradicts
+ * the schema comes back as the planner's own `{result: 'error', reason: 'nodes[<i>].<field>
+ * must be ...'}` — one sentence, both runtimes, compared over stdio by
+ * `tools/conformance/suites/workplan.mjs`.
  *
- * A NODE WITH NO `id` RAISES, and raising is the port: `node["id"]` is a `KeyError` on the
- * reference, whose `str()` is the key in single quotes, so the SDK's envelope reads
- * `Error executing tool work_plan: 'id'`. Defaulting it here would answer a plan over a
- * node the reference refused to look at.
- *
- * WHERE THE DYNAMIC HALF STOPS, said rather than hidden. Python keeps an id's own type and
- * this side stringifies it with `str()`'s spelling (`reprValue` for every non-`str`), so a
- * document mixing `5` and `"5"` is two nodes there and one here, and a non-numeric
- * `priority` is a `TypeError` there and a 0 here. Both need a node whose types contradict
- * `assets/tools/work_plan.json`, which nothing in the shift-work corpus produces; they are
- * named here because an unwritten difference is the one that is found later.
+ * A NODE WITH NO `id` STILL RAISES, and raising is the port: `node["id"]` is a `KeyError` on
+ * the reference, whose `str()` is the key in single quotes, so the SDK's envelope reads
+ * `Error executing tool work_plan: 'id'` (`tool/no-id` in the same suite). It is reproduced
+ * here, before the planner runs, because the planner's own answer to a missing id is the
+ * non-string-id sentence and the reference never reaches that line.
  */
 function planNodes(value) {
-    const pyText = (v) => (v.t === 'str' ? v.v : reprValue(v));
     const items = value !== undefined && value.t === 'list' ? value.v : [];
     return items.map((item) => {
-        const node = item.t === 'dict' ? item.v : new Map();
-        const id = node.get('id');
-        if (id === undefined)
+        if (item.t === 'dict' && !item.v.has('id'))
             throw new BantamError("'id'");
-        const declared = node.get('depends_on');
-        const priority = node.get('priority');
-        return {
-            id: pyText(id),
-            // `list(node.get("depends_on") or [])`: missing, `null` and `[]` are one case.
-            depends_on: declared !== undefined && declared.t === 'list' ? declared.v.map(pyText) : [],
-            priority: priority !== undefined && (priority.t === 'int' || priority.t === 'float') ? Number(priority.v) : 0,
-        };
+        return toJs(item);
     });
 }
 /** `int | None` after validation: the tagged int, or `null` for the default. */

package/dist/mcp/status.js

@@ -251,11 +251,14 @@ export function indexPressureCondition(memory) {
     // and this comparison is the whole reason they cannot.
     if (size === null || size * 100 < INDEX_PRESSURE_PERCENT * budget)
         return null;
+    // AT OR OVER THE BUDGET IS NOT "CLOSE" (job65/#186): the reply that carried the budget
+    // refusal used to close with "the next save is close to being refused". At `size >= budget`
+    // no save that adds a byte can land, so the sentence says so; the 90 % band keeps its words.
+    const consequence = size >= budget ? 'so it is full and every save is refused until it is compacted' : 'so the next save is close to being refused';
     return {
         key: 'index-budget-low',
-        sentence: `the memory index is ${size} bytes of a ${budget}-byte budget, so the next save ` +
-            'is close to being refused — archive or shorten facts with ' +
-            '`bantamkit-memory compact`.',
+        sentence: `the memory index is ${size} bytes of a ${budget}-byte budget, ${consequence} — ` +
+            'archive or shorten facts with `bantamkit-memory compact`.',
     };
 }
 /**
@@ -422,7 +425,11 @@ export function statusReport(memory, log, conditions, identity, tools, prompts,
                 : `${plural(facts, 'fact')} in the project store`) +
             ', index ' +
             (size === null ? 'unreadable' : String(size)) +
-            ` of ${budget} bytes`,
+            ` of ${budget} bytes` +
+            // job65/#142: the store this line counts, by path. WAS: no path at all, so a store the
+            // walk picked up ABOVE the project — an ancestor's, or `~/.bantamkit/memory` itself —
+            // answered as the writable project layer with nothing on the surface saying where.
+            `; bound to ${memory.store.root}`,
         `event log: ${log.enabled ? 'on' : 'off'}`,
         // THE UPDATE LINE IS NOT A CONDITION, and that is the ruling of 2026-09-19 rather than an
         // omission. A newer version existing is not a fault: the server is serving correctly, and

package/dist/mcpreport.d.ts

@@ -74,6 +74,18 @@ export interface HostCall {
 }
 /** The one timestamp the join hangs on when only one end was logged. */
 export declare function anchorMs(call: HostCall): number;
+/**
+ * The two input paths, spelled in ASCII.
+ *
+ * `docs/mcpreport.md` promises an ASCII report, and the two paths it echoes are the only
+ * bytes in it that come from outside a closed vocabulary. Measured 2026-10-13 (#187): a root
+ * named `แคช-😀` reached stdout verbatim. Every UTF-16 code unit outside printable ASCII
+ * (0x20–0x7E) becomes `\uXXXX`, lowercase hex — one escape per code unit, so a character
+ * outside the BMP is two — and nothing else is touched: a backslash stays a backslash, so a
+ * Windows path reads as typed. The reference walks code points and splits astral ones into
+ * surrogates by hand; the two spell the same bytes.
+ */
+export declare function escapeAscii(text: string): string;
 export interface PairedCalls {
     readonly calls: HostCall[];
     readonly incomplete: number;

package/dist/mcpreport.js

@@ -211,6 +211,57 @@ export function parseHostLine(line) {
 export function anchorMs(call) {
     return call.startMs !== null ? call.startMs : (call.endMs ?? 0);
 }
+/**
+ * `min()` / `max()` over a non-empty list, as a LOOP, and `list.extend` as a loop too.
+ *
+ * `Math.min(...values)` and `out.push(...lines)` spread a list into CALL ARGUMENTS, and V8
+ * caps those at the stack. Measured 2026-10-14 (#130): one session of 130,000 calls — 32 MB
+ * of host log, a legal busy day — ended `--mcp-report` with `RangeError: Maximum call stack
+ * size exceeded` on this side where the reference answered the same log in 1.4 s. The host
+ * log is UNBOUNDED by contract (`docs/mcpreport.md`: the host never rotates it), so nothing
+ * derived from it — a session's anchors, a bucket's durations, one line per session — may be
+ * spread into a call. `[...items]` in an array literal is iteration, not a call, and stays.
+ */
+function minOf(values) {
+    let best = values[0];
+    for (let i = 1; i < values.length; i += 1)
+        if (values[i] < best)
+            best = values[i];
+    return best;
+}
+function maxOf(values) {
+    let best = values[0];
+    for (let i = 1; i < values.length; i += 1)
+        if (values[i] > best)
+            best = values[i];
+    return best;
+}
+function extend(out, lines) {
+    for (const line of lines)
+        out.push(line);
+}
+/**
+ * The two input paths, spelled in ASCII.
+ *
+ * `docs/mcpreport.md` promises an ASCII report, and the two paths it echoes are the only
+ * bytes in it that come from outside a closed vocabulary. Measured 2026-10-13 (#187): a root
+ * named `แคช-😀` reached stdout verbatim. Every UTF-16 code unit outside printable ASCII
+ * (0x20–0x7E) becomes `\uXXXX`, lowercase hex — one escape per code unit, so a character
+ * outside the BMP is two — and nothing else is touched: a backslash stays a backslash, so a
+ * Windows path reads as typed. The reference walks code points and splits astral ones into
+ * surrogates by hand; the two spell the same bytes.
+ */
+export function escapeAscii(text) {
+    let out = '';
+    for (let i = 0; i < text.length; i += 1) {
+        const unit = text.charCodeAt(i);
+        if (unit >= 0x20 && unit <= 0x7e)
+            out += text[i];
+        else
+            out += `\\u${unit.toString(16).padStart(4, '0')}`;
+    }
+    return out;
+}
 /** `sorted(key=...)` over tuples of numbers and strings — Python's, so codepoint order. */
 function byKey(items, key) {
     return [...items].sort((a, b) => {
@@ -508,8 +559,8 @@ function candidates(event, calls, windowMs) {
         const ends = [call.startMs, call.endMs].filter((t) => t !== null);
         if (ends.length === 0)
             continue;
-        const lo = Math.min(...ends) - windowMs;
-        const hi = Math.max(...ends) + windowMs;
+        const lo = minOf(ends) - windowMs;
+        const hi = maxOf(ends) + windowMs;
         if (lo <= event.tsMs && event.tsMs <= hi)
             out.push(index);
     }
@@ -628,22 +679,23 @@ export function render(host, events, joined) {
         out.push(`host-log-root: unknown on this platform (${host.platform}); set ${HOST_LOG_ROOT_ENV}`);
     }
     else if (host.missing === 'not-found') {
-        out.push(`host-log-root: not found at ${host.root}`);
+        out.push(`host-log-root: not found at ${escapeAscii(host.root ?? '')}`);
     }
     else {
-        out.push(`host-log-root: ${host.root}`);
+        out.push(`host-log-root: ${escapeAscii(host.root ?? '')}`);
     }
     out.push(`host-log-dirs: ${host.dirs}`, `host-log-files: ${host.files}`, `host-records: ${host.records}`, `host-records-lifecycle: ${host.lifecycle}`, `host-records-unclassified: ${host.unclassified}`, `host-error-records: ${host.errors}`, `host-calls: ${host.calls.length}`, `host-calls-incomplete: ${host.incomplete}`, `host-calls-orphan-completion: ${host.orphanCompletions}`);
     if (events.missing === 'off')
         out.push('event-log: off (BANTAMKIT_EVENT_LOG unset or off)');
-    else if (events.missing === 'not-found')
-        out.push(`event-log: not found at ${events.path}`);
+    else if (events.missing === 'not-found') {
+        out.push(`event-log: not found at ${escapeAscii(events.path ?? '')}`);
+    }
     else
-        out.push(`event-log: ${events.path}`);
+        out.push(`event-log: ${escapeAscii(events.path ?? '')}`);
     out.push(`event-records: ${events.records}`, `event-records-unreadable: ${events.unreadable}`, '', '[join]', 'method: (ts, tool) interval containment, mutually unique only', 'APPROXIMATE: the host stamps the dispatch, bantamkit stamps the decision,' +
         ' and under concurrency the two files can disagree about order. (ts, tool)' +
         ' is EVIDENCE, NOT A KEY.', `window-ms: ${joined.windowMs}`, `matched-pairs: ${joined.matched.length}`, `ambiguous-groups: ${joined.ambiguousGroups.length}`, `ambiguous-events: ${joined.ambiguousEvents}`, `ambiguous-calls: ${joined.ambiguousCalls}`, `unmatched-events: ${joined.unmatchedEvents.length}`, `unmatched-calls: ${joined.unmatchedCalls.length}`, `attributed-events: ${joined.matched.length} of ${events.events.length}`);
-    out.push(...linesOrNone(joined.ambiguousGroups.map(([e, c]) => `ambiguous-group: events=${e} calls=${c}`)));
+    extend(out, linesOrNone(joined.ambiguousGroups.map(([e, c]) => `ambiguous-group: events=${e} calls=${c}`)));
     // --- durations: the number NEITHER file holds. `ms` is source A, `outcome` is B.
     const buckets = new Map();
     for (const [event, call] of joined.matched) {
@@ -659,8 +711,8 @@ export function render(host, events, joined) {
         }
     }
     out.push('', '[durations]', 'matched pairs only; ms from the host, outcome from bantamkit');
-    out.push(...linesOrNone(byKey([...buckets.values()], (b) => [b.tool, b.outcome]).map(({ tool, outcome, values }) => `${tool} ${outcome} n=${values.length} min=${Math.min(...values)}` +
-        ` p50=${p50(values)} max=${Math.max(...values)}`)));
+    extend(out, linesOrNone(byKey([...buckets.values()], (b) => [b.tool, b.outcome]).map(({ tool, outcome, values }) => `${tool} ${outcome} n=${values.length} min=${minOf(values)}` +
+        ` p50=${p50(values)} max=${maxOf(values)}`)));
     // --- sessions: the only place a sessionId exists, plus what B could attach to it.
     const perSession = new Map();
     for (const call of host.calls) {
@@ -675,19 +727,19 @@ export function render(host, events, joined) {
         attributed.set(call.session, (attributed.get(call.session) ?? 0) + 1);
     }
     const orderedSessions = byKey([...perSession.entries()], ([name, calls]) => [
-        Math.min(...calls.map(anchorMs)),
+        minOf(calls.map(anchorMs)),
         name,
     ]);
     out.push('', '[sessions]');
-    out.push(...linesOrNone(orderedSessions.map(([name, calls]) => {
+    extend(out, linesOrNone(orderedSessions.map(([name, calls]) => {
         const anchors = calls.map(anchorMs);
         const tools = [...new Set(calls.map((c) => c.tool))].sort(cmpCodepoint);
         return (`${name} calls=${calls.length}` +
             ` ok=${calls.filter((c) => c.ok === true).length}` +
             ` fail=${calls.filter((c) => c.ok === false).length}` +
             ` incomplete=${calls.filter((c) => c.ok === null).length}` +
-            ` first=${formatTimestamp(Math.min(...anchors))}` +
-            ` last=${formatTimestamp(Math.max(...anchors))}` +
+            ` first=${formatTimestamp(minOf(anchors))}` +
+            ` last=${formatTimestamp(maxOf(anchors))}` +
             ` attributed=${attributed.get(name) ?? 0}` +
             ` tools=${tools.join(',')}`);
     })));
@@ -703,7 +755,7 @@ export function render(host, events, joined) {
             ` session=${call.session} later-calls=${later.length}` +
             ` later-same-tool=${later.filter((c) => c.tool === event.tool).length}`);
     }
-    out.push(...linesOrNone(follow));
+    extend(out, linesOrNone(follow));
     // --- the host's errors, counted and never quoted.
     out.push('', '[host-errors]', `records=${host.errors} with-tool=${host.errorsWithTool}` +
         ` without-tool=${host.errors - host.errorsWithTool}`, 'text withheld by design: the host log has been measured to persist argument' +

package/dist/memory/cli.js

@@ -89,6 +89,18 @@ function positive(text) {
         throw new ArgumentTypeError('must be >= 1');
     return value;
 }
+/**
+ * `_nonnegative`: `--reserve 0` is a real request — compact to the budget itself — and the
+ * tool's schema says `minimum: 0`, so the CLI accepts it too (#134). WAS `positive`, which
+ * refused 0 with `must be >= 1` on both CLIs while `memory_compact` took it. `typeName` is
+ * `_nonnegative` for the reason `positive` gives: argparse prints the callable's `__name__`.
+ */
+function nonnegative(text) {
+    const value = pyIntStrict(text);
+    if (value < 0)
+        throw new ArgumentTypeError('must be >= 0');
+    return value;
+}
 /**
  * `common(sub)`: the store selector and the budget, on every subcommand.
  *
@@ -176,9 +188,12 @@ const PARSER = {
                             dest: 'reserve',
                             metavar: 'BYTES',
                             kind: 'store',
-                            help: 'headroom to leave below the budget (default: the largest index line kept)',
-                            convert: positive,
-                            typeName: '_positive',
+                            // The default is `MemoryStore.compact`'s (job46): the sentence quotes it rather
+                            // than the pre-job46 "largest index line kept" it used to state (#134).
+                            help: 'headroom to leave below the budget (default: the budget minus its 90 percent ' +
+                                'warning line, plus the largest index line kept; capped at half the budget)',
+                            convert: nonnegative,
+                            typeName: '_nonnegative',
                             defaultValue: null,
                         },
                     ])),

package/dist/memory/component.d.ts

@@ -104,6 +104,21 @@ export interface RecallOutcome {
      * that says so, `null` for every other query — the walk that has always run, unchanged.
      */
     readonly lookup: string | null;
+    /**
+     * Every fact file a layer this walk READ could not read as a fact (job65/#119), as
+     * `{layer, file, reason}`; the reply names them in a closing paragraph (`skippedNote`).
+     */
+    readonly skipped: ReadonlyArray<{
+        layer: string;
+        file: string;
+        reason: string;
+    }>;
+    /**
+     * The header line of each fact in the reply, in reply order, BUILT FROM THE PARSED FIELDS
+     * (job65/#155). The hook reads these instead of filtering the reply's lines, so a body line
+     * shaped like a header can never pass for one.
+     */
+    readonly headers: readonly string[];
 }
 /**
  * What `dream` DID, beside the sentence it says about it.
@@ -384,5 +399,7 @@ export declare class Memory {
      * literal, so the message and the resolver cannot drift onto two different variables.
      */
     private bindingDiagnosis;
+    /** `[layer] [name] (type) description`, from the parsed fields (job65/#155). */
+    private header;
     private format;
 }