@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

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

@@ -1,424 +0,0 @@
-/**
- * `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

@@ -1,76 +0,0 @@
-/**
- * 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

@@ -1,140 +0,0 @@
-/**
- * Vendored port of the pi host edit tool's text-normalization primitives, so
- * the read-guard's oldText->range matching agrees *by construction* with how the
- * host actually applies edits (exact-then-fuzzy in normalized space).
- *
- * SOURCE OF TRUTH: `@earendil-works/pi-coding-agent`
- *   `dist/core/tools/edit-diff.js` -- `normalizeForFuzzyMatch`, `normalizeToLF`,
- *   `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
- * functions are therefore intentionally COPIED, not imported -- keep each one
- * behaviourally identical to the host. The companion sync test
- * (`tests/clients/host-edit-normalize-sync.test.ts`) re-reads the host source
- * from devDeps and fails if it drifts from this port, pinning the floor below.
- *
- * The Unicode fold classes are built from explicit code points (HOST_* below)
- * rather than literal glyphs so this file stays pure-ASCII; the code-point sets
- * are the same ones the host hard-codes as \u escapes in `normalizeForFuzzyMatch`.
- *
- * Refs #257 (read-guard / edit-autopatch alignment with the host edit tool).
- */
-/**
- * Host SDK version this port mirrors. Bump together with the devDependency
- * 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.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 -> ' */
-export const HOST_SMART_SINGLE_QUOTES = [0x2018, 0x2019, 0x201a, 0x201b];
-/** U+201C U+201D U+201E U+201F -> " */
-export const HOST_SMART_DOUBLE_QUOTES = [0x201c, 0x201d, 0x201e, 0x201f];
-/** U+2010..U+2015 dashes + U+2212 minus -> - */
-export const HOST_UNICODE_DASHES = [
-    0x2010, 0x2011, 0x2012, 0x2013, 0x2014, 0x2015, 0x2212,
-];
-/** U+00A0 NBSP, U+2002..U+200A spaces, U+202F, U+205F, U+3000 -> space */
-export const HOST_SPECIAL_SPACES = [
-    0x00a0, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009,
-    0x200a, 0x202f, 0x205f, 0x3000,
-];
-/** U+FEFF byte-order mark */
-export const HOST_BOM_CODE_POINT = 0xfeff;
-const charClass = (codePoints) => new RegExp(`[${String.fromCharCode(...codePoints)}]`, "g");
-const SMART_SINGLE_QUOTES_RE = charClass(HOST_SMART_SINGLE_QUOTES);
-const SMART_DOUBLE_QUOTES_RE = charClass(HOST_SMART_DOUBLE_QUOTES);
-const UNICODE_DASHES_RE = charClass(HOST_UNICODE_DASHES);
-const SPECIAL_SPACES_RE = charClass(HOST_SPECIAL_SPACES);
-const BOM = String.fromCharCode(HOST_BOM_CODE_POINT);
-// --- verbatim host ports (edit-diff.js) ---------------------------------------
-/** First-occurrence-wins line-ending detection (CRLF vs LF). */
-export function detectLineEnding(content) {
-    const crlfIdx = content.indexOf("\r\n");
-    const lfIdx = content.indexOf("\n");
-    if (lfIdx === -1)
-        return "\n";
-    if (crlfIdx === -1)
-        return "\n";
-    return crlfIdx < lfIdx ? "\r\n" : "\n";
-}
-/** Collapse CRLF and lone-CR line endings to LF. */
-export function normalizeToLF(text) {
-    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
-/** Restore LF text back to the detected ending (no-op for LF files). */
-export function restoreLineEndings(text, ending) {
-    return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
-}
-/**
- * Normalize text for fuzzy matching. Mirrors the host's progressive ladder:
- * NFKC -> strip trailing whitespace per line -> smart quotes -> Unicode
- * dashes/hyphens -> special Unicode spaces. None of these transforms add or
- * remove a newline, so line numbers computed on the result map 1:1 to file
- * lines.
- */
-export function normalizeForFuzzyMatch(text) {
-    return text
-        .normalize("NFKC")
-        .split("\n")
-        .map((line) => line.trimEnd())
-        .join("\n")
-        .replace(SMART_SINGLE_QUOTES_RE, "'")
-        .replace(SMART_DOUBLE_QUOTES_RE, '"')
-        .replace(UNICODE_DASHES_RE, "-")
-        .replace(SPECIAL_SPACES_RE, " ");
-}
-/** Strip a leading UTF-8 BOM if present. */
-export function stripBom(content) {
-    return content.startsWith(BOM)
-        ? { bom: BOM, text: content.slice(1) }
-        : { bom: "", text: content };
-}
-// --- composed guard helper ----------------------------------------------------
-/**
- * Full host MATCH-space normalization used by the read-guard's oldText->range
- * resolver and the autopatch synthetic-read bridge: BOM strip -> LF -> fuzzy
- * fold. A needle normalized this way finds exactly what the host's
- * `fuzzyFindText` / `countOccurrences` would find, so the gate no longer
- * rejects edits the host would apply (smart quotes, em-dashes, NBSP, BOM, lone
- * CR, NFKC-equivalent forms). Newline positions are preserved relative to the
- * LF view, so occurrence line numbers stay aligned with the file.
- */
-export function normalizeForGuardMatch(text) {
-    return normalizeForFuzzyMatch(normalizeToLF(stripBom(text).text));
-}
-/**
- * Replicate the host edit tool's match *decision* for a single oldText against
- * file content, WITHOUT applying anything: exact-then-fuzzy find + duplicate
- * count in fuzzy space, exactly as `fuzzyFindText` + `countOccurrences` do
- * (edit-diff.js). The host pre-strips BOM and normalizes to LF, so this does the
- * same before matching.
- *
- * Used as the read-guard's counterfactual log: when the guard blocks an edit,
- * `wouldApply === true` flags a false-block (the host would have applied it),
- * `false` confirms a genuine miss (the host would also fail). This is the only
- * way to measure the guard's false-block rate without an A/B harness (#257).
- */
-export function hostWouldApplyOldText(content, oldText) {
-    const c = normalizeToLF(stripBom(content).text);
-    const o = normalizeToLF(stripBom(oldText).text);
-    if (o.length === 0) {
-        return { wouldApply: false, occurrences: 0, usedFuzzyMatch: false };
-    }
-    const exactFound = c.indexOf(o) !== -1;
-    // The host always counts duplicates in fuzzy space, even for an exact match.
-    const fuzzyContent = normalizeForFuzzyMatch(c);
-    const fuzzyOldText = normalizeForFuzzyMatch(o);
-    const fuzzyFound = fuzzyContent.indexOf(fuzzyOldText) !== -1;
-    const occurrences = fuzzyOldText.length === 0 ? 0 : fuzzyContent.split(fuzzyOldText).length - 1;
-    return {
-        wouldApply: (exactFound || fuzzyFound) && occurrences === 1,
-        occurrences,
-        usedFuzzyMatch: !exactFound && fuzzyFound,
-    };
-}

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

@@ -1,39 +0,0 @@
-/** Host-neutral capabilities available to the pi-lens engine (#1358 S2). */
-/**
- * Headless/test implementation. Its feature-detection defaults deliberately
- * match the pre-ports absent-host paths: unknown trust/mode, fail-open spawn,
- * and no-op delivery surfaces.
- */
-export function createDefaultHostPorts(overrides = {}) {
-    const unknownMode = () => "unknown";
-    const defaults = {
-        notify: { user: () => { } },
-        trust: { isProjectTrusted: () => "unknown" },
-        mode: {
-            current: unknownMode,
-            supportsTuiWidget: () => true,
-            suppressesUserNotify: () => false,
-        },
-        log: { extension: () => { }, debug: () => { }, sink: () => () => { } },
-        emit: { bus: () => { } },
-        status: { set: () => { } },
-        spawn: { abortSignal: () => undefined, isAllowed: () => true },
-        render: { invalidate: () => { } },
-        session: { id: () => undefined },
-        workspace: { cwd: () => undefined, projectRoot: () => undefined },
-        flags: { get: () => undefined },
-        tools: { has: async () => false, getActive: () => [], setActive: () => { } },
-    };
-    // SAFETY: `Object.fromEntries` is typed `Record<string, T>` — it cannot
-    // carry the key literals or the per-group value types through. The keys
-    // come from `Object.entries(defaults)`, and `defaults` is declared as a
-    // complete `HostPorts`, so every group is present; each value is that
-    // group's default spread-merged with the same group's override, so no
-    // group's member set shrinks. Add a group to `HostPorts` without adding it
-    // to `defaults` and this cast becomes a lie, which is why `defaults` is
-    // annotated rather than inferred.
-    return Object.fromEntries(Object.entries(defaults).map(([group, value]) => [
-        group,
-        { ...value, ...overrides[group] },
-    ]));
-}