mixdog 0.7.1

package/src/agent/orchestrator/tools/builtin/shell-output.mjs

@@ -0,0 +1,36 @@
+import { countSplitLines } from './path-utils.mjs';
+
+export const SHELL_OUTPUT_MAX_CHARS = 30_000;
+
+export const SMART_BASH_MAX_LINES = 400;
+export const SMART_BASH_MAX_BYTES = 30_000;
+export const SMART_BASH_HEAD_LINES = 80;
+export const SMART_BASH_TAIL_LINES = 80;
+
+export function smartMiddleTruncate(content) {
+    const s = typeof content === 'string' ? content : String(content ?? '');
+    if (s.length <= SMART_BASH_MAX_BYTES) {
+        const fastLines = s.split('\n');
+        if (fastLines.length <= SMART_BASH_MAX_LINES) return s;
+        const head = fastLines.slice(0, SMART_BASH_HEAD_LINES).join('\n');
+        const tail = fastLines.slice(-SMART_BASH_TAIL_LINES).join('\n');
+        const middle = fastLines.length - SMART_BASH_HEAD_LINES - SMART_BASH_TAIL_LINES;
+        return `${head}\n\n... [TRUNCATED — ${middle} lines middle elided; total ${fastLines.length} lines. Rerun with tighter filters for more] ...\n\n${tail}`;
+    }
+    const lines = s.split('\n');
+    if (lines.length <= SMART_BASH_MAX_LINES) {
+        const head = s.slice(0, SMART_BASH_MAX_BYTES);
+        return `${head}\n\n... [TRUNCATED — output exceeded ${Math.round(SMART_BASH_MAX_BYTES / 1024)} KB on a single line] ...`;
+    }
+    const head = lines.slice(0, SMART_BASH_HEAD_LINES).join('\n');
+    const tail = lines.slice(-SMART_BASH_TAIL_LINES).join('\n');
+    const middle = lines.length - SMART_BASH_HEAD_LINES - SMART_BASH_TAIL_LINES;
+    const totalKb = Math.round(s.length / 1024);
+    return `${head}\n\n... [TRUNCATED — ${middle} lines middle elided; total ${lines.length} lines / ${totalKb} KB. Rerun with tighter filters for more] ...\n\n${tail}`;
+}
+
+export function capShellOutput(content) {
+    const s = typeof content === 'string' ? content : String(content ?? '');
+    if (s.length <= SHELL_OUTPUT_MAX_CHARS && countSplitLines(s) <= SMART_BASH_MAX_LINES) return s;
+    return smartMiddleTruncate(s);
+}

package/src/agent/orchestrator/tools/builtin/shell-runtime.mjs

