token-goat 2.9.29 → 2.9.31

package/dist/token-goat-chunk-5RG5SBL6.mjs

@@ -0,0 +1,221 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/code_fold.ts
+init_define_import_meta_env();
+var FOLDABLE_KINDS = /* @__PURE__ */ new Set(["function", "method", "func", "def", "fn", "procedure", "constructor", "variable"]);
+var MIN_FOLDED_ROWS = 3;
+function planBodyFolds(rows, spans, keep, minSpan) {
+  if (rows.length === 0 || spans.length === 0 || keep < 1) return [];
+  const rowAt = /* @__PURE__ */ new Map();
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    if (row !== void 0) rowAt.set(row.no, i);
+  }
+  const ordered = [...spans].sort((a, b) => a.lineStart - b.lineStart || b.lineEnd - a.lineEnd);
+  let firstDeliveredLine = null;
+  for (const line of rowAt.keys()) if (firstDeliveredLine === null || line < firstDeliveredLine) firstDeliveredLine = line;
+  const folds = [];
+  let foldedThrough = -1;
+  for (const span of ordered) {
+    if (!FOLDABLE_KINDS.has(span.kind)) continue;
+    if (span.lineEnd - span.lineStart + 1 < minSpan) continue;
+    if (span.lineStart <= foldedThrough) continue;
+    if (firstDeliveredLine !== null && span.lineStart < firstDeliveredLine) continue;
+    const firstFolded = span.lineStart + keep;
+    if (firstFolded > span.lineEnd) continue;
+    let startIdx = -1;
+    let endIdx = -1;
+    for (let line = firstFolded; line <= span.lineEnd; line++) {
+      const idx = rowAt.get(line);
+      if (idx === void 0) continue;
+      if (startIdx < 0) startIdx = idx;
+      endIdx = idx;
+    }
+    if (startIdx < 0 || endIdx < startIdx) continue;
+    const len = endIdx - startIdx + 1;
+    const firstRow = rows[startIdx];
+    const lastRow = rows[endIdx];
+    if (firstRow === void 0 || lastRow === void 0) continue;
+    if (lastRow.no - firstRow.no + 1 !== len) continue;
+    if (len < MIN_FOLDED_ROWS) continue;
+    folds.push({ startIdx, len, name: span.name, kind: "body", declLine: span.lineStart, firstLine: firstRow.no, lastLine: lastRow.no });
+    foldedThrough = span.lineEnd;
+  }
+  return folds;
+}
+var SLASH_STAR = { line: ["//"], open: "/*", close: "*/" };
+function advanceTemplateState(text, inTemplate) {
+  let t = inTemplate;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (c === "`") {
+      t = !t;
+      continue;
+    }
+    if (t) continue;
+    if (c === "/" && text[i + 1] === "/") return t;
+    if (c === "'" || c === '"') {
+      const q = c;
+      i++;
+      while (i < text.length && text[i] !== q) {
+        if (text[i] === "\\") i++;
+        i++;
+      }
+    }
+  }
+  return t;
+}
+var HASH = { line: ["#"] };
+var DOUBLE_DASH = { line: ["--"] };
+var COMMENT_SYNTAX = new Map([
+  ...["ts", "tsx", "js", "jsx", "mjs", "cjs", "java", "c", "h", "cc", "cpp", "hpp", "cs", "go", "rs", "swift", "kt", "scala", "php", "dart"].map(
+    (ext) => [ext, SLASH_STAR]
+  ),
+  ...["py", "rb", "sh", "bash", "zsh", "pl", "r"].map((ext) => [ext, HASH]),
+  ...["sql", "lua", "hs"].map((ext) => [ext, DOUBLE_DASH])
+]);
+function commentSyntaxFor(path) {
+  const dot = path.lastIndexOf(".");
+  if (dot < 0) return null;
+  return COMMENT_SYNTAX.get(path.slice(dot + 1).toLowerCase()) ?? null;
+}
+function planCommentFolds(rows, syntax, commentKeep, commentMinBlock, occupied) {
+  if (syntax === null || rows.length === 0 || commentKeep < 1 || commentMinBlock < 1) return [];
+  const folds = [];
+  let i = 0;
+  let inBlock = false;
+  const tracksTemplates = syntax.open === "/*";
+  let inTemplate = false;
+  while (i < rows.length) {
+    const start = i;
+    while (i < rows.length) {
+      const text = rows[i]?.text ?? "";
+      const trimmed = text.trim();
+      if (tracksTemplates) {
+        const wasInTemplate = inTemplate;
+        inTemplate = advanceTemplateState(text, inTemplate);
+        if (wasInTemplate || inTemplate) {
+          inBlock = false;
+          break;
+        }
+      }
+      if (inBlock) {
+        if (syntax.close !== void 0 && trimmed.includes(syntax.close)) inBlock = false;
+        i++;
+        continue;
+      }
+      if (syntax.open !== void 0 && trimmed.startsWith(syntax.open)) {
+        if (syntax.close === void 0 || !trimmed.slice(syntax.open.length).includes(syntax.close)) inBlock = true;
+        i++;
+        continue;
+      }
+      if (syntax.line.some((p) => trimmed.startsWith(p))) {
+        i++;
+        continue;
+      }
+      break;
+    }
+    const runLen = i - start;
+    if (runLen >= commentMinBlock) {
+      const foldStart = start + commentKeep;
+      const len = i - foldStart;
+      const firstRow = rows[foldStart];
+      const lastRow = rows[i - 1];
+      if (len >= MIN_FOLDED_ROWS && firstRow !== void 0 && lastRow !== void 0 && lastRow.no - firstRow.no + 1 === len) {
+        let clear = true;
+        for (let k = foldStart; k < i; k++) {
+          if (occupied.has(k)) {
+            clear = false;
+            break;
+          }
+        }
+        if (clear) folds.push({ startIdx: foldStart, len, name: "comment", kind: "comment", firstLine: firstRow.no, lastLine: lastRow.no });
+      }
+    }
+    if (i === start) i++;
+  }
+  return folds;
+}
+function mergeFolds(body, comment) {
+  const merged = [...body, ...comment].sort((a, b) => a.startIdx - b.startIdx || b.len - a.len);
+  const out = [];
+  let through = -1;
+  for (const fold of merged) {
+    if (fold.startIdx <= through) continue;
+    out.push(fold);
+    through = fold.startIdx + fold.len - 1;
+  }
+  return out;
+}
+var MAX_FOLD_DETAIL = 400;
+var FOLD_DETAIL_SUFFIX_BUDGET = 16;
+var PROSE_FOLD_MIN_CHARS = 400;
+var PROSE_FOLD_MAX_KEEP_RATIO = 0.6;
+var PROSE_FOLD_MIN_SENTENCE = 40;
+var PROSE_STRUCTURAL_RE = /^\s*(?:#{1,6}\s|```|~~~|\||>|\d+[.)]\s*$|[-*+]\s*$)/;
+var PROSE_FENCE_RE = /^\s*(?:```|~~~)/;
+var PROSE_ABBREV_RE = /(?:\b(?:e\.g|i\.e|vs|cf|etc|approx|al|Dr|Mr|Ms|St|Fig|No)\.|\b[^\W\d_]\.)$/;
+function proseSentenceEnd(text) {
+  for (const m of text.matchAll(/[.!?][*_`)\]"'”’]*(?=\s|$)/gu)) {
+    const term = m.index + 1;
+    const end = m.index + m[0].length;
+    if (end < PROSE_FOLD_MIN_SENTENCE) continue;
+    if (PROSE_ABBREV_RE.test(text.slice(0, term))) continue;
+    return end;
+  }
+  return null;
+}
+function planProseFolds(rows, claimed) {
+  const folds = [];
+  let inFence = false;
+  for (let i = 0; i < rows.length; i++) {
+    if (claimed.has(i)) continue;
+    const row = rows[i];
+    if (row === void 0) continue;
+    const text = row.text;
+    if (PROSE_FENCE_RE.test(text)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    if (text.length < PROSE_FOLD_MIN_CHARS) continue;
+    if (PROSE_STRUCTURAL_RE.test(text)) continue;
+    const end = proseSentenceEnd(text);
+    if (end === null || end > text.length * PROSE_FOLD_MAX_KEEP_RATIO) continue;
+    folds.push({ startIdx: i, len: 1, name: "paragraph", kind: "prose", keep: text.slice(0, end), firstLine: row.no, lastLine: row.no });
+  }
+  return folds;
+}
+function foldDetail(path, folds, maxLen = MAX_FOLD_DETAIL) {
+  const head = `${path}::`;
+  const ids = folds.map((f) => f.kind === "body" ? f.name : `#${f.firstLine}-${f.lastLine}`);
+  const budget = maxLen - head.length - FOLD_DETAIL_SUFFIX_BUDGET;
+  const kept = [];
+  let used = 0;
+  for (const id of ids) {
+    const add = kept.length === 0 ? id.length : id.length + 1;
+    if (used + add > budget) break;
+    kept.push(id);
+    used += add;
+  }
+  const dropped = ids.length - kept.length;
+  if (kept.length === 0) return `${head}+${ids.length} folds`;
+  return dropped > 0 ? `${head}${kept.join(",")},+${dropped} more` : `${head}${kept.join(",")}`;
+}
+
+export {
+  planBodyFolds,
+  commentSyntaxFor,
+  planCommentFolds,
+  mergeFolds,
+  planProseFolds,
+  foldDetail
+};

package/dist/{token-goat-chunk-RRNZMM3A.mjs → token-goat-chunk-5Y6ZYL6U.mjs}

@@ -3107,6 +3107,21 @@ function encodePng(width, height, rgba) {
   const iendChunk = makePngChunk("IEND", Buffer.alloc(0));
   return Buffer.concat([signature, ihdrChunk, idatChunk, iendChunk]);
 }
+function bmpHasAlpha(buf, layout) {
+  const { compression, bpp, pixelOffset, rowStride, width, height } = layout;
+  if (bpp !== 32) return false;
+  const dibSize = buf.readUInt32LE(14);
+  if (compression === 3 && dibSize >= 56 && buf.length >= 14 + 56) {
+    return buf.readUInt32LE(14 + 52) !== 0;
+  }
+  for (let y = 0; y < height; y++) {
+    const rowOffset = pixelOffset + y * rowStride;
+    for (let x = 0; x < width; x++) {
+      if (buf[rowOffset + x * 4 + 3] !== 0) return true;
+    }
+  }
+  return false;
+}
 function decodeBmp(buf) {
   if (buf.length < 54 || buf[0] !== 66 || buf[1] !== 77) {
     throw new Error("Invalid BMP signature");
@@ -3125,8 +3140,12 @@ function decodeBmp(buf) {
     throw new Error("Unsupported BMP bit depth: " + bpp);
   }
   assertDecodableSize("BMP", width, height, 4);
-  const outRgba = Buffer.alloc(width * height * 4);
   const rowStride = Math.floor((bpp * width + 31) / 32) * 4;
+  if (pixelOffset + (height - 1) * rowStride + width * (bpp / 8) > buf.length) {
+    throw new Error("BMP pixel data truncated");
+  }
+  const outRgba = Buffer.alloc(width * height * 4);
+  const alphaIsReal = bmpHasAlpha(buf, { compression, bpp, pixelOffset, rowStride, width, height });
   for (let y = 0; y < height; y++) {
     const srcY = topDown ? y : height - 1 - y;
     const rowOffset = pixelOffset + srcY * rowStride;
@@ -3143,7 +3162,7 @@ function decodeBmp(buf) {
         outRgba[outIdx] = buf[pxOffset + 2] ?? 0;
         outRgba[outIdx + 1] = buf[pxOffset + 1] ?? 0;
         outRgba[outIdx + 2] = buf[pxOffset] ?? 0;
-        outRgba[outIdx + 3] = buf[pxOffset + 3] ?? 255;
+        outRgba[outIdx + 3] = alphaIsReal ? buf[pxOffset + 3] ?? 255 : 255;
       }
     }
   }

package/dist/token-goat-chunk-646E6U44.mjs

@@ -0,0 +1,398 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  MAX_LINES_FOR_DIFF,
+  lcsLength,
+  readKnownText,
+  readShapeOf,
+  splitLines
+} from "./token-goat-chunk-5AC66HNP.mjs";
+import "./token-goat-chunk-WBA5SKT4.mjs";
+import {
+  sessionStateKey
+} from "./token-goat-chunk-C75NA7PL.mjs";
+import {
+  preToolPathDeclined
+} from "./token-goat-chunk-P6VGNTQT.mjs";
+import {
+  contextOutput,
+  denyOutput,
+  getCwd,
+  getFilePath,
+  getToolInput,
+  getToolName,
+  passOutput,
+  resolveEventPath
+} from "./token-goat-chunk-76FGDLRO.mjs";
+import {
+  dropFileLineRangesIfChanged,
+  getFileLineRanges,
+  markHintShown,
+  wasFileFullyReadThisSession,
+  wasHintShown
+} from "./token-goat-chunk-GL3ETKSC.mjs";
+import {
+  recordStat
+} from "./token-goat-chunk-U4WHMG6Y.mjs";
+import "./token-goat-chunk-GVB2MUST.mjs";
+import "./token-goat-chunk-XB5KKOCG.mjs";
+import "./token-goat-chunk-OUKDTVNU.mjs";
+import "./token-goat-chunk-BFCWY73P.mjs";
+import "./token-goat-chunk-KGEFFSHD.mjs";
+import "./token-goat-chunk-XX6O25RN.mjs";
+import "./token-goat-chunk-HAVAOB3S.mjs";
+import "./token-goat-chunk-T5P5ACNQ.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import "./token-goat-chunk-QYHO5CPH.mjs";
+import {
+  fingerprintContent,
+  resolveProjectRoot
+} from "./token-goat-chunk-4GBVPH3D.mjs";
+import "./token-goat-chunk-YZAAZU2S.mjs";
+import "./token-goat-chunk-IVE6U7KV.mjs";
+import {
+  isWithinQuietHours
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  canQuoteArg,
+  echoedValue,
+  fencedCommand,
+  fileSubject,
+  quotedArg
+} from "./token-goat-chunk-GGGG7RWB.mjs";
+import {
+  canonicalize
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  displaySafePath,
+  normalizePath
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/write_guard_hooks.ts
+init_define_import_meta_env();
+
+// src/sibling_copy.ts
+init_define_import_meta_env();
+import { basename, dirname, extname, join } from "node:path";
+var BACKUP_EXTENSIONS = /* @__PURE__ */ new Set([".bak", ".orig", ".new"]);
+var VERSIONED_STEM = /^(.*\D)[_.-]?v\d+$/i;
+var COPY_SUFFIX_STEM = /^(.+?)(?:[_.-](?:new|fixed|copy|old|orig|backup|bak)| copy| - copy| \(\d+\))$/i;
+var SERIES_DIRECTORIES = /* @__PURE__ */ new Set(["migrations", "versions", "fixtures", "__snapshots__"]);
+var VERSION_DIRECTORY = /^v\d+$/i;
+function siblingCandidates(filePath) {
+  const dir = dirname(filePath);
+  const base = basename(filePath);
+  const ext = extname(base);
+  const stem = ext === "" ? base : base.slice(0, -ext.length);
+  const names = [];
+  if (BACKUP_EXTENSIONS.has(ext.toLowerCase()) && extname(stem) !== "") names.push(stem);
+  const versioned = VERSIONED_STEM.exec(stem);
+  if (versioned !== null) names.push(versioned[1].replace(/[_.-]+$/, "") + ext);
+  const copied = COPY_SUFFIX_STEM.exec(stem);
+  if (copied !== null) names.push(copied[1] + ext);
+  return names.filter((name, i) => name !== "" && name !== ext && name !== base && names.indexOf(name) === i).map((name) => join(dir, name));
+}
+function globToRegExp(glob) {
+  let source = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*" && glob[i + 1] === "*") {
+      source += ".*";
+      i++;
+    } else if (c === "*") {
+      source += "[^/]*";
+    } else if (c === "?") {
+      source += "[^/]";
+    } else {
+      source += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+  }
+  return new RegExp("(?:^|/)" + source + "$", "i");
+}
+function directorySegments(normalized, projectRoot) {
+  const root = projectRoot === null ? "" : projectRoot.replace(/\\/g, "/").replace(/\/+$/, "");
+  if (root !== "" && normalized.toLowerCase().startsWith(root.toLowerCase() + "/")) return normalized.slice(root.length + 1).split("/").slice(0, -1).map((s) => s.toLowerCase());
+  if (root === "") return normalized.split("/").slice(0, -1).map((s) => s.toLowerCase());
+  return normalized.split("/").slice(-2, -1).map((s) => s.toLowerCase());
+}
+function siblingCopyExcluded(filePath, allow, projectRoot) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const segments = directorySegments(normalized, projectRoot);
+  if (segments.some((s) => SERIES_DIRECTORIES.has(s) || VERSION_DIRECTORY.test(s))) return true;
+  return allow.some((glob) => glob !== "" && globToRegExp(glob.replace(/\\/g, "/")).test(normalized));
+}
+function siblingCopyMessage(original, unchangedPct) {
+  const shown = displaySafePath(original);
+  const outline = canQuoteArg(shown) ? `, or run ${fencedCommand("token-goat outline " + quotedArg(shown))} to find the part to change` : "";
+  return `This new file repeats about ${Math.round(unchangedPct)}% of an existing file in the same directory. Edit the original with \`Edit\` or \`token-goat replace\` instead of writing a second copy of it${outline}. If a separate copy is intended, carry on.`;
+}
+
+// src/write_guards.ts
+init_define_import_meta_env();
+var ELLIPSIS = String.raw`(?:\.{3}|…)`;
+var COMMENT_LEAD = String.raw`(?:/{2,}|#+|/\*+|\*+|<!--|--|;+|%+|"""|''')`;
+var COMMENT_CLOSE = String.raw`(?:\*+/|-->|"""|''')`;
+var KEYWORD = String.raw`(?:rest|remainder|remaining|existing|unchanged|omitted|truncated|previous|same as|other)`;
+var SUBJECT = String.raw`(?:rest of (?:the )?(?:file|code|content|function|class|module|implementation|method)|existing (?:code|content|implementation)|remaining (?:code|content|lines|implementation)|previous (?:code|content))`;
+var REST_SUBJECT = String.raw`(?:rest of (?:the )?(?:file|code|content|function|class|module|implementation|method)|remaining (?:code|content|lines|implementation))`;
+var TRAILER = String.raw`(?:(?:is |remains |stays |goes )?(?:unchanged|here|omitted|as[- ]is|the same|same as before|as before|above|below))`;
+var MAX_ELISION_LINE_CHARS = 120;
+var LEADING_COMMENT = new RegExp(`^${COMMENT_LEAD}`);
+var TRAILING_COMMENT = new RegExp(`${COMMENT_CLOSE}$`);
+var ANY_ELLIPSIS = new RegExp(ELLIPSIS, "g");
+var HAS_ELLIPSIS = new RegExp(ELLIPSIS);
+var STARTS_WITH_ELLIPSIS = new RegExp(`^${ELLIPSIS}`);
+var ENDS_WITH_ELLIPSIS = new RegExp(`${ELLIPSIS}$`);
+var LEAD_THEN_TRAILER = new RegExp(`^(?:keep )?(?:the )?${KEYWORD}(?: \\S+){0,4}? (?:unchanged|here|omitted|truncated|as[- ]is|the same|as before|above|below)$`, "i");
+var WRAPPED_MARKER = new RegExp(`^(?:the )?${KEYWORD}(?: \\S+){0,3}$`, "i");
+var SUBJECT_ONLY = new RegExp(`^${SUBJECT}(?: ${TRAILER})?$`, "i");
+var SUBJECT_QUALIFIED = new RegExp(`^${SUBJECT} (?:(?:is |are |remains? |stays? )?(?:unchanged|omitted|truncated|not shown|as[- ]is|as before|same as before)|(?:remains?|stays?|is|are) (?:the )?same)$`, "i");
+var REST_PLACED = new RegExp(`^(?:${REST_SUBJECT} (?:(?:goes |is |comes )?(?:here|above|below)|follows)|rest of (?:the )?implementation)$`, "i");
+var ELLIPSIS_QUALIFIER = new RegExp(`^(?:(?:the )?(?:same as before|as before|unchanged|omitted|truncated|not shown)|\\d+ (?:more )?\\S+ (?:omitted|truncated|not shown|unchanged|hidden|elided))$`, "i");
+var BRACKET_NOTE = new RegExp(`^(?:truncated|omitted|content (?:truncated|omitted)|(?:remaining|rest of)[^\\]]{0,60}(?:omitted|truncated|unchanged)|\\d+ (?:more )?lines? (?:omitted|truncated|folded))$`, "i");
+var FOLD_MARKER = new RegExp(`^${ELLIPSIS}\\s*\\d+\\s+(?:more\\s+)?lines?\\b.*\\bfolded\\b`, "i");
+var TOKEN_GOAT_NOTICE = /^\[token-goat[: ].{0,200}\]$/;
+function spaced(text) {
+  return text.replace(ANY_ELLIPSIS, " ").replace(/\s+/g, " ").trim();
+}
+function isElisionLine(trimmed) {
+  if (trimmed === "" || trimmed.length > MAX_ELISION_LINE_CHARS) return false;
+  if (TOKEN_GOAT_NOTICE.test(trimmed) || FOLD_MARKER.test(trimmed)) return true;
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) return BRACKET_NOTE.test(spaced(trimmed.slice(1, -1)));
+  const led = LEADING_COMMENT.test(trimmed);
+  if (!led && !STARTS_WITH_ELLIPSIS.test(trimmed)) return false;
+  const body = led ? trimmed.replace(LEADING_COMMENT, "").replace(TRAILING_COMMENT, "").trim() : trimmed;
+  const payload = spaced(body).replace(/^[([](.*)[)\]]$/, "$1").trim();
+  const hasEllipsis = HAS_ELLIPSIS.test(body);
+  if (!hasEllipsis) return SUBJECT_QUALIFIED.test(payload) || REST_PLACED.test(payload);
+  if (SUBJECT_ONLY.test(payload) || ELLIPSIS_QUALIFIER.test(payload)) return true;
+  return LEAD_THEN_TRAILER.test(payload) || STARTS_WITH_ELLIPSIS.test(body) && ENDS_WITH_ELLIPSIS.test(body) && WRAPPED_MARKER.test(payload);
+}
+function findNewElisionLine(newText, knownText) {
+  let known;
+  for (const raw of splitLines(newText)) {
+    const trimmed = raw.trim();
+    if (!isElisionLine(trimmed)) continue;
+    known ??= new Set(splitLines(typeof knownText === "function" ? knownText() : knownText).map((l) => l.trim()));
+    if (!known.has(trimmed)) return trimmed;
+  }
+  return null;
+}
+function patchAddedLines(patch) {
+  const files = [];
+  let current;
+  for (const line of patch.split(/\r\n|\r|\n/)) {
+    const header = /^\*\*\* (?:Add|Update) File: (.+)$/.exec(line);
+    const moved = /^\*\*\* Move to: (.+)$/.exec(line);
+    if (header !== null) {
+      current = { path: header[1].trim(), added: [] };
+      files.push(current);
+    } else if (moved !== null && current !== void 0) {
+      current.path = moved[1].trim();
+    } else if (line.startsWith("*** ")) {
+      current = void 0;
+    } else if (current !== void 0 && line.startsWith("+")) {
+      current.added.push(line.slice(1));
+    }
+  }
+  return files;
+}
+var MAX_DIFF_SPAN = 2e3;
+function removedLineIndexes(oldLines, newLines) {
+  let head = 0;
+  while (head < oldLines.length && head < newLines.length && oldLines[head] === newLines[head]) head++;
+  let tail = 0;
+  while (tail < oldLines.length - head && tail < newLines.length - head && oldLines[oldLines.length - 1 - tail] === newLines[newLines.length - 1 - tail]) tail++;
+  const n = oldLines.length - head - tail;
+  const m = newLines.length - head - tail;
+  const removed = [];
+  if (m === 0 || n > MAX_DIFF_SPAN || m > MAX_DIFF_SPAN) {
+    for (let i2 = 0; i2 < n; i2++) removed.push(head + i2);
+    return removed;
+  }
+  const width = m + 1;
+  const goesLeft = new Uint8Array(Math.ceil((n + 1) * width / 8));
+  let above = new Uint16Array(width);
+  let row = new Uint16Array(width);
+  for (let i2 = 1; i2 <= n; i2++) {
+    for (let j2 = 1; j2 <= m; j2++) {
+      if (oldLines[head + i2 - 1] === newLines[head + j2 - 1]) {
+        row[j2] = (above[j2 - 1] ?? 0) + 1;
+      } else {
+        const left = row[j2 - 1] ?? 0;
+        const up = above[j2] ?? 0;
+        row[j2] = Math.max(left, up);
+        if (left >= up) goesLeft[i2 * width + j2 >> 3] |= 1 << (i2 * width + j2 & 7);
+      }
+    }
+    ;
+    [above, row] = [row, above];
+  }
+  let i = n;
+  let j = m;
+  while (i > 0) {
+    if (j > 0 && oldLines[head + i - 1] === newLines[head + j - 1]) {
+      i--;
+      j--;
+    } else if (j > 0 && ((goesLeft[i * width + j >> 3] ?? 0) & 1 << (i * width + j & 7)) !== 0) {
+      j--;
+    } else {
+      removed.push(head + i - 1);
+      i--;
+    }
+  }
+  return removed.reverse();
+}
+function unseenRemovedRuns(oldLines, newLines, served) {
+  const unseen = removedLineIndexes(oldLines, newLines).map((i) => i + 1).filter((line) => !served.some(([s, e]) => line >= s && line <= e));
+  const runs = [];
+  for (const line of unseen) {
+    const last = runs[runs.length - 1];
+    if (last !== void 0 && last[1] === line - 1) last[1] = line;
+    else runs.push([line, line]);
+  }
+  return runs;
+}
+var BLIND_DROP_MIN_LINES = 5;
+function countRunLines(runs) {
+  return runs.reduce((sum, [s, e]) => sum + (e - s + 1), 0);
+}
+var ELISION_ADVICE = "Write the real content, or change only the part you mean to with `Edit` or `token-goat replace`. If this exact text is intended, repeat the identical call and it goes through.";
+function placeholderMessage(line) {
+  const shown = echoedValue(line.length > 100 ? line.slice(0, 100) + "..." : line);
+  return `This call writes a placeholder line (${shown}) that is not in the file now. Written as it stands, that line replaces whatever it stands for. ${ELISION_ADVICE}`;
+}
+var MAX_QUOTED_PLACEHOLDERS = 3;
+function placeholdersMessage(found) {
+  if (found.length === 1) return placeholderMessage(found[0]);
+  const quoted = found.slice(0, MAX_QUOTED_PLACEHOLDERS).map((line) => echoedValue(line.length > 100 ? line.slice(0, 100) + "..." : line));
+  const more = found.length > quoted.length ? ` and ${found.length - quoted.length} more` : "";
+  return `This call writes ${found.length} placeholder lines (${quoted.join(", ")}${more}) that are not in the files now. Written as they stand, each replaces whatever it stands for. ${ELISION_ADVICE}`;
+}
+function blindDropMessage(filePath, runs) {
+  const total = countRunLines(runs);
+  const named = [...runs].sort((a, b) => b[1] - b[0] - (a[1] - a[0])).slice(0, 3).sort((a, b) => a[0] - b[0]);
+  const shownPath = displaySafePath(filePath);
+  const commands = named.map(([s, e]) => fencedCommand("token-goat read " + quotedArg(`${shownPath}@${s}-${e}`)));
+  return `This Write would delete ${total} lines of ${fileSubject(commands.join(" "), shownPath, filePath)} that this session never read in full (lines ${named.map(([s, e]) => s === e ? String(s) : `${s}-${e}`).join(", ")}). Read them first with ${commands.join(" or ")}, or change only what you mean to with \`Edit\` or \`token-goat replace\`. If dropping them is intended, repeat the identical call and it goes through.`;
+}
+
+// src/write_guard_hooks.ts
+function guardVerdict(key, message, detail) {
+  const hints = loadConfig().hints;
+  const policy = hints.write_blind_drop;
+  if (policy === "off" || wasHintShown(key)) return passOutput();
+  if (policy === "warn" && isWithinQuietHours(hints.quiet_hours)) return passOutput();
+  markHintShown(key);
+  recordStat("write_blind_drop", 0, 0, void 0, detail);
+  return policy === "deny" ? denyOutput(message) : contextOutput(message);
+}
+function guardKey(kind, file, text) {
+  return "write_blind_drop:" + kind + ":" + fingerprintContent(file + "\0" + text);
+}
+function placeholderGuard(event, filePath, newText, knownText) {
+  if (loadConfig().hints.write_blind_drop === "off") return passOutput();
+  const line = findNewElisionLine(newText, knownText);
+  if (line === null) return passOutput();
+  return guardVerdict(guardKey("placeholder", filePath, newText), placeholderMessage(line), "kind=placeholder tool=" + (getToolName(event) ?? "unknown"));
+}
+function blindDropGuard(event, filePath, newContent, oldLines, newLines) {
+  if (loadConfig().hints.write_blind_drop === "off") return passOutput();
+  const normalized = normalizePath(filePath);
+  const shape = readShapeOf(sessionStateKey(event), normalized);
+  if (shape === null || shape === "fold" || shape === "truncated") return passOutput();
+  if (wasFileFullyReadThisSession(normalized)) return passOutput();
+  dropFileLineRangesIfChanged(normalized);
+  const served = getFileLineRanges(normalized);
+  if (shape === "partial" && served.length === 0) return passOutput();
+  const runs = unseenRemovedRuns(oldLines, newLines, served);
+  if (countRunLines(runs) < BLIND_DROP_MIN_LINES) return passOutput();
+  return guardVerdict(guardKey("blind", filePath, newContent), blindDropMessage(filePath, runs), "kind=blind_drop last_read=" + shape + " lines=" + countRunLines(runs));
+}
+function siblingCopyGuard(event, filePath, newContent) {
+  const cfg = loadConfig().hints;
+  if (!cfg.write_sibling_copy) return passOutput();
+  const candidates = siblingCandidates(filePath);
+  if (candidates.length === 0) return passOutput();
+  const cwd = getCwd(event);
+  if (siblingCopyExcluded(canonicalize(filePath, cwd), cfg.write_sibling_copy_allow, cwd === void 0 ? null : resolveProjectRoot({ project: cwd }))) return passOutput();
+  const newLines = splitLines(newContent);
+  if (newLines.length > MAX_LINES_FOR_DIFF) return passOutput();
+  for (const original of candidates) {
+    const oldLines = splitLines(readKnownText(original));
+    if (oldLines.length < cfg.write_rewrite_min_lines || oldLines.length > MAX_LINES_FOR_DIFF) continue;
+    const unchangedPct = lcsLength(oldLines, newLines) / oldLines.length * 100;
+    if (unchangedPct < cfg.write_rewrite_unchanged_pct) continue;
+    const key = "write_sibling_copy:" + fingerprintContent(original);
+    if (wasHintShown(key)) return passOutput();
+    markHintShown(key);
+    const shownPct = Math.round(unchangedPct);
+    recordStat("write_sibling_copy", 0, 0, void 0, "unchanged_pct=" + shownPct);
+    return contextOutput(siblingCopyMessage(original, unchangedPct));
+  }
+  return passOutput();
+}
+var MAX_EDIT_FILES_CHECKED = 20;
+function preEditPlaceholderGuard(event) {
+  if (loadConfig().hints.write_blind_drop === "off") return passOutput();
+  const input = getToolInput(event);
+  const patch = typeof input["command"] === "string" ? input["command"] : input["input"];
+  if (typeof patch === "string" && input["new_string"] === void 0 && input["edits"] === void 0 && input["replacements"] === void 0) {
+    for (const file of patchAddedLines(patch)) {
+      const target = resolveEventPath(event, file.path);
+      if (preToolPathDeclined(event, target)) continue;
+      const verdict2 = placeholderGuard(event, target, file.added.join("\n"), () => readKnownText(target));
+      if (verdict2.hookType !== "pass") return verdict2;
+    }
+    return passOutput();
+  }
+  const known = /* @__PURE__ */ new Map();
+  const fileText = (path) => {
+    let text = known.get(path);
+    if (text === void 0) known.set(path, text = readKnownText(path));
+    return text;
+  };
+  const edits = [];
+  if (Array.isArray(input["replacements"])) {
+    for (const raw of input["replacements"]) {
+      const named = raw !== null && typeof raw === "object" ? raw["filePath"] : void 0;
+      edits.push({ path: typeof named === "string" && named !== "" ? resolveEventPath(event, named) : void 0, raw });
+    }
+  } else {
+    const filePath = getFilePath(event);
+    for (const raw of Array.isArray(input["edits"]) ? input["edits"] : [input]) edits.push({ path: filePath, raw });
+  }
+  const flagged = [];
+  const examined = /* @__PURE__ */ new Set();
+  for (const { path, raw } of edits) {
+    if (path === void 0 || raw === null || typeof raw !== "object" || preToolPathDeclined(event, path)) continue;
+    const edit = raw;
+    const newString = edit["new_string"] ?? edit["newString"];
+    if (typeof newString !== "string") continue;
+    if (!examined.has(path)) {
+      if (examined.size >= MAX_EDIT_FILES_CHECKED) continue;
+      examined.add(path);
+    }
+    const oldString = edit["old_string"] ?? edit["oldString"];
+    const replaced = typeof oldString === "string" ? oldString : "";
+    const line = findNewElisionLine(newString, () => fileText(path) + "\n" + replaced);
+    const key = guardKey("placeholder", path, newString);
+    if (line !== null && !wasHintShown(key)) flagged.push({ line, key });
+  }
+  if (flagged.length === 0) return passOutput();
+  const verdict = guardVerdict(flagged[0].key, placeholdersMessage(flagged.map((f) => f.line)), "kind=placeholder tool=" + (getToolName(event) ?? "unknown") + " entries=" + flagged.length);
+  if (verdict.hookType !== "pass") for (const { key } of flagged) markHintShown(key);
+  return verdict;
+}
+export {
+  blindDropGuard,
+  placeholderGuard,
+  preEditPlaceholderGuard,
+  siblingCopyGuard
+};