@herbertgao/pi-extensions 2026.8.11 → 2026.8.13

package/node_modules/pi-lens/dist/clients/finding-delivery-gate.js

@@ -177,7 +177,15 @@ function gated(file, description, gates, evidence, extra = {}) {
 }
 /** Factory for a `labeled` entry — see {@link gated}'s doc for why this exists. */
 function labeled(file, description, reason, ageSource, evidence = [], extra = {}) {
-    return { mode: "labeled", file, description, reason, ageSource, evidence, ...extra };
+    return {
+        mode: "labeled",
+        file,
+        description,
+        reason,
+        ageSource,
+        evidence,
+        ...extra,
+    };
 }
 const RUNTIME_TURN_FILE = "clients/runtime-turn.ts";
 const LENS_DIAGNOSTICS_FILE = "tools/lens-diagnostics.ts";
@@ -223,6 +231,15 @@ export const DELIVERY_SURFACES = {
     "runtime-turn:disposition-suppressed-notice": labeled(RUNTIME_TURN_FILE, "Turn-end running disposition-suppressed-count notice (#1616).", "A live running total accumulated from this turn's own gate/disposition " +
         "calls above (`dispositionSuppressedTotal`) — telemetry ABOUT the other " +
         "gated surfaces, not a cache of its own.", "live"),
+    // #2001/#2002 collect-later: findings an auxiliary LSP published AFTER its
+    // aux-grace window expired, probed from the client cache at the next
+    // turn_end. Gated on the mark timestamp: a cited file deleted or edited
+    // since the mark drops its findings (never delivered before, and the
+    // drifting edit already re-touched the file — a fresh pending pair
+    // supersedes this one), with both drop arms counted in the
+    // `late_auxiliary_findings` latency record rather than silenced.
+    "runtime-turn:late-auxiliary-findings": gated(RUNTIME_TURN_FILE, "Turn-end late-auxiliary LSP findings (collect-later probe of aux " +
+        "client caches whose grace window expired).", ["gateFindingsByPathFreshness"], ['store: "late-auxiliary-findings"']),
     "runtime-turn:cascade-blocker": labeled(RUNTIME_TURN_FILE, "Turn-end 🧪 cascade neighbor blocker.", "Cascade results settle synchronously this turn where possible " +
         "(`settleCascadeRuns`), but an unsettled compute can carry over to a " +
         "later turn (bounded by a carry cap) — this round does not freshness-" +
@@ -246,7 +263,15 @@ export const DELIVERY_SURFACES = {
         partialReason: "call-graph freshness/invalidation policy is out of this PR's scope — " +
             "tracked as a follow-up, not silently assumed fresh.",
     }),
-    "lens-diagnostics:mode-full": gated(LENS_DIAGNOSTICS_FILE, "`lens_diagnostics mode=full` report.", ["applyDispositions", "applyRulePolicy", "reconcileProjectDiagnosticsSnapshot"], ["applyDispositions(", "applyRulePolicy(", "reconcileProjectDiagnosticsSnapshot("]),
+    "lens-diagnostics:mode-full": gated(LENS_DIAGNOSTICS_FILE, "`lens_diagnostics mode=full` report.", [
+        "applyDispositions",
+        "applyRulePolicy",
+        "reconcileProjectDiagnosticsSnapshot",
+    ], [
+        "applyDispositions(",
+        "applyRulePolicy(",
+        "reconcileProjectDiagnosticsSnapshot(",
+    ]),
     "lens-diagnostics:mode-all": gated(LENS_DIAGNOSTICS_FILE, "`lens_diagnostics mode=all` report (widget-state read).", ["reconcileStaleWidgetFiles", "reconcileStaleWidgetDependencyBlockers"], ["reconcileStaleWidgetFiles(", "reconcileStaleWidgetDependencyBlockers("]),
     // #1634 review round F3: this was the most important gap — the tool's
     // DEFAULT mode rendered cached `file:line` findings with zero freshness
@@ -269,6 +294,36 @@ export const DELIVERY_SURFACES = {
         "accumulator is drained and cleared at the moment of injection, so the " +
         "content IS the current state by construction.", "live"),
     "project-diagnostics:persisted-snapshot": gated(LENS_DIAGNOSTICS_FILE, "Cross-session persisted project-diagnostics snapshot read.", ["reconcileProjectDiagnosticsSnapshot"], ["reconcileProjectDiagnosticsSnapshot("]),
+    // ── #2028: the remaining agent-facing surfaces ──────────────────────────
+    // Registered after #2028's root-cause review found the 🔴 STOP block
+    // rendering stale/deleted-file blockers because its surface was never in
+    // this registry — the exact "gated or labeled, never neither" gap this
+    // module exists to close.
+    "tool-call:stop-blocker": gated("clients/pipeline.ts", "Per-edit 🔴 STOP blocker output appended to the write/edit tool result.", ["dropFindingsForMissingPaths"], ['store: "stop-blocker"']),
+    // The freshness stack itself (own-file mtime + reverse-dependency mtimes
+    // via isEntryFresh, plus the #1095 content binding) lives inside
+    // clients/lsp/workspace-diagnostics-cache.ts; the two evidence calls are
+    // the tool's literal entry points into that gated path.
+    "lsp-diagnostics:tool-output": gated("tools/lsp-diagnostics.ts", "`lsp_diagnostics` batch/directory sweep results. Cache hits replay through " +
+        "the shared workspace-diagnostics cache: createWorkspaceDiagnosticsCacheContext " +
+        "is the tool's entry, and its lookup() applies the #671/#672 freshness stack " +
+        "(own-file mtime + reverse-dependency mtimes via isEntryFresh) plus the " +
+        "#1095 content binding.", [
+        "createWorkspaceDiagnosticsCacheContext",
+        "isEntryFresh",
+        "cacheCtx.lookup",
+    ], [
+        "createWorkspaceDiagnosticsCacheContext(resolvedCwd)",
+        "cacheCtx.lookup(file, scopeKey)",
+    ]),
+    "git-guard:commit-blocked": labeled("clients/git-guard.ts", "Git-guard commit/push 🔴 COMMIT BLOCKED verdict (--lens-guard).", "Synchronous preflight rejection returned inline with the failed git " +
+        "command — no stored state is delivered, so nothing can go stale between " +
+        "detection and delivery.", "live"),
+    "read-guard-tool-lines:preflight-errors": labeled("clients/read-guard-tool-lines.ts", "Read-guard hashline BLOCKED / RE-READ REQUIRED preflight errors.", "Computed fresh per edit attempt and returned as that attempt's rejection — " +
+        "no cached findings are replayed, so there is no staleness window.", "live"),
+    "tool-call:duplicate-export-blocker": labeled("clients/runtime-tool-call.ts", "Duplicate-export STOP rejection returned inline with the failed edit.", "Synchronous preflight rejection computed per edit attempt; no stored state.", "live"),
+    "agent-behavior:thrashing-notice": labeled("clients/agent-behavior-client.ts", "In-result thrashing/blind-write detection notice.", "Ephemeral notice computed at detection time inside the same tool result — " +
+        "no persistence and no cache, so nothing can be stale.", "live"),
 };
 function assertPartialStatusHasReason(id, entry) {
     if (entry.status === "partial" && !entry.partialReason) {

package/node_modules/pi-lens/dist/clients/formatters.js

@@ -491,7 +491,7 @@ const EXPLICIT_FORMATTER_CONFIG_CHECKS = new Map([
     ["mix", (cwd) => hasMixFormatConfig(cwd)],
 ]);
 function hasExplicitFormatterConfig(formatterName, cwd, ext) {
-    return EXPLICIT_FORMATTER_CONFIG_CHECKS.get(formatterName)?.(cwd, ext) ?? false;
+    return (EXPLICIT_FORMATTER_CONFIG_CHECKS.get(formatterName)?.(cwd, ext) ?? false);
 }
 // Exported for the "every registered formatter is selectable" coverage guard
 // (formatter-policy-consistency.test.ts, #1572): derived from the table above,
@@ -509,7 +509,8 @@ async function hasEditorConfig(cwd) {
     }
 }
 async function indentationArgs(filePath, tool, cwd) {
-    if (await hasEditorConfig(cwd) || hasExplicitFormatterConfig(tool, cwd, path.extname(filePath))) {
+    if ((await hasEditorConfig(cwd)) ||
+        hasExplicitFormatterConfig(tool, cwd, path.extname(filePath))) {
         return [];
     }
     let content;
@@ -524,9 +525,15 @@ async function indentationArgs(filePath, tool, cwd) {
         return null;
     const indentation = detectIndentation(content);
     if (tool === "shfmt")
-        return indentation.style === "tab" ? ["-i", "0"] : ["-i", String(indentation.width)];
+        return indentation.style === "tab"
+            ? ["-i", "0"]
+            : ["-i", String(indentation.width)];
     if (tool === "prettier") {
-        return [indentation.style === "tab" ? "--use-tabs" : "--no-use-tabs", "--tab-width", String(indentation.width)];
+        return [
+            indentation.style === "tab" ? "--use-tabs" : "--no-use-tabs",
+            "--tab-width",
+            String(indentation.width),
+        ];
     }
     if (tool === "ruff") {
         // `ruff format` has NO --indent-style/--indent-width flags (it errors with
@@ -540,7 +547,12 @@ async function indentationArgs(filePath, tool, cwd) {
             `format.indent-style='${indentation.style}'`,
         ];
     }
-    return ["--indent-style", indentation.style, "--indent-width", String(indentation.width)];
+    return [
+        "--indent-style",
+        indentation.style,
+        "--indent-width",
+        String(indentation.width),
+    ];
 }
 /**
  * Every biome invocation must carry this. Biome exits 1 with "No files were
@@ -671,9 +683,35 @@ export const prettierFormatter = {
             hasNearestPackageJsonField(cwd, "prettier"));
     },
 };
+/**
+ * Turns "no target files left after ignore rules" into a clean exit 0.
+ *
+ * oxfmt is offered for every extension in `OXFMT_SUPPORTED_EXTENSIONS` as soon
+ * as a config exists, but a config's `ignorePatterns` can exclude any of them.
+ * Handed a path it has been told to ignore, oxfmt 0.64.0 exits 2 with
+ * "Expected at least one target file. All matched files may have been excluded
+ * by ignore rules." Under the #1337 strict default that reads as a formatting
+ * failure, so a user whose oxfmt config ignores (say) Markdown sees an error on
+ * every Markdown edit.
+ *
+ * Same class as biome's "No files were processed in the specified paths", and
+ * the same fix: ask the tool not to treat an empty target set as an error,
+ * rather than teaching `formatFile` to forgive an exit code. This is the
+ * narrower repair — a flag cannot mask anything else, whereas status- or
+ * message-keyed leniency would have to be trusted to stay tight across oxfmt
+ * releases. Verified against oxfmt 0.64.0: with the flag, an ignored path exits
+ * 0 untouched, a normal file is still rewritten, and an unparseable file still
+ * exits 2. `tests/clients/dispatch/oxfmt-ignored-file-noop.test.ts` pins all
+ * three against the real binary.
+ *
+ * The flag also silences a genuinely missing file, which `formatFile` never
+ * reaches: it reads the file before it spawns anything, so a missing path
+ * fails there.
+ */
+const OXFMT_NO_ERROR_ON_UNMATCHED = "--no-error-on-unmatched-pattern";
 export const oxfmtFormatter = {
     name: "oxfmt",
-    command: ["oxfmt", "$FILE"],
+    command: ["oxfmt", OXFMT_NO_ERROR_ON_UNMATCHED, "$FILE"],
     // #1337 audit: oxfmt (and the `vp fmt --write` path) publish no exit-code
     // table. `--write` is the default and `--check` is the separate verification
     // mode, so there is no documented nonzero-on-reformat. Absent a documented
@@ -681,6 +719,9 @@ export const oxfmtFormatter = {
     // mode of guessing wrong the other way is a silent no-op (#1336).
     async resolveCommand(filePath, cwd) {
         if (hasVitePlusConfig(cwd)) {
+            // No unmatched-pattern flag here: this is `vp`, a different CLI with
+            // its own arguments. Whether `vp fmt` has the same empty-target
+            // behavior is unverified, so nothing is claimed about it.
             const localVp = await findInNodeModules("vp", cwd);
             if (localVp)
                 return [localVp, "fmt", filePath, "--write"];
@@ -690,10 +731,10 @@ export const oxfmtFormatter = {
         }
         const local = await findInNodeModules("oxfmt", cwd);
         if (local)
-            return [local, filePath];
+            return [local, OXFMT_NO_ERROR_ON_UNMATCHED, filePath];
         const found = await which("oxfmt");
         if (found)
-            return [found, filePath];
+            return [found, OXFMT_NO_ERROR_ON_UNMATCHED, filePath];
         return null;
     },
     // Single source of truth: OXFMT_SUPPORTED_EXTENSIONS in tool-policy.ts.
@@ -834,7 +875,10 @@ export const shfmtFormatter = {
         const inPath = await which("shfmt");
         if (inPath)
             return [inPath, "-w", ...styleArgs, filePath];
-        return resolveManagedSmartDefaultCommand("shfmt", filePath, ["-w", ...styleArgs]);
+        return resolveManagedSmartDefaultCommand("shfmt", filePath, [
+            "-w",
+            ...styleArgs,
+        ]);
     },
     async detect(_cwd) {
         if ((await which("shfmt")) !== null)
@@ -1290,28 +1334,88 @@ const detectionCache = new BoundedLruCache(32);
 // Kotlin/Spotless gradle files, sqlfluff's setup.cfg, and oxfmt's
 // vite-plus.json / additional vite.config extensions).
 const FORMATTER_CONFIG_FILES = [
-    "package.json", "biome.json", "biome.jsonc", ".prettierrc", ".prettierrc.json",
-    ".prettierrc.yml", ".prettierrc.yaml", ".prettierrc.js", ".prettierrc.cjs",
-    ".prettierrc.mjs", "prettier.config.js", "prettier.config.cjs", "prettier.config.mjs",
-    "prettier.config.ts", "pyproject.toml", "ruff.toml", ".ruff.toml", "black.toml",
-    ".black", "tox.ini", "setup.cfg", "requirements.txt", "Pipfile", ".sqlfluff", ".rubocop.yml", ".rubocop.yaml", "Gemfile", ".clang-format",
-    "_clang-format", ".php-cs-fixer.php", ".php-cs-fixer.dist.php", "stylua.toml",
-    ".stylua.toml", ".ocamlformat", ".editorconfig", ".google-java-format",
-    ".ktfmt", ".ktfmt.kts", "build.gradle.kts", "build.gradle", "settings.gradle.kts", "settings.gradle",
-    ".cljfmt.edn", "cljfmt.edn", ".cljfmt",
-    ".cmake-format", ".cmake-format.yaml", ".cmake-format.yml", ".cmake-format.json", ".cmake-format.py",
-    "cmake-format.py", "cmake-format.yaml", "cmake-format.yml",
-    "oxfmt.toml", ".oxfmtrc.json", "vite-plus.json",
-    "vite.config.ts", "vite.config.mts", "vite.config.cts", "vite.config.js", "vite.config.mjs", "vite.config.cjs",
-    "PSScriptAnalyzerSettings.psd1", "ScriptAnalyzerSettings.psd1",
+    "package.json",
+    "biome.json",
+    "biome.jsonc",
+    ".prettierrc",
+    ".prettierrc.json",
+    ".prettierrc.yml",
+    ".prettierrc.yaml",
+    ".prettierrc.js",
+    ".prettierrc.cjs",
+    ".prettierrc.mjs",
+    "prettier.config.js",
+    "prettier.config.cjs",
+    "prettier.config.mjs",
+    "prettier.config.ts",
+    "pyproject.toml",
+    "ruff.toml",
+    ".ruff.toml",
+    "black.toml",
+    ".black",
+    "tox.ini",
+    "setup.cfg",
+    "requirements.txt",
+    "Pipfile",
+    ".sqlfluff",
+    ".rubocop.yml",
+    ".rubocop.yaml",
+    "Gemfile",
+    ".clang-format",
+    "_clang-format",
+    ".php-cs-fixer.php",
+    ".php-cs-fixer.dist.php",
+    "stylua.toml",
+    ".stylua.toml",
+    ".ocamlformat",
+    ".editorconfig",
+    ".google-java-format",
+    ".ktfmt",
+    ".ktfmt.kts",
+    "build.gradle.kts",
+    "build.gradle",
+    "settings.gradle.kts",
+    "settings.gradle",
+    ".cljfmt.edn",
+    "cljfmt.edn",
+    ".cljfmt",
+    ".cmake-format",
+    ".cmake-format.yaml",
+    ".cmake-format.yml",
+    ".cmake-format.json",
+    ".cmake-format.py",
+    "cmake-format.py",
+    "cmake-format.yaml",
+    "cmake-format.yml",
+    "oxfmt.toml",
+    ".oxfmtrc.json",
+    "vite-plus.json",
+    "vite.config.ts",
+    "vite.config.mts",
+    "vite.config.cts",
+    "vite.config.js",
+    "vite.config.mjs",
+    "vite.config.cjs",
+    "PSScriptAnalyzerSettings.psd1",
+    "ScriptAnalyzerSettings.psd1",
     // #1595 sweep additions.
-    ".csharpierrc", ".csharpierrc.json", ".csharpierrc.yaml", ".csharpierrc.yml",
-    ".ormolu", "taplo.toml", ".taplo.toml", ".terraform.lock.hcl", ".swiftformat",
-    ".fantomasignore", ".formatter.exs",
+    ".csharpierrc",
+    ".csharpierrc.json",
+    ".csharpierrc.yaml",
+    ".csharpierrc.yml",
+    ".ormolu",
+    "taplo.toml",
+    ".taplo.toml",
+    ".terraform.lock.hcl",
+    ".swiftformat",
+    ".fantomasignore",
+    ".formatter.exs",
 ];
 async function formatterConfigSignature(cwd) {
     const paths = await findUp(FORMATTER_CONFIG_FILES, cwd);
-    const parts = await Promise.all(paths.sort((a, b) => a.localeCompare(b)).map(async (filePath) => {
+    const parts = await Promise.all(paths
+        .sort((a, b) => a.localeCompare(b))
+        .map(async (filePath) => {
         try {
             const stat = await fs.stat(filePath);
             return `${filePath}:${stat.mtimeMs}:${stat.size}`;
@@ -1529,6 +1633,19 @@ export function clearFormatterCache() {
     detectionCache.clear();
     resetWhichLatches();
 }
+/**
+ * Test-only internals access for the session-state registry probe (#1895):
+ * the conformance suite must arm all four pieces of state this reset claims
+ * to cover and prove none survives.
+ */
+export function _getFormatterResetStateForTests() {
+    return {
+        whichLatchByCommand,
+        whichTransientCommands,
+        cooldownRecordedForRetryAtMs,
+        detectionCache,
+    };
+}
 export function clearFormatterRuntimeState() {
     detectionCache.clear();
     resetWhichLatches();

package/node_modules/pi-lens/dist/clients/freshness.js

@@ -0,0 +1,38 @@
+/**
+ * Freshness kernel (#1739): ONE comparator and ONE verdict type for every
+ * "was this file modified after my reference timestamp?" gate.
+ *
+ * The same staleness comparison was independently reimplemented in at least
+ * six stores (advisory-provenance, blocker-freshness,
+ * project-diagnostics/cache [#1711], widget-state ×3, lsp/workspace-
+ * diagnostics-cache), and three of those copies carried the identical
+ * mtime-tolerance defect fixed separately in #1710/#1711/#1664. This module
+ * is the single implementation going forward; the registered-or-fail sweep
+ * (`tests/clients/freshness-sweep.test.ts`) fails on new out-of-kernel
+ * comparisons so the population cannot silently regrow.
+ *
+ * Deliberately NOT here: age-based checks (`Date.now() - mtime > TTL` — that
+ * is expiry, not freshness against a reference event) and max-selection
+ * comparisons (`mtime > best.mtimeMs`) — neither compares against a scan or
+ * record timestamp, which is what this kernel's verdict means.
+ */
+/** Shared drift tolerance: raised from 0 to 50ms after measured Windows mtime skew produced 42 false demotions in 50 runs (#1710 evidence). */
+export const MTIME_DRIFT_TOLERANCE_MS = 50;
+/**
+ * Compare an observed mtime against a reference timestamp (the scan, record,
+ * or touch instant whose validity depends on the file not having moved).
+ *
+ * `mtimeMs === undefined` means the caller had no readable mtime (stat
+ * failed, file gone). The kernel does NOT choose a policy for that case -
+ * callers differ legitimately (a diagnostics cache drops, a drift detector
+ * skips) - so it reports `indeterminate` and the caller maps it.
+ */
+export function freshnessFromMtime(input) {
+    const tolerance = input.toleranceMs ?? MTIME_DRIFT_TOLERANCE_MS;
+    if (input.mtimeMs === undefined) {
+        return { verdict: "indeterminate", reason: "no-mtime-evidence" };
+    }
+    return input.mtimeMs > input.referenceMs + tolerance
+        ? { verdict: "stale", reason: "modified-after-reference" }
+        : { verdict: "fresh" };
+}

package/node_modules/pi-lens/dist/clients/git-guard.js

@@ -152,7 +152,8 @@ function canonicalizeGuardCommand(command) {
         if (!quote && (ch === "'" || ch === '"')) {
             quote = ch === "'" ? "single" : "double";
         }
-        else if ((quote === "single" && ch === "'") || (quote === "double" && ch === '"')) {
+        else if ((quote === "single" && ch === "'") ||
+            (quote === "double" && ch === '"')) {
             quote = undefined;
         }
     }
@@ -241,7 +242,10 @@ function containsGuardedSubstitution(command, depth) {
                 : command.startsWith(">(", i)
                     ? delimitedSubstitutionBody(command, i, ">(", ")")
                     : ch === "`"
-                        ? { body: command.slice(i + 1, command.indexOf("`", i + 1)), end: command.indexOf("`", i + 1) }
+                        ? {
+                            body: command.slice(i + 1, command.indexOf("`", i + 1)),
+                            end: command.indexOf("`", i + 1),
+                        }
                         : undefined;
         if (substitution && substitution.end >= 0) {
             const nested = canonicalizeGuardCommand(substitution.body);
@@ -309,7 +313,13 @@ function containsCommitOrPush(tokens, depth) {
                 i += 1;
                 continue;
             }
-            if (["--config-env", "--git-dir", "--work-tree", "--exec-path", "--namespace"].some((prefix) => option.startsWith(`${prefix}=`))) {
+            if ([
+                "--config-env",
+                "--git-dir",
+                "--work-tree",
+                "--exec-path",
+                "--namespace",
+            ].some((prefix) => option.startsWith(`${prefix}=`))) {
                 i += 1;
                 continue;
             }
@@ -319,12 +329,15 @@ function containsCommitOrPush(tokens, depth) {
         return verbs.length === 1 && (verbs[0] === "commit" || verbs[0] === "push");
     }
     const leadingExecutable = commandTokens[0] ?? "";
-    const knownCommandStringWrapper = isShellWrapper(leadingExecutable) || isCommandStringWrapper(leadingExecutable);
+    const knownCommandStringWrapper = isShellWrapper(leadingExecutable) ||
+        isCommandStringWrapper(leadingExecutable);
     if (!knownCommandStringWrapper) {
         // Unknown launchers are a fail-closed boundary only when they explicitly
         // accept a command string. Re-tokenizing the value keeps literal mentions
         // such as `myprog -c "echo git push"` out of the guarded-command path.
-        const unknownSwitchIndex = commandTokens.slice(1).findIndex((token) => (token.startsWith("-") || token.startsWith("/")) && token.length > 1);
+        const unknownSwitchIndex = commandTokens
+            .slice(1)
+            .findIndex((token) => (token.startsWith("-") || token.startsWith("/")) && token.length > 1);
         if (unknownSwitchIndex < 0)
             return false;
         const commandIndex = unknownSwitchIndex + 2;
@@ -389,7 +402,8 @@ function isTurnEndFindingsCache(value) {
         !!record.fileContentHashes &&
         typeof record.fileContentHashes === "object" &&
         Object.values(record.fileContentHashes).every((hash) => typeof hash === "string") &&
-        (record.affectedFilesTruncated === undefined || typeof record.affectedFilesTruncated === "boolean") &&
+        (record.affectedFilesTruncated === undefined ||
+            typeof record.affectedFilesTruncated === "boolean") &&
         (record.blockingFiles === undefined || Array.isArray(record.blockingFiles)));
 }
 function cacheRecord(cacheManager, cwd) {
@@ -413,7 +427,10 @@ export function writeGitGuardRecord(cacheManager, runtime, cwd, record) {
         cwd,
         runtime,
         generation: 0,
-        files: capped.files.map((file) => ({ path: file, role: "affected" })),
+        files: capped.files.map((file) => ({
+            path: file,
+            role: "affected",
+        })),
         truncated: capped.truncated,
     });
     const fileContentHashes = Object.fromEntries(currentProvenance.files.map((file) => [
@@ -523,7 +540,9 @@ export function syncGitGuardRecord(runtime, cacheManager, cwd, editedFilePath) {
         markCacheUnknown(runtime, "blocking_provenance_untrusted");
         return;
     }
-    const editedKey = editedFilePath ? guardPathKey(editedFilePath, cwd) : undefined;
+    const editedKey = editedFilePath
+        ? guardPathKey(editedFilePath, cwd)
+        : undefined;
     const testFiles = existing?.testFailureFiles ?? [];
     const remainingBlockingFiles = editedKey && existingBlockingFiles.length > 0
         ? existingBlockingFiles.filter((file) => guardPathKey(file, cwd) !== editedKey)
@@ -553,7 +572,10 @@ export function syncGitGuardRecord(runtime, cacheManager, cwd, editedFilePath) {
             : existing?.blockerContent;
     const hasTestFailures = existing?.testFailures === true;
     const hasBlockers = !!blockerContent || hasTestFailures;
-    const content = [blockerContent, hasTestFailures ? existing?.testFailureContent : undefined]
+    const content = [
+        blockerContent,
+        hasTestFailures ? existing?.testFailureContent : undefined,
+    ]
         .filter((value) => !!value)
         .join("\n\n");
     if (!hasBlockers && !content) {
@@ -612,7 +634,9 @@ export function clearGitGuardTestFailure(cacheManager, cwd, runtime, passedFiles
     const existing = cacheRecord(cacheManager, cwd);
     if (!existing?.testFailures)
         return;
-    const passedKeys = new Set((passedFiles.length > 0 ? passedFiles : existing.testFailureFiles ?? []).map((file) => guardPathKey(file, cwd)));
+    const passedKeys = new Set((passedFiles.length > 0
+        ? passedFiles
+        : (existing.testFailureFiles ?? [])).map((file) => guardPathKey(file, cwd)));
     const remainingFiles = (existing.testFailureFiles ?? []).filter((file) => !passedKeys.has(guardPathKey(file, cwd)));
     const blockerContent = existing.blockerContent ?? "";
     if (!blockerContent && remainingFiles.length === 0) {
@@ -634,7 +658,9 @@ export function clearGitGuardTestFailure(cacheManager, cwd, runtime, passedFiles
         sessionId: runtime.telemetrySessionId,
         projectSeqStart: runtime.turnStartProjectSeq,
         projectSeqEnd: runtime.projectSeq,
-        fileSeqByPath: Object.fromEntries(runtime.getFileSeqEntries().map(([filePath, seq]) => [guardPathKey(filePath, cwd), seq])),
+        fileSeqByPath: Object.fromEntries(runtime
+            .getFileSeqEntries()
+            .map(([filePath, seq]) => [guardPathKey(filePath, cwd), seq])),
         fileContentHashes: {},
     });
 }
@@ -643,7 +669,9 @@ export function evaluateGitGuard(runtime, cacheManager, cwd) {
         logDecision(cwd, "blocked", "runtime_blockers", {
             projectSeq: runtime.projectSeq,
         });
-        const detail = runtime.gitGuardSummary ? `\n${runtime.gitGuardSummary}` : "";
+        const detail = runtime.gitGuardSummary
+            ? `\n${runtime.gitGuardSummary}`
+            : "";
         return {
             block: true,
             reason: `🔴 COMMIT BLOCKED (--lens-guard): unresolved blockers must be fixed before commit/push.${detail}\nRun lens_diagnostics mode=all for full details, then commit again.`,
@@ -713,7 +741,9 @@ export function evaluateGitGuard(runtime, cacheManager, cwd) {
     }
     // A deleted/ignored affected file has been resolved; no stale blocker is
     // allowed to survive solely because its old path remains in the record.
-    if (record.hasBlockers && liveFiles.length === 0 && record.affectedFiles.length > 0) {
+    if (record.hasBlockers &&
+        liveFiles.length === 0 &&
+        record.affectedFiles.length > 0) {
         logDecision(cwd, "allowed", "affected_files_resolved", {
             projectSeq: record.projectSeqEnd,
         });

package/node_modules/pi-lens/dist/clients/go-client.js

@@ -33,9 +33,7 @@ export class GoClient {
     availability;
     log;
     constructor(verbose = false) {
-        this.log = verbose
-            ? createSubsystemLogger("go")
-            : () => { };
+        this.log = verbose ? createSubsystemLogger("go") : () => { };
         this.availability = createToolchainAvailability({
             tool: "go",
             label: "Go",

package/node_modules/pi-lens/dist/clients/grammar-source.js

@@ -33,7 +33,7 @@ export const GRAMMAR_SOURCE_OVERRIDES = {
 };
 /** The URL a grammar wasm is fetched from (override if any, else the aggregator). */
 export function grammarSourceUrl(filename) {
-    return GRAMMAR_SOURCE_OVERRIDES[filename]?.url ?? `${GRAMMAR_CDN_BASE}/${filename}`;
+    return (GRAMMAR_SOURCE_OVERRIDES[filename]?.url ?? `${GRAMMAR_CDN_BASE}/${filename}`);
 }
 /**
  * Grammars built in-house and committed to `vendor/grammars/`.

package/node_modules/pi-lens/dist/clients/gzip-stage-write.js

@@ -38,7 +38,7 @@ import { stagePathFor } from "./atomic-write-staging.js";
  * the caller must treat as a persist failure (both persist workers fall back
  * to a main-thread rewrite on an error result).
  */
-export async function writeGzipStageFile(data, stagePath, testDelayMs) {
+export async function writeGzipStageFile(data, stagePath, testDelayMs, options) {
     const tmpPath = stagePathFor(stagePath);
     try {
         if (testDelayMs) {
@@ -48,6 +48,18 @@ export async function writeGzipStageFile(data, stagePath, testDelayMs) {
         const json = JSON.stringify(data);
         const serializeMs = performance.now() - serializeStarted;
         const rawBytes = Buffer.byteLength(json);
+        const semanticFingerprint = options?.semanticFingerprint?.(json);
+        if (semanticFingerprint !== undefined &&
+            options?.skipIfFingerprints?.includes(semanticFingerprint)) {
+            return {
+                rawBytes,
+                gzBytes: 0,
+                serializeMs,
+                writeMs: 0,
+                semanticFingerprint,
+                skippedUnchanged: true,
+            };
+        }
         const writeStarted = performance.now();
         await fs.promises.mkdir(path.dirname(stagePath), { recursive: true });
         const chunks = function* () {
@@ -60,7 +72,13 @@ export async function writeGzipStageFile(data, stagePath, testDelayMs) {
         await fs.promises.rename(tmpPath, stagePath);
         const writeMs = performance.now() - writeStarted;
         const gzBytes = (await fs.promises.stat(stagePath)).size;
-        return { rawBytes, gzBytes, serializeMs, writeMs };
+        return {
+            rawBytes,
+            gzBytes,
+            serializeMs,
+            writeMs,
+            semanticFingerprint,
+        };
     }
     catch (err) {
         await fs.promises.rm(tmpPath, { force: true }).catch(() => { });
@@ -76,7 +94,7 @@ export async function writeGzipStageFile(data, stagePath, testDelayMs) {
  * each supplies only how to derive its own result's routing fields from the
  * request. Throws immediately if loaded outside a worker thread.
  */
-export function serveGzipStageWorker(buildBaseResult) {
+export function serveGzipStageWorker(buildBaseResult, options) {
     const port = parentPort;
     if (!port) {
         throw new Error("gzip stage persist worker requires a parent port");
@@ -87,11 +105,19 @@ export function serveGzipStageWorker(buildBaseResult) {
                 ...buildBaseResult(request),
             };
             try {
-                const metrics = await writeGzipStageFile(request.data, request.stagePath, request.testDelayMs);
+                const fingerprint = options?.semanticFingerprint;
+                const metrics = await writeGzipStageFile(request.data, request.stagePath, request.testDelayMs, {
+                    semanticFingerprint: fingerprint
+                        ? (json) => fingerprint(request, json)
+                        : undefined,
+                    skipIfFingerprints: options?.skipIfFingerprints?.(request),
+                });
                 result.rawBytes = metrics.rawBytes;
                 result.gzBytes = metrics.gzBytes;
                 result.serializeMs = metrics.serializeMs;
                 result.writeMs = metrics.writeMs;
+                result.semanticFingerprint = metrics.semanticFingerprint;
+                result.skippedUnchanged = metrics.skippedUnchanged;
             }
             catch (err) {
                 result.error = err instanceof Error ? err.message : String(err);

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

@@ -128,9 +128,7 @@ export function hostWouldApplyOldText(content, oldText) {
     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;
+    const occurrences = fuzzyOldText.length === 0 ? 0 : fuzzyContent.split(fuzzyOldText).length - 1;
     return {
         wouldApply: (exactFound || fuzzyFound) && occurrences === 1,
         occurrences,

package/node_modules/pi-lens/dist/clients/install-diagnostics.js

@@ -52,7 +52,8 @@ export function collectInstallDiagnostics() {
         const pj = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
         return String(pj.version ?? "unknown");
     }, "unknown");
-    const bunVersion = globalThis.Bun?.version;
+    const bunVersion = globalThis.Bun
+        ?.version;
     const runtime = bunVersion
         ? `bun ${bunVersion}`
         : `node ${process.versions.node}`;
@@ -88,7 +89,8 @@ export function collectInstallDiagnostics() {
     }, false);
     const grammars = safe(() => {
         let dir = path.dirname(require.resolve("web-tree-sitter"));
-        while (path.basename(dir) !== "web-tree-sitter" && dir !== path.dirname(dir)) {
+        while (path.basename(dir) !== "web-tree-sitter" &&
+            dir !== path.dirname(dir)) {
             dir = path.dirname(dir);
         }
         return fs.existsSync(path.join(dir, "grammars", "tree-sitter-typescript.wasm"));