@@ -0,0 +1,214 @@
+import { spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import { basename, dirname, join } from 'path';
+
+let _resolvedShell = null;
+// Per-kind cache for resolveShellFor(). 'default' aliases resolveShell()'s
+// singleton; 'bash'/'powershell' get their own memoized slots. ONLY a
+// successful (non-null) resolution is cached — a resolution MISS is
+// deliberately not memoized so the next call re-probes (Git Bash / pwsh may
+// be installed mid-session, and PATH can change for a long-lived host).
+const _resolvedShellByKind = new Map();
+
+function shellTypeFor(shell) {
+    const stem = basename(String(shell || '')).toLowerCase().replace(/\.exe$/, '');
+    if (stem === 'pwsh' || stem === 'powershell') return 'powershell';
+    if (stem === 'bash' || stem === 'zsh' || stem === 'sh') return 'posix';
+    return process.platform === 'win32' ? 'powershell' : 'posix';
+}
+
+function shellSpec(shell, shellType = shellTypeFor(shell)) {
+    if (shellType === 'powershell') {
+        return {
+            shell,
+            shellArg: '-Command',
+            shellArgs: ['-NoLogo', '-NoProfile', '-NonInteractive', '-WindowStyle', 'Hidden', '-Command'],
+            shellType,
+        };
+    }
+    return { shell, shellArg: '-c', shellArgs: ['-c'], shellType };
+}
+
+function firstExistingPathFromWhere(commandName) {
+    try {
+        const r = spawnSync('cmd.exe', ['/d', '/s', '/c', `where ${commandName}`], {
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+            timeout: 1000,
+        });
+        if (r.status !== 0 || !r.stdout) return null;
+        const lines = r.stdout.toString('utf8').split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+        return lines.find(p => existsSync(p)) || null;
+    } catch {
+        return null;
+    }
+}
+
+function resolveWindowsPowerShell() {
+    const pwsh = firstExistingPathFromWhere('pwsh.exe');
+    if (pwsh) return shellSpec(pwsh, 'powershell');
+
+    const systemRoot = process.env.SystemRoot || process.env.WINDIR || 'C:\\Windows';
+    const bundled = join(systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+    if (existsSync(bundled)) return shellSpec(bundled, 'powershell');
+
+    const powershell = firstExistingPathFromWhere('powershell.exe');
+    if (powershell) return shellSpec(powershell, 'powershell');
+
+    return shellSpec('powershell.exe', 'powershell');
+}
+
+export function resolveShell() {
+    if (_resolvedShell) return _resolvedShell;
+    const isWindows = process.platform === 'win32'
+        || !!(process.env.WINDIR || process.env.SystemRoot);
+    if (!isWindows) {
+        _resolvedShell = shellSpec('/bin/sh', 'posix');
+        return _resolvedShell;
+    }
+    const explicit = process.env.CLAUDE_CODE_SHELL;
+    if (explicit && shellTypeFor(explicit) === 'powershell') {
+        _resolvedShell = shellSpec(explicit);
+        return _resolvedShell;
+    }
+    _resolvedShell = resolveWindowsPowerShell();
+    return _resolvedShell;
+}
+
+function _isWindows() {
+    return process.platform === 'win32' || !!(process.env.WINDIR || process.env.SystemRoot);
+}
+
+// Resolve Git Bash on Windows. Strategy (invariant-based, no silent fallback):
+//  1. Iterate ALL `where git.exe` hits — a shim (Scoop/Chocolatey/winget under
+//     a \shims\ dir) or a second install can be the FIRST match yet not a real
+//     Git-for-Windows layout with a sibling bash.exe. For each, walk a few
+//     ancestor levels of <gitDir> and probe the two known launcher shapes
+//     (<root>\bin\bash.exe, <root>\usr\bin\bash.exe). This tolerates git.exe
+//     living under cmd\, bin\, or mingw64\bin\ without a fixed sibling distance.
+//  2. `where bash.exe` EXCLUDING any hit under System32 — that path is the WSL
+//     `bash.exe` launcher, which is the wrong target (launches a Linux distro,
+//     not Git-for-Windows bash).
+// Returns a posix shellSpec, or null when Git Bash is genuinely not installed.
+function resolveWindowsGitBash() {
+    for (const git of allExistingPathsFromWhere('git.exe')) {
+        const bash = probeGitBashFromGitExe(git);
+        if (bash) return shellSpec(bash, 'posix');
+    }
+    // Fallback: a bare `bash.exe` on PATH, but never the System32 WSL launcher.
+    const bash = firstExistingPathFromWhereExcluding('bash.exe', /\\system32\\/i);
+    if (bash) return shellSpec(bash, 'posix');
+    // Final fallback: probe well-known Git-for-Windows install roots on the
+    // filesystem directly. PATH-independent and spawn-free, so it still resolves
+    // when a long-lived server process inherited an env without Git\cmd, or when
+    // the `where` probe times out (both observed in practice). Windows-only:
+    // this function is reached solely via the _isWindows() branch in
+    // resolveShellFor, so the hardcoded Windows paths never run on other OSes.
+    const direct = gitBashFromKnownWindowsRoots();
+    if (direct) return shellSpec(direct, 'posix');
+    return null;
+}
+
+// Probe standard Git-for-Windows install roots via the filesystem only.
+// Env-var roots first (machine ProgramFiles + per-user LOCALAPPDATA installs),
+// then fixed Program Files fallbacks for the rare case those vars are empty.
+function gitBashFromKnownWindowsRoots() {
+    const env = process.env;
+    const roots = [];
+    for (const base of [env.ProgramW6432, env.ProgramFiles, env['ProgramFiles(x86)']]) {
+        if (base) roots.push(join(base, 'Git'));
+    }
+    if (env.LOCALAPPDATA) roots.push(join(env.LOCALAPPDATA, 'Programs', 'Git'));
+    roots.push('C:\\Program Files\\Git', 'C:\\Program Files (x86)\\Git');
+    for (const root of roots) {
+        for (const rel of [['bin', 'bash.exe'], ['usr', 'bin', 'bash.exe']]) {
+            const cand = join(root, ...rel);
+            if (existsSync(cand)) return cand;
+        }
+    }
+    return null;
+}
+
+// Walk up to 3 ancestor levels from <gitExe>'s directory, probing each
+// candidate install root for bin\bash.exe then usr\bin\bash.exe. Covers
+// git.exe under <root>\cmd\, <root>\bin\, and <root>\mingw64\bin\.
+function probeGitBashFromGitExe(gitExe) {
+    let dir = dirname(gitExe);
+    for (let level = 0; level < 3 && dir; level++) {
+        for (const rel of [['bin', 'bash.exe'], ['usr', 'bin', 'bash.exe']]) {
+            const cand = join(dir, ...rel);
+            if (existsSync(cand)) return cand;
+        }
+        const parent = dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    return null;
+}
+
+function allExistingPathsFromWhere(commandName) {
+    try {
+        const r = spawnSync('cmd.exe', ['/d', '/s', '/c', `where ${commandName}`], {
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+            timeout: 1000,
+        });
+        if (r.status !== 0 || !r.stdout) return [];
+        return r.stdout.toString('utf8').split(/\r?\n/).map(s => s.trim())
+            .filter(Boolean).filter(p => existsSync(p));
+    } catch {
+        return [];
+    }
+}
+
+function firstExistingPathFromWhereExcluding(commandName, excludeRe) {
+    try {
+        const r = spawnSync('cmd.exe', ['/d', '/s', '/c', `where ${commandName}`], {
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+            timeout: 1000,
+        });
+        if (r.status !== 0 || !r.stdout) return null;
+        const lines = r.stdout.toString('utf8').split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+        return lines.find(p => existsSync(p) && !excludeRe.test(p)) || null;
+    } catch {
+        return null;
+    }
+}
+
+// Kind-aware shell resolution. kind:
+//  'default'    → identical to resolveShell() (PowerShell on Windows, /bin/sh elsewhere).
+//  'bash'       → on Windows, Git Bash (or null if not installed); elsewhere /bin/sh (POSIX is already bash-compatible).
+//  'powershell' → on Windows, resolveShell(); elsewhere pwsh if present, else null.
+// Each kind is memoized independently, but ONLY on success: a resolution miss
+// (null) is not cached, so the caller's clear-error path is re-probed on the
+// next call rather than pinned for the life of the process.
+export function resolveShellFor(kind = 'default') {
+    if (kind == null || kind === 'default') return resolveShell();
+    if (_resolvedShellByKind.has(kind)) return _resolvedShellByKind.get(kind);
+
+    let spec = null;
+    if (kind === 'bash') {
+        spec = _isWindows() ? resolveWindowsGitBash() : shellSpec('/bin/sh', 'posix');
+    } else if (kind === 'powershell') {
+        if (_isWindows()) {
+            spec = resolveShell();
+        } else {
+            const pwsh = (() => {
+                try {
+                    const r = spawnSync('which', ['pwsh'], { stdio: ['ignore', 'pipe', 'ignore'], timeout: 1000 });
+                    if (r.status !== 0 || !r.stdout) return null;
+                    const p = r.stdout.toString('utf8').split(/\r?\n/).map(s => s.trim()).find(Boolean);
+                    return p && existsSync(p) ? p : null;
+                } catch { return null; }
+            })();
+            spec = pwsh ? shellSpec(pwsh, 'powershell') : null;
+        }
+    } else {
+        spec = resolveShell();
+    }
+
+    // Cache positively only — see the _resolvedShellByKind / doc comments above.
+    if (spec) _resolvedShellByKind.set(kind, spec);
+    return spec;
+}

package/src/agent/orchestrator/tools/builtin/snapshot-helpers.mjs

@@ -0,0 +1,143 @@
+import { hashText } from './hash-utils.mjs';
+
+/** Mirrors read-single-tool.mjs detectReadEncoding (BOM-only, no sniffing). */
+export function detectReadEncodingFromBuffer(buf) {
+    if (!Buffer.isBuffer(buf) || buf.length < 2) {
+        return { encoding: 'utf8', bomLen: 0 };
+    }
+    if (buf[0] === 0xff && buf[1] === 0xfe) {
+        return { encoding: 'utf16le', bomLen: 2 };
+    }
+    if (buf[0] === 0xfe && buf[1] === 0xff) {
+        return { encoding: 'utf16be', bomLen: 2 };
+    }
+    if (buf.length >= 3 && buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf) {
+        return { encoding: 'utf8', bomLen: 3 };
+    }
+    return { encoding: 'utf8', bomLen: 0 };
+}
+
+/** Decode on-disk bytes the same way as a full read (for snapshot hash / stale checks). */
+export function decodeRawBufferForSnapshotCheck(rawBuf) {
+    const enc = detectReadEncodingFromBuffer(rawBuf);
+    // Strip the BOM for BOTH encodings (bomLen is 0 when absent, so non-BOM
+    // utf8 is unchanged). The read path hashes BOM-stripped content; a utf8 BOM
+    // left in here produced a hash mismatch and false "modified since read".
+    if (enc.encoding === 'utf16le') {
+        return rawBuf.subarray(enc.bomLen).toString('utf16le');
+    }
+    if (enc.encoding === 'utf16be') {
+        // No Node 'utf16be' encoding: swap pairs to LE (even length) then decode.
+        const body = rawBuf.subarray(enc.bomLen);
+        const even = body.length & ~1;
+        return Buffer.from(body.subarray(0, even)).swap16().toString('utf16le');
+    }
+    return rawBuf.subarray(enc.bomLen).toString('utf-8');
+}
+
+export function rangeHashesForReadRanges(content, ranges) {
+    const rows = Array.isArray(ranges) ? ranges : [];
+    if (rows.length === 0) return [];
+    // Split CRLF-insensitively: streaming reads strip a trailing \r per
+    // line before hashing (read-streaming.mjs), so the regular path and
+    // snapshot validation must normalise \r the same way or CRLF files
+    // produce mismatched rangeHashes (false "modified since read").
+    const lines = String(content ?? '').split(/\r?\n/);
+    const out = [];
+    for (const range of rows) {
+        if (!range) continue;
+        const startLine = Math.max(1, Number(range.startLine));
+        const endLine = range.endLine === Infinity ? Infinity : Number(range.endLine);
+        if (!Number.isFinite(startLine) || (!Number.isFinite(endLine) && endLine !== Infinity)) continue;
+        if (endLine !== Infinity && endLine < startLine) continue;
+        const startIdx = startLine - 1;
+        const endIdx = endLine === Infinity ? lines.length : Math.min(lines.length, endLine);
+        out.push({ startLine, endLine, hash: hashText(lines.slice(startIdx, endIdx).join('\n')) });
+    }
+    return out;
+}
+
+export function rangeHashesFromRenderedReadText(rendered, ranges) {
+    const rows = Array.isArray(ranges) ? ranges : [];
+    if (rows.length === 0) return [];
+    const byLine = new Map();
+    for (const line of String(rendered ?? '').split('\n')) {
+        const m = /^(\d+)[\t│→]/.exec(line);
+        if (!m) continue;
+        byLine.set(Number(m[1]), line.slice(m[0].length));
+    }
+    const out = [];
+    for (const range of rows) {
+        if (!range) continue;
+        const startLine = Math.max(1, Number(range.startLine));
+        const endLine = range.endLine === Infinity ? Infinity : Number(range.endLine);
+        if (!Number.isFinite(startLine) || !Number.isFinite(endLine) || endLine < startLine) continue;
+        const lines = [];
+        let complete = true;
+        for (let lineNo = startLine; lineNo <= endLine; lineNo++) {
+            if (!byLine.has(lineNo)) { complete = false; break; }
+            lines.push(byLine.get(lineNo));
+        }
+        if (complete) out.push({ startLine, endLine, hash: hashText(lines.join('\n')) });
+    }
+    return out;
+}
+
+export function statMatchesSnapshot(stat, snapshot) {
+    if (!stat || !snapshot) return false;
+    if (typeof snapshot.size !== 'number' || stat.size !== snapshot.size) return false;
+    if (!Number.isFinite(snapshot.mtimeMs) || Math.abs(stat.mtimeMs - snapshot.mtimeMs) > 1) {
+        return false;
+    }
+    if (Number.isFinite(snapshot.ctimeMs)) {
+        if (!Number.isFinite(stat.ctimeMs) || Math.abs(stat.ctimeMs - snapshot.ctimeMs) > 1) {
+            return false;
+        }
+    }
+    return true;
+}
+
+export function normaliseRangeHashEntry(row) {
+    if (!row || typeof row.hash !== 'string' || !row.hash) return null;
+    const startLine = Math.max(1, Number(row.startLine));
+    const endLine = row.endLine === Infinity ? Infinity : Number(row.endLine);
+    if (!Number.isFinite(startLine) || (!Number.isFinite(endLine) && endLine !== Infinity)) return null;
+    if (endLine !== Infinity && endLine < startLine) return null;
+    return { startLine, endLine, hash: row.hash };
+}
+
+export function snapshotCoversFullFile(snapshot) {
+    if (!snapshot || !Array.isArray(snapshot.ranges)) return false;
+    return snapshot.ranges.some((r) => r.startLine <= 1 && r.endLine === Infinity);
+}
+
+/** Logical line count captured at read-time (wc-l compatible). Undefined if absent. */
+export function snapshotFileLineCount(snapshot) {
+    const n = snapshot?.fileLineCount;
+    return Number.isFinite(n) && n >= 0 ? Math.trunc(n) : undefined;
+}
+
+// Finite full-coverage check. A single full-file read records the
+// {1, Infinity} sentinel (snapshotCoversFullFile), but a large file is
+// output-capped so isFullFileView never fires and only finite ranges are
+// recorded. Paging through the whole file then yields contiguous finite
+// ranges that still cover every line — recognise that as full coverage so
+// overwrite isn't permanently blocked. Caller passes the file's current
+// line count; invariant: covered iff merged ranges span [1, lineCount].
+export function snapshotRangesCoverAllLines(snapshot, lineCount) {
+    if (!snapshot || !Array.isArray(snapshot.ranges) || snapshot.ranges.length === 0) return false;
+    if (!(lineCount > 0)) return true;
+    const ranges = snapshot.ranges
+        .map((r) => ({
+            s: Math.max(1, Number(r.startLine) || 1),
+            e: r.endLine === Infinity ? lineCount : Math.min(lineCount, Number(r.endLine) || 0),
+        }))
+        .filter((r) => r.e >= r.s)
+        .sort((a, b) => a.s - b.s);
+    let covered = 0;
+    for (const r of ranges) {
+        if (r.s > covered + 1) break;
+        if (r.e > covered) covered = r.e;
+    }
+    return covered >= lineCount;
+}

package/src/agent/orchestrator/tools/builtin/snapshot-store.mjs

@@ -0,0 +1,206 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { writeJsonAtomicSync } from '../../../../shared/atomic-file.mjs';
+
+// Mixdog read/write/edit share a scoped snapshot store. Value stores the
+// mtime + size at read-time. A missing scope is fail-closed: snapshots without
+// a real scope id are NOT recorded under a shared default bucket (would let
+// worker A's read satisfy worker B's edit-gate across sessions via a persisted
+// __global__.json).
+const readFilesByScope = new Map(); // scope → Map(fullPath → { mtimeMs, size, ...meta })
+
+// ── Disk-persisted snapshot store ────────────────────────────────────────
+// Mirror the in-memory readFilesByScope to per-scope JSON files under
+// `${PLUGIN_DATA}/read-snapshots/`. Hydration is lazy (first scope access);
+// flush is debounced and drained synchronously on process exit.
+const SNAPSHOT_DIR = (() => {
+    try {
+        const dataDir = process.env.CLAUDE_PLUGIN_DATA;
+        if (!dataDir) return null;
+        const dir = join(dataDir, 'read-snapshots');
+        // R4 data-at-rest: snapshot entries reveal which files an actor
+        // has read; clamp dir to owner-only on POSIX (advisory on Windows).
+        if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 0o700 });
+        return dir;
+    } catch { return null; }
+})();
+
+const SNAPSHOT_STALE_MS = 30 * 24 * 60 * 60 * 1000;
+(function sweepStaleSnapshotScopes() {
+    if (!SNAPSHOT_DIR) return;
+    let entries;
+    try { entries = readdirSync(SNAPSHOT_DIR); }
+    catch { return; }
+    const now = Date.now();
+    for (const name of entries) {
+        if (!name.endsWith('.json')) continue;
+        const full = join(SNAPSHOT_DIR, name);
+        try {
+            const st = statSync(full);
+            if ((now - st.mtimeMs) > SNAPSHOT_STALE_MS) unlinkSync(full);
+        } catch { /* missing / race — skip */ }
+    }
+})();
+
+const PERSIST_DEBOUNCE_MS = 500;
+const persistPending = new Map(); // scopeKey → Timeout
+const scopeHydrated = new Set();
+
+function snapshotScopeFilePath(scopeKey) {
+    if (!SNAPSHOT_DIR) return null;
+    const safe = String(scopeKey).replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 200);
+    return join(SNAPSHOT_DIR, `${safe}.json`);
+}
+
+// R3 H1: persisted snapshots are read-back from disk on lazy hydration and
+// directly trusted by the edit-gate (`isSnapshotStale` early-returns false
+// on stat match). A malformed / forged entry must NEVER reach the gate, so
+// every field that downstream code consumes is shape-validated here. Bad
+// entries are dropped silently (treated as "never read") rather than
+// surfaced — the model will simply be forced to re-read before edit.
+const MAX_RANGES_PER_ENTRY = 4096;
+function isValidPersistedSnapshotEntry(snap) {
+    if (!snap || typeof snap !== 'object' || Array.isArray(snap)) return false;
+    if (!Number.isFinite(snap.mtimeMs)) return false;
+    if (!Number.isFinite(snap.size) || snap.size < 0) return false;
+    if (snap.ctimeMs !== undefined && !Number.isFinite(snap.ctimeMs)) return false;
+    if (snap.contentHash !== undefined && snap.contentHash !== null) {
+        if (typeof snap.contentHash !== 'string') return false;
+        if (!/^[a-f0-9]{1,128}$/i.test(snap.contentHash)) return false;
+    }
+    if (snap.ranges !== undefined) {
+        if (!Array.isArray(snap.ranges)) return false;
+        if (snap.ranges.length > MAX_RANGES_PER_ENTRY) return false;
+    }
+    if (snap.rangeHashes !== undefined) {
+        if (!Array.isArray(snap.rangeHashes)) return false;
+        if (snap.rangeHashes.length > MAX_RANGES_PER_ENTRY) return false;
+    }
+    if (snap.rangeHash !== undefined && snap.rangeHash !== null && typeof snap.rangeHash !== 'string') return false;
+    if (snap.grepOnly !== undefined && typeof snap.grepOnly !== 'boolean') return false;
+    return true;
+}
+
+function loadScopeFromDisk(scopeKey) {
+    const path = snapshotScopeFilePath(scopeKey);
+    if (!path || !existsSync(path)) return new Map();
+    try {
+        const raw = readFileSync(path, 'utf-8');
+        const obj = _reviveInfinitySentinels(JSON.parse(raw));
+        if (!obj || typeof obj !== 'object' || Array.isArray(obj)) return new Map();
+        const map = new Map();
+        for (const [fp, snap] of Object.entries(obj)) {
+            if (typeof fp !== 'string' || !fp) continue;
+            if (!isValidPersistedSnapshotEntry(snap)) continue;
+            map.set(fp, snap);
+        }
+        return map;
+    } catch { return new Map(); }
+}
+
+// JSON cannot represent Infinity (it serializes to null), which silently turns
+// a full-file range { endLine: Infinity } into { endLine: null } on persist and
+// breaks the `endLine === Infinity` full-coverage checks after hydrate. Convert
+// Infinity to a unique sentinel on write and back on read. Shape-agnostic deep
+// clone (does NOT mutate the live in-memory snapshot objects).
+const INFINITY_SENTINEL = '__mixdog_Infinity_sentinel__';
+function _withInfinitySentinels(value) {
+    if (value === Infinity) return INFINITY_SENTINEL;
+    if (Array.isArray(value)) return value.map(_withInfinitySentinels);
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) out[k] = _withInfinitySentinels(v);
+        return out;
+    }
+    return value;
+}
+function _reviveInfinitySentinels(value) {
+    if (value === INFINITY_SENTINEL) return Infinity;
+    if (Array.isArray(value)) return value.map(_reviveInfinitySentinels);
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) out[k] = _reviveInfinitySentinels(v);
+        return out;
+    }
+    return value;
+}
+
+function persistScopeSync(scopeKey) {
+    const path = snapshotScopeFilePath(scopeKey);
+    if (!path) return;
+    const readFiles = readFilesByScope.get(scopeKey);
+    if (!readFiles || readFiles.size === 0) {
+        // Empty scope: remove on-disk file so it doesn't grow stale.
+        try { if (existsSync(path)) unlinkSync(path); } catch {}
+        return;
+    }
+    const obj = {};
+    for (const [fp, snap] of readFiles.entries()) obj[fp] = snap;
+    try { writeJsonAtomicSync(path, _withInfinitySentinels(obj), { compact: true, lock: true, mode: 0o600 }); } catch {}
+}
+
+export function deleteReadSnapshotPathEverywhere(fullPath) {
+    for (const [scopeKey, readFiles] of readFilesByScope.entries()) {
+        if (readFiles.delete(fullPath)) scheduleScopePersist(scopeKey);
+    }
+    if (!SNAPSHOT_DIR) return;
+    let entries;
+    try { entries = readdirSync(SNAPSHOT_DIR); }
+    catch { return; }
+    for (const name of entries) {
+        if (!name.endsWith('.json')) continue;
+        const p = join(SNAPSHOT_DIR, name);
+        try {
+            const obj = JSON.parse(readFileSync(p, 'utf-8'));
+            if (!obj || typeof obj !== 'object' || !Object.prototype.hasOwnProperty.call(obj, fullPath)) continue;
+            delete obj[fullPath];
+            if (Object.keys(obj).length === 0) unlinkSync(p);
+            else writeJsonAtomicSync(p, obj, { compact: true, lock: true, mode: 0o600 });
+        } catch {}
+    }
+}
+
+export function scheduleScopePersist(scopeKey) {
+    if (scopeKey === null || scopeKey === undefined) return;
+    if (persistPending.has(scopeKey)) return;
+    const t = setTimeout(() => {
+        persistPending.delete(scopeKey);
+        try { persistScopeSync(scopeKey); } catch {}
+    }, PERSIST_DEBOUNCE_MS);
+    if (t.unref) t.unref();
+    persistPending.set(scopeKey, t);
+}
+
+function flushAllScopesSync() {
+    for (const [key, timer] of persistPending) {
+        try { clearTimeout(timer); } catch {}
+        try { persistScopeSync(key); } catch {}
+    }
+    persistPending.clear();
+}
+process.on('exit', flushAllScopesSync);
+
+export function readScopeKey(scope) {
+    return scope ? String(scope) : null;
+}
+
+export function readFilesForScope(scope) {
+    const key = readScopeKey(scope);
+    if (key === null) {
+        // No scope id: fail-closed. Return a fresh ephemeral Map that is
+        // never cached in readFilesByScope, never hydrated, never
+        // persisted to disk. Writes are dropped on the floor, lookups
+        // return undefined → edit-gate cannot pass without a real scoped
+        // read. Closes the cross-session bypass via __global__.json.
+        return new Map();
+    }
+    let readFiles = readFilesByScope.get(key);
+    if (!readFiles) {
+        // Lazy hydrate: pull persisted snapshots for this scope from disk
+        // on first access. Subsequent gets stay in-memory.
+        readFiles = scopeHydrated.has(key) ? new Map() : loadScopeFromDisk(key);
+        scopeHydrated.add(key);
+        readFilesByScope.set(key, readFiles);
+    }
+    return readFiles;
+}