@herbertgao/pi-extensions 2026.9.0 → 2026.9.2

package/node_modules/pi-lens/dist/clients/hashline-anchor.js

@@ -0,0 +1,424 @@
+/**
+ * `pi-hashline-edit-pro` anchor resolution (#2423 review round 1, finding F1).
+ *
+ * ## Why this module exists
+ *
+ * `pi-hashline-edit-pro` addresses lines by a bare THREE-CHARACTER base62
+ * anchor — `"aB3"`, never `"42"`. Its schema says so in as many words
+ * (`src/payload-contract.ts`: *"Bare 3-char anchor only (e.g. \"aB3\")"*), and
+ * its parser accepts exactly `trimmed.length === ANCHOR_LEN && ALPH_RE.test()`
+ * (`src/hashline/parse.ts`). The first cut of the shape adapter in
+ * `clients/mutating-tool.ts` read those fields as DECIMAL line numbers, so
+ * against the real extension every anchor was "malformed" and the adapter
+ * blocked a working edit tool.
+ *
+ * This module reproduces the extension's own line-hash function so pi-lens can
+ * map an anchor back to a line, and does it from the extension's source rather
+ * than from a guess. Everything below is a port of
+ * `pi-hashline-edit-pro@8f027ca1c2a0796ccf1c15bd5a0d12db5d9fb9f0`
+ * (github.com/YuGiMob/pi-hashline-edit-pro, branch `master`):
+ *
+ * - `src/hashline/alphabet.ts` — `HASH_LEN = 3`, the 62-character alphabet
+ *   `A-Za-z0-9`.
+ * - `src/hashline/hash.ts` — `hashSource` (strip `\r`, `trimEnd`, truncate to
+ *   `MAX_HASH_SOURCE_BYTES = 500` UTF-8 bytes on a code-point boundary),
+ *   `baseIdx = (xxh32(source) >>> 14) % 62**3`, and open-addressed collision
+ *   probing with stride `62**2 + 62 + 1` over a used-index bitset.
+ * - `src/hashline/hasher.ts` — `xxh32` is `xxhash-wasm`'s `h32`, i.e. standard
+ *   XXH32 with seed 0 over the UTF-8 bytes. Reimplemented here in ~40 lines of
+ *   integer arithmetic rather than taking a runtime dependency (pi installs
+ *   pi-lens with `npm install --omit=dev`, so a hashing dep would ship to every
+ *   user for one adapter).
+ * - `src/hashline/resolve.ts` — `resAnchorFromMap`: an anchor resolves ONLY
+ *   when it matches exactly one line. Zero matches is `not_found`, two or more
+ *   is `ambiguous`, and the extension refuses both rather than guessing.
+ *
+ * `tests/clients/hashline-anchor.test.ts` pins the port against a vector table
+ * generated by RUNNING the upstream code with the real `xxhash-wasm`, so a
+ * drift in either direction is a red test rather than a silent misattribution.
+ *
+ * ## Why resolution is gated on UNIQUE CONTENT (review round 3, finding F1) —
+ * and why the gate is NOT a correctness proof (review round 4, finding F1)
+ *
+ * The live extension does not recompute hashes on every read. It persists a
+ * per-file snapshot (`src/hash-store.ts`) and, after every edit, carries a
+ * surviving line's old anchor forward (`mapStableHashes` in
+ * `src/hashline/hash.ts`) before persisting the result — so the anchors the
+ * agent sends back are STORE-CARRIED, not freshly computed. pi-lens has no
+ * access to that store and can only recompute with `_lineHashesPure`.
+ *
+ * Where a line's canonical content is unique in the file, the store's anchor
+ * for it and pi-lens's own recomputed anchor for it USUALLY agree — that is
+ * the case the gate below exists to hold. Where content is NOT unique — `}`,
+ * a blank line, `continue;`, a bare comment-close line — the anchor comes
+ * from probing, whose result depends on every line before it, so an edit
+ * anywhere upstream repermutes those anchors among the identical lines. A
+ * store-carried anchor then still matches EXACTLY ONE line under
+ * recomputation: a confident, unique, WRONG answer.
+ *
+ * Gating on "the matched line's content is unique" narrows that failure a
+ * long way, but it is not a proof, and review round 4 measured the two
+ * mechanisms that survive it:
+ *
+ * (a) The gate is ONE-SIDED: it checks the MATCHED line's content, never the
+ *     anchor's own provenance. A probe-derived anchor that truly belongs to
+ *     some duplicate-content line elsewhere can, by construction of the
+ *     probe stride, land on the same anchor VALUE as a completely unrelated
+ *     unique-content line's own base index. Measured case: a file with 25
+ *     occurrences of a bare block-comment-close line — the store-carried
+ *     anchor for one of them resolved to an unrelated unique-content line
+ *     1532 lines away, and the gate answered it, because that OTHER line's
+ *     content is (correctly) unique. A unique answer is not evidence the
+ *     anchor was ever meant for it.
+ * (b) Content uniqueness does not imply base-index uniqueness. `baseIdx =
+ *     (xxh32(source) >>> 14) % 238328` has only 238,328 slots; over enough
+ *     DISTINCT line contents in a real file, two different contents collide
+ *     on the same base index and one of them is probed to a different slot
+ *     — the identical open-addressing mechanism as a literal duplicate, just
+ *     between lines whose content is each unique. Measured across 220 files:
+ *     194 of 74,386 unique-content lines carry a probe-derived anchor, not
+ *     their own content's base index.
+ *
+ * So `resolveHashlineAnchor` answers when the matched line's canonical
+ * content occurs exactly once in the file — a gate that removes nearly all
+ * of the literal-duplicate case and neither (a) nor (b). Measured over 220
+ * files and five edit shapes (~550,000 anchors asked): roughly 2 anchors
+ * resolved to the wrong line, against ~67% of anchors answered at all. That
+ * residual is ACCEPTED (review round 4 orchestrator decision), not fixed
+ * here: closing it needs either the extension's own store, which pi-lens
+ * does not have, or refusing every anchor within probing distance of a
+ * collision, which costs far more coverage than the ~2-in-550,000 residual
+ * is worth. Everything the gate refuses is `content_not_unique`: unresolved,
+ * which is a report and never a block. pi-lens's uncertainty about a
+ * third-party tool's addressing is not evidence that the agent's edit is
+ * wrong. An unresolved anchor degrades to "mutation recognized, lines
+ * unknown" — the same state a host `edit` with an unknown schema reaches on
+ * master — so the file still gets its turn-state entry (the whole file as
+ * its modified range), its deferred format and its change-log receipt.
+ *
+ * This costs coverage: roughly a third of the lines in a typical TypeScript
+ * file are blank or a bare brace. Trading those for an almost-always-correct
+ * answer on the rest is the deliberate choice — a wrong line range is worse
+ * than no line range on average, because the guard acts on it, but "gated on
+ * unique content" is a reduction of the wrong-line rate, not its elimination.
+ */
+import * as nodeFs from "node:fs";
+import { BoundedFifoMap } from "./bounded-cache.js";
+/** `HASH_LEN` in `src/hashline/alphabet.ts`. */
+const HASHLINE_ANCHOR_LENGTH = 3;
+/** `ALPH` in `src/hashline/alphabet.ts`. Order is load-bearing: it is the digit set. */
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+/** `HASH_SPACE` — 62**3 = 238328 addressable anchors. */
+const HASH_SPACE = ALPHABET.length ** HASHLINE_ANCHOR_LENGTH;
+/** `HASH_PROBE_STRIDE` — 62**2 + 62 + 1, the open-addressing step. */
+const HASH_PROBE_STRIDE = ALPHABET.length ** 2 + ALPHABET.length + 1;
+/** `MAX_HASH_SOURCE_BYTES` in `src/constants.ts`. */
+const MAX_HASH_SOURCE_BYTES = 500;
+const BITSET_WORDS = Math.ceil(HASH_SPACE / 32);
+const ANCHOR_TOKEN_RE = /^[A-Za-z0-9]{3}$/;
+// --- XXH32 (seed 0), the algorithm behind `xxhash-wasm`'s `h32` -------------
+const XXH_PRIME1 = 0x9e3779b1;
+const XXH_PRIME2 = 0x85ebca77;
+const XXH_PRIME3 = 0xc2b2ae3d;
+const XXH_PRIME4 = 0x27d4eb2f;
+const XXH_PRIME5 = 0x165667b1;
+function rotl32(value, bits) {
+    return (value << bits) | (value >>> (32 - bits));
+}
+function xxhRound(acc, input) {
+    return (Math.imul(rotl32((acc + Math.imul(input, XXH_PRIME2)) | 0, 13), XXH_PRIME1) | 0);
+}
+/**
+ * Standard XXH32 with seed 0 over `bytes`. Returns an unsigned 32-bit integer,
+ * matching `xxh32()` in `src/hashline/hasher.ts`.
+ */
+export function xxh32Bytes(bytes) {
+    const length = bytes.length;
+    let index = 0;
+    let hash;
+    if (length >= 16) {
+        const limit = length - 16;
+        let v1 = (XXH_PRIME1 + XXH_PRIME2) | 0;
+        let v2 = XXH_PRIME2 | 0;
+        let v3 = 0;
+        let v4 = -XXH_PRIME1 | 0;
+        do {
+            v1 = xxhRound(v1, readU32(bytes, index));
+            v2 = xxhRound(v2, readU32(bytes, index + 4));
+            v3 = xxhRound(v3, readU32(bytes, index + 8));
+            v4 = xxhRound(v4, readU32(bytes, index + 12));
+            index += 16;
+        } while (index <= limit);
+        hash =
+            (rotl32(v1, 1) + rotl32(v2, 7) + rotl32(v3, 12) + rotl32(v4, 18)) | 0;
+    }
+    else {
+        hash = XXH_PRIME5 | 0;
+    }
+    hash = (hash + length) | 0;
+    while (index + 4 <= length) {
+        hash =
+            Math.imul(rotl32((hash + Math.imul(readU32(bytes, index), XXH_PRIME3)) | 0, 17), XXH_PRIME4) | 0;
+        index += 4;
+    }
+    while (index < length) {
+        hash =
+            Math.imul(rotl32((hash + Math.imul(bytes[index], XXH_PRIME5)) | 0, 11), XXH_PRIME1) | 0;
+        index += 1;
+    }
+    hash = (hash ^ (hash >>> 15)) | 0;
+    hash = Math.imul(hash, XXH_PRIME2) | 0;
+    hash = (hash ^ (hash >>> 13)) | 0;
+    hash = Math.imul(hash, XXH_PRIME3) | 0;
+    hash = (hash ^ (hash >>> 16)) | 0;
+    return hash >>> 0;
+}
+function readU32(bytes, offset) {
+    return (bytes[offset] |
+        (bytes[offset + 1] << 8) |
+        (bytes[offset + 2] << 16) |
+        (bytes[offset + 3] << 24) |
+        0);
+}
+// --- The line-hash function -------------------------------------------------
+/** `canon` in `src/hashline/hash.ts`. */
+function canon(line) {
+    return line.replace(/\r/g, "").trimEnd();
+}
+/** `splitLines` in `src/utils.ts`. An empty file is ONE empty line. */
+function splitLines(text) {
+    if (text.length === 0)
+        return [""];
+    const lines = text.split("\n");
+    return text.endsWith("\n") ? lines.slice(0, -1) : lines;
+}
+/**
+ * `hashSource` in `src/hashline/hash.ts`, as bytes.
+ *
+ * Upstream truncates the STRING to 500 UTF-8 bytes by iterating code points
+ * (`truncateToBytes` in `src/utils.ts`) and then hashes its UTF-8 encoding.
+ * Cutting the encoded buffer back to the last non-continuation byte is the
+ * same operation, because a UTF-8 code point occupies contiguous bytes.
+ */
+function hashSourceBytes(line) {
+    const bytes = Buffer.from(canon(line), "utf8");
+    if (bytes.length <= MAX_HASH_SOURCE_BYTES)
+        return bytes;
+    let cut = MAX_HASH_SOURCE_BYTES;
+    while (cut > 0 && (bytes[cut] & 0xc0) === 0x80)
+        cut -= 1;
+    return bytes.subarray(0, cut);
+}
+/**
+ * The same `hashSource` value as a string — the key upstream itself compares
+ * lines by (`newByContent` / `removedByContent` in `mapStableHashes`). Two
+ * lines with the same key are indistinguishable to BOTH implementations, which
+ * is exactly the condition the uniqueness gate tests. Decoding the truncated
+ * buffer is lossless because the cut lands on a code-point boundary.
+ */
+function hashSourceKey(line) {
+    return Buffer.from(hashSourceBytes(line)).toString("utf8");
+}
+function indexToAnchor(index) {
+    let out = "";
+    let remaining = index;
+    for (let digit = 0; digit < HASHLINE_ANCHOR_LENGTH; digit += 1) {
+        out = ALPHABET[remaining % ALPHABET.length] + out;
+        remaining = Math.floor(remaining / ALPHABET.length);
+    }
+    return out;
+}
+function getBit(bits, index) {
+    return ((bits[index >>> 5] >>> (index & 31)) & 1) !== 0;
+}
+function setBit(bits, index) {
+    bits[index >>> 5] |= 1 << (index & 31);
+}
+function nextZeroBit(bits, start) {
+    let index = start % HASH_SPACE;
+    for (let step = 0; step < HASH_SPACE; step += 1) {
+        if (!getBit(bits, index))
+            return index;
+        index += HASH_PROBE_STRIDE;
+        if (index >= HASH_SPACE)
+            index -= HASH_SPACE;
+    }
+    // Upstream throws `[E_FILE_TOO_LARGE]` here. pi-lens is an observer, so it
+    // reports "cannot address this file" instead of failing the caller.
+    return -1;
+}
+/**
+ * `_lineHashesPure` in `src/hashline/hash.ts`: one anchor per line of
+ * ALREADY-NORMALIZED content (BOM stripped, CRLF folded to LF).
+ *
+ * Returns `undefined` for a file with more lines than the anchor space can
+ * address, which is where upstream raises `[E_FILE_TOO_LARGE]`.
+ */
+export function computeHashlineAnchors(content) {
+    const lines = splitLines(content);
+    if (lines.length > HASH_SPACE)
+        return undefined;
+    const anchors = [];
+    anchors.length = lines.length;
+    const used = new Uint32Array(BITSET_WORDS);
+    let hint = 0;
+    const sourceCache = new Map();
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        let baseIndex = sourceCache.get(line);
+        if (baseIndex === undefined) {
+            baseIndex = (xxh32Bytes(hashSourceBytes(line)) >>> 14) % HASH_SPACE;
+            sourceCache.set(line, baseIndex);
+        }
+        if (!getBit(used, baseIndex)) {
+            setBit(used, baseIndex);
+            hint = baseIndex + HASH_PROBE_STRIDE;
+            anchors[i] = indexToAnchor(baseIndex);
+            continue;
+        }
+        const probed = nextZeroBit(used, hint);
+        if (probed < 0)
+            return undefined;
+        setBit(used, probed);
+        hint = probed + HASH_PROBE_STRIDE;
+        anchors[i] = indexToAnchor(probed);
+    }
+    return anchors;
+}
+// --- Anchor tokens ----------------------------------------------------------
+/**
+ * The anchor token an edit-pro request carries, or `undefined` when the value
+ * is not one. Mirrors `parseRef` in `src/hashline/parse.ts`: trim, then require
+ * exactly three characters from the alphabet. A decimal line number is NOT an
+ * anchor.
+ */
+export function normalizeHashlineAnchorToken(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return ANCHOR_TOKEN_RE.test(trimmed) ? trimmed : undefined;
+}
+/**
+ * Files larger than this are not anchor-resolved. The extension itself caps at
+ * `MAX_HASH_LINES` (62**3 lines); this byte cap keeps the synchronous read on
+ * the tool_call path bounded regardless of line length.
+ */
+const MAX_ANCHOR_FILE_BYTES = 4 * 1024 * 1024;
+/**
+ * Bounded memo. `classifyMutatingTool` runs several times per tool call and the
+ * same file is asked about repeatedly; without this every ask re-reads and
+ * re-hashes the file. Keyed by path and invalidated by mtime/size, so an edit
+ * between two asks is USUALLY not answered from the stale index.
+ *
+ * "Usually" (review round 4, finding F5): mtime/size alone is not sufficient.
+ * A same-size rewrite that lands within one filesystem mtime tick (mtime
+ * resolution is coarser than a millisecond on some platforms/filesystems)
+ * changes neither key, so the memo can serve stale content for a file that
+ * genuinely changed. The memo only ever needs to survive WITHIN one tool
+ * call — the repeated-ask case above — so `dropHashlineAnchorMemo` is called
+ * at the `tool_call` boundary in `runtime-tool-call.ts` (`handleToolCallImpl`
+ * entry) to bound its lifetime to that, rather than trusting mtime/size
+ * across calls.
+ */
+const ANCHOR_INDEX_CACHE_LIMIT = 8;
+const ANCHOR_INDEX_CACHE = new BoundedFifoMap(ANCHOR_INDEX_CACHE_LIMIT);
+/**
+ * Drop the memo. Called at the `tool_call` boundary in production
+ * (`runtime-tool-call.ts`) so a stale mtime/size match from a PRIOR tool call
+ * can never leak into this one (review round 4, finding F5), and as a test
+ * seam so a fixture rewrite is never answered from cache.
+ */
+export function dropHashlineAnchorMemo() {
+    ANCHOR_INDEX_CACHE.clear();
+}
+function buildAnchorIndex(filePath) {
+    let stats;
+    try {
+        stats = nodeFs.statSync(filePath);
+    }
+    catch {
+        return { failure: "file_unreadable" };
+    }
+    if (!stats.isFile())
+        return { failure: "file_unreadable" };
+    if (stats.size > MAX_ANCHOR_FILE_BYTES)
+        return { failure: "file_too_large" };
+    const cached = ANCHOR_INDEX_CACHE.get(filePath);
+    if (cached &&
+        cached.mtimeMs === stats.mtimeMs &&
+        cached.size === stats.size) {
+        return { index: cached.index, contentUnique: cached.contentUnique };
+    }
+    let raw;
+    try {
+        raw = nodeFs.readFileSync(filePath, "utf8");
+    }
+    catch {
+        return { failure: "file_unreadable" };
+    }
+    // `readNormFile` in the extension strips the BOM and folds line endings to
+    // LF before hashing, so the same normalization has to happen here.
+    const normalized = (raw.startsWith("") ? raw.slice(1) : raw)
+        .replace(/\r\n/g, "\n")
+        .replace(/\r/g, "\n");
+    const anchors = computeHashlineAnchors(normalized);
+    if (anchors === undefined)
+        return { failure: "file_too_large" };
+    const index = new Map();
+    for (let i = 0; i < anchors.length; i += 1) {
+        index.set(anchors[i], i + 1);
+    }
+    // Content multiplicity, keyed exactly as upstream keys it. A line whose key
+    // repeats is unanswerable: see the module header.
+    const lines = splitLines(normalized);
+    const keys = [];
+    keys.length = lines.length;
+    const keyCounts = new Map();
+    const keyCache = new Map();
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        let key = keyCache.get(line);
+        if (key === undefined) {
+            key = hashSourceKey(line);
+            keyCache.set(line, key);
+        }
+        keys[i] = key;
+        keyCounts.set(key, (keyCounts.get(key) ?? 0) + 1);
+    }
+    const contentUnique = keys.map((key) => keyCounts.get(key) === 1);
+    ANCHOR_INDEX_CACHE.set(filePath, {
+        mtimeMs: stats.mtimeMs,
+        size: stats.size,
+        index,
+        contentUnique,
+    });
+    return { index, contentUnique };
+}
+/**
+ * Resolve one anchor token against the file's CURRENT content.
+ *
+ * TWO conditions, both required (review round 3, finding F1):
+ *
+ * 1. The anchor matches a line of the recomputed table — `resAnchorFromMap` in
+ *    `src/hashline/resolve.ts` requires that much.
+ * 2. That line's canonical content occurs exactly once in the file. Without
+ *    this, a store-carried anchor for one `}` resolves confidently to a
+ *    DIFFERENT `}`, and the wrong range reaches the read guard. The module
+ *    header has the measurement — including the residual this narrows but
+ *    does not close (review round 4, finding F1).
+ */
+export function resolveHashlineAnchor(filePath, anchor) {
+    const token = normalizeHashlineAnchorToken(anchor);
+    if (token === undefined)
+        return { failure: "not_an_anchor" };
+    const built = buildAnchorIndex(filePath);
+    if ("failure" in built)
+        return { failure: built.failure };
+    const line = built.index.get(token);
+    if (line === undefined)
+        return { failure: "anchor_not_found" };
+    if (built.contentUnique[line - 1] !== true) {
+        return { failure: "content_not_unique" };
+    }
+    return { line };
+}

