token-goat 2.6.0 → 2.6.1

package/README.md

@@ -356,6 +356,7 @@ To upgrade cleanly:
 |---------|-------------|
 | `token-goat symbol <name>` | Jump to a symbol definition. |
 | `token-goat read "file::symbol"` | Pull one function or class, not the whole file. Supports qualified lookups (`read "file.py::Class.method"`) and line ranges: `read "file.py@10-40"` for lines 10 to 40 inclusive, or `read "file.py@42"` for one line. Line ranges read straight from disk, so they work on any file, including paths outside an indexed project. |
+| `token-goat replace <file>` | Replace one string in a file using `--old-from`/`--new-from` or `--old-b64`/`--new-b64`; `--all` replaces every match. |
 | `token-goat section "doc.md::Heading"` | Pull one Markdown section by heading. A miss that is an unambiguous prefix of exactly one heading auto-redirects with a `(redirected from: …)` marker (and a `redirectedFrom` field under `--json`). Disambiguate duplicates with `"doc.md::Heading#2"`. |
 | `token-goat skill-section "<name>::<heading>"` | Extract a named section from an installed skill without reading the full skill file. |
 | `token-goat skeleton "file"` | Show all signatures in a file without bodies — typically 70–90% fewer tokens than a full read. |

package/dist/token-goat.mjs

