pi-lens 3.8.66 → 3.8.67

package/dist/clients/dispatch/runners/lsp.js

@@ -189,7 +189,7 @@ const lspRunner = {
             .map((d, idx) => ({ d, idx }))
             .filter(({ d }) => d.severity === 1)
             .slice(0, MAX_CODE_ACTION_LOOKUPS);
-        for (const { d, idx } of blockingDiagIndexes) {
+        await Promise.all(blockingDiagIndexes.map(async ({ d, idx }) => {
             try {
                 const start = d.range.start;
                 const end = d.range.end ?? d.range.start;
@@ -202,17 +202,26 @@ const lspRunner = {
             catch {
                 // Best-effort enrichment only; base diagnostics remain authoritative.
             }
-        }
+        }));
         const diagnostics = convertLspDiagnostics(validLspDiags, diagnosticPath, { fixSuggestionByIndex });
         // convertLspDiagnostics maps validLspDiags 1:1, so re-tag any
         // auxiliary-sourced diagnostics (opengrep emits source "Semgrep", …) with
         // their tool id + semantic policy — language-server diagnostics keep "lsp".
         // blockingAllowed is per-workspace (e.g. curated repo rules), computed once.
         const blockingAllowedByProfile = new Map();
+        // Diagnostics dropped by the tool's NATIVE inline suppression (e.g. opengrep
+        // `# nosemgrep`, #441). Reuses `content` from the sync read above.
+        const suppressedIndices = new Set();
         for (let i = 0; i < diagnostics.length; i++) {
             const profile = findAuxiliaryProfileForSource(validLspDiags[i]?.source);
             if (!profile)
                 continue;
+            if (profile.isSuppressed) {
+                if (profile.isSuppressed(validLspDiags[i], content)) {
+                    suppressedIndices.add(i);
+                    continue;
+                }
+            }
             let blockingAllowed = blockingAllowedByProfile.get(profile);
             if (blockingAllowed === undefined) {
                 blockingAllowed = profile.allowBlocking?.(ctx.cwd) ?? false;
@@ -228,10 +237,13 @@ const lspRunner = {
             if (defectClass)
                 d.defectClass = defectClass;
         }
-        const hasErrors = diagnostics.some((d) => d.semantic === "blocking");
+        const keptDiagnostics = suppressedIndices.size
+            ? diagnostics.filter((_, i) => !suppressedIndices.has(i))
+            : diagnostics;
+        const hasErrors = keptDiagnostics.some((d) => d.semantic === "blocking");
         const resultSemantic = hasErrors
             ? "blocking"
-            : diagnostics.length > 0
+            : keptDiagnostics.length > 0
                 ? "warning"
                 : "none";
         return {
@@ -239,7 +251,7 @@ const lspRunner = {
             // "failed" here means the file has blocking type errors — the check ran
             // fine. Tag it so the smell analyzer doesn't read it as a runner crash.
             failureKind: hasErrors ? "blocking_diagnostics" : undefined,
-            diagnostics,
+            diagnostics: keptDiagnostics,
             semantic: resultSemantic,
         };
     },

package/dist/clients/dispatch/runners/tree-sitter.js

@@ -7,6 +7,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { RuleCache } from "../../cache/rule-cache.js";
+import { isTestFile } from "../../file-utils.js";
 import { resolvePackagePath } from "../../package-root.js";
 import { buildOrUpdateGraph, computeImpactCascade, recordEntitySnapshotDiff, } from "../../review-graph/service.js";
 import { getSharedTreeSitterClient, isTreeSitterWasmAborted, markTreeSitterWasmAborted, resolveTreeSitterLanguage, } from "../../tree-sitter-shared.js";
@@ -403,9 +404,13 @@ const treeSitterRunner = {
         // Run all queries regardless of blockingOnly — warning-tier results are logged
         // for diagnostic history but filtered from agent output by the dispatcher.
         // Only skip "review" tier queries on write (too noisy / expensive).
-        const effectiveQueries = ctx.blockingOnly
+        // Per-rule test-file carve-out (#440): rules that are noise in tests (e.g.
+        // python-assert-production — `assert` is the idiomatic test assertion) opt
+        // out via `skip_test_files` while the runner otherwise runs on test files.
+        const fileIsTest = isTestFile(filePath);
+        const effectiveQueries = (ctx.blockingOnly
             ? languageQueries.filter((q) => q.inline_tier !== "review")
-            : languageQueries;
+            : languageQueries).filter((q) => !(fileIsTest && q.skip_test_files));
         logTreeSitter({
             phase: "queries_loaded",
             filePath,

package/dist/clients/latency-logger.js

@@ -2,27 +2,23 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { isTestMode } from "./env-utils.js";
 import { getGlobalPiLensDir } from "./file-utils.js";
+import { createNdjsonLogger } from "./ndjson-logger.js";
 const LATENCY_LOG_DIR = getGlobalPiLensDir();
 const LATENCY_LOG_FILE = path.join(LATENCY_LOG_DIR, "latency.log");
-try {
-    if (!fs.existsSync(LATENCY_LOG_DIR)) {
-        fs.mkdirSync(LATENCY_LOG_DIR, { recursive: true });
-    }
-}
-catch { }
+const writer = createNdjsonLogger({ filePath: LATENCY_LOG_FILE });
 export function logLatency(entry) {
     if (isTestMode()) {
         return;
     }
-    const line = `${JSON.stringify({ ts: new Date().toISOString(), ...entry })}\n`;
-    try {
-        fs.appendFileSync(LATENCY_LOG_FILE, line);
-    }
-    catch { }
+    writer.log({ ts: new Date().toISOString(), ...entry });
 }
 export function getLatencyLogPath() {
     return LATENCY_LOG_FILE;
 }
+/** Resolve once all enqueued latency writes are on disk (tests/shutdown). */
+export function flushLatencyLog() {
+    return writer.flush();
+}
 export function readLatencyLog(limit = 100) {
     try {
         const content = fs.readFileSync(LATENCY_LOG_FILE, "utf-8");
@@ -37,8 +33,7 @@ export function readLatencyLog(limit = 100) {
     }
 }
 export function clearLatencyLog() {
-    try {
-        fs.writeFileSync(LATENCY_LOG_FILE, "");
-    }
-    catch { }
+    // Enqueue the truncate in the same serialized queue so a clear cannot race a
+    // pending drain. Await flushLatencyLog() if you need the file empty on disk.
+    writer.truncate();
 }

package/dist/clients/lsp/config.js

@@ -1,11 +1,12 @@
 /**
  * LSP Configuration for pi-lens
  *
- * Allows users to define custom LSP servers via configuration.
+ * Allows users to define custom LSP servers and override initialization options
+ * for built-in servers via configuration.
  *
- * Config file: .pi-lens/lsp.json
+ * Config file: .pi-lens/lsp.json (or .pi-lens.json, pi-lsp.json)
  *
- * Example:
+ * Example — custom server:
  * {
  *   "servers": {
  *     "my-server": {
@@ -17,6 +18,33 @@
  *     }
  *   }
  * }
+ *
+ * Example — override initializationOptions for a built-in server:
+ * {
+ *   "serverOverrides": {
+ *     "rust": {
+ *       "initializationOptions": {
+ *         "check": { "command": "clippy", "allTargets": true },
+ *         "cargo": { "features": "all", "targetDir": true }
+ *       }
+ *     },
+ *     "nix": {
+ *       "initializationOptions": {
+ *         "nixpkgs": { "expr": "import <nixpkgs> {}" },
+ *         "options": {
+ *           "home_manager": { "expr": "(builtins.getFlake (toString ./.)).homeConfigurations.me.options" }
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * The `initializationOptions` object is deep-merged onto the server's built-in
+ * defaults, so you only need to specify the keys you want to change or add.
+ * User-supplied values win on conflicts at every level of nesting.
+ *
+ * Server IDs match the `id` field of each built-in server definition in
+ * clients/lsp/server.ts (e.g. "rust", "nix", "bash", "python", "go", "ts").
  */
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -73,6 +101,7 @@ export function createCustomServer(config, id) {
 const EMPTY_CONFIG = {
     customServers: [],
     disabledServerIds: new Set(),
+    serverOverrides: new Map(),
 };
 const workspaceConfigs = new Map();
 /** In-flight config initialization promises to prevent duplicate concurrent loads */
@@ -121,9 +150,26 @@ export async function initLSPConfig(cwd) {
                 }
             }
         }
+        const serverOverrides = new Map();
+        if (config.serverOverrides) {
+            for (const [id, entry] of Object.entries(config.serverOverrides)) {
+                if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+                    const initOpts = entry.initializationOptions;
+                    if (initOpts !== undefined &&
+                        typeof initOpts === "object" &&
+                        initOpts !== null &&
+                        !Array.isArray(initOpts)) {
+                        serverOverrides.set(id, {
+                            initializationOptions: initOpts,
+                        });
+                    }
+                }
+            }
+        }
         workspaceConfigs.set(normalizedCwd, {
             customServers,
             disabledServerIds,
+            serverOverrides,
         });
     })();
     configInFlight.set(normalizedCwd, promise);
@@ -158,6 +204,18 @@ export function getServersForFileWithConfig(filePath) {
         return extensions.includes(ext) || extensions.includes(base);
     });
 }
+/**
+ * Look up an initializationOptions override for a built-in server.
+ * Returns undefined when no config was loaded or no override was specified
+ * for this server ID.
+ *
+ * @param serverId  Built-in server id (e.g. "rust", "nix", "bash")
+ * @param filePath  Any file path within the project (used to locate the
+ *                  workspace config that was loaded for this directory tree)
+ */
+export function getServerInitOverride(serverId, filePath) {
+    return getConfigForFile(filePath).serverOverrides.get(serverId);
+}
 export function resetLSPConfigStateForTests() {
     workspaceConfigs.clear();
 }

package/dist/clients/lsp/index.js

@@ -18,12 +18,48 @@ import { logLatency } from "../latency-logger.js";
 import { withDeadline } from "../deadline-utils.js";
 import { normalizeMapKey, uriToPath } from "../path-utils.js";
 import { createLSPClient } from "./client.js";
-import { getServersForFileWithConfig } from "./config.js";
+import { getServersForFileWithConfig, getServerInitOverride } from "./config.js";
 import { getLanguageId } from "./language.js";
 import { LSP_SERVERS, isDirectLspCommandTemporarilyUnavailable, } from "./server.js";
 import { getStrategy } from "./server-strategies.js";
 import { raceToCompletion } from "./aggregation.js";
 import { applyWorkspaceEdit, mergeWorkspaceTextEditsByPriority, summarizeWorkspaceEdit, } from "./edits.js";
+// --- Init override helpers ---
+/**
+ * Recursively merges `override` onto `base`. Override wins on leaf conflicts
+ * at every nesting level; arrays and non-plain-object values are replaced, not
+ * merged (consistent with standard LSP settings merge semantics).
+ */
+function deepMergeObjects(base, override) {
+    const result = { ...base };
+    for (const [key, val] of Object.entries(override)) {
+        if (val !== null &&
+            typeof val === "object" &&
+            !Array.isArray(val) &&
+            result[key] !== null &&
+            typeof result[key] === "object" &&
+            !Array.isArray(result[key])) {
+            result[key] = deepMergeObjects(result[key], val);
+        }
+        else {
+            result[key] = val;
+        }
+    }
+    return result;
+}
+/**
+ * Merges user-supplied initializationOptions onto a server's built-in defaults.
+ * - If neither side is defined → undefined (no options sent).
+ * - If only one side is defined → that side is returned directly.
+ * - Both defined → deep merge, user wins on conflicts.
+ */
+export function mergeInitializationOptions(base, override) {
+    if (!override)
+        return base;
+    if (!base)
+        return override;
+    return deepMergeObjects(base, override);
+}
 const BROKEN_BASE_COOLDOWN_MS = 15_000;
 const BROKEN_MAX_COOLDOWN_MS = 5 * 60_000; // cap at 5 minutes
 const BROKEN_PERMANENT_AFTER = 5; // disable for session after N consecutive failures
@@ -567,11 +603,13 @@ export class LSPService {
                 }
                 return undefined;
             }
+            const override = getServerInitOverride(server.id, filePath);
+            const mergedInit = mergeInitializationOptions(spawned.initialization, override?.initializationOptions);
             const client = await createLSPClient({
                 serverId: server.id,
                 process: spawned.process,
                 root,
-                initialization: spawned.initialization,
+                initialization: mergedInit,
                 initializeTimeoutMs: server.initializeTimeoutMs,
             });
             const wsDiag = typeof client.getWorkspaceDiagnosticsSupport === "function"
@@ -1386,7 +1424,9 @@ export class LSPService {
             options.maxFiles > 0
             ? Math.floor(options.maxFiles)
             : getMaxWorkspaceDiagnosticFiles();
-        const files = await collectWorkspaceDiagnosticFiles(root, maxFiles, signal);
+        const files = options.files
+            ? options.files.slice(0, maxFiles)
+            : await collectWorkspaceDiagnosticFiles(root, maxFiles, signal);
         // Per-file wall-clock: a language server that hangs during spawn/initialize
         // would otherwise park a worker on `touchFile` FOREVER (the per-edit
         // diagnostic wait is bounded, but client acquisition here is not) — the root

package/dist/clients/ndjson-logger.js

@@ -0,0 +1,150 @@
+/**
+ * Shared write-plumbing for the hand-rolled NDJSON debug loggers in clients/.
+ *
+ * One buffered async writer replaces eight drifting copies of append+rotate.
+ * `log()`/`append()` are synchronous-call, async-write: they enqueue a
+ * serialized line and a single in-flight `fs.promises.appendFile` drains the
+ * queue — no `appendFileSync` on the per-edit hot path (latency-logger alone
+ * fired ~10–20 sync appends per edit, #454/#361/#368).
+ *
+ * Errors are swallowed best-effort, matching every current logger. A
+ * best-effort SYNC flush is registered on `process.on("exit")` (appendFileSync
+ * is fine at exit — not the hot path; no child spawning, #234).
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+function resolve(v) {
+    return typeof v === "function" ? v() : v;
+}
+// One shared exit handler flushes every logger — avoids an EventEmitter
+// MaxListeners warning once more than ~10 loggers exist (we ship eight, plus
+// diagnostic + test instances). No child spawning at teardown (#234).
+const exitFlushers = new Set();
+let exitHandlerRegistered = false;
+/** Test-only view of the registered exit flushers (see ndjson-logger.test.ts). */
+export function _exitFlushersForTest() {
+    return exitFlushers;
+}
+function registerExitFlusher(flushSync) {
+    exitFlushers.add(flushSync);
+    if (!exitHandlerRegistered) {
+        exitHandlerRegistered = true;
+        process.on("exit", () => {
+            for (const flush of exitFlushers) {
+                try {
+                    flush();
+                }
+                catch { }
+            }
+        });
+    }
+}
+export function createNdjsonLogger(options) {
+    const queue = [];
+    let drainPromise = null;
+    let ensuredDir = false;
+    function ensureDir(file) {
+        if (ensuredDir)
+            return;
+        try {
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            ensuredDir = true;
+        }
+        catch { }
+    }
+    function rotateIfNeeded(file) {
+        if (options.maxBytes === undefined)
+            return;
+        try {
+            const size = fs.statSync(file).size;
+            if (size < options.maxBytes)
+                return;
+            const backup = options.backupPath
+                ? resolve(options.backupPath)
+                : `${file}.1`;
+            try {
+                fs.rmSync(backup, { force: true });
+            }
+            catch { }
+            fs.renameSync(file, backup);
+        }
+        catch {
+            // no file yet, or rename raced — nothing to rotate
+        }
+    }
+    async function drainLoop() {
+        // Peek, write, then remove — an item stays in the queue until it is on
+        // disk, so a teardown flushSync (which abandons this async loop) never
+        // drops an item this loop had already dequeued but not yet written.
+        while (queue.length > 0) {
+            const item = queue[0];
+            const file = resolve(options.filePath);
+            ensureDir(file);
+            try {
+                if (item.kind === "truncate") {
+                    await fs.promises.writeFile(file, "");
+                }
+                else {
+                    rotateIfNeeded(file);
+                    await fs.promises.appendFile(file, item.line);
+                }
+            }
+            catch {
+                // telemetry is best-effort
+            }
+            queue.shift();
+        }
+    }
+    function drain() {
+        // Serialize: a single in-flight drain owns the queue. flush() awaits this
+        // same promise, so it never resolves before pending writes land. The loop
+        // re-checks queue.length, so items enqueued mid-drain are picked up before
+        // the promise settles — no stranded item, no second concurrent drainer.
+        if (!drainPromise) {
+            drainPromise = drainLoop().finally(() => {
+                drainPromise = null;
+            });
+        }
+        return drainPromise;
+    }
+    function enqueue(item) {
+        queue.push(item);
+        void drain();
+    }
+    function flushSync() {
+        // Drain the in-memory queue synchronously — safe at process exit.
+        while (queue.length > 0) {
+            const item = queue.shift();
+            const file = resolve(options.filePath);
+            ensureDir(file);
+            try {
+                if (item.kind === "truncate") {
+                    fs.writeFileSync(file, "");
+                }
+                else {
+                    rotateIfNeeded(file);
+                    fs.appendFileSync(file, item.line);
+                }
+            }
+            catch { }
+        }
+    }
+    // Best-effort teardown flush of anything still buffered, via the single
+    // shared exit handler. appendFileSync is fine here — not the hot path.
+    registerExitFlusher(flushSync);
+    return {
+        log(obj) {
+            enqueue({ kind: "line", line: `${JSON.stringify(obj)}\n` });
+        },
+        append(line) {
+            enqueue({ kind: "line", line: `${line}\n` });
+        },
+        truncate() {
+            enqueue({ kind: "truncate" });
+        },
+        async flush() {
+            await drain();
+        },
+        flushSync,
+    };
+}

package/dist/clients/pipeline.js

@@ -169,8 +169,12 @@ function createPhaseTracker(toolName, filePath) {
 export { hasEslintConfig, hasRubocopConfig, hasSqlfluffConfig, hasStylelintConfig, };
 const _eslintCache = new Map();
 /**
- * Run eslint --fix on a file. Returns number of fixable issues resolved,
- * or 0 if ESLint is not configured / not available.
+ * Run eslint --fix on a file. Runs a single spawn and diffs the file before/after,
+ * same idiom as the other autofix helpers below. Exit code 1 (unfixable problems
+ * remain) is allowed because fixes may still have been applied; only exit code 2
+ * (config/fatal error) is treated as failure.
+ * Returns 1 if the file changed, 0 if ESLint is not configured / not available /
+ * made no changes.
  */
 async function tryEslintFix(filePath, cwd) {
     const userHasConfig = hasEslintConfig(cwd);
@@ -193,40 +197,7 @@ async function tryEslintFix(filePath, cwd) {
     if (!cached.available || !cached.bin)
         return 0;
     const cmd = cached.bin;
-    const configArgs = [];
-    // --fix-dry-run returns JSON with fixable counts without writing to disk.
-    // Use it to get the real count, then apply with --fix only if needed.
-    const dry = await safeSpawnAsync(cmd, [
-        "--fix-dry-run",
-        "--format",
-        "json",
-        "--no-error-on-unmatched-pattern",
-        ...configArgs,
-        filePath,
-    ], { timeout: 30000, cwd });
-    if (dry.status === 2)
-        return 0;
-    let fixableCount = 0;
-    let anyDryRunOutput = false;
-    try {
-        const results = JSON.parse(dry.stdout);
-        fixableCount = results.reduce((sum, r) => sum + (r.fixableErrorCount ?? 0) + (r.fixableWarningCount ?? 0), 0);
-        // `--fix-dry-run` reports the POST-fix state: when every problem is
-        // auto-fixable, `messages`/`fixableErrorCount` are 0 and the fixed source
-        // lands in the `output` field instead. Keying on `fixableErrorCount` alone
-        // therefore misses the common "all fixable" case and never applies fixes.
-        anyDryRunOutput = results.some((r) => typeof r.output === "string");
-    }
-    catch {
-        /* treat as zero fixable on error */
-    }
-    if (fixableCount === 0 && !anyDryRunOutput)
-        return 0;
-    // Apply the fixes
-    const fix = await safeSpawnAsync(cmd, ["--fix", "--no-error-on-unmatched-pattern", ...configArgs, filePath], { timeout: 30000, cwd });
-    if (fix.status === 2)
-        return 0;
-    return fixableCount > 0 ? fixableCount : anyDryRunOutput ? 1 : 0;
+    return detectFileChangedAfterCommand(filePath, cmd, ["--fix", "--no-error-on-unmatched-pattern", filePath], cwd, [1]);
 }
 async function tryStylelintFix(filePath, cwd) {
     const cmd = await resolveToolCommandWithInstallFallback(cwd, "stylelint");
@@ -926,15 +897,28 @@ export async function runPipeline(ctx, deps) {
         diagnosticCount: dispatchResult.diagnostics.length,
     });
     // --- 6. Cascade diagnostics (LSP only) ---
-    // Deferred: cascade errors in OTHER files are NOT shown inline — surfaced at
-    // turn_end so mid-refactor intermediate errors don't derail the agent.
-    const cascadeRun = getFlag("no-lsp")
+    // Kicked off UNAWAITED so the graph rebuild + neighbor LSP pulls run
+    // concurrently after the edit returns rather than blocking it (#450). The
+    // result is never shown inline — settled (bounded) and surfaced at turn_end.
+    // The stored promise must never reject: an unhandled rejection is fatal, so a
+    // failing compute resolves to an "error" skip-run instead.
+    const cascadePromise = getFlag("no-lsp")
         ? undefined
-        : await computeCascadeForFile(filePath, cwd, {
+        : computeCascadeForFile(filePath, cwd, {
             hasBlockers,
             dbg,
             turnSeq: ctx.telemetry?.turnIndex,
             writeSeq: ctx.telemetry?.writeIndex,
+            seqState: ctx.seqState,
+        }).catch((err) => {
+            dbg(`cascade compute failed for ${filePath}: ${err}`);
+            return {
+                filePath,
+                result: undefined,
+                neighborCount: 0,
+                diagnosticCount: 0,
+                skipReason: "error",
+            };
         });
     // --- Final timing + all-clear ---
     const elapsed = Date.now() - pipelineStart;
@@ -965,7 +949,7 @@ export async function runPipeline(ctx, deps) {
     return {
         output,
         hasBlockers,
-        cascadeRun,
+        cascadePromise,
         isError: false,
         fileModified,
         changedFiles,

package/dist/clients/project-diagnostics/scanner.js

@@ -197,7 +197,9 @@ export async function scanProjectDiagnostics(options) {
     const cwd = path.resolve(options.cwd);
     const { signal } = options;
     const maxFiles = Math.max(1, options.maxFiles ?? DEFAULT_MAX_FILES);
-    const files = await collectSourceFilesAsync(cwd, { maxFiles });
+    const files = options.files
+        ? options.files.slice(0, maxFiles)
+        : await collectSourceFilesAsync(cwd, { maxFiles });
     // Check cancellation at each phase boundary so a full-mode scan stops
     // promptly when the agent/user aborts (#341). The per-phase runners are
     // already file-capped, so phase granularity is enough to bound the work.
@@ -226,7 +228,11 @@ export async function scanProjectDiagnostics(options) {
     };
     // A cancelled scan yields a partial snapshot; don't persist it as the
     // authoritative cross-session cache — only a complete run is cacheable.
-    if (signal?.aborted)
+    // Likewise, an explicit `files` scan (#461) only covers a caller-chosen
+    // subset (e.g. git-staged files), not the whole project — persisting it
+    // would poison the cross-session cache with a partial view that a later
+    // unscoped `refreshRunners=cached` read would wrongly trust as complete.
+    if (signal?.aborted || options.files)
         return snapshot;
     saveProjectDiagnosticsSnapshot(cwd, snapshot);
     return snapshot;

package/dist/clients/read-guard-logger.js

@@ -1,25 +1,22 @@
-import * as fs from "node:fs";
 import * as path from "node:path";
 import { isTestMode } from "./env-utils.js";
 import { getGlobalPiLensDir } from "./file-utils.js";
+import { createNdjsonLogger } from "./ndjson-logger.js";
 const READ_GUARD_LOG_DIR = getGlobalPiLensDir();
 const READ_GUARD_LOG_FILE = path.join(READ_GUARD_LOG_DIR, "read-guard.log");
 const READ_GUARD_LOG_BACKUP_FILE = path.join(READ_GUARD_LOG_DIR, "read-guard.log.1");
 const MAX_LOG_BYTES = Math.max(128 * 1024, Number.parseInt(process.env.PI_LENS_READ_GUARD_MAX_BYTES ?? "1048576", 10) ||
     1048576);
+const writer = createNdjsonLogger({
+    filePath: READ_GUARD_LOG_FILE,
+    maxBytes: MAX_LOG_BYTES,
+    backupPath: READ_GUARD_LOG_BACKUP_FILE,
+});
 const VERBOSE_READ_GUARD_LOG = process.env.PI_LENS_READ_GUARD_VERBOSE === "1" ||
     process.env.PI_LENS_READ_GUARD_LOG === "verbose";
 const LOG_ALLOWED_EDITS = process.env.PI_LENS_READ_GUARD_LOG_ALLOWS === "1";
 const SNAPSHOT_LOG_SETTING = (process.env.PI_LENS_READ_GUARD_LOG_SNAPSHOTS ?? "1").toLowerCase();
 const LOG_SNAPSHOT_VALIDATION = !["0", "false", "off"].includes(SNAPSHOT_LOG_SETTING);
-try {
-    if (!fs.existsSync(READ_GUARD_LOG_DIR)) {
-        fs.mkdirSync(READ_GUARD_LOG_DIR, { recursive: true });
-    }
-}
-catch (err) {
-    void err;
-}
 function shouldLogEvent(event) {
     if (VERBOSE_READ_GUARD_LOG)
         return true;
@@ -40,38 +37,16 @@ function shouldLogEvent(event) {
         event === "edit_partial_apply" ||
         event === "touched_lines_missing");
 }
-function rotateIfNeeded() {
-    try {
-        if (!fs.existsSync(READ_GUARD_LOG_FILE))
-            return;
-        const size = fs.statSync(READ_GUARD_LOG_FILE).size;
-        if (size < MAX_LOG_BYTES)
-            return;
-        try {
-            fs.rmSync(READ_GUARD_LOG_BACKUP_FILE, { force: true });
-        }
-        catch (err) {
-            void err;
-        }
-        fs.renameSync(READ_GUARD_LOG_FILE, READ_GUARD_LOG_BACKUP_FILE);
-    }
-    catch (err) {
-        void err;
-    }
-}
 export function logReadGuardEvent(entry) {
     if (isTestMode() || !shouldLogEvent(entry.event)) {
         return;
     }
-    const line = `${JSON.stringify({ ts: new Date().toISOString(), ...entry })}\n`;
-    try {
-        rotateIfNeeded();
-        fs.appendFileSync(READ_GUARD_LOG_FILE, line);
-    }
-    catch (err) {
-        void err;
-    }
+    writer.log({ ts: new Date().toISOString(), ...entry });
 }
 export function getReadGuardLogPath() {
     return READ_GUARD_LOG_FILE;
 }
+/** Resolve once all enqueued read-guard writes are on disk (tests/shutdown). */
+export function flushReadGuardLog() {
+    return writer.flush();
+}