package/node_modules/pi-lens/dist/clients/hook-budgets.js

@@ -0,0 +1,76 @@
+/**
+ * The per-hook wall-clock budgets, in ONE table (#2523).
+ *
+ * ## What a budget here means
+ *
+ * The maintainer contract behind #2523: only the write/edit `tool_result`
+ * path may block pi's host loop. `session_start`, `turn_end`, `agent_end`,
+ * `agent_settled` and read-only `tool_result` must either finish inside a
+ * small bound or deliver their work OFF-hook (`clients/deferred-lsp-work.ts`,
+ * `publishActionableWarningsReport` #2509, the test-runner `agent_settled`
+ * delivery #2366, the cascade deferred settle #450) — deliver, never drop.
+ *
+ * A number here is the TOTAL wall time the hook may spend, not a per-await
+ * allowance. `0` means the hook may not await anything at all: whatever it
+ * does must be synchronous bookkeeping or fire-and-forget with its own
+ * bound.
+ *
+ * The numbers are the contract's, not a measurement: they are the ceilings
+ * the maintainer set for what the host may be made to wait for. #2523's
+ * sweep measured today's reality against them —  `turn_end` p50 3687 ms /
+ * p90 14246 ms against a 3000 ms budget, `agent_end` p90 10043 ms against
+ * 1000 ms — which is what makes this table a target rather than a
+ * description.
+ *
+ * ## Why a table, and why it is not wired yet
+ *
+ * Slice 1 of #2523 ships the enforcement PRIMITIVE (`bounded()` in
+ * `clients/deadline-utils.ts`) and the guard that makes a new unbounded hook
+ * await impossible to add (`tests/config/hook-await-bounds.test.ts`). It
+ * deliberately changes NO hook's behavior. This table exists now so the
+ * guard's exemption table can say which hook each unbounded await belongs to
+ * — a claim that is checked, since every exemption's `hook` field must be a
+ * key of {@link HOOK_WALL_BUDGET_MS}. Slice 2 (AC3-AC8) wires it into the
+ * outer `bounded()` around each registered handler.
+ *
+ * #1978's phase-budget watchdog is the general form of this idea ("every
+ * recorded duration gets a declared budget"). When it lands it must CONSUME
+ * this table for the hook family rather than declare a second set of hook
+ * numbers — AGENTS.md's single-source-of-truth rule, and #2523 AC7 says so
+ * explicitly.
+ */
+/**
+ * Total wall-clock budget per hook, in milliseconds. `0` = may not await.
+ *
+ * `session_start` is the one VISIBLE budget: 5 s of startup is work the user
+ * is already watching a progress line for. Everything else is time the user
+ * did not ask to spend.
+ */
+export const HOOK_WALL_BUDGET_MS = Object.freeze({
+    /** Visible startup work; the user is watching a progress line. */
+    session_start: 5000,
+    /** Pure bookkeeping — nothing here may await (#2523 contract). */
+    turn_start: 0,
+    /** Measured p50 3687 ms / p90 14246 ms today. The gap IS the issue. */
+    turn_end: 3000,
+    /** Measured p90 10043 ms today, from one unbounded pipeline re-entry. */
+    agent_end: 1000,
+    /** The designated place for settled-time sweeps; the widest non-edit budget. */
+    agent_settled: 10000,
+    /** Read/Grep/Glob/Bash: must never await analyzer bootstrap (AC5). */
+    tool_result_read_only: 500,
+    /** The ONLY path the contract lets block the host, and only this long. */
+    tool_result_edit: 10000,
+    /** Teardown: spawning or awaiting here aborts libuv (#234). */
+    session_shutdown: 0,
+    /** Synchronous message contribution; the host is blocked on the answer. */
+    context: 0,
+    /** Fork bookkeeping; the session is being replaced under it. */
+    session_before_fork: 0,
+});
+/** Every declared hook family, for sweeps that must enumerate them. */
+export const HOOK_BUDGET_KEYS = Object.keys(HOOK_WALL_BUDGET_MS);
+/** Type guard for a string that names a declared hook family. */
+export function isHookBudgetKey(value) {
+    return Object.hasOwn(HOOK_WALL_BUDGET_MS, value);
+}

