bantamkit-mcp 0.29.2 → 0.31.0

package/dist/mcp/pyargs.js

@@ -126,6 +126,38 @@ export const ARG_MODELS = {
     // `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
+    // number — `2`, `-1`, `2.0` — is `bool_parsing`; a FRACTIONAL float is `bool_type`, a
+    // different frame from the integral one and the reason the float arm is split; a string
+    // is matched case-insensitively against two closed sets and is NOT stripped first, so
+    // `'true'` validates and `' true '` is `bool_parsing`; `''` is `bool_parsing`; a list or a
+    // dict is `bool_type`; and an explicit `null` is the default.
+    memory_dream: { model: 'memory_dreamArguments', fields: [opt('dry_run', 'bool')] },
+    // `repo_map(root: str, focus: list[str] | None = None, budget: int | None = None)` on
+    // the reference (job45 row 10). `root` is the strict `str` every other string field is —
+    // `123` is `string_type`. `focus` is the same `list[str]` as `skill_audit`'s `enabled`,
+    // so a non-list is `list_type` and a list holding a non-string is `focus.0` /
+    // `string_type`. `budget` is the lax `int` that `k`, `reserve` and `limit` are: `'2'`,
+    // `True` and `3.0` validate, `'2.5'` is `int_parsing`, `2.5` is `int_from_float`, and an
+    // explicit `null` is the default. No `le`, because the reference binds none — the
+    // manifest's `minimum: 0` is advisory to the client and the handler's own refusal is the
+    // negative one, exactly as `skill_audit`'s `budget` works.
+    repo_map: {
+        model: 'repo_mapArguments',
+        fields: [req('root', 'str'), opt('focus', 'listStr'), opt('budget', 'int')],
+    },
+    // `token_ledger(root: str, model: str | None = None, prices: str | None = None)` on the
+    // reference (job46, AS-1(c)). All three are the strict `str` every other string field is —
+    // `123` is `string_type`, not a coerced `'123'` — and an explicit `null` is the default for
+    // the two optional ones. There is no `int` here at all, which is why this entry is the
+    // shortest on the surface: the tool's every number is READ off the corpus rather than
+    // passed in, so there is no lax-int arm to measure.
+    token_ledger: {
+        model: 'token_ledgerArguments',
+        fields: [req('root', 'str'), opt('model', 'str'), opt('prices', 'str')],
+    },
     skill_audit: {
         model: 'skill_auditArguments',
         fields: [
@@ -178,6 +210,13 @@ function truncateRepr(text) {
         tail += 1;
     return `${decoder.decode(bytes.slice(0, head))}...${decoder.decode(bytes.slice(tail))}`;
 }
+/**
+ * The two closed sets pydantic-core matches a string against for a lax `bool`, lowercased.
+ *
+ * No stripping: `' true '` is `bool_parsing` on the reference, measured over the wire.
+ */
+const BOOL_TRUE = new Set(['1', 'on', 't', 'true', 'y', 'yes']);
+const BOOL_FALSE = new Set(['0', 'off', 'f', 'false', 'n', 'no']);
 /** i64, which is the width pydantic parses an int into before it complains about size. */
 const I64_MAX = 9223372036854775807n;
 const I64_MIN = -9223372036854775808n;
@@ -258,6 +297,45 @@ function checkField(spec, value) {
             }
             return bad.length > 0 ? bad : { value };
         }
+        case 'bool': {
+            const parsing = () => [
+                {
+                    loc: spec.name,
+                    type: 'bool_parsing',
+                    msg: 'Input should be a valid boolean, unable to interpret input',
+                    input: value,
+                },
+            ];
+            const wrongType = () => [
+                { loc: spec.name, type: 'bool_type', msg: 'Input should be a valid boolean', input: value },
+            ];
+            if (value.t === 'bool')
+                return { value };
+            if (value.t === 'int') {
+                if (value.v === 0n || value.v === 1n)
+                    return { value: { t: 'bool', v: value.v === 1n } };
+                return parsing();
+            }
+            if (value.t === 'float') {
+                // A FRACTIONAL float is `bool_type` and an out-of-range integral one is
+                // `bool_parsing`. Measured, and not a distinction anyone would guess: `0.5` and
+                // `2.0` are both floats and they refuse under different frames.
+                if (!Number.isInteger(value.v))
+                    return wrongType();
+                if (value.v === 0 || value.v === 1)
+                    return { value: { t: 'bool', v: value.v === 1 } };
+                return parsing();
+            }
+            if (value.t === 'str') {
+                const key = value.v.toLowerCase();
+                if (BOOL_TRUE.has(key))
+                    return { value: { t: 'bool', v: true } };
+                if (BOOL_FALSE.has(key))
+                    return { value: { t: 'bool', v: false } };
+                return parsing();
+            }
+            return wrongType();
+        }
         case 'int': {
             const checked = checkInt(spec.name, value);
             if (!('value' in checked))

package/dist/mcp/server.d.ts

@@ -1,17 +1,20 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import * as repomap from '../repomap.js';
 import { EventLog } from '../eventlog.js';
 import type { Memory } from '../memory/component.js';
 import type { RawStdioTransport } from './transport.js';
 /**
- * The eleven, in the order `build_server` lists them — which is the order `tools/list` emits.
+ * The thirteen, in the order `build_server` lists them — which is the order `tools/list` emits.
  *
  * `bantamkit_status` went LAST rather than first, `memory_compact` after it rather than
- * beside `memory_save` where a reader would look for it, `bantamkit_read` after that and
- * `skill_audit` after that, for the same reason the reference appends all four: registration
- * order IS the served order, and appending is the only edit that leaves the other ten where
- * every existing declaration says they are.
+ * beside `memory_save` where a reader would look for it, `bantamkit_read` after that,
+ * `skill_audit` after that, `memory_dream` after that, `repo_map` after that and
+ * `token_ledger` after that, for the
+ * same reason the reference appends all six: registration order IS the served order, and
+ * appending is the only edit that leaves the other twelve where every existing declaration
+ * says they are.
  */
-export declare const MCP_TOOLS: readonly ["memory_save", "memory_recall", "validate_json", "shiftwork_clock_in", "shiftwork_clock_out", "shiftwork_status", "build_identity", "bantamkit_status", "memory_compact", "bantamkit_read", "skill_audit"];
+export declare const MCP_TOOLS: readonly ["memory_save", "memory_recall", "validate_json", "shiftwork_clock_in", "shiftwork_clock_out", "shiftwork_status", "build_identity", "bantamkit_status", "memory_compact", "bantamkit_read", "skill_audit", "memory_dream", "repo_map", "token_ledger"];
 /**
  * The advertisement for one tool, out of its manifest, with the surface checked.
  *
@@ -28,6 +31,34 @@ export declare const MCP_TOOLS: readonly ["memory_save", "memory_recall", "valid
  * that detects drift. Registered here, not fixed here; `runtime-py` is the reference.
  */
 export declare function fromManifest(name: string): Record<string, unknown>;
+/**
+ * The last paragraph of every `repo_map` reply, refusal excepted. FIXED AND MANDATORY, and
+ * byte-identical to the reference's `REPO_MAP_TAIL`.
+ *
+ * Roadmap row 10's build gate was "build only after #4 shows discovery tokens dominate",
+ * and #4 REFUTED it: discovery is 0.114 % of real prompt tokens because 97.8 % of the bill
+ * is `cache_read`. The feature ships on an explicit ruling to build it anyway, as a
+ * PRECISION feature. A surface that let a caller believe the map is a token saving would
+ * say the one thing the measurement forbids, so the refutation travels with every answer
+ * rather than living only in a doc nobody reads at call time.
+ *
+ * The second sentence is the budget's unit, for the same reason: `DEFAULT_BUDGET = 4000` is
+ * "1 K tokens" only at the char/4 convention, whose error bar is unmeasured because
+ * measuring it needs the tokenizer the pure-node ruling forbids.
+ */
+export declare const REPO_MAP_TAIL: string;
+/** What a listing says when there is nothing to list. The reference's `REPO_MAP_EMPTY`. */
+export declare const REPO_MAP_EMPTY = "(nothing listed: no file under this root scanned into a definition)";
+/**
+ * The `repo_map` tool's prose, byte for byte, from the structured result.
+ *
+ * Split out of the handler for the same reason the reference splits `repo_map_reply` out of
+ * its own: one shape to reproduce rather than a format string buried in a `case`, and the
+ * `repomap` conformance suite compares the rendered reply without standing up a server. No
+ * float is ever rendered here — `repomap`'s trap (8); every number on the header line is an
+ * integer, and `String(1.0)` is `'1'` where `repr(1.0)` is `'1.0'`.
+ */
+export declare function repoMapReply(result: repomap.RepoMap): string;
 /**
  * Assemble the MCP server around one Memory instance (the per-person state).
  *

package/dist/mcp/server.js

@@ -31,7 +31,10 @@ import { AssetNotFound, assetsRoot, loadSkill, loadToolAsset } from '../assets.j
 import { BantamError } from '../errors.js';
 import { bantamkitReadUnknownPart, documentError, documentManifest, documentOffsetPastEnd, documentPage, schemaError, toolFailed, } from '../contract.js';
 import * as docread from '../docread.js';
+import * as repomap from '../repomap.js';
 import * as skillaudit from '../skillaudit.js';
+import { PriceTableError } from '../pricing.js';
+import * as tokenledger from '../tokenledger.js';
 import { EventLog } from '../eventlog.js';
 import { PyOSError, asPyOSError, pyReadText } from '../memory/pyfs.js';
 import { fromJs, parseJson, reprValue, toJs } from '../pyjson.js';
@@ -41,13 +44,15 @@ import { ARG_MODELS, PyValidationFailure, validateArguments } from './pyargs.js'
 import { sdkJson } from './sdkjson.js';
 import { degradedConditions, degradedNotice, SERVED_PROMPTS, SERVED_RESOURCE_TEMPLATES, statusReport, STATUS_NAME, STATUS_PROMPT_DESCRIPTION, STATUS_PROMPT_TAIL, STATUS_PROMPT_TITLE, } from './status.js';
 /**
- * The eleven, in the order `build_server` lists them — which is the order `tools/list` emits.
+ * The thirteen, in the order `build_server` lists them — which is the order `tools/list` emits.
  *
  * `bantamkit_status` went LAST rather than first, `memory_compact` after it rather than
- * beside `memory_save` where a reader would look for it, `bantamkit_read` after that and
- * `skill_audit` after that, for the same reason the reference appends all four: registration
- * order IS the served order, and appending is the only edit that leaves the other ten where
- * every existing declaration says they are.
+ * beside `memory_save` where a reader would look for it, `bantamkit_read` after that,
+ * `skill_audit` after that, `memory_dream` after that, `repo_map` after that and
+ * `token_ledger` after that, for the
+ * same reason the reference appends all six: registration order IS the served order, and
+ * appending is the only edit that leaves the other twelve where every existing declaration
+ * says they are.
  */
 export const MCP_TOOLS = [
     'memory_save',
@@ -61,6 +66,9 @@ export const MCP_TOOLS = [
     'memory_compact',
     'bantamkit_read',
     'skill_audit',
+    'memory_dream',
+    'repo_map',
+    'token_ledger',
 ];
 /**
  * The advertisement for one tool, out of its manifest, with the surface checked.
@@ -147,6 +155,65 @@ const asText = (value) => (value && value.t === 'str' ? value.v : '');
 function asInt(value) {
     return value && value.t === 'int' ? Number(value.v) : null;
 }
+/**
+ * The errno family `Path.exists()` and `Path.is_dir()` answer `False` for instead of
+ * raising — CPython `pathlib`'s `_IGNORED_ERRNOS`, spelled as Node's `code` strings.
+ *
+ * Not a guess and not a superset: anything OUTSIDE this set makes both predicates raise on
+ * the reference, so it must reach `recordRaise` here too. A `statSync` wrapped in a bare
+ * `catch { }` would turn a permission failure into "no such directory", which is a
+ * different sentence about a different problem.
+ */
+const EXISTS_IGNORED = new Set(['ENOENT', 'ENOTDIR', 'EBADF', 'ELOOP']);
+/**
+ * The last paragraph of every `repo_map` reply, refusal excepted. FIXED AND MANDATORY, and
+ * byte-identical to the reference's `REPO_MAP_TAIL`.
+ *
+ * Roadmap row 10's build gate was "build only after #4 shows discovery tokens dominate",
+ * and #4 REFUTED it: discovery is 0.114 % of real prompt tokens because 97.8 % of the bill
+ * is `cache_read`. The feature ships on an explicit ruling to build it anyway, as a
+ * PRECISION feature. A surface that let a caller believe the map is a token saving would
+ * say the one thing the measurement forbids, so the refutation travels with every answer
+ * rather than living only in a doc nobody reads at call time.
+ *
+ * The second sentence is the budget's unit, for the same reason: `DEFAULT_BUDGET = 4000` is
+ * "1 K tokens" only at the char/4 convention, whose error bar is unmeasured because
+ * measuring it needs the tokenizer the pure-node ruling forbids.
+ */
+export const REPO_MAP_TAIL = 'This is a precision pass, not a token saving: this feature\'s build gate was REFUTED ' +
+    'by measurement — discovery is 0.114% of real prompt tokens, because 97.8% of the ' +
+    'bill is cache_read — so a map does not make a session cheaper. What it buys is the ' +
+    'right file found sooner.\n' +
+    'The budget above is UTF-8 BYTES of listing, not tokens: neither runtime carries a ' +
+    'model tokenizer and this tool will not pretend to one.';
+/** What a listing says when there is nothing to list. The reference's `REPO_MAP_EMPTY`. */
+export const REPO_MAP_EMPTY = '(nothing listed: no file under this root scanned into a definition)';
+/**
+ * The `repo_map` tool's prose, byte for byte, from the structured result.
+ *
+ * Split out of the handler for the same reason the reference splits `repo_map_reply` out of
+ * its own: one shape to reproduce rather than a format string buried in a `case`, and the
+ * `repomap` conformance suite compares the rendered reply without standing up a server. No
+ * float is ever rendered here — `repomap`'s trap (8); every number on the header line is an
+ * integer, and `String(1.0)` is `'1'` where `repr(1.0)` is `'1.0'`.
+ */
+export function repoMapReply(result) {
+    const focus = result.focus.length > 0
+        ? result.focus.join(', ')
+        : '(none) — plain centrality over the whole tree';
+    const head = `repo map: ${result.nodes} files scanned, ${result.definitions} definitions, ` +
+        `${result.edges} edges.\n` +
+        `focus: ${focus}\n` +
+        `budget: ${result.budget} UTF-8 bytes; listing ${result.listingBytes} bytes; ` +
+        `rendered ${result.filesRendered} files, ` +
+        `${result.definitionsRendered} definitions.`;
+    const body = result.text !== '' ? result.text : REPO_MAP_EMPTY;
+    return `${head}\n\n${body}\n\n${REPO_MAP_TAIL}`;
+}
+/** `bool | None` after validation: the tagged bool, or `null` for the default. */
+function asBool(value) {
+    return value && value.t === 'bool' ? value.v : null;
+}
 /**
  * Run `body` and, if it throws, record the exception's TYPE before letting it fly on.
  *
@@ -448,6 +515,29 @@ function runTool(name, memory, args, version, log, documents) {
             });
             return { value: { t: 'str', v: noted(outcome.reply) }, wrapped: true };
         }
+        case 'memory_dream': {
+            // Consolidate what the project layer and the machine-wide profile layer both hold
+            // under one name (job45, roadmap row 5). `dryRun` DEFAULTS TO TRUE and the default
+            // lives HERE rather than in the component, exactly as the reference's handler carries
+            // it: a client that omits the argument sends nothing, `asBool` answers `null`, and
+            // turning that into the SAFE answer is this handler's job. It is the only tool on
+            // this surface that writes into the user's home directory, and the only one whose
+            // effect is machine-wide — a fact archived out of the profile store stops answering
+            // for every other project on this machine with no store of its own.
+            //
+            // THE RECORD IS A DECISION. `DreamOutcome.status` is read off `DreamResult.applied`,
+            // `.overBudget` and `.changes` — never off the reply, whose prose is allowed to
+            // improve without moving a single byte of the event log.
+            const dryRun = asBool(args.get('dry_run'));
+            const outcome = recordRaise(log, 'memory_dream', () => memory.dreamOutcome(dryRun === null ? true : dryRun));
+            log.record('memory_dream', outcome.status, {
+                absolutised: outcome.absolutised,
+                consumed: outcome.consumed,
+                dry_run: outcome.dryRun,
+                merged: outcome.merged,
+            });
+            return { value: { t: 'str', v: noted(outcome.reply) }, wrapped: true };
+        }
         case 'bantamkit_read': {
             // The reader on the MCP surface (job43): `docread` digests, `contract` words it. The
             // handler makes the SAME `contract` calls the reference's `bantamkit_read` makes,
@@ -645,6 +735,120 @@ function runTool(name, memory, args, version, log, documents) {
                 return { value: { t: 'str', v: noted(result.asJson()) }, wrapped: true };
             });
         }
+        case 'repo_map': {
+            // The ranked definition map on the MCP surface (job45 row 10): `repomap` measures,
+            // this serves it. Byte for byte the reference's `repo_map` handler.
+            //
+            // THE THREE REFUSALS LIVE HERE AND NOT IN `repomap.ts`, and that is deliberate.
+            // `repoMap()` over a root that does not exist answers an EMPTY map on both runtimes
+            // — `os.walk` yields nothing for a missing directory and `walkSources`' `readdirSync`
+            // catch does the same — which is the right answer for a library and the wrong one for
+            // a tool: a caller who typed the path wrong would be told the tree holds no source.
+            // So the argument checks are the SURFACE's, and the engine J45-9/J45-10 proved
+            // byte-identical is not touched.
+            //
+            // THE `statSync` ARM IS `Path.exists()` / `Path.is_dir()`, NOT A SHORTCUT FOR THEM.
+            // Both pathlib predicates SWALLOW the not-here errno family and re-raise anything
+            // else, so `EXISTS_IGNORED` below is that family spelled out: a dangling symlink and
+            // `a-file.py/sub` are "no such directory" on both runtimes, while a permission
+            // failure flies to `recordRaise` rather than being dressed up as a missing tree.
+            //
+            // THE RECORD IS A DECISION AND HOLDS NO PATH. `root` is what the operator typed and
+            // `focus` is the name of the file they are editing; neither is a decision this
+            // handler made, so neither is written down. The counts are.
+            const root = asText(args.get('root'));
+            const focusArg = args.get('focus');
+            const focus = focusArg !== undefined && focusArg.t === 'list'
+                ? focusArg.v.map((item) => (item.t === 'str' ? item.v : ''))
+                : [];
+            const budgetArg = args.get('budget');
+            const budget = budgetArg !== undefined && budgetArg.t === 'int' ? Number(budgetArg.v) : repomap.DEFAULT_BUDGET;
+            return recordRaise(log, 'repo_map', () => {
+                const refuse = (detail) => {
+                    log.record('repo_map', 'refused');
+                    return { value: { t: 'str', v: noted(toolFailed('repo_map', detail)) }, wrapped: true };
+                };
+                if (root === '')
+                    return refuse('root must not be empty; name the directory to map');
+                if (budget < 0)
+                    return refuse(`budget must not be negative; got ${budget}`);
+                let stat = null;
+                try {
+                    stat = statSync(root);
+                }
+                catch (e) {
+                    const code = e?.code;
+                    if (!EXISTS_IGNORED.has(String(code)))
+                        throw asPyOSError(e, root);
+                }
+                if (stat === null)
+                    return refuse(`no such directory: ${root}`);
+                if (!stat.isDirectory())
+                    return refuse(`${root} is a file, not a directory to map`);
+                const result = repomap.repoMap(root, { focus, budget });
+                log.record('repo_map', 'mapped', {
+                    definitions: result.definitions,
+                    edges: result.edges,
+                    files_rendered: result.filesRendered,
+                    listing_bytes: result.listingBytes,
+                    nodes: result.nodes,
+                });
+                return { value: { t: 'str', v: noted(repoMapReply(result)) }, wrapped: true };
+            });
+        }
+        case 'token_ledger': {
+            // The transcript ledger on the MCP surface (job46, AS-1(c)): `tokenledger` measures,
+            // this serves it. Byte for byte the reference's `token_ledger` handler.
+            //
+            // THE REPLY IS A JSON DOCUMENT AND NOT PROSE, the same shape and for the same reason as
+            // `skill_audit` above: a caller comparing `totals` before and after a change, or
+            // deciding whether `omissions` explain a total that looks too small, has to read
+            // numbers rather than parse a sentence back out of English. `asJson` is the reply
+            // verbatim and the only string this layer authors is the refusal.
+            //
+            // THE FOUR REFUSALS ARE ARGUMENT FAILURES — an empty `root`, a `root` that is missing,
+            // a `root` that is a file, an empty `model` — so they go through `toolFailed`, and
+            // unlike `repo_map` above they live in the MODULE rather than here: `read()` over a
+            // missing root does not answer an empty ledger that a caller could mistake for a real
+            // one, it refuses, so there is nothing for this layer to add.
+            //
+            // `PriceTableError` is caught BESIDE `TokenLedgerError` and is not the same kind of
+            // thing: it is an operator configuration fault reached only when `model` names a price
+            // table that will not load. It is still an argument failure from the CALLER's side —
+            // it names the path they passed — so it is refused rather than crashing the request.
+            //
+            // THE RECORD IS A DECISION, NEVER A REPLY. `read` carries the four counts the host
+            // cannot see and `refused` carries nothing at all, and no token count is recorded
+            // either: the event log is a record of what this server DID, and the numbers are the
+            // reply.
+            const root = asText(args.get('root'));
+            const modelArg = args.get('model');
+            const model = modelArg !== undefined && modelArg.t === 'str' ? modelArg.v : null;
+            const pricesArg = args.get('prices');
+            const prices = pricesArg !== undefined && pricesArg.t === 'str' ? pricesArg.v : null;
+            return recordRaise(log, 'token_ledger', () => {
+                let result;
+                try {
+                    result = tokenledger.read(root, { model, prices });
+                }
+                catch (e) {
+                    // `except (tokenledger.TokenLedgerError, PriceTableError, OSError)`. Both classes
+                    // extend `BantamError` and both already carry the reference's own sentence.
+                    if (!(e instanceof tokenledger.TokenLedgerError) && !(e instanceof PriceTableError)) {
+                        throw e;
+                    }
+                    log.record('token_ledger', 'refused');
+                    return { value: { t: 'str', v: noted(toolFailed('token_ledger', e)) }, wrapped: true };
+                }
+                log.record('token_ledger', 'read', {
+                    transcripts: result.transcripts,
+                    lines: result.lines,
+                    requests: result.requests,
+                    sessions: result.sessions.length,
+                });
+                return { value: { t: 'str', v: noted(tokenledger.asJson(result)) }, wrapped: true };
+            });
+        }
         default:
             // `tool_manager.call_tool` raises `ToolError(f"Unknown tool: {name}")`, which the
             // handler turns into an isError result rather than a JSON-RPC error.

package/dist/mcp/status.d.ts

@@ -1,5 +1,7 @@
 import type { EventLog } from '../eventlog.js';
 import { Memory } from '../memory/component.js';
+import { INDEX_PRESSURE_PERCENT } from '../memory/store.js';
+import type { Install } from './identity.js';
 /**
  * The tool AND the prompt answer to this one name. Deliberately the same word: the operator
  * who read `bantamkit_status` in a footer must find it in their prompt menu without
@@ -31,14 +33,13 @@ export declare const STATUS_PROMPT_TAIL: string;
 export declare const SERVED_PROMPTS = 1;
 export declare const SERVED_RESOURCE_TEMPLATES = 2;
 /**
- * Percent of the index budget that has to be SPENT before the store is called degraded.
- *
- * 90 and not 100 because the useful moment is before the refusal, not after it: at 100% the
- * next `memory_save` has already failed and the operator has already seen the error. An
- * INTEGER percent, compared by cross-multiplication below, so the two runtimes cannot land
- * on opposite sides of the line through a float they rounded differently.
+ * `INDEX_PRESSURE_PERCENT` is re-exported here, where it used to be DEFINED, so that
+ * `import { INDEX_PRESSURE_PERCENT } from './mcp/status.js'` keeps resolving. It moved down
+ * to `memory/store.ts` in job46 (J46-5, mirroring the reference's J46-4):
+ * `MemoryStore.compact` is the remedy the sentence below names, and it cannot clear a warning
+ * whose line it cannot see. The comment that says why the number is 90 moved with it.
  */
-export declare const INDEX_PRESSURE_PERCENT = 90;
+export { INDEX_PRESSURE_PERCENT };
 /**
  * One thing that is wrong, carried in the two forms the two surfaces need.
  *
@@ -135,6 +136,20 @@ export declare function unreadableLayerCondition(memory: Memory): Condition | nu
  * not a divergence and is not fixed here; it is registered in `docs/porting.md`. The sentence
  * says "archive or shorten facts", which is what the operator has to do either way.
  *
+ * AMENDMENT (job46, J46-5): THE PARAGRAPH ABOVE IS A RECORD OF A DEFECT THAT IS NOW CLOSED,
+ * and it is left standing because it is the measurement that motivated the fix. What it says
+ * was true until this job: the band was real, and on this machine's own project store
+ * (101 facts, index.md 21819 bytes of a 24000-byte budget = 90.91%, largest index line 361
+ * bytes so the old target was 23639 = 98.50%) `compact()` answered `archived: []` with this
+ * very sentence on screen. What has changed is the second half — "is not fixed here". It is
+ * fixed now, in the layer that owns it: `MemoryStore.compact`'s default `reserve` is measured
+ * from `undegradedIndexCeiling(budget)` rather than from `budget`, so running the command
+ * this sentence names clears the condition this sentence reports. Both runtimes moved in the
+ * same job (the reference in `87cc1f7`), because a band that closed on one side only would be
+ * the divergence the paragraph above correctly said this was not. The register entry's own
+ * closure is not written here — that is a `docs/porting.md` edit, and it waits on a
+ * conformance case comparing the two answers.
+ *
  * THIS SENTENCE IS FOR THE OPERATOR; THE MODEL HAS ITS OWN REMEDY. Since job42 the model
  * can call `memory_compact` (the ninth served tool) when a save is actually refused, and
  * the refused-budget reply in `memory/component.ts` names it. That does not change this
@@ -152,13 +167,40 @@ export declare function indexPressureCondition(memory: Memory): Condition | null
  * BOTH on and known to have lost a record is a problem anyone can act on.
  */
 export declare function eventLogCondition(log: EventLog): Condition | null;
+/**
+ * This install came from a path on this machine, and that path is gone.
+ *
+ * THE ONE CONDITION THAT NAMES A PATH, and the exception is deliberate. Every other sentence
+ * here refuses one because `assetsRoot()` resolves differently in the two runtimes by
+ * construction, so a path would be an uncomparable value bought for nothing. This path is not
+ * the server's own location — it is the origin THE INSTALLER WROTE DOWN, it is the entire
+ * actionable content of the finding (AS-7's measured case is a tarball under a
+ * `/private/tmp/.../scratchpad` that no longer exists), and a sentence saying "something is
+ * missing" without saying what would be a sentence nobody can act on.
+ *
+ * THE REMEDY IS THE ONE THAT ACTUALLY MOVES SOMETHING. J46-4 spent a unit removing a condition
+ * whose remedy exited 0 having changed nothing, and this is exactly the shape that invites
+ * another: `npm update` where a dangling `file:` install lives is a no-op BY CONSTRUCTION. So
+ * the sentence sends the reader at a reinstall BY NAME from a registry, which replaces the
+ * install rather than trying to refresh it in place. `bantamkit` is the PRODUCT name and is
+ * copied verbatim from the reference — it is not the npm package id, and turning it into one
+ * is how `git_commit` diverged on a noun.
+ *
+ * THE DERIVED HALF IS MEMOISED AND THIS HALF IS NOT: the shape cannot change under a running
+ * process, the path's existence can, and it is the one that has to be read now.
+ */
+export declare function installSourceCondition(install: Install | null): Condition | null;
 /**
  * Everything wrong right now, worst first. An empty array means healthy.
  *
  * ORDER IS SEVERITY AND IT IS LOAD-BEARING, because the footer shows the first one: a pack
  * that vanished breaks every asset-backed surface; an unreadable layer makes recall ANSWER
  * WRONGLY rather than fail; a full index refuses the next save; a broken event log costs
- * diagnostics only.
+ * diagnostics only; and a dangling install origin costs nothing AT ALL right now — the server
+ * is serving correctly, and what is broken is the next attempt to update it. That is why it is
+ * last despite being the one that went unnoticed for five releases
+ * (`docs/roadmap-agent-stack.md` AS-7): severity here is what is failing, not what has been
+ * failing longest.
  *
  * EVERY CONDITION IS OBSERVED, NOT INFERRED — no heartbeat, no timer, no last-seen timestamp.
  * Each one is a state a test can construct and then watch this report: delete the pack, make a
@@ -167,8 +209,10 @@ export declare function eventLogCondition(log: EventLog): Condition | null;
  * claimed.
  *
  * THE COST, because this runs on every tool call: one `stat` for the index, one `stat` for the
- * pack, one directory listing per memory layer (two to four), and a field read for the log. No
- * fact file is opened and no index is parsed.
+ * pack, one directory listing per memory layer (two to four), a field read for the log, and one
+ * `stat` for the install origin. No fact file is opened, no index is parsed, and
+ * `node_modules` is NOT walked for a hidden lockfile — `currentInstall` does that once per
+ * process, because the bytes that were imported cannot change under a running one.
  */
 export declare function degradedConditions(memory: Memory, log: EventLog): Condition[];
 /**