@@ -9498,7 +9498,7 @@ init_define_import_meta_env();
 import { createRequire } from "node:module";
 function resolveVersion() {
   if (true) {
-    return "2.6.0";
+    return "2.6.1";
   }
   const require2 = createRequire(import.meta.url);
   const pkg = require2("../package.json");
@@ -13243,34 +13243,10 @@ function pruneDeletedFiles(rootPrefix, dbPath = globalDbPath()) {
   return pruned;
 }
 
-// src/relay.ts
-init_define_import_meta_env();
-
-// src/bridges/index.ts
-init_define_import_meta_env();
-
-// src/bridges/registry.ts
-init_define_import_meta_env();
-function detectHarness() {
-  const env = process.env;
-  if (env["TERM_PROGRAM"] === "claude-code" || env["CLAUDE_CODE_VERSION"] !== void 0) {
-    return "claudecode";
-  }
-  if (env["CODEX_SESSION_ID"] !== void 0) return "codex";
-  if (env["OPENCODE_SESSION_ID"] !== void 0) return "opencode";
-  return "generic";
-}
-var _cached = null;
-function resetHarnessCache() {
-  _cached = null;
-}
-registerReset(resetHarnessCache);
-
-// src/bridges/claudecode.ts
-init_define_import_meta_env();
-
-// src/bridges/codex.ts
+// src/hooks_index.ts
 init_define_import_meta_env();
+import * as fs10 from "node:fs";
+import * as path12 from "node:path";
 
 // src/hook_registry.ts
 init_define_import_meta_env();
@@ -13307,11 +13283,18 @@ var CLAUDE_CODE_EVENT_NAMES = {
   user_prompt_submit: "UserPromptSubmit",
   subagent_stop: "SubagentStop"
 };
+var EVENTS_WITHOUT_ADDITIONAL_CONTEXT = /* @__PURE__ */ new Set([
+  "notification",
+  "pre_compact"
+]);
 function serializeOutput(output, eventName) {
   switch (output.hookType) {
     case "deny":
       return JSON.stringify({ decision: "block", reason: output.message });
     case "context":
+      if (EVENTS_WITHOUT_ADDITIONAL_CONTEXT.has(eventName)) {
+        return JSON.stringify({ systemMessage: output.context });
+      }
       return JSON.stringify({
         hookSpecificOutput: {
           hookEventName: CLAUDE_CODE_EVENT_NAMES[eventName],
@@ -13333,6 +13316,111 @@ function serializeOutput(output, eventName) {
   }
 }
 
+// src/hooks_common.ts
+init_define_import_meta_env();
+function getToolName(event) {
+  return event.toolName;
+}
+function getToolInput(event) {
+  return event.toolInput;
+}
+function getFilePath(event) {
+  const value = event.toolInput["file_path"];
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function passOutput() {
+  return { hookType: "pass" };
+}
+function denyOutput(message) {
+  return { hookType: "deny", message };
+}
+function contextOutput(context) {
+  return { hookType: "context", context };
+}
+
+// src/hooks_index.ts
+function dirtyQueuePath() {
+  return path12.join(dataDir(), "queue", "dirty.txt");
+}
+function appendDirtyPath(normalizedPath) {
+  const queuePath = dirtyQueuePath();
+  const dir = path12.dirname(queuePath);
+  try {
+    fs10.mkdirSync(dir, { recursive: true });
+  } catch (e) {
+    if (e.code !== "EEXIST" || !fs10.existsSync(dir)) throw e;
+  }
+  let leadingNewline = "";
+  try {
+    const existing = fs10.readFileSync(queuePath, "utf8");
+    if (existing.length > 0 && !existing.endsWith("\n")) leadingNewline = "\n";
+  } catch {
+  }
+  fs10.appendFileSync(queuePath, `${leadingNewline}${normalizedPath}
+`);
+}
+function getDirtyPaths() {
+  const queuePath = dirtyQueuePath();
+  let raw;
+  try {
+    raw = fs10.readFileSync(queuePath, "utf8");
+  } catch {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const out2 = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "" || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    out2.push(trimmed);
+  }
+  return out2;
+}
+function preCompactIndexHandler(_event) {
+  const paths = getDirtyPaths();
+  if (paths.length > 0) {
+    const sidecar = path12.join(dataDir(), "queue", "pending.txt");
+    try {
+      fs10.mkdirSync(path12.dirname(sidecar), { recursive: true });
+      atomicWriteBytes(sidecar, Buffer.from(`${paths.join("\n")}
+`, "utf8"));
+    } catch {
+    }
+  }
+  return passOutput();
+}
+registerHook("pre_compact", preCompactIndexHandler);
+
+// src/relay.ts
+init_define_import_meta_env();
+
+// src/bridges/index.ts
+init_define_import_meta_env();
+
+// src/bridges/registry.ts
+init_define_import_meta_env();
+function detectHarness() {
+  const env = process.env;
+  if (env["TERM_PROGRAM"] === "claude-code" || env["CLAUDE_CODE_VERSION"] !== void 0) {
+    return "claudecode";
+  }
+  if (env["CODEX_SESSION_ID"] !== void 0) return "codex";
+  if (env["OPENCODE_SESSION_ID"] !== void 0) return "opencode";
+  return "generic";
+}
+var _cached = null;
+function resetHarnessCache() {
+  _cached = null;
+}
+registerReset(resetHarnessCache);
+
+// src/bridges/claudecode.ts
+init_define_import_meta_env();
+
+// src/bridges/codex.ts
+init_define_import_meta_env();
+
 // src/hooks_cli.ts
 init_define_import_meta_env();
 var _LOG = {
@@ -13435,34 +13523,12 @@ var HOOK_EVENTS = [
 
 // src/hooks_read.ts
 init_define_import_meta_env();
-import * as fs16 from "node:fs";
-import * as path17 from "node:path";
-
-// src/hooks_common.ts
-init_define_import_meta_env();
-function getToolName(event) {
-  return event.toolName;
-}
-function getToolInput(event) {
-  return event.toolInput;
-}
-function getFilePath(event) {
-  const value = event.toolInput["file_path"];
-  return typeof value === "string" && value !== "" ? value : void 0;
-}
-function passOutput() {
-  return { hookType: "pass" };
-}
-function denyOutput(message) {
-  return { hookType: "deny", message };
-}
-function contextOutput(context) {
-  return { hookType: "context", context };
-}
+import * as fs17 from "node:fs";
+import * as path18 from "node:path";
 
 // src/config.ts
 init_define_import_meta_env();
-import * as fs10 from "node:fs";
+import * as fs11 from "node:fs";
 
 // node_modules/smol-toml/dist/index.js
 init_define_import_meta_env();
@@ -14582,7 +14648,7 @@ function loadConfig() {
   const p = configPath();
   let currentMtime = 0;
   try {
-    currentMtime = fs10.statSync(p).mtimeMs;
+    currentMtime = fs11.statSync(p).mtimeMs;
   } catch {
   }
   const envFp = configEnvFingerprint();
@@ -14592,7 +14658,7 @@ function loadConfig() {
   let raw = {};
   if (currentMtime !== 0) {
     try {
-      const text = fs10.readFileSync(p, "utf8");
+      const text = fs11.readFileSync(p, "utf8");
       raw = parse2(text);
     } catch {
     }
@@ -14627,7 +14693,7 @@ function loadPersistedConfig() {
   const p = configPath();
   let raw = {};
   try {
-    const text = fs10.readFileSync(p, "utf8");
+    const text = fs11.readFileSync(p, "utf8");
     raw = parse2(text);
   } catch {
   }
@@ -14997,8 +15063,8 @@ function saveConfig(config) {
 
 // src/snapshots.ts
 init_define_import_meta_env();
-import * as fs11 from "node:fs";
-import * as path12 from "node:path";
+import * as fs12 from "node:fs";
+import * as path13 from "node:path";
 import * as crypto from "node:crypto";
 import * as os4 from "node:os";
 var MAX_SNAPSHOTS_PER_SESSION = 150;
@@ -15012,10 +15078,10 @@ var SESSION_DIR_RE = /[^a-zA-Z0-9_-]/g;
 function sessionDir(sessionId) {
   if (!sessionId) return null;
   const safe = sessionId.replace(SESSION_DIR_RE, "_").slice(0, 64) || "anon";
-  const base = path12.join(os4.homedir(), ".token-goat", "session_snapshots");
-  const candidate = path12.join(base, safe);
+  const base = path13.join(os4.homedir(), ".token-goat", "session_snapshots");
+  const candidate = path13.join(base, safe);
   try {
-    const rel = path12.relative(base, candidate);
+    const rel = path13.relative(base, candidate);
     if (rel.startsWith("..")) return null;
   } catch {
     return null;
@@ -15028,7 +15094,7 @@ function pathKey(filePath) {
 function snapshot_path(sessionId, filePath) {
   const d = sessionDir(sessionId);
   if (!d) return null;
-  return path12.join(d, `${pathKey(filePath)}.bin`);
+  return path13.join(d, `${pathKey(filePath)}.bin`);
 }
 function kindSidecarPath(snapshotPath) {
   return snapshotPath + ".kind";
@@ -15036,11 +15102,11 @@ function kindSidecarPath(snapshotPath) {
 function writeSnapshotKind(sidecarPath, kind) {
   try {
     const safeKind = VALID_KINDS.has(kind) ? kind : KIND_READ;
-    const dir = path12.dirname(sidecarPath);
-    if (!fs11.existsSync(dir)) {
-      fs11.mkdirSync(dir, { recursive: true });
+    const dir = path13.dirname(sidecarPath);
+    if (!fs12.existsSync(dir)) {
+      fs12.mkdirSync(dir, { recursive: true });
     }
-    fs11.writeFileSync(sidecarPath, safeKind, "utf8");
+    fs12.writeFileSync(sidecarPath, safeKind, "utf8");
     return true;
   } catch {
     return false;
@@ -15049,12 +15115,12 @@ function writeSnapshotKind(sidecarPath, kind) {
 function evictOldest(d, maxCount) {
   try {
     const entries = [];
-    const files = fs11.readdirSync(d);
+    const files = fs12.readdirSync(d);
     for (const file of files) {
-      const fullPath = path12.join(d, file);
+      const fullPath = path13.join(d, file);
       if (!file.endsWith(".bin")) continue;
       try {
-        const stat2 = fs11.statSync(fullPath);
+        const stat2 = fs12.statSync(fullPath);
         entries.push([fullPath, stat2.mtimeMs]);
       } catch {
         continue;
@@ -15066,10 +15132,10 @@ function evictOldest(d, maxCount) {
     const over = entries.length - maxCount;
     for (const [p] of entries.slice(0, over)) {
       try {
-        fs11.unlinkSync(p);
+        fs12.unlinkSync(p);
         removed++;
         try {
-          fs11.unlinkSync(kindSidecarPath(p));
+          fs12.unlinkSync(kindSidecarPath(p));
         } catch {
         }
       } catch {
@@ -15098,9 +15164,9 @@ function store(sessionId, filePath, content, opts = {}) {
   if (!p) return null;
   const sha = crypto.createHash("sha256").update(stored).digest("hex");
   try {
-    if (fs11.existsSync(p)) {
+    if (fs12.existsSync(p)) {
       try {
-        const existing = fs11.readFileSync(p);
+        const existing = fs12.readFileSync(p);
         if (Buffer.from(existing).equals(stored)) {
           return {
             path: p,
@@ -15111,14 +15177,14 @@ function store(sessionId, filePath, content, opts = {}) {
       } catch {
       }
     }
-    const dir = path12.dirname(p);
-    if (!fs11.existsSync(dir)) {
-      fs11.mkdirSync(dir, { recursive: true });
+    const dir = path13.dirname(p);
+    if (!fs12.existsSync(dir)) {
+      fs12.mkdirSync(dir, { recursive: true });
     }
     evictOldest(dir, MAX_SNAPSHOTS_PER_SESSION - 1);
     const tempPath = p + ".tmp";
-    fs11.writeFileSync(tempPath, stored);
-    fs11.renameSync(tempPath, p);
+    fs12.writeFileSync(tempPath, stored);
+    fs12.renameSync(tempPath, p);
     const sidecar = kindSidecarPath(p);
     writeSnapshotKind(sidecar, kind);
     return {
@@ -15132,9 +15198,9 @@ function store(sessionId, filePath, content, opts = {}) {
 }
 function load(sessionId, filePath, opts = {}) {
   const p = snapshot_path(sessionId, filePath);
-  if (!p || !fs11.existsSync(p)) return null;
+  if (!p || !fs12.existsSync(p)) return null;
   try {
-    const stat2 = fs11.statSync(p);
+    const stat2 = fs12.statSync(p);
     if (stat2.size > MAX_SNAPSHOT_BYTES) {
       return null;
     }
@@ -15142,7 +15208,7 @@ function load(sessionId, filePath, opts = {}) {
     return null;
   }
   try {
-    const data = fs11.readFileSync(p);
+    const data = fs12.readFileSync(p);
     if (opts.expected_sha) {
       const actualSha = crypto.createHash("sha256").update(data).digest("hex");
       if (actualSha.toLowerCase() !== opts.expected_sha.toLowerCase()) {
@@ -15664,7 +15730,7 @@ function dispatchFileTypeHandler(filePath, content, contentLengthHint) {
 
 // src/stats.ts
 init_define_import_meta_env();
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 
 // src/render/stats_renderer.ts
 init_define_import_meta_env();
@@ -16445,7 +16511,7 @@ CREATE INDEX IF NOT EXISTS idx_stats_kind ON stats(kind);
 var _globalSchemaApplied = /* @__PURE__ */ new Set();
 registerReset(() => _globalSchemaApplied.clear());
 function getGlobalDb() {
-  const dbPath = path13.join(dataDir(), "global.db");
+  const dbPath = path14.join(dataDir(), "global.db");
   const db = getDb(dbPath);
   if (!_globalSchemaApplied.has(dbPath)) {
     db.exec(GLOBAL_SCHEMA_SQL);
@@ -16639,9 +16705,9 @@ function renderStats2(opts) {
 // src/project.ts
 init_define_import_meta_env();
 import * as crypto2 from "node:crypto";
-import * as fs12 from "node:fs";
+import * as fs13 from "node:fs";
 import * as os5 from "node:os";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 var WSL_PREFIX_RE = /^\/mnt\/([a-zA-Z])\/(.*)$/;
 var CYGWIN_PREFIX_RE = /^\/cygdrive\/([a-zA-Z])\/(.*)$/;
 var MSYS_PREFIX_RE = /^\/([a-zA-Z])\/(.*)$/;
@@ -16678,9 +16744,9 @@ function canonicalize(inputPath) {
   const slashed = pathStr.replace(/\\/g, "/");
   let pre = isWin32 ? normalizeShellDrivePrefix(slashed) : slashed;
   if (pre !== slashed) {
-    pre = (isWin32 ? path14.win32.resolve : path14.resolve)(pre);
+    pre = (isWin32 ? path15.win32.resolve : path15.resolve)(pre);
   } else {
-    pre = (isWin32 ? path14.win32.resolve : path14.resolve)(pathStr);
+    pre = (isWin32 ? path15.win32.resolve : path15.resolve)(pathStr);
   }
   let normalized = pre.replace(/\\/g, "/");
   if (isWin32) {
@@ -16706,7 +16772,7 @@ function makeProjectAt(root) {
     );
   }
   try {
-    const stat2 = fs12.statSync(canonical);
+    const stat2 = fs13.statSync(canonical);
     if (!stat2.isDirectory()) {
       throw new Error(`makeProjectAt: path is not a directory: ${canonical}`);
     }
@@ -16722,11 +16788,11 @@ function makeProjectAt(root) {
 function isRepoContainer(pathStr) {
   let nestedRepos = 0;
   try {
-    const entries = fs12.readdirSync(pathStr, { withFileTypes: true });
+    const entries = fs13.readdirSync(pathStr, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const gitPath = path14.join(pathStr, entry.name, ".git");
-        if (fs12.existsSync(gitPath)) {
+        const gitPath = path15.join(pathStr, entry.name, ".git");
+        if (fs13.existsSync(gitPath)) {
           nestedRepos++;
           if (nestedRepos >= REPO_CONTAINER_THRESHOLD) {
             return true;
@@ -16740,17 +16806,17 @@ function isRepoContainer(pathStr) {
   return false;
 }
 function markerExists(current, marker) {
-  const markerPath = path14.join(current, marker);
+  const markerPath = path15.join(current, marker);
   try {
-    if (!fs12.existsSync(markerPath)) {
+    if (!fs13.existsSync(markerPath)) {
       return false;
     }
-    const stat2 = fs12.lstatSync(markerPath);
+    const stat2 = fs13.lstatSync(markerPath);
     if (!stat2.isSymbolicLink()) {
       return true;
     }
-    const resolved = fs12.realpathSync(markerPath);
-    const rel = path14.relative(path14.resolve(current), path14.resolve(resolved));
+    const resolved = fs13.realpathSync(markerPath);
+    const rel = path15.relative(path15.resolve(current), path15.resolve(resolved));
     return !rel.startsWith("..");
   } catch {
     return false;
@@ -16785,7 +16851,7 @@ function findProject(cwd) {
         break;
       }
     }
-    const parent = path14.dirname(current);
+    const parent = path15.dirname(current);
     if (parent === current) {
       break;
     }
@@ -16796,11 +16862,11 @@ function findProject(cwd) {
 
 // src/skill_cache.ts
 init_define_import_meta_env();
-import * as fs13 from "fs/promises";
+import * as fs14 from "fs/promises";
 import { createHash as createHash4 } from "crypto";
 import { resolve as resolve6 } from "path";
 import { homedir as homedir5 } from "os";
-import { readdirSync as readdirSync6, readFileSync as readFileSync8, existsSync as existsSync8, statSync as statSync9, unlinkSync as unlinkSync4 } from "node:fs";
+import { readdirSync as readdirSync6, readFileSync as readFileSync9, existsSync as existsSync9, statSync as statSync9, unlinkSync as unlinkSync4 } from "node:fs";
 var COMPACT_END_MARKER = "<!-- COMPACT_END -->";
 var SKILLS_OUTPUT_SUBDIR = "skills";
 var _skillOutputsDirOverride = null;
@@ -16819,7 +16885,7 @@ function skillsSourceDir() {
 }
 async function ensureSkillsDir() {
   try {
-    await fs13.mkdir(skillOutputsDir(), { recursive: true });
+    await fs14.mkdir(skillOutputsDir(), { recursive: true });
   } catch {
   }
 }
@@ -16927,14 +16993,14 @@ function extractNamedSection(body, heading) {
 async function listOutputs() {
   try {
     const dir = skillOutputsDir();
-    const entries = await fs13.readdir(dir, { withFileTypes: true });
+    const entries = await fs14.readdir(dir, { withFileTypes: true });
     const metas = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".meta")) {
         continue;
       }
       try {
-        const content = await fs13.readFile(resolve6(dir, entry.name), "utf-8");
+        const content = await fs14.readFile(resolve6(dir, entry.name), "utf-8");
         const meta = JSON.parse(content);
         metas.push(meta);
       } catch {
@@ -16971,8 +17037,8 @@ async function findCrossSessionEntry(skillName, contentSha) {
       const bodyPath = resolve6(dir, `${meta.outputId}.txt`);
       const gzPath = resolve6(dir, `${meta.outputId}.gz`);
       try {
-        const bodyExists = await fs13.access(bodyPath).then(() => true).catch(() => false);
-        const gzExists = await fs13.access(gzPath).then(() => true).catch(() => false);
+        const bodyExists = await fs14.access(bodyPath).then(() => true).catch(() => false);
+        const gzExists = await fs14.access(gzPath).then(() => true).catch(() => false);
         if (bodyExists || gzExists) {
           return meta;
         }
@@ -17050,7 +17116,7 @@ function getCompactAnySessionSync(skillName) {
       if (!entry.isFile() || !entry.name.endsWith("@compact")) continue;
       if (!entry.name.endsWith(suffix)) continue;
       try {
-        const text = readFileSync8(resolve6(dir, entry.name), "utf-8");
+        const text = readFileSync9(resolve6(dir, entry.name), "utf-8");
         if (text.trim()) return text;
       } catch {
         continue;
@@ -17079,7 +17145,7 @@ async function readSkillHits(skillName) {
     if (!name) return { count: 0, lastTs: 0 };
     const dir = skillOutputsDir();
     const hitsFile = resolve6(dir, `${sanitizeSkillId(name)}.hits`);
-    const content = await fs13.readFile(hitsFile, "utf-8").catch(() => null);
+    const content = await fs14.readFile(hitsFile, "utf-8").catch(() => null);
     if (content) {
       const parsed = JSON.parse(content);
       return parsed;
@@ -17094,14 +17160,14 @@ var SKILL_HIT_LOCK_STALE_MS = 5e3;
 async function acquireSkillHitLock(lockPath) {
   for (let attempt = 0; attempt < SKILL_HIT_LOCK_MAX_ATTEMPTS; attempt++) {
     try {
-      await fs13.mkdir(lockPath);
+      await fs14.mkdir(lockPath);
       return true;
     } catch (err2) {
       if (err2.code !== "EEXIST") return false;
       try {
-        const st = await fs13.stat(lockPath);
+        const st = await fs14.stat(lockPath);
         if (Date.now() - st.mtimeMs > SKILL_HIT_LOCK_STALE_MS) {
-          await fs13.rmdir(lockPath).catch(() => {
+          await fs14.rmdir(lockPath).catch(() => {
           });
           continue;
         }
@@ -17128,7 +17194,7 @@ async function incrementSkillHit(skillName) {
       hits.lastTs = Date.now();
       await atomicWriteText(hitsFile, JSON.stringify(hits, null, 2));
     } finally {
-      if (locked) await fs13.rmdir(lockPath).catch(() => {
+      if (locked) await fs14.rmdir(lockPath).catch(() => {
       });
     }
   } catch {
@@ -17163,14 +17229,14 @@ async function listSkills(sessionId) {
       let compactLen = 0;
       let compactText = "";
       try {
-        const stat2 = await fs13.stat(resolve6(dir, compactFileId));
+        const stat2 = await fs14.stat(resolve6(dir, compactFileId));
         compactLen = stat2.size;
-        compactText = await fs13.readFile(resolve6(dir, compactFileId), "utf-8").catch(() => "");
+        compactText = await fs14.readFile(resolve6(dir, compactFileId), "utf-8").catch(() => "");
       } catch {
         compactLen = 0;
       }
       const hasMarker = extractCompactFromMarker(
-        await fs13.readFile(resolve6(dir, `${meta.outputId}.txt`), "utf-8").catch(() => "")
+        await fs14.readFile(resolve6(dir, `${meta.outputId}.txt`), "utf-8").catch(() => "")
       ) !== null;
       const compactStale = isCompactStale(compactText, meta.skillName, meta.contentSha);
       const { count: hitCount } = await readSkillHits(meta.skillName);
@@ -17210,7 +17276,7 @@ async function installedSkillPath(skillName) {
   if (!name) return null;
   const diskPath = resolve6(skillsSourceDir(), name, "SKILL.md");
   try {
-    await fs13.access(diskPath);
+    await fs14.access(diskPath);
     return diskPath;
   } catch {
     return null;
@@ -17220,7 +17286,7 @@ function pruneSkillOutputs(maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_
   const dir = skillOutputsDir();
   let removed = 0;
   try {
-    if (!existsSync8(dir)) return 0;
+    if (!existsSync9(dir)) return 0;
     const cutoff = Date.now() - maxAgeMs;
     const entries = [];
     for (const file of readdirSync6(dir)) {
@@ -17228,7 +17294,7 @@ function pruneSkillOutputs(maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_
       const outputId = file.slice(0, -".meta".length);
       let ts;
       try {
-        const parsed = JSON.parse(readFileSync8(resolve6(dir, file), "utf-8"));
+        const parsed = JSON.parse(readFileSync9(resolve6(dir, file), "utf-8"));
         ts = parsed.ts;
       } catch {
         try {
@@ -17270,8 +17336,8 @@ function pruneSkillOutputs(maxCount = DEFAULT_MAX_COUNT, maxAgeMs = DEFAULT_MAX_
 
 // src/image_shrink.ts
 init_define_import_meta_env();
-import * as fs14 from "node:fs";
-import * as path15 from "node:path";
+import * as fs15 from "node:fs";
+import * as path16 from "node:path";
 var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".png",
   ".jpg",
@@ -17298,7 +17364,7 @@ async function loadSharp() {
   return _sharpCache;
 }
 function isImagePath(p) {
-  return IMAGE_EXTENSIONS.has(path15.extname(p).toLowerCase());
+  return IMAGE_EXTENSIONS.has(path16.extname(p).toLowerCase());
 }
 async function shrinkImage(input, opts) {
   const maxDimension = opts?.maxDimension ?? DEFAULT_MAX_DIMENSION;
@@ -17330,7 +17396,7 @@ async function shrinkImage(input, opts) {
 }
 function statSize(absPath) {
   try {
-    const st = fs14.statSync(absPath);
+    const st = fs15.statSync(absPath);
     return st.isFile() ? st.size : null;
   } catch {
     return null;
@@ -17344,7 +17410,7 @@ async function preReadImageHandler(event) {
   if (size === null || size < DEFAULT_SIZE_THRESHOLD_BYTES) return passOutput();
   let input;
   try {
-    input = fs14.readFileSync(filePath);
+    input = fs15.readFileSync(filePath);
   } catch {
     return passOutput();
   }
@@ -17353,7 +17419,7 @@ async function preReadImageHandler(event) {
   const saved = result.originalBytes - result.shrunkBytes;
   const pct = Math.round(saved / result.originalBytes * 100);
   const dataUrl = `data:image/${result.format};base64,${result.data.toString("base64")}`;
-  const summary = `token-goat shrank ${path15.basename(filePath)}: ${Math.round(result.originalBytes / 1024)}kb -> ${Math.round(result.shrunkBytes / 1024)}kb (${pct}% smaller, ${result.width}x${result.height} ${result.format}).`;
+  const summary = `token-goat shrank ${path16.basename(filePath)}: ${Math.round(result.originalBytes / 1024)}kb -> ${Math.round(result.shrunkBytes / 1024)}kb (${pct}% smaller, ${result.width}x${result.height} ${result.format}).`;
   return contextOutput(`${summary}
 ${dataUrl}`);
 }
@@ -17361,16 +17427,16 @@ registerHook("pre_tool_use", preReadImageHandler, { toolName: "Read" });
 
 // src/doc_compact.ts
 init_define_import_meta_env();
-import * as fs15 from "fs";
+import * as fs16 from "fs";
 import * as crypto3 from "crypto";
-import * as path16 from "path";
+import * as path17 from "path";
 var defaultSentencesPerSection = 2;
 var headerPrefix = "<!-- token-goat doc-compact source-hash:";
 var headerRegex = /^<!-- token-goat doc-compact source-hash:(\S+) source:(.+?) -->$/;
 var compactSubdir = "doc_compacts";
 function sourceHash(filePath) {
   try {
-    const data = fs15.readFileSync(filePath);
+    const data = fs16.readFileSync(filePath);
     return crypto3.createHash("sha256").update(data).digest("hex");
   } catch {
     return "";
@@ -17378,18 +17444,18 @@ function sourceHash(filePath) {
 }
 function _compactSlug(absPathStr) {
   const h = crypto3.createHash("sha256").update(absPathStr.toLowerCase()).digest("hex").slice(0, 12);
-  const ext2 = path16.extname(absPathStr);
-  const stem = path16.basename(absPathStr, ext2);
+  const ext2 = path17.extname(absPathStr);
+  const stem = path17.basename(absPathStr, ext2);
   const safeStem = stem.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 32);
   return `${h}_${safeStem}`;
 }
 function compactPathFor(sourcePath) {
-  const abs = path16.resolve(sourcePath);
-  return path16.join(dataDir(), compactSubdir, `${_compactSlug(abs)}.md`);
+  const abs = path17.resolve(sourcePath);
+  return path17.join(dataDir(), compactSubdir, `${_compactSlug(abs)}.md`);
 }
 function readCompactHeader(compactPath) {
   try {
-    const text = fs15.readFileSync(compactPath, "utf-8");
+    const text = fs16.readFileSync(compactPath, "utf-8");
     const firstLine = text.split("\n")[0] || "";
     const m = firstLine.match(headerRegex);
     if (!m || !m[1] || !m[2]) return null;
@@ -17408,15 +17474,15 @@ function isCompactFresh(compactPath, sourcePath) {
 }
 function markCompactStale(compactPath) {
   try {
-    if (!fs15.existsSync(compactPath)) return false;
-    const text = fs15.readFileSync(compactPath, "utf-8");
+    if (!fs16.existsSync(compactPath)) return false;
+    const text = fs16.readFileSync(compactPath, "utf-8");
     const lines = text.split("\n");
     if (!lines[0]) return false;
     const m = lines[0].match(headerRegex);
     if (!m || m[1] === "STALE") return false;
     const oldHash = m[1];
     lines[0] = lines[0].replace(`source-hash:${oldHash}`, "source-hash:STALE");
-    fs15.writeFileSync(compactPath, lines.join("\n"), "utf-8");
+    fs16.writeFileSync(compactPath, lines.join("\n"), "utf-8");
     return true;
   } catch {
     return false;
@@ -17424,7 +17490,7 @@ function markCompactStale(compactPath) {
 }
 function readCompactBody(compactPath) {
   try {
-    const text = fs15.readFileSync(compactPath, "utf-8");
+    const text = fs16.readFileSync(compactPath, "utf-8");
     const lines = text.split("\n");
     if (lines.length < 2) return null;
     const body = lines.slice(1).join("\n").trimStart();
@@ -17434,17 +17500,17 @@ function readCompactBody(compactPath) {
   }
 }
 function writeCompact(compactPath, sourcePath, compactBody, sourceRel) {
-  const srcPath = path16.resolve(sourcePath);
+  const srcPath = path17.resolve(sourcePath);
   const sha = sourceHash(srcPath);
-  const displayRel = sourceRel || path16.basename(srcPath);
+  const displayRel = sourceRel || path17.basename(srcPath);
   const header = `${headerPrefix}${sha} source:${displayRel} -->
 `;
   const fullText = header + compactBody.trimStart();
-  const dir = path16.dirname(compactPath);
-  if (!fs15.existsSync(dir)) {
-    fs15.mkdirSync(dir, { recursive: true });
+  const dir = path17.dirname(compactPath);
+  if (!fs16.existsSync(dir)) {
+    fs16.mkdirSync(dir, { recursive: true });
   }
-  fs15.writeFileSync(compactPath, fullText, "utf-8");
+  fs16.writeFileSync(compactPath, fullText, "utf-8");
 }
 function buildExtractiveCompact(text, maxSentences) {
   const max = maxSentences ?? defaultSentencesPerSection;
@@ -17536,7 +17602,7 @@ function extractDocCompact(body, heading) {
 }
 function compactDoc(filePath, heading) {
   try {
-    const body = fs15.readFileSync(filePath, "utf-8");
+    const body = fs16.readFileSync(filePath, "utf-8");
     const compact = extractDocCompact(body, heading);
     return compact || null;
   } catch {
@@ -17570,7 +17636,7 @@ function sessionArtifactRecall(filePath) {
 }
 function statSize2(absPath) {
   try {
-    return fs16.statSync(absPath).size;
+    return fs17.statSync(absPath).size;
   } catch {
     return null;
   }
@@ -17626,7 +17692,7 @@ function buildLineDiff(oldContent, newContent, label) {
 }
 function scanCrossSessionManifests(projectRoot, projectHash2, filePath, ttlSecs) {
   try {
-    const relPath = path17.relative(projectRoot, filePath).replace(/\\/g, "/");
+    const relPath = path18.relative(projectRoot, filePath).replace(/\\/g, "/");
     const manifests = readAllSessionManifests(projectHash2, ttlSecs);
     for (const data of manifests) {
       const files = data["files"];
@@ -17654,7 +17720,7 @@ function preReadHandler(event) {
       "node_modules is typically noise; use npm ls, npm outdated, or npm audit instead for dependency info. To force access, use: token-goat read node_modules/package/file.js::symbol-name or token-goat section node_modules/package/file.js::heading"
     );
   }
-  const basename13 = path17.basename(normalized);
+  const basename13 = path18.basename(normalized);
   if (isLockFile(basename13)) {
     return denyOutput(
       'Lock files are rarely useful to read in full. Use `token-goat section "' + normalized + '::<section>"` to extract a specific dependency, or read the relevant manifest instead.'
@@ -17690,7 +17756,7 @@ function preReadHandler(event) {
   const skillName = detectSkillFile(normalized);
   if (skillName && basename13 === "SKILL.md") {
     try {
-      const body = fs16.readFileSync(normalized, "utf-8");
+      const body = fs17.readFileSync(normalized, "utf-8");
       const bodySha = contentHash(body);
       const compact = getCompactAnySessionSync(skillName);
       const stale = isCompactStale(compact, skillName, bodySha);
@@ -17726,7 +17792,7 @@ function preReadHandler(event) {
       const sz = statSize2(normalized);
       if (sz !== null && sz >= MARKDOWN_SIZE_THRESHOLD) {
         markdownSize = sz;
-        fileContent = fs16.readFileSync(normalized, "utf8");
+        fileContent = fs17.readFileSync(normalized, "utf8");
       }
     } catch {
     }
@@ -17783,7 +17849,7 @@ function preReadHandler(event) {
         try {
           const sz = statSize2(normalized);
           if (sz !== null && sz <= 256 * 1024) {
-            const currentContent = fs16.readFileSync(normalized, "utf8");
+            const currentContent = fs17.readFileSync(normalized, "utf8");
             const TRUNC_MARKER = "\n<snapshot truncated at ";
             const oldRaw = oldArtifactSnap.toString("utf8");
             const truncIdx = oldRaw.indexOf(TRUNC_MARKER);
@@ -17826,7 +17892,7 @@ function preReadHandler(event) {
       recordFileRead(normalized);
       recordStat("session_hint", 0, 0);
       return denyOutput(
-        'File was truncated on last read (>33K tokens). Use `token-goat skeleton "' + normalized + '"` for structure or `token-goat read "' + normalized + '::SymbolName"` for one function.'
+        'File was truncated on last read (>33K tokens). Use `token-goat skeleton "' + normalized + '"` for structure or `token-goat read "' + normalized + '::SymbolName"` for one function. To edit it anyway, use `token-goat replace "' + normalized + "\" --old-from <oldfile> --new-from <newfile>` \u2014 Read/Edit's own precondition can't be satisfied after this deny."
       );
     }
     const sessionId = getSessionId();
@@ -17835,7 +17901,7 @@ function preReadHandler(event) {
       try {
         const sz = statSize2(normalized);
         if (sz !== null && sz <= 256 * 1024) {
-          const currentContent = fs16.readFileSync(normalized, "utf8");
+          const currentContent = fs17.readFileSync(normalized, "utf8");
           const TRUNC_MARKER = "\n<snapshot truncated at ";
           const oldRaw = oldSnap.toString("utf8");
           const truncIdx = oldRaw.indexOf(TRUNC_MARKER);
@@ -17872,7 +17938,7 @@ function preReadHandler(event) {
       if (!project) {
         project = makeProjectAt(cwd);
       }
-      const relPath = path17.relative(project.root, normalized).replace(/\\/g, "/");
+      const relPath = path18.relative(project.root, normalized).replace(/\\/g, "/");
       if (!relPath.startsWith("..")) {
         const ttlSecs = config.hints.cross_session_read_dedup_ttl_secs;
         if (scanCrossSessionManifests(project.root, project.hash, normalized, ttlSecs)) {
@@ -17901,25 +17967,25 @@ function preReadHandler(event) {
     }
     if (wasFileTruncatedThisSession(normalized)) {
       return denyOutput(
-        'File was truncated on last read (>33K tokens). Use `token-goat skeleton "' + normalized + '"` for structure or `token-goat read "' + normalized + '::SymbolName"` for one function.'
+        'File was truncated on last read (>33K tokens). Use `token-goat skeleton "' + normalized + '"` for structure or `token-goat read "' + normalized + '::SymbolName"` for one function. To edit it anyway, use `token-goat replace "' + normalized + "\" --old-from <oldfile> --new-from <newfile>` \u2014 Read/Edit's own precondition can't be satisfied after this deny."
       );
     }
     if (/\.(md|mdx|markdown|rst)$/i.test(basename13)) {
       return denyOutput(
-        'Markdown file already read this session. Use `token-goat section "' + normalized + '::HeadingName"` to read one section.'
+        'Markdown file already read this session. Use `token-goat section "' + normalized + '::HeadingName"` to read one section. To edit it anyway, use `token-goat replace "' + normalized + "\" --old-from <oldfile> --new-from <newfile>` \u2014 Read/Edit's own precondition can't be satisfied after this deny."
       );
     }
     const isSourceExt = /\.(ts|tsx|js|jsx|py|go|rs|java|rb|php|swift|kt|cpp|c|h)$/i.test(basename13);
     if (isSourceExt && reads >= 2) {
       recordStat("read_count_deny", rereadBytes, Math.round(rereadBytes / 4));
       return denyOutput(
-        "Read this file " + reads + ' times already \u2014 use `token-goat read "' + normalized + '::Symbol"`, `token-goat skeleton ' + normalized + "`, or `token-goat outline " + normalized + "` to pull just the part you need."
+        "Read this file " + reads + ' times already \u2014 use `token-goat read "' + normalized + '::Symbol"`, `token-goat skeleton ' + normalized + "`, or `token-goat outline " + normalized + '` to pull just the part you need. To edit it anyway, use `token-goat replace "' + normalized + "\" --old-from <oldfile> --new-from <newfile>` \u2014 Read/Edit's own precondition can't be satisfied after this deny."
       );
     }
     const hint = _isDocFile(normalized) ? 'Use `token-goat section "' + normalized + '::SectionName"` to read one section.' : "Use token-goat read/section/symbol to re-read surgically.";
     if (rereadBytes >= REREAD_DENY_BYTES || reads >= 2) {
       return denyOutput(
-        normalized + " was already read this session (" + reads + " " + plural2 + "). " + hint
+        normalized + " was already read this session (" + reads + " " + plural2 + "). " + hint + ' To edit it anyway, use `token-goat replace "' + normalized + "\" --old-from <oldfile> --new-from <newfile>` \u2014 Read/Edit's own precondition can't be satisfied after this deny."
       );
     }
     return contextOutput(
@@ -17934,7 +18000,7 @@ function preReadHandler(event) {
     recordStat("session_hint", size, Math.round(size / 4));
     if (size >= LARGE_FILE_DENY_BYTES) {
       return denyOutput(
-        normalized + " is very large (" + kb + "KB). " + hint + " Use Read with offset/limit to sample specific sections."
+        normalized + " is very large (" + kb + "KB). " + hint + ' Use Read with offset/limit to sample specific sections. To edit it anyway, use `token-goat replace "' + normalized + "\" --old-from <oldfile> --new-from <newfile>` \u2014 Read/Edit's own precondition can't be satisfied after this deny."
       );
     }
     recordFileRead(normalized);
@@ -17945,7 +18011,7 @@ function preReadHandler(event) {
       "Note: " + normalized + " is large (" + kb + "KB). " + hint
     );
   }
-  const fileTypeExt = path17.extname(normalized).slice(1).toLowerCase();
+  const fileTypeExt = path18.extname(normalized).slice(1).toLowerCase();
   const binaryExts = /* @__PURE__ */ new Set(["pdf", "docx", "xlsx", "pptx", "odt", "ods", "ott", "odp"]);
   const textTypeExts = /* @__PURE__ */ new Set(["html", "htm", "xhtml", "txt", "log", "out", "err", "trace", "csv", "tsv"]);
   const fileStatSize = size ?? statSize2(normalized) ?? 0;
@@ -17954,7 +18020,7 @@ function preReadHandler(event) {
     let ftContent = "";
     if (!binaryExts.has(fileTypeExt)) {
       try {
-        ftContent = fs16.readFileSync(normalized, "utf8");
+        ftContent = fs17.readFileSync(normalized, "utf8");
       } catch {
       }
     }
@@ -17987,13 +18053,13 @@ function postReadHandler(event) {
   if (respText.includes("[Truncated:") || respText.includes("Truncated: PARTIAL view")) {
     markFileTruncated(normalized);
   }
-  const postBasename = path17.basename(normalized);
+  const postBasename = path18.basename(normalized);
   const diffSourcesEnabled = loadConfig().hints.serve_diff_on_reread;
   if (/\.(md|mdx|markdown|rst|txt)$/i.test(postBasename) || isSessionArtifactFile(normalized) || diffSourcesEnabled && DIFFABLE_SOURCE_RE.test(postBasename)) {
     try {
       const sz = statSize2(normalized);
       if (sz !== null && sz <= 256 * 1024) {
-        const content = fs16.readFileSync(normalized);
+        const content = fs17.readFileSync(normalized);
         store(getSessionId(), normalized, content);
       }
     } catch {
@@ -18009,7 +18075,7 @@ function postReadHandler(event) {
       const sessionState = exportSessionState();
       const mappedFiles = [];
       for (const fileEntry of sessionState.files) {
-        const relPath = path17.relative(project.root, fileEntry.path).replace(/\\/g, "/");
+        const relPath = path18.relative(project.root, fileEntry.path).replace(/\\/g, "/");
         if (!relPath.startsWith("..")) {
           mappedFiles.push({
             rel_path: relPath,
@@ -18028,65 +18094,6 @@ registerHook("post_tool_use", postReadHandler, { toolName: "Read" });
 // src/hooks_edit.ts
 init_define_import_meta_env();
 import * as path19 from "node:path";
-
-// src/hooks_index.ts
-init_define_import_meta_env();
-import * as fs17 from "node:fs";
-import * as path18 from "node:path";
-function dirtyQueuePath() {
-  return path18.join(dataDir(), "queue", "dirty.txt");
-}
-function appendDirtyPath(normalizedPath) {
-  const queuePath = dirtyQueuePath();
-  const dir = path18.dirname(queuePath);
-  try {
-    fs17.mkdirSync(dir, { recursive: true });
-  } catch (e) {
-    if (e.code !== "EEXIST" || !fs17.existsSync(dir)) throw e;
-  }
-  let leadingNewline = "";
-  try {
-    const existing = fs17.readFileSync(queuePath, "utf8");
-    if (existing.length > 0 && !existing.endsWith("\n")) leadingNewline = "\n";
-  } catch {
-  }
-  fs17.appendFileSync(queuePath, `${leadingNewline}${normalizedPath}
-`);
-}
-function getDirtyPaths() {
-  const queuePath = dirtyQueuePath();
-  let raw;
-  try {
-    raw = fs17.readFileSync(queuePath, "utf8");
-  } catch {
-    return [];
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const out2 = [];
-  for (const line of raw.split("\n")) {
-    const trimmed = line.trim();
-    if (trimmed === "" || seen.has(trimmed)) continue;
-    seen.add(trimmed);
-    out2.push(trimmed);
-  }
-  return out2;
-}
-function preCompactIndexHandler(_event) {
-  const paths = getDirtyPaths();
-  if (paths.length > 0) {
-    const sidecar = path18.join(dataDir(), "queue", "pending.txt");
-    try {
-      fs17.mkdirSync(path18.dirname(sidecar), { recursive: true });
-      atomicWriteBytes(sidecar, Buffer.from(`${paths.join("\n")}
-`, "utf8"));
-    } catch {
-    }
-  }
-  return passOutput();
-}
-registerHook("pre_compact", preCompactIndexHandler);
-
-// src/hooks_edit.ts
 function postEditHandler(event) {
   const filePath = getFilePath(event);
   if (filePath === void 0) return passOutput();
@@ -32015,15 +32022,24 @@ function extractHeadFile(cmd) {
   return { filePath, isDoc, isConfig };
 }
 function extractSedRange(cmd) {
-  const m = /^sed\s+-n\s+['"](\d+),(\d+)p['"]\s+(?:"([^"]+)"|'([^']+)'|(\S+))(?:\s+2>\/dev\/null)?\s*$/.exec(cmd);
+  const m = /^sed\s+-n\s+['"](?:\d+,\d+p)(?:;\d+,\d+p)*['"]\s+(?:"([^"]+)"|'([^']+)'|(\S+))(?:\s+2>\/dev\/null)?\s*$/.exec(cmd);
   if (!m) return null;
-  const start = parseInt(m[1], 10);
-  const end = parseInt(m[2], 10);
-  const filePath = m[3] ?? m[4] ?? m[5];
+  const quotedAddress = /['"]([^'"]+)['"]/.exec(cmd);
+  if (!quotedAddress) return null;
+  const ranges = [];
+  for (const clause of quotedAddress[1].split(";")) {
+    const cm = /^(\d+),(\d+)p$/.exec(clause ?? "");
+    if (!cm) return null;
+    const start = parseInt(cm[1], 10);
+    const end = parseInt(cm[2], 10);
+    if (start < 1 || end < start) return null;
+    ranges.push([start, end]);
+  }
+  if (ranges.length === 0) return null;
+  const filePath = m[1] ?? m[2] ?? m[3];
   if (filePath === void 0) return null;
   if (isTempPath(filePath)) return null;
-  if (start < 1 || end < start) return null;
-  return { filePath, start, end };
+  return { filePath, ranges };
 }
 var SYMBOL_BEARING_LANGUAGES = /* @__PURE__ */ new Set([
   "python",
@@ -32044,20 +32060,21 @@ var SYMBOL_BEARING_LANGUAGES = /* @__PURE__ */ new Set([
   "bash",
   "powershell"
 ]);
-function sedRangeHint(filePath, start, end) {
+function sedRangeHint(filePath, ranges) {
   const lang = detectLanguage(filePath);
-  const rangeRead = '`token-goat read "' + filePath + "@" + start + "-" + end + '"`';
+  const rangeReads = ranges.map(([s, e]) => '`token-goat read "' + filePath + "@" + s + "-" + e + '"`');
+  const allReads = rangeReads.length === 2 ? rangeReads.join(" and ") : rangeReads.length >= 3 ? rangeReads.slice(0, -1).join(", ") + ", and " + rangeReads[rangeReads.length - 1] : rangeReads[0];
   const prefix = "`sed -n` line-range reads bypass read hooks. ";
   if (lang === "markdown") {
-    return prefix + 'For Markdown, `token-goat section "' + filePath + '::<heading>"` extracts a whole section by name (robust to line shifts); or ' + rangeRead + " for exactly those lines.";
+    return prefix + 'For Markdown, `token-goat section "' + filePath + '::<heading>"` extracts a whole section by name (robust to line shifts); or ' + allReads + " for exactly those lines.";
   }
   if (lang === "toml" || lang === "json" || lang === "yaml" || lang === "ini") {
-    return prefix + 'For config, `token-goat config-get "' + filePath + '" <key>` or `token-goat section "' + filePath + '::<block>"` extracts one value; or ' + rangeRead + " for exactly those lines.";
+    return prefix + 'For config, `token-goat config-get "' + filePath + '" <key>` or `token-goat section "' + filePath + '::<block>"` extracts one value; or ' + allReads + " for exactly those lines.";
   }
   if (SYMBOL_BEARING_LANGUAGES.has(lang)) {
-    return prefix + 'For a whole function/class, `token-goat symbol <name>` or `token-goat read "' + filePath + '::<Symbol>"` is robust to line shifts; or ' + rangeRead + " for exactly those lines.";
+    return prefix + 'For a whole function/class, `token-goat symbol <name>` or `token-goat read "' + filePath + '::<Symbol>"` is robust to line shifts; or ' + allReads + " for exactly those lines.";
   }
-  return prefix + "Use " + rangeRead + " to read exactly those lines.";
+  return prefix + "Use " + allReads + " to read exactly those lines.";
 }
 function findRangeOverlap(prior, start, end) {
   let best = null;
@@ -32541,15 +32558,23 @@ function preBashHandler(event) {
   }
   const sedRange = extractSedRange(cmd);
   if (sedRange !== null) {
-    const { filePath, start, end } = sedRange;
+    const { filePath, ranges } = sedRange;
     recordStat("session_hint", 0, 0);
     const sedDedupKey = resolveIndexPath(filePath, preHookCwd ?? process.cwd());
-    const priorOverlap = findRangeOverlap(getFileLineRanges(sedDedupKey), start, end);
-    recordFileLineRange(sedDedupKey, start, end);
-    if (priorOverlap !== null) {
-      return contextOutput(sedOverlapHint(filePath, priorOverlap, start, end));
+    const overlapHints = [];
+    const freshRanges = [];
+    for (const [start, end] of ranges) {
+      const priorOverlap = findRangeOverlap(getFileLineRanges(sedDedupKey), start, end);
+      recordFileLineRange(sedDedupKey, start, end);
+      if (priorOverlap !== null) {
+        overlapHints.push(sedOverlapHint(filePath, priorOverlap, start, end));
+      } else {
+        freshRanges.push([start, end]);
+      }
     }
-    return contextOutput(sedRangeHint(filePath, start, end));
+    const hints = [...overlapHints];
+    if (freshRanges.length > 0) hints.push(sedRangeHint(filePath, freshRanges));
+    return contextOutput(hints.join(" "));
   }
   const catJsonPipe = extractCatJsonPipe(cmd);
   if (catJsonPipe !== null) {
@@ -40161,6 +40186,12 @@ function atomicWriteBuffer(dest, data) {
     throw e;
   }
 }
+function enqueueDirtyPathSafe(filePath) {
+  try {
+    appendDirtyPath(resolveIndexPath(filePath));
+  } catch {
+  }
+}
 function mapFsError(e, src, dest) {
   const fe = e;
   if (fe.code === "ENOENT") {
@@ -40171,6 +40202,9 @@ function mapFsError(e, src, dest) {
     throw new CliError(`destination directory does not exist: ${destDir}`);
   }
   if (fe.code === "ENOTDIR") {
+    if (src !== void 0 && dest === void 0) {
+      throw new CliError(`source path contains a file where a directory was expected: ${src}`);
+    }
     throw new CliError(`destination path contains a file where a directory was expected: ${dest ?? fe.path ?? ""}`);
   }
   if (fe.code === "EISDIR") {
@@ -40180,6 +40214,9 @@ function mapFsError(e, src, dest) {
     throw new CliError(`destination is a directory, not a file: ${dest ?? (errPath || "(unknown)")}`);
   }
   if (fe.code === "EACCES" || fe.code === "EPERM") {
+    if (src !== void 0 && dest === void 0) {
+      throw new CliError(`permission denied reading: ${src}`);
+    }
     throw new CliError(`permission denied writing to: ${dest ?? fe.path ?? ""}`);
   }
   if (fe.code === "EROFS") {
@@ -40233,6 +40270,76 @@ var WIN_RESERVED = /* @__PURE__ */ new Set([
   "CONIN$",
   "CONOUT$"
 ]);
+function validateWritablePath(dest, label) {
+  if (!dest || !dest.trim()) {
+    throw new CliError(`${label} path cannot be empty`);
+  }
+  if (dest.includes("\0")) {
+    throw new CliError(`${label} path contains a null byte`);
+  }
+  if (isWindows()) {
+    const base = path33.basename(dest);
+    const stem = base.replace(/\.[^.]*$/, "").toUpperCase();
+    if (WIN_RESERVED.has(stem)) {
+      throw new CliError(`${label} '${base}' is a reserved Windows device name`);
+    }
+    if (base.endsWith(".") || base.endsWith(" ")) {
+      throw new CliError(`${label} filename '${base}' ends with '${base.slice(-1)}' \u2014 Windows NTFS silently strips trailing dots and spaces, which would clobber a different file`);
+    }
+  }
+}
+function parseMaxStdinMB() {
+  const raw = process.env["TOKEN_GOAT_MAX_STDIN_MB"] ?? "512";
+  const maxMB = parseInt(raw, 10);
+  if (!Number.isFinite(maxMB) || maxMB <= 0) {
+    throw new CliError(`TOKEN_GOAT_MAX_STDIN_MB must be a positive integer; got '${raw}'`);
+  }
+  return maxMB;
+}
+function readTextFileBounded(filePath, label, allowStdIn = false) {
+  if (!filePath || !filePath.trim()) {
+    throw new CliError(`${label} path cannot be empty`);
+  }
+  if (filePath.includes("\0")) {
+    throw new CliError(`${label} path contains a null byte`);
+  }
+  if (!allowStdIn && !isWindows() && /^\/dev\/(stdin|fd\/0)$|^\/proc\/self\/fd\/0$/.test(filePath) && process.stdin.isTTY) {
+    const altLabel = label.endsWith("-from") ? label.replace("-from", "-b64") : "a regular file path";
+    throw new CliError(`${label} ${filePath} requires piped input; use ${altLabel} for interactive use`);
+  }
+  try {
+    const st = fs31.statSync(filePath);
+    if (st.isFIFO() || st.isSocket()) {
+      throw new CliError(`${label} '${filePath}' is a special file (FIFO or socket) \u2014 only regular files are supported`);
+    }
+    const maxBytes = parseMaxStdinMB() * 1024 * 1024;
+    if (st.size > maxBytes) {
+      throw new CliError(`${label} '${filePath}' exceeds size limit (${Math.round(st.size / 1024 / 1024)} MB); set TOKEN_GOAT_MAX_STDIN_MB to override`);
+    }
+    return fs31.readFileSync(filePath, "utf8");
+  } catch (e) {
+    if (e instanceof CliError) throw e;
+    mapFsError(e, filePath);
+  }
+}
+function decodeBase64Text(payload, label) {
+  const normalized = payload.replace(/\s/g, "").replace(/-/g, "+").replace(/_/g, "/");
+  if (payload !== "" && normalized === "") {
+    throw new CliError(`${label} payload contains only whitespace \u2014 likely a shell expansion error; pass an empty string explicitly for a zero-byte file`);
+  }
+  const maxBytes = parseMaxStdinMB() * 1024 * 1024;
+  const decodedSize = Math.floor(normalized.replace(/=+$/, "").length * 3 / 4);
+  if (decodedSize > maxBytes) {
+    throw new CliError(`${label} payload would decode to ${Math.round(decodedSize / 1024 / 1024)} MB which exceeds size limit; set TOKEN_GOAT_MAX_STDIN_MB to override`);
+  }
+  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(normalized)) {
+    throw new CliError(`${label} payload contains non-base64 characters \u2014 check for shell expansion of $VAR or backticks`);
+  }
+  if (normalized.replace(/=+$/, "").length % 4 === 1) {
+    throw new CliError(`${label} payload length is invalid (trailing single base64 character cannot decode to any bytes \u2014 payload is likely truncated)`);
+  }
+  return Buffer.from(normalized, "base64").toString("utf8");
+}
 function cmdWriteFile(dest, opts) {
   if (!dest || !dest.trim()) {
     throw new CliError("destination path cannot be empty");
@@ -40281,6 +40388,7 @@ function cmdWriteFile(dest, opts) {
       if (e instanceof CliError) throw e;
       mapFsError(e, opts.from, dest);
     }
+    enqueueDirtyPathSafe(dest);
     return;
   }
   if (opts.b64 !== void 0) {
@@ -40308,6 +40416,7 @@ function cmdWriteFile(dest, opts) {
     } catch (e) {
       mapFsError(e, void 0, dest);
     }
+    enqueueDirtyPathSafe(dest);
     return;
   }
   if (process.stdin.isTTY) {
@@ -40341,6 +40450,7 @@ function cmdWriteFile(dest, opts) {
       cleanup();
       try {
         atomicWriteBuffer(dest, Buffer.concat(chunks));
+        enqueueDirtyPathSafe(dest);
         resolve15();
       } catch (e) {
         try {
@@ -40371,6 +40481,52 @@ function cmdWriteFile(dest, opts) {
     process.stdin.resume();
   });
 }
+function cmdReplace(file, opts) {
+  validateWritablePath(file, "target file");
+  const targetText = readTextFileBounded(file, "target file", true);
+  const usingFrom = opts.oldFrom !== void 0 || opts.newFrom !== void 0;
+  const usingB64 = opts.oldB64 !== void 0 || opts.newB64 !== void 0;
+  if (usingFrom && usingB64) {
+    throw new CliError("cannot mix --old-from/--new-from with --old-b64/--new-b64");
+  }
+  if (!usingFrom && !usingB64) {
+    throw new CliError("must provide either --old-from/--new-from or --old-b64/--new-b64");
+  }
+  if (usingFrom) {
+    if (opts.oldFrom === void 0 || opts.newFrom === void 0) {
+      throw new CliError("must pass both --old-from and --new-from together");
+    }
+  } else {
+    if (opts.oldB64 === void 0 || opts.newB64 === void 0) {
+      throw new CliError("must pass both --old-b64 and --new-b64 together");
+    }
+  }
+  const oldText = usingFrom ? readTextFileBounded(opts.oldFrom, "--old-from") : decodeBase64Text(opts.oldB64, "--old-b64");
+  const newText = usingFrom ? readTextFileBounded(opts.newFrom, "--new-from") : decodeBase64Text(opts.newB64, "--new-b64");
+  if (oldText === "") {
+    throw new CliError("old string cannot be empty");
+  }
+  let occurrences = 0;
+  let cursor = 0;
+  while ((cursor = targetText.indexOf(oldText, cursor)) !== -1) {
+    occurrences += 1;
+    cursor += oldText.length;
+  }
+  if (occurrences === 0) {
+    throw new CliError(`old string not found in ${file}`);
+  }
+  if (occurrences > 1 && !opts.all) {
+    throw new CliError(`old string appears ${occurrences} times in ${file} \u2014 pass --all to replace every occurrence, or provide a more specific match`);
+  }
+  const replaced = occurrences === 1 && !opts.all ? targetText.replace(oldText, () => newText) : targetText.replaceAll(oldText, () => newText);
+  try {
+    atomicWriteBuffer(file, Buffer.from(replaced, "utf8"));
+  } catch (e) {
+    mapFsError(e, void 0, file);
+  }
+  enqueueDirtyPathSafe(file);
+  out(`replaced ${occurrences} occurrence${occurrences === 1 ? "" : "s"} in ${file}`);
+}
 async function cmdGdriveSections(fileId, opts) {
   if (opts.heading !== void 0) {
     const content = await getSectionContent(fileId, opts.heading);
@@ -40805,6 +40961,7 @@ function buildProgram() {
   );
   program2.command("config-get <file> <key>").description("read one value from a config file (TOML/JSON/YAML/INI)").action((file, key) => runExit(() => runConfigGet({ file, key })));
   program2.command("write-file <dest>").description("write exact bytes to a file \u2014 handles backticks, quotes, $vars, CRLF without escaping\n\nModes: --b64 PAYLOAD (base64), --from SOURCE (copy file), or piped stdin").option("--from <source>", "copy bytes from this source file instead of stdin/base64").option("--b64 <payload>", "decode base64 payload and write to dest").action(guard(cmdWriteFile));
+  program2.command("replace <file>").description("replace one string in a file; supply old/new text via --old-from/--new-from or --old-b64/--new-b64, and use --all to replace every occurrence").option("--old-from <source>", "read the old text from this source file").option("--new-from <source>", "read the new text from this source file").option("--old-b64 <payload>", "base64 payload for the old text").option("--new-b64 <payload>", "base64 payload for the new text").option("--all", "replace every occurrence instead of requiring a unique match").action(guard(cmdReplace));
   program2.command("gdrive-sections <file-id>").description("fetch and list sections from a public Google Doc").option("--heading <name>", "get content of one named section").action(guard(cmdGdriveSections));
   program2.command("compress").description("run a shell command and emit a compressed view of its output").requiredOption("-c, --cmd <command>", "the shell command to run, as one string").option("-f, --filter <name>", "filter name (auto-detected from the command when omitted)").option("--timeout <seconds>", "wall-clock timeout in seconds (0 = built-in default)").option("--no-compress", "stream output raw without compression (debug the wrapper)").option("--profile <name>", "compression profile: aggressive | balanced | minimal").option("--max-tokens <n>", "post-compress token cap (0 = no cap)").action(cmdCompress);
   program2.command("version").description("print the token-goat version").action(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "token-goat",
-  "version": "2.6.0",
+  "version": "2.6.1",
   "description": "Surgical token-reduction companion for Claude Code and other AI coding agents",
   "type": "module",
   "main": "./dist/token-goat.mjs",