package/node_modules/pi-lens/dist/clients/host-edit-normalize.js

@@ -5,7 +5,10 @@
  *
  * SOURCE OF TRUTH: `@earendil-works/pi-coding-agent`
  *   `dist/core/tools/edit-diff.js` -- `normalizeForFuzzyMatch`, `normalizeToLF`,
- *   `detectLineEnding`, `restoreLineEndings`, `stripBom`.
+ *   `detectLineEnding`, `restoreLineEndings`. As of 0.85.1 the BOM
+ *   split/strip primitive (`stripBom`'s underlying `splitBom`) moved to
+ *   `dist/utils/text.js`, imported by edit-diff.js rather than inlined there
+ *   -- see the sync test's two-source read.
  *
  * The host SDK is a *type-only* dependency at runtime (pi installs extensions
  * with `npm install --omit=dev`, so the SDK is not in `node_modules`). These
@@ -25,7 +28,7 @@
  * floor in package.json and re-confirm the sync test when the host changes its
  * normalization ladder.
  */
-export const HOST_EDIT_DIFF_SDK_FLOOR = "0.79.9";
+export const HOST_EDIT_DIFF_SDK_FLOOR = "0.85.1";
 // Host normalizeForFuzzyMatch code-point sets (edit-diff.js). Exported so the
 // sync test can assert the host source still encodes exactly these.
 /** U+2018 U+2019 U+201A U+201B -> ' */

package/node_modules/pi-lens/dist/clients/host-ports.js

@@ -34,6 +34,6 @@ export function createDefaultHostPorts(overrides = {}) {
     // annotated rather than inferred.
     return Object.fromEntries(Object.entries(defaults).map(([group, value]) => [
         group,
-        { ...value, ...(overrides[group] ?? {}) },
+        { ...value, ...overrides[group] },
     ]));
 }