mixdog 0.8.1 → 0.9.1

package/vendor/ink/build/ink.js

@@ -181,6 +181,11 @@ export default class Ink {
     // cells ({ x1, y1, x2, y2 } inclusive, normalized) or null. The App sets it
     // via setSelection(); onRender forwards it to the renderer for highlighting.
     selectionRect = null;
+    // [mixdog fork] Coalesce drag-selection repaints when a frame is pending.
+    isRendering = false;
+    selectionRepaintQueued = false;
+    selectionRepaintFlushPending = false;
+    selectionRepaintEpoch = 0;
     // [mixdog fork] text under the current selection rect, refreshed every render
     // from the output grid. Read back via getSelectionText() on drag-release.
     selectedText = null;
@@ -318,9 +323,9 @@ export default class Ink {
         this.log.setCursorPosition(position);
     };
     // [mixdog fork] Update the mouse drag-selection rectangle and repaint so the
-    // inverse highlight tracks the drag live. Called by the App's mouse handler.
+    // inverse highlight tracks the drag. Called by the App's mouse handler.
     // A no-op-equal update is skipped to avoid redundant frames during motion.
-    setSelection = (rect) => {
+    setSelection = (rect, options = {}) => {
         const a = this.selectionRect;
         const same = a === rect ||
             (a && rect &&
@@ -333,16 +338,47 @@ export default class Ink {
                 a.clipY2 === rect.clipY2 &&
                 a.captureText === rect.captureText);
         if (same) {
-            return;
+            if (!options.immediate) {
+                return;
+            }
+        }
+        else {
+            this.selectionRect = rect ?? null;
         }
-        this.selectionRect = rect ?? null;
         if (!this.isUnmounted) {
-            // Drag selection is a direct manipulation gesture. Route it through
-            // the unthrottled renderer so the highlight tracks the pointer
-            // instead of trailing behind at maxFps.
-            this.rootNode.onImmediateRender();
+            if (options.immediate) {
+                this.selectionRepaintEpoch++;
+                this.selectionRepaintFlushPending = false;
+                this.rootNode.onImmediateRender();
+                return;
+            }
+            this.scheduleSelectionRepaint();
         }
     };
+    scheduleSelectionRepaint = () => {
+        if (this.hasPendingThrottledRender) {
+            return;
+        }
+        if (this.isRendering) {
+            this.selectionRepaintQueued = true;
+            return;
+        }
+        if (this.selectionRepaintFlushPending) {
+            return;
+        }
+        this.selectionRepaintFlushPending = true;
+        const epoch = ++this.selectionRepaintEpoch;
+        queueMicrotask(() => {
+            this.selectionRepaintFlushPending = false;
+            if (epoch !== this.selectionRepaintEpoch || this.isUnmounted) {
+                return;
+            }
+            if (this.hasPendingThrottledRender) {
+                return;
+            }
+            this.rootNode.onImmediateRender();
+        });
+    };
     // [mixdog fork] Given a 0-based cell (x, y), return the inclusive rect of the
     // word (maximal run of non-whitespace cells) on that single row, or null if
     // the cell is whitespace/empty or out of range. Reuses the cached cell-value
@@ -401,6 +437,8 @@ export default class Ink {
             this.nextRenderCommit.resolve();
             this.nextRenderCommit = undefined;
         }
+        this.isRendering = true;
+        try {
         const startTime = performance.now();
         const { output, outputHeight, staticOutput, cursor, selectedText, plainRows } = render(this.rootNode, this.isScreenReaderEnabled, this.selectionRect);
         // [mixdog fork] Cache the text under the current selection rect so the App
@@ -488,6 +526,14 @@ export default class Ink {
             this.fullStaticOutput += staticOutput;
         }
         this.renderInteractiveFrame(output, outputHeight, hasStaticOutput ? staticOutput : '');
+        }
+        finally {
+            this.isRendering = false;
+            if (this.selectionRepaintQueued) {
+                this.selectionRepaintQueued = false;
+                this.scheduleSelectionRepaint();
+            }
+        }
     };
     render(node) {
         const tree = (React.createElement(AccessibilityContext.Provider, { value: { isScreenReaderEnabled: this.isScreenReaderEnabled } },

package/vendor/ink/build/output.js

@@ -308,7 +308,12 @@ export default class Output {
         // [mixdog fork] Snapshot per-row, column-indexed cell values so the App
         // can compute word boundaries (double-click select) without retaining
         // this Output instance, which is created fresh per render and discarded.
-        const plainRows = sel ? undefined : output.map((row) => (row || []).map((cell) => (cell?.value ?? '')));
+        // ALWAYS build this, even while a selection rect is active: gating it on
+        // `!sel` froze the snapshot at the frame the first selection appeared, so
+        // every later double-click read STALE cell rows (wrong/empty words) until
+        // the selection cleared. Applying the selection above only rewrites cell
+        // `styles`, never `value`, so reading `value` here stays correct.
+        const plainRows = output.map((row) => (row || []).map((cell) => (cell?.value ?? '')));
         const generatedOutput = output
             .map(line => {
             // See https://github.com/vadimdemedes/ink/pull/564#issuecomment-1637022742

package/src/agents/scheduler-task.md

@@ -1,3 +0,0 @@
-# Scheduler Task
-
-Scheduled task execution agent.

package/src/agents/web-researcher/AGENT.md

@@ -1,3 +0,0 @@
-# Web Researcher
-
-External web and documentation research agent.

package/src/agents/web-researcher/agent.json

@@ -1,6 +0,0 @@
-{
-  "id": "web-researcher",
-  "name": "Web Researcher",
-  "description": "Web, documentation, and external reference research.",
-  "entry": "AGENT.md"
-}

package/src/agents/webhook-handler.md

@@ -1,3 +0,0 @@
-# Webhook Handler
-
-Inbound webhook event analysis agent.

package/src/hooks/lib/permission-rules.cjs

@@ -1,170 +0,0 @@
-'use strict';
-/**
- * permission-rules.cjs
- * Pattern matcher and priority evaluator. Priority order and Tool(content)
- * parsing mirror Claude Code native logic; specifier matching uses a local
- * path/command glob (native delegates per-tool content matching to each tool).
- *
- * Priority (highest → lowest): deny > ask > allow > mode default
- *
- * Pattern forms:
- *   mcp__*              → toolName starts with "mcp__"
- *   ToolName            → exact toolName match (no parens)
- *   ToolName(*)         → toolName matches AND specifier glob matches any
- *   ToolName(specifier) → toolName matches AND specifier glob matches
- *                         toolInput.path / .command / .file
- *   Glob chars: * (any chars within segment), ** (any segments)
- *
- * No external deps; no eval/Function.
- */
-
-// Read-only tool set (mixdog tool names).
-const READ_ONLY_TOOLS = new Set([
-  'read', 'list', 'glob', 'grep', 'find_symbol', 'find_references', 'find_callers', 'explore',
-  'recall', 'search', 'fetch', 'web_fetch',
-  'schedule_status', 'list_models', 'job_wait', 'download_attachment',
-]);
-
-/**
- * Find the index of the first/last UNescaped occurrence of a char.
- * A char is escaped when preceded by an odd number of backslashes.
- * Mirrors native permissionRuleParser.findFirst/LastUnescapedChar.
- */
-function findFirstUnescapedChar(str, char) {
-  for (let i = 0; i < str.length; i++) {
-    if (str[i] !== char) continue;
-    let bs = 0, j = i - 1;
-    while (j >= 0 && str[j] === '\\') { bs++; j--; }
-    if (bs % 2 === 0) return i;
-  }
-  return -1;
-}
-
-function findLastUnescapedChar(str, char) {
-  for (let i = str.length - 1; i >= 0; i--) {
-    if (str[i] !== char) continue;
-    let bs = 0, j = i - 1;
-    while (j >= 0 && str[j] === '\\') { bs++; j--; }
-    if (bs % 2 === 0) return i;
-  }
-  return -1;
-}
-
-/** Reverse escapeRuleContent: \( -> (, \) -> ), \\ -> \ (order matters). */
-function unescapeRuleContent(content) {
-  return content
-    .replace(/\\\(/g, '(')
-    .replace(/\\\)/g, ')')
-    .replace(/\\\\/g, '\\');
-}
-
-/**
- * Convert a glob pattern string to a RegExp.
- * Supports: * (non-slash wildcard), ** (any), ? (single char).
- * Safe: no eval.
- */
-function globToRegex(glob) {
-  let src = '';
-  let i = 0;
-  while (i < glob.length) {
-    const ch = glob[i];
-    if (ch === '*' && glob[i + 1] === '*') {
-      src += '.*';
-      i += 2;
-      if (glob[i] === '/') i++; // consume trailing slash
-    } else if (ch === '*') {
-      src += '[^/\\\\]*';
-      i++;
-    } else if (ch === '?') {
-      src += '[^/\\\\]';
-      i++;
-    } else {
-      // Escape regex metacharacters
-      src += ch.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-      i++;
-    }
-  }
-  return new RegExp('^' + src + '$', 'i');
-}
-
-/**
- * Match a single pattern entry against (toolName, toolInput).
- * Returns true if the pattern applies.
- */
-function matchesPattern(pattern, toolName, toolInput) {
-  if (typeof pattern !== 'string') return false;
-
-  // Detect Tool(specifier) form. Escape-aware, mirroring native
-  // permissionRuleValueFromString: only UNescaped parens delimit the
-  // specifier, and the close paren must be the final char.
-  const parenIdx = findFirstUnescapedChar(pattern, '(');
-  const closeIdx = findLastUnescapedChar(pattern, ')');
-  if (parenIdx > 0 && closeIdx === pattern.length - 1 && closeIdx > parenIdx) {
-    const namePart = pattern.slice(0, parenIdx);
-    const rawSpecifier = pattern.slice(parenIdx + 1, closeIdx);
-
-    if (toolName !== namePart) return false;
-
-    // Empty "()" or wildcard "(*)" specifier → tool-wide rule, match any
-    if (rawSpecifier === '' || rawSpecifier === '*') return true;
-
-    // Unescape \( \) before glob matching
-    const specifier = unescapeRuleContent(rawSpecifier);
-    // Match specifier against known path-bearing fields
-    const specRe = globToRegex(specifier);
-    const inp = toolInput || {};
-    const candidates = [...new Set([
-      inp.path, inp.command, inp.file, inp.file_path, inp.base_path, inp.cwd,
-      ...(Array.isArray(inp.path)      ? inp.path.map(p => (p && typeof p === 'object' ? p.path : p)) : []),
-      ...(Array.isArray(inp.reads)     ? inp.reads.map(r => r?.path)                              : []),
-      ...(Array.isArray(inp.edits)     ? inp.edits.flatMap(e => [e?.path, e?.file_path])          : []),
-      ...(Array.isArray(inp.writes)    ? inp.writes.flatMap(w => [w?.path, w?.file_path])         : []),
-    ].filter(v => typeof v === 'string'))];
-
-    return candidates.some(c => specRe.test(c));
-  }
-
-  // Prefix wildcard: e.g. "mcp__*"
-  if (pattern.endsWith('*')) {
-    const prefix = pattern.slice(0, -1);
-    return toolName.startsWith(prefix);
-  }
-
-  // Glob on toolName itself (may contain * or **)
-  if (pattern.includes('*') || pattern.includes('?')) {
-    return globToRegex(pattern).test(toolName);
-  }
-
-  // Exact match
-  return toolName === pattern;
-}
-
-/**
- * Evaluate priority rules against a tool call.
- *
- * @param {string}   toolName
- * @param {object}   toolInput
- * @param {string[]} allowList
- * @param {string[]} denyList
- * @param {string[]} askList
- * @returns {'deny'|'ask'|'allow'|null}  null = no list matched (use mode default)
- */
-function evaluateRules(toolName, toolInput, allowList, denyList, askList) {
-  if (denyList.some(p => matchesPattern(p, toolName, toolInput))) return 'deny';
-  if (askList.some(p => matchesPattern(p, toolName, toolInput)))  return 'ask';
-  if (allowList.some(p => matchesPattern(p, toolName, toolInput))) return 'allow';
-  return null;
-}
-
-/**
- * Determine whether a tool is considered read-only.
- * For mcp__ tools: strip the mcp__ prefix chain and check the short tool name.
- */
-function isReadOnlyTool(toolName) {
-  // Strip mcp__plugin_...__  prefix (one or more double-underscore segments)
-  const parts = toolName.split('__');
-  const shortName = parts[parts.length - 1];
-  return READ_ONLY_TOOLS.has(shortName);
-}
-
-module.exports = { matchesPattern, evaluateRules, isReadOnlyTool, READ_ONLY_TOOLS };

package/src/hooks/lib/settings-loader.cjs

@@ -1,112 +0,0 @@
-'use strict';
-/**
- * settings-loader.cjs
- * Loads and merges Mixdog settings from three tiers (lowest → highest):
- *   1. User global:   $MIXDOG_CONFIG_DIR/settings.json (or ~/.mixdog/settings.json)
- *   2. Project:       $MIXDOG_PROJECT_DIR/.mixdog/settings.json  (or cwd/.mixdog/settings.json)
- *   3. Project local: $MIXDOG_PROJECT_DIR/.mixdog/settings.local.json
- *
- * Only `permissions` sub-tree is returned; the rest is ignored.
- * Pure fs/path — no external deps.
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-// ── In-process mtime-driven cache ────────────────────────────────────────────
-// Keyed by resolved file path. Each entry: { mtime: number|null, data: any }.
-// Invalidated per-tier independently when mtime changes.
-// TTL: never-expire by default (mtime-driven only).
-const _fileCache = new Map();
-
-function readJsonCached(filePath) {
-  let entry = _fileCache.get(filePath);
-  let mtime = null;
-  try { mtime = fs.statSync(filePath).mtimeMs; } catch { /* file absent */ }
-  if (entry && entry.mtime === mtime) return entry.data;
-  let data = null;
-  if (mtime !== null) {
-    try { data = JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch { data = null; }
-  }
-  _fileCache.set(filePath, { mtime, data });
-  return data;
-}
-
-/** Clear the entire settings cache (for test isolation). */
-function clearSettingsCache() {
-  _fileCache.clear();
-}
-
-/**
- * Merge two permissions objects (base then overlay).
- * Arrays are concatenated and de-duped; scalar fields are overwritten.
- */
-function mergePermissions(base, overlay) {
-  if (!overlay) return base || {};
-  if (!base) return overlay || {};
-
-  const merged = Object.assign({}, base);
-
-  for (const key of ['allow', 'deny', 'ask']) {
-    const b = Array.isArray(base[key]) ? base[key] : [];
-    const o = Array.isArray(overlay[key]) ? overlay[key] : [];
-    const combined = [...b, ...o];
-    if (combined.length) merged[key] = [...new Set(combined)];
-  }
-
-  // scalar: overlay wins
-  if (overlay.defaultMode !== undefined) merged.defaultMode = overlay.defaultMode;
-
-  return merged;
-}
-
-/**
- * Load and merge settings from all three tiers.
- * Returns `{ allow: string[], deny: string[], ask: string[], defaultMode: string }`.
- */
-function loadPermissions(projectDir) {
-  const userConfigDir = process.env.MIXDOG_CONFIG_DIR ||
-    path.join(os.homedir(), '.mixdog');
-  const projDir = projectDir ||
-    process.env.MIXDOG_PROJECT_DIR ||
-    process.cwd();
-
-  const userSettings    = readJsonCached(path.join(userConfigDir, 'settings.json'));
-  const projectSettings = readJsonCached(path.join(projDir, '.mixdog', 'settings.json'));
-  const localSettings   = readJsonCached(path.join(projDir, '.mixdog', 'settings.local.json'));
-
-  // Accept permissions from `settings.permissions` (canonical) OR top-level
-  // `allow`/`deny`/`ask`/`defaultMode` fields (common user shorthand).
-  function extractPerms(s) {
-    if (!s) return {};
-    const nested = (s.permissions && typeof s.permissions === 'object') ? s.permissions : {};
-    const topLevel = {};
-    for (const key of ['allow', 'deny', 'ask']) {
-      if (Array.isArray(s[key])) topLevel[key] = s[key];
-    }
-    if (typeof s.defaultMode === 'string') topLevel.defaultMode = s.defaultMode;
-    return mergePermissions(nested, topLevel);
-  }
-  const userPerms    = extractPerms(userSettings);
-  const projectPerms = extractPerms(projectSettings);
-  const localPerms   = extractPerms(localSettings);
-
-  let merged = mergePermissions({}, userPerms);
-  merged = mergePermissions(merged, projectPerms);
-  merged = mergePermissions(merged, localPerms);
-
-  const VALID_MODES = new Set(['default', 'acceptEdits', 'plan', 'dontAsk', 'bypassPermissions', 'auto']);
-  const rawMode = merged.defaultMode;
-  const resolvedMode = (typeof rawMode === 'string' && VALID_MODES.has(rawMode))
-    ? rawMode
-    : 'default';
-  return {
-    allow:       Array.isArray(merged.allow)       ? merged.allow       : [],
-    deny:        Array.isArray(merged.deny)        ? merged.deny        : [],
-    ask:         Array.isArray(merged.ask)         ? merged.ask         : [],
-    defaultMode: resolvedMode,
-  };
-}
-
-module.exports = { loadPermissions, clearSettingsCache };

package/src/lib/hook-pipe-path.cjs

@@ -1,10 +0,0 @@
-'use strict';
-
-// Single source for the hook IPC path. Centralizes an existing platform
-// contract (not new heuristic). Rust mirror native/mixdog-shim/src/main.rs:34-43
-// must stay in sync.
-module.exports = function hookPipePath() {
-  return process.platform === 'win32'
-    ? '\\\\.\\pipe\\mixdog-hooks'
-    : require('path').join(process.env.XDG_RUNTIME_DIR || '/tmp', 'mixdog-hooks.sock');
-};

package/src/rules/bridge/00-common.md

@@ -1,5 +0,0 @@
-# Bridge Constraints
-
-- Use English for bridge-agent communication.
-- Do not touch git/Ship. Even when the brief instructs `git add` / `commit` /
-  `push` / `stash`, refuse with `git operations deferred to Lead`.

package/src/rules/bridge/30-explorer.md

@@ -1,4 +0,0 @@
-# Role: explorer
-
-Explore locates relevant code surfaces and quickly summarizes what is there
-with coordinates. Stay rough and descriptive: do not debug, decide, or judge.

package/src/rules/lead/00-tool-lead.md

@@ -1,5 +0,0 @@
-# Lead Tool Use
-
-- Lead owns repo-local shell work: git, build, test, run, and verification commands.
-- Use `shell` directly for approved git/build/test/run work; do not delegate those commands to bridge agents.
-- Use bridge agents for scoped implementation, research, review, and debugging, not for git commit/push/stash or Ship.

package/src/rules/shared/00-language.md

@@ -1,3 +0,0 @@
-# Language
-
-- Prefer responding in the language used by the user.

package/src/runtime/agent/orchestrator/tools/builtin/native-edit-runner.mjs

@@ -1,110 +0,0 @@
-import { existsSync } from 'fs';
-import { dirname, join, resolve } from 'path';
-import { performance } from 'perf_hooks';
-import { fileURLToPath } from 'url';
-import { snapshotCoversFullFile } from './snapshot-helpers.mjs';
-import { getPluginData } from '../../config.mjs';
-import { findCachedPatchBinary } from '../patch-binary-fetcher.mjs';
-import { runServerEdit } from '../patch.mjs';
-
-const PLUGIN_ROOT = process.env.MIXDOG_ROOT
-    || resolve(dirname(fileURLToPath(import.meta.url)), '../../../../..');
-const NATIVE_EDIT_DEFAULT_BIN = join(
-    PLUGIN_ROOT,
-    'native/mixdog-patch/target/release',
-    process.platform === 'win32' ? 'mixdog-patch.exe' : 'mixdog-patch',
-);
-
-export function nativeEditMode() {
-    return String(process.env.MIXDOG_EDIT_NATIVE || 'auto').toLowerCase();
-}
-
-function nativeEditBinCandidate() {
-    const override = process.env.MIXDOG_EDIT_NATIVE_BIN || process.env.MIXDOG_PATCH_NATIVE_BIN;
-    if (override) return { path: override, kind: 'override' };
-    if (existsSync(NATIVE_EDIT_DEFAULT_BIN)) return { path: NATIVE_EDIT_DEFAULT_BIN, kind: 'local' };
-    const cached = findCachedPatchBinary(getPluginData());
-    if (cached) return { path: cached, kind: 'cached' };
-    return { path: NATIVE_EDIT_DEFAULT_BIN, kind: 'missing' };
-}
-
-export function nativeEditBinPath() {
-    return nativeEditBinCandidate().path;
-}
-
-export function nativeEditShouldAttempt({ editSnapshot, oldStr, newStr, preloadedContent, preloadedRawBuf }) {
-    const mode = nativeEditMode();
-    if (/^(0|false|no|off|js|legacy)$/i.test(mode)) return false;
-    const forcedNative = /^(1|true|yes|on|native)$/i.test(mode);
-    const candidate = nativeEditBinCandidate();
-    if (!existsSync(candidate.path)) return false;
-    // Cached release prebuilds are guaranteed valid for apply_patch, but older
-    // manifests (currently v0.6.5 in clean CI) predate the EDIT server protocol.
-    // In auto mode, native edit is only an acceleration, so require either a
-    // local cargo build or an explicit override. If a user forces native mode,
-    // still try the cached binary and surface any protocol failure.
-    if (candidate.kind === 'cached' && !forcedNative) return false;
-    if (!snapshotCoversFullFile(editSnapshot)) return false;
-    if (preloadedContent !== null || preloadedRawBuf !== null) return false;
-    if (typeof oldStr !== 'string' || oldStr.length === 0 || typeof newStr !== 'string') return false;
-    if (forcedNative) return true;
-    // auto: the persistent server removed per-call spawn cost, so route edits to
-    // native edit2 by default (B3). Same-size edits keep the JS in-place partial
-    // write, which rewrites bytes in place instead of the whole file.
-    const oldBytes = Buffer.byteLength(oldStr, 'utf-8');
-    const newBytes = Buffer.byteLength(newStr, 'utf-8');
-    if (oldBytes === newBytes) return false;
-    return true;
-}
-
-export async function runNativeExactEdit({ fullPath, oldStr, newStr, replaceAll, signal = null }) {
-    const forcedNative = /^(1|true|yes|on|native)$/i.test(nativeEditMode());
-    if (signal?.aborted) {
-        return { ok: false, fallback: false, error: signal.reason?.message || signal.reason || 'native edit aborted' };
-    }
-    const oldBuf = Buffer.from(oldStr, 'utf-8');
-    const newBuf = Buffer.from(newStr, 'utf-8');
-    const started = performance.now();
-    try {
-        // PARITY GUARD: the native engine MATCHES via the curly-quote fold
-        // tier but applies new_string verbatim, silently downgrading the
-        // file's typographic quotes (JS slow path preserves them via
-        // preserveQuoteTypography). When old_string carries quote-family
-        // chars — the only inputs that can land on the curly tier — probe
-        // with a dry run (persistent server, ~ms) and defer curly-tier
-        // matches to the JS editor.
-        if (/["'‘’“”]/.test(oldStr)) {
-            const probe = await runServerEdit({ fullPath, oldBuf, newBuf, replaceAll, dryRun: true, signal });
-            if (probe?.tier === 'curly') {
-                return { ok: false, fallback: true, error: 'curly-quote fold match — deferred to JS editor for typography preservation' };
-            }
-        }
-        const res = await runServerEdit({ fullPath, oldBuf, newBuf, replaceAll, signal });
-        return {
-            ok: true,
-            replacements: res.replacements,
-            readMs: res.readMs,
-            applyMs: res.applyMs,
-            writeMs: res.writeMs,
-            totalMs: res.totalMs,
-            roundtripMs: res.roundtripMs ?? (performance.now() - started),
-            stage: res.tier,
-            contentHash: res.contentHash,
-        };
-    } catch (err) {
-        if (err?.name === 'AbortError') {
-            return { ok: false, fallback: false, error: err.message };
-        }
-        const msg = String(err?.message || err);
-        // Tier misses and not-found map to a JS fallback; transport/spawn errors
-        // also fall back so a server hiccup never blocks an edit. Older cached
-        // mixdog-patch binaries (for example the v0.6.5 release prebuilds used
-        // by clean CI before a local cargo build exists) support APPLY but not
-        // the EDIT server protocol, and answer EDIT with the APPLY parser's
-        // "bad header" error. In auto mode that means "native edit unavailable",
-        // not "the edit is invalid", so fall through to the JS editor. When the
-        // user explicitly forces native mode, keep surfacing the native failure.
-        const fallback = !forcedNative && /old_string (?:not found|found \d+ times)|not valid UTF-8|no exact match|not found|server|bad header|bad edit header/i.test(msg);
-        return { ok: false, fallback, error: msg };
-    }
-}

package/src/runtime/agent/orchestrator/tools/mutation-content-cache.mjs

@@ -1,67 +0,0 @@
-import * as nodeBuffer from 'node:buffer';
-import { readFileSync } from 'node:fs';
-import { readFile as readFileAsync } from 'node:fs/promises';
-import { decodeRawBufferForSnapshotCheck } from './builtin/snapshot-helpers.mjs';
-
-function keyForPath(fullPath) {
-  const text = String(fullPath || '');
-  return process.platform === 'win32' ? text.toLowerCase() : text;
-}
-
-export function isValidUtf8Buffer(buf) {
-  if (typeof nodeBuffer.isUtf8 === 'function') return nodeBuffer.isUtf8(buf);
-  if (typeof Buffer.isUtf8 === 'function') return Buffer.isUtf8(buf);
-  return Buffer.from(buf.toString('utf-8'), 'utf-8').equals(buf);
-}
-
-export function createMutationContentCache() {
-  const entries = new Map();
-
-  function getOrCreate(fullPath) {
-    const key = keyForPath(fullPath);
-    let entry = entries.get(key);
-    if (!entry) {
-      entry = { fullPath, rawBuf: null, content: null };
-      entries.set(key, entry);
-    }
-    return entry;
-  }
-
-  function seedBuffer(fullPath, rawBuf) {
-    const entry = getOrCreate(fullPath);
-    entry.rawBuf = rawBuf;
-    entry.content = null;
-    return entry;
-  }
-
-  function readBufferSync(fullPath) {
-    const entry = getOrCreate(fullPath);
-    if (!Buffer.isBuffer(entry.rawBuf)) entry.rawBuf = readFileSync(fullPath);
-    return entry.rawBuf;
-  }
-
-  async function readBuffer(fullPath) {
-    const entry = getOrCreate(fullPath);
-    if (!Buffer.isBuffer(entry.rawBuf)) entry.rawBuf = await readFileAsync(fullPath);
-    return entry.rawBuf;
-  }
-
-  function readTextSync(fullPath) {
-    const entry = getOrCreate(fullPath);
-    if (typeof entry.content !== 'string') {
-      entry.content = decodeRawBufferForSnapshotCheck(readBufferSync(fullPath));
-    }
-    return entry.content;
-  }
-
-  function getEntry(fullPath) {
-    return entries.get(keyForPath(fullPath)) || null;
-  }
-
-  function clear(fullPath = null) {
-    if (fullPath) entries.delete(keyForPath(fullPath));
-    else entries.clear();
-  }
-
-  return { seedBuffer, readBuffer, readBufferSync, readTextSync, getEntry, clear };
-}