pi-hashline-edit-pro 6.2.0 → 6.3.0

package/src/copy-move.ts

@@ -9,6 +9,8 @@ import {
   lineHashes,
   MAX_HASH_LINES,
   parseHashRef,
+  planEdit,
+  preserveDeletionSeparators,
   resEdit,
   resolveAnchorLine,
   stripAnchorRow,
@@ -17,7 +19,7 @@ import {
   type HTEdit,
 } from "./hashline";
 import { formatAnchorReclaimNotice, servedForPath, takeReclaimedPaths, withAnchorSession } from "./anchor-registry";
-import { batchMemberFor, batchServedFor, ensureBatchBase, executeBatchMember, noteBatchFailure, pendingBatchMemberFor, type BatchBase, type PlannedMember } from "./batch";
+import { batchMemberFor, batchServedFor, ensureBatchBase, executeBatchMember, noteBatchFailure, pendingBatchMemberFor, registerBatchPlanner, type BatchBase, type BatchMemberPlanner, type PlannedMember } from "./batch";
 import { loadP, loadGuide } from "./prompts";
 import { assertTransferReq, normReq, type TransferReq } from "./payload-contract";
 import { abortIf, assertByteLimit, isRec, splitLines } from "./utils";
@@ -332,13 +334,13 @@ async function commitMovePair(input: {
   const destinationSpan = input.destination.pipe.spans?.[0];
   const sourceSpan = input.source.pipe.spans?.[0];
   const destinationSeparators = destinationSpan
-    ? separatorsForSpans(input.destination.pipe.originalSeparators, input.destination.pipe.originalHashes.length, [destinationSpan], input.destination.pipe.result, input.destination.pipe.originalEnding)
+    ? separatorsForSpans(input.destination.pipe.originalSeparators, input.destination.pipe.originalHashes.length, [destinationSpan], input.destination.pipe.result, input.destination.pipe.originalEnding, splitLines(input.destination.pipe.originalNormalized))
     : undefined;
   if (destinationSeparators !== undefined && destinationSpan !== undefined) {
     applyEndingOverrides(destinationSeparators, destinationSpan.start, input.destination.endingOverrides);
   }
   const sourceSeparators = sourceSpan
-    ? separatorsForSpans(input.source.pipe.originalSeparators, input.source.pipe.originalHashes.length, [sourceSpan], input.source.pipe.result, input.source.pipe.originalEnding)
+    ? separatorsForSpans(input.source.pipe.originalSeparators, input.source.pipe.originalHashes.length, [sourceSpan], input.source.pipe.result, input.source.pipe.originalEnding, splitLines(input.source.pipe.originalNormalized))
     : undefined;
   const destinationBytes = input.destination.pipe.bom + (destinationSeparators !== undefined
     ? joinSeparators(input.destination.pipe.result, destinationSeparators)
@@ -600,50 +602,38 @@ function preloadFromBase(base: BatchBase): NormFile {
   };
 }
 
-async function executeBatchTransfer(
-  kind: TransferKind,
-  member: PlannedMember,
-  refs: TransferRefs,
-  warnings: string[],
-  targetPath: string,
-  mutationTargetPath: string,
-  cwd: string,
-  signal?: AbortSignal,
-): Promise<TResult> {
-  const base = await ensureBatchBase({ member, targetPath, mutationTargetPath, cwd, signal });
-  const displayPath = toDisplayPath(cwd, base.absolutePath, targetPath);
-  let plan: TransferPlan;
-  try {
-    plan = buildTransferEdit({ kind, refs, preload: preloadFromBase(base), displayPath, served: batchServedFor(member) });
-  } catch (error) {
-    await noteAnchorError(base.absolutePath, error);
-    noteBatchFailure(member, error);
-    throw error;
-  }
-  const resWarnings: string[] = [];
-  let hedit: HEdit;
-  try {
-    hedit = resEdit(plan.editParams, resWarnings);
-  } catch (error) {
-    noteBatchFailure(member, error);
-    throw error;
-  }
-  return executeBatchMember({
-    kind,
-    member,
-    targetPath,
-    mutationTargetPath,
-    cwd,
-    signal,
-    hedit,
-    extraWarnings: [...warnings, ...resWarnings],
-    foldedLines: plan.foldedAnchorLines,
-    ...(plan.anchorCarry !== undefined ? { carryIndex: plan.anchorCarry } : {}),
-    ...(plan.servedOverride !== undefined ? { servedOverride: plan.servedOverride } : {}),
-    ...(plan.endingOverrides !== undefined ? { contentSeparators: plan.endingOverrides } : {}),
-  });
+function planTransferBatchMember(kind: TransferKind): BatchMemberPlanner {
+  return (input) => {
+    if (input.member.sourceTarget !== undefined && input.member.sourceTarget !== input.member.target) return undefined;
+    const req = normReq(input.member.args);
+    assertTransferReq(req);
+    const { refs, warnings } = parseTransferAnchors(req);
+    const preload = preloadFromBase(input.base);
+    const transferPlan = buildTransferEdit({ kind, refs, preload, displayPath: input.displayPath, served: input.served });
+    const resWarnings: string[] = [];
+    const hedit = resEdit(transferPlan.editParams, resWarnings);
+    const effectiveHedit = preserveDeletionSeparators(hedit, input.base.baseLines, input.base.hashes);
+    const planned = planEdit(input.base.content, effectiveHedit, input.base.hashes, {
+      filePath: input.displayPath,
+      servedHashes: transferPlan.servedOverride ?? input.served,
+      signal: input.signal,
+      baseFileLines: input.base.baseLines,
+    });
+    return {
+      hedit,
+      warnings: [...warnings, ...resWarnings],
+      planned,
+      foldedLines: transferPlan.foldedAnchorLines,
+      ...(transferPlan.anchorCarry !== undefined ? { carryIndex: transferPlan.anchorCarry } : {}),
+      ...(transferPlan.servedOverride !== undefined ? { servedOverride: transferPlan.servedOverride } : {}),
+      ...(transferPlan.endingOverrides !== undefined ? { contentSeparators: transferPlan.endingOverrides } : {}),
+    };
+  };
 }
 
+registerBatchPlanner("copy", planTransferBatchMember("copy"));
+registerBatchPlanner("move", planTransferBatchMember("move"));
+
 async function executeBatchCrossCopy(
   member: PlannedMember,
   refs: TransferRefs,
@@ -687,17 +677,18 @@ async function executeBatchCrossCopy(
     throw error;
   }
   return executeBatchMember({
-    kind: "copy",
     member,
     targetPath: destinationPath,
     mutationTargetPath,
     cwd,
     signal,
-    hedit,
-    extraWarnings: [...warnings, ...resWarnings],
-    foldedLines: prepared.destinationFolded,
-    ...(prepared.destinationFolded === 1 ? { carryIndex: 0 } : {}),
-    contentSeparators: prepared.endingOverrides,
+    plan: {
+      hedit,
+      warnings: [...warnings, ...resWarnings],
+      foldedLines: prepared.destinationFolded,
+      ...(prepared.destinationFolded === 1 ? { carryIndex: 0 } : {}),
+      contentSeparators: prepared.endingOverrides,
+    },
   });
 }
 
@@ -751,21 +742,22 @@ async function executeBatchCrossMove(
     ...(sourcePipe.hadUtf8DecodeErrors ? ["Non-UTF-8 bytes were shown as U+FFFD; this edit rewrote the file as UTF-8."] : []),
   ];
   return executeBatchMember({
-    kind: "move",
     member,
     targetPath: destinationPath,
     mutationTargetPath,
     cwd,
     signal,
-    hedit,
-    extraWarnings: [...warnings, ...resWarnings, ...sourceWarnings],
-    foldedLines: prepared.destinationFolded,
-    ...(prepared.destinationFolded === 1 ? { carryIndex: 0 } : {}),
-    contentSeparators: prepared.endingOverrides,
-    sourceMove: {
-      displayPath: prepared.sourceDisplay,
-      mutationTargetPath: prepared.sourcePreload.absolutePath,
-      pipe: sourcePipe,
+    plan: {
+      hedit,
+      warnings: [...warnings, ...resWarnings, ...sourceWarnings],
+      foldedLines: prepared.destinationFolded,
+      ...(prepared.destinationFolded === 1 ? { carryIndex: 0 } : {}),
+      contentSeparators: prepared.endingOverrides,
+      sourceMove: {
+        displayPath: prepared.sourceDisplay,
+        mutationTargetPath: prepared.sourcePreload.absolutePath,
+        pipe: sourcePipe,
+      },
     },
   });
 }
@@ -932,20 +924,20 @@ export function buildTransferToolDef(kind: TransferKind, flags: EditToolFlags =
         const canonical = normReq(params);
         assertTransferReq(canonical);
         const req = canonical;
+        const member = batchMemberFor(_toolCallId);
         let refs: TransferRefs;
         let warnings: string[];
         try {
           ({ refs, warnings } = parseTransferAnchors(req));
-          await throwIfStrictInput(warnings);
+          const sameFileMember = member !== undefined && (member.sourceTarget === undefined || member.sourceTarget === member.target);
+          if (!sameFileMember) await throwIfStrictInput(warnings);
         } catch (error) {
-          const member = batchMemberFor(_toolCallId);
           if (member) noteBatchFailure(member, error);
           throw error;
         }
         let sourcePath: string;
         let destinationPath: string;
         try {
-          const member = batchMemberFor(_toolCallId);
           if (member) {
             await assertTransferPathOption(req, ctx.cwd, member);
             sourcePath = member.sourceTarget ?? member.target;
@@ -954,15 +946,13 @@ export function buildTransferToolDef(kind: TransferKind, flags: EditToolFlags =
             ({ sourcePath, destinationPath } = await resolveTransferTargets(req, ctx.cwd));
           }
         } catch (error) {
-          const member = batchMemberFor(_toolCallId);
           if (member) noteBatchFailure(member, error);
           throw error;
         }
         if (sourcePath === destinationPath) {
           return queuedEdit(sourcePath, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
-            const member = batchMemberFor(_toolCallId);
             if (member) {
-              return executeBatchTransfer(kind, member, refs, warnings, sourcePath, mutationTargetPath, ctx.cwd, signal);
+              return executeBatchMember({ member, targetPath: sourcePath, mutationTargetPath, cwd: ctx.cwd, signal });
             }
             const preload = await readNormFile(sourcePath, ctx.cwd, {
               signal,
@@ -999,7 +989,6 @@ export function buildTransferToolDef(kind: TransferKind, flags: EditToolFlags =
             });
           });
         }
-        const member = batchMemberFor(_toolCallId);
         if (member) {
           return queuedEdit(destinationPath, ctx.cwd, signal, async (_absolutePath, mutationTargetPath) => {
             return kind === "copy"

package/src/edit-common.ts

@@ -66,7 +66,7 @@ function batchGuideline(flags: EditToolFlags): string {
   const tools = operationNames(SHARED_EDIT_OPS, flags);
   const outcome = flags.autoRead ? "diff" : "result";
   const script = flags.codemode ? ` ${SCRIPT_BATCH_GUIDELINE}` : "";
-  return `${tools}: same-file calls in one message are grouped into one batch; earlier calls reply \`In batch N (queued)\` and the last call shows the combined ${outcome}, with one undo for the whole batch.${script}`;
+  return `${tools}: same-file calls in one message are grouped into one batch; earlier calls reply \`In batch N (queued)\` and the last applied call shows the combined ${outcome}, with one undo for the whole batch. A call whose own request is invalid (anchors, shape, or \`old_string\`) fails on its own and is left out of the batch; the rest still commits.${script}`;
 }
 
 function diffGuideline(flags: EditToolFlags): string {
@@ -233,6 +233,7 @@ export interface PathRequirementInput {
   anchor?: string;
   providedPath?: unknown;
   cwd: string;
+  anchorTarget?: string;
 }
 
 export async function resolveEditTargetWithRequirement(input: PathRequirementInput): Promise<string> {
@@ -243,9 +244,10 @@ export async function resolveEditTargetWithRequirement(input: PathRequirementInp
   if (requirePath && (typeof input.providedPath !== "string" || input.providedPath.length === 0)) {
     throw new Error('[E_BAD_SHAPE] Edit request requires a non-empty "path" string when require-path mode is on. Provide `path` matching the file the anchors were served for.');
   }
-  const anchorTarget = typeof input.anchor === "string"
-    ? resolveEditTarget(input.anchor)
-    : resolveEditTarget(input.removeFrom as string, input.removeTo);
+  const anchorTarget = input.anchorTarget
+    ?? (typeof input.anchor === "string"
+      ? resolveEditTarget(input.anchor)
+      : resolveEditTarget(input.removeFrom as string, input.removeTo));
   if (requirePath) {
     const { resolved } = await resolveInCwd(input.providedPath as string, input.cwd);
     if (resolved !== anchorTarget) {

package/src/grep.ts

@@ -66,104 +66,22 @@ function compileGrepGlob(glob: string): RegExp {
   }
 }
 
-function buildRegex(pattern: string, literal: boolean, ignoreCase: boolean): RegExp {
-  if (!literal) assertSafeRegex(pattern);
-  const source = literal ? pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") : pattern;
+function regexSource(pattern: string, literal: boolean): string {
+  return literal ? pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") : pattern;
+}
+
+function assertPattern(pattern: string, literal: boolean, ignoreCase: boolean): void {
   try {
-    return new RegExp(source, ignoreCase ? "ui" : "u");
+    new RegExp(regexSource(pattern, literal), ignoreCase ? "ui" : "u");
   } catch {
     throw new Error(`[E_BAD_SHAPE] Invalid pattern: ${pattern}`);
   }
 }
 
-interface RegexGroupRisk {
-  hasQuantifier: boolean;
-  hasAlternation: boolean;
-}
-
-function unsafeRegex(pattern: string): never {
-  throw new Error(
-    `[E_UNSAFE_REGEX] Refusing potentially exponential regex: ${pattern}. Use literal: true or simplify the expression.`,
-  );
-}
-
-function assertSafeRegex(pattern: string): void {
-  if (pattern.length > 4096) unsafeRegex(pattern);
-  const groups: RegexGroupRisk[] = [];
-  let inClass = false;
-  let escaped = false;
-  let variableQuantifiers = 0;
-  let lastAtom: { groupRisky: boolean; quantified: boolean } | undefined;
-  for (let i = 0; i < pattern.length; i++) {
-    const ch = pattern[i]!;
-    if (escaped) {
-      if (!inClass && (/[1-9]/.test(ch) || (ch === "k" && pattern[i + 1] === "<"))) {
-        unsafeRegex(pattern);
-      }
-      escaped = false;
-      lastAtom = { groupRisky: false, quantified: false };
-      continue;
-    }
-    if (ch === "\\") {
-      escaped = true;
-      continue;
-    }
-    if (inClass) {
-      if (ch === "]") {
-        inClass = false;
-        lastAtom = { groupRisky: false, quantified: false };
-      }
-      continue;
-    }
-    if (ch === "[") {
-      inClass = true;
-      continue;
-    }
-    if (ch === "(") {
-      groups.push({ hasQuantifier: false, hasAlternation: false });
-      lastAtom = undefined;
-      continue;
-    }
-    if (ch === ")") {
-      const group = groups.pop();
-      if (group) {
-        lastAtom = {
-          groupRisky: group.hasQuantifier || group.hasAlternation,
-          quantified: false,
-        };
-      }
-      continue;
-    }
-    if (ch === "|") {
-      const group = groups.at(-1);
-      if (group) group.hasAlternation = true;
-      lastAtom = undefined;
-      continue;
-    }
-    let quantifierLength = 0;
-    if (ch === "*" || ch === "+" || ch === "?") {
-      quantifierLength = 1;
-    } else if (ch === "{") {
-      quantifierLength = /^\{\d+(?:,\d*)?\}/.exec(pattern.slice(i))?.[0].length ?? 0;
-    }
-    if (ch === "{" && quantifierLength > 0) {
-      const quant = pattern.slice(i, i + quantifierLength);
-      const m = /^\{(\d+)/.exec(quant);
-      if (m && Number(m[1]) > 1000) unsafeRegex(pattern);
-    }
-    if (quantifierLength > 0 && lastAtom) {
-      if (ch === "?" && lastAtom.quantified) continue;
-      const variable = ch !== "{" || pattern.slice(i, i + quantifierLength).includes(",");
-      if (variable && ++variableQuantifiers > 1) unsafeRegex(pattern);
-      if (lastAtom.groupRisky) unsafeRegex(pattern);
-      const group = groups.at(-1);
-      if (group) group.hasQuantifier = true;
-      lastAtom.quantified = true;
-      i += quantifierLength - 1;
-      continue;
-    }
-    lastAtom = { groupRisky: false, quantified: false };
-  }
+interface RgMatchLine {
+  line: number;
+  start: number;
+  end: number;
 }
 
 interface FileHit {
@@ -199,11 +117,23 @@ function snapCharBoundaries(line: string, start: number, end: number): [number,
   return [s, e];
 }
 
-function grepMatchFragment(line: string, regex: RegExp): string {
-  const m = regex.exec(line);
-  const matchStart = m?.index ?? 0;
-  const matchLen = m?.[0].length ?? 0;
+function byteOffsetToCharIndex(line: string, byteOffset: number): number {
+  if (byteOffset <= 0) return 0;
+  let bytes = 0;
+  let index = 0;
+  for (const char of line) {
+    if (bytes >= byteOffset) return index;
+    const codePoint = char.codePointAt(0)!;
+    bytes += codePoint < 0x80 ? 1 : codePoint < 0x800 ? 2 : codePoint < 0x10000 ? 3 : 4;
+    index += char.length;
+  }
+  return index;
+}
+
+function grepMatchFragment(line: string, startByte: number, endByte: number): string {
   const budget = GREP_ROW_CONTENT_BYTES - 6;
+  const matchStart = byteOffsetToCharIndex(line, startByte);
+  const matchLen = Math.max(0, byteOffsetToCharIndex(line, endByte) - matchStart);
   const half = Math.floor((budget - Math.min(matchLen, budget)) / 2);
   const [start, end] = snapCharBoundaries(line, Math.max(0, matchStart - half), Math.min(line.length, matchStart + matchLen + half));
   const content = truncateToBytes(line.slice(start, end), budget);
@@ -220,20 +150,21 @@ function grepHeadFragment(line: string): string {
 function makeHitFromIndices(
   norm: { normalized: string; fileHashes: string[]; absolutePath: string; hadUtf8DecodeErrors: boolean },
   displayPath: string,
-  matchIndices: number[],
+  matches: RgMatchLine[],
   context: number,
-  regex: RegExp | undefined,
   totalMatchCount: number,
   keptMatchCount: number,
 ): FileHit {
   const lines = visLines(norm.normalized);
   const shown = new Set<number>();
-  const kept = matchIndices.slice(0, keptMatchCount);
-  for (const i of kept) {
-    for (let j = Math.max(0, i - context); j <= Math.min(lines.length - 1, i + context); j++) shown.add(j);
+  const kept = matches.slice(0, keptMatchCount);
+  for (const match of kept) {
+    const lineIndex = match.line - 1;
+    for (let j = Math.max(0, lineIndex - context); j <= Math.min(lines.length - 1, lineIndex + context); j++) shown.add(j);
   }
   const sorted = [...shown].sort((a, b) => a - b);
-  const matchSet = new Set(matchIndices);
+  const matchByLine = new Map<number, RgMatchLine>();
+  for (const match of matches) matchByLine.set(match.line - 1, match);
   const rows: string[] = [];
   const hashes: string[] = [];
   const lineNumbers: number[] = [];
@@ -244,7 +175,8 @@ function makeHitFromIndices(
     const line = lines[idx]!;
     const row = fmtRow(hash, line);
     if (Buffer.byteLength(row, "utf-8") > MAX_GREP_LINE_BYTES) {
-      const content = matchSet.has(idx) && regex ? grepMatchFragment(line, regex) : grepHeadFragment(line);
+      const match = matchByLine.get(idx);
+      const content = match !== undefined ? grepMatchFragment(line, match.start, match.end) : grepHeadFragment(line);
       rows.push(fmtRow(hash, content));
       hashes.push(hash);
       lineNumbers.push(idx + 1);
@@ -270,7 +202,7 @@ function makeHitFromIndices(
     totalMatchCount,
     fragmented,
     texts,
-    matchLines: kept.map((index) => index + 1),
+    matchLines: kept.map((match) => match.line),
     hadUtf8DecodeErrors: norm.hadUtf8DecodeErrors,
   };
 }
@@ -330,7 +262,7 @@ async function collectRgMatches(
   req: GrepReq,
   signal: AbortSignal | undefined,
   repoRooted: boolean,
-): Promise<Map<string, number[]>> {
+): Promise<Map<string, RgMatchLine[]>> {
   const args = ["--json", "--line-number", "--color=never", "--hidden", "--glob", "!.git"];
   if (!repoRooted) args.push("--no-require-git");
   const wanted = req.limit ?? 100;
@@ -342,8 +274,8 @@ async function collectRgMatches(
   if (req.ignoreCase) args.push("--ignore-case");
   if (req.literal) args.push("--fixed-strings");
   args.push("--", pattern, searchPath);
-  const result = new Map<string, number[]>();
-  return await new Promise<Map<string, number[]>>((resolve, reject) => {
+  const result = new Map<string, RgMatchLine[]>();
+  return await new Promise<Map<string, RgMatchLine[]>>((resolve, reject) => {
     const child = spawn(rgPath, args, { stdio: ["ignore", "pipe", "pipe"] });
     const rl = createInterface({ input: child.stdout });
     let stderr = "";
@@ -367,7 +299,7 @@ async function collectRgMatches(
     };
     rl.on("line", (line) => {
       if (!line.trim()) return;
-      let event: { type?: string; data?: { path?: { text?: string }; line_number?: number } };
+      let event: { type?: string; data?: { path?: { text?: string }; line_number?: number; submatches?: Array<{ start?: number; end?: number }> } };
       try {
         event = JSON.parse(line);
       } catch {
@@ -383,8 +315,11 @@ async function collectRgMatches(
           } catch {
             abs = filePath;
           }
+          const submatch = event.data?.submatches?.[0];
+          const start = typeof submatch?.start === "number" ? submatch.start : 0;
+          const end = typeof submatch?.end === "number" ? submatch.end : start;
           const list = result.get(abs) ?? [];
-          list.push(lineNumber);
+          list.push({ line: lineNumber, start, end });
           result.set(abs, list);
         }
       }
@@ -481,8 +416,7 @@ export function fmtGrepCall(args: { pattern?: unknown; path?: unknown; glob?: un
 function highlightRegex(args: unknown): RegExp | undefined {
   if (!isRec(args) || typeof args.pattern !== "string" || args.pattern.length === 0) return undefined;
   try {
-    const validated = buildRegex(args.pattern, args.literal === true, args.ignoreCase === true);
-    return new RegExp(validated.source, validated.flags.includes("i") ? "giu" : "gu");
+    return new RegExp(regexSource(args.pattern, args.literal === true), args.ignoreCase === true ? "giu" : "gu");
   } catch {
     return undefined;
   }
@@ -584,7 +518,7 @@ export function regGrep(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
           const globPath = toDisplayPath(globRoot, absPath);
           return globRegex.test(globPath) || globRegex.test(displayPath);
         };
-        const validatedRegex = buildRegex(req.pattern, req.literal === true, req.ignoreCase === true);
+        assertPattern(req.pattern, req.literal === true, req.ignoreCase === true);
         const rgPath = await resolveRgPath();
         const hits: FileHit[] = [];
         let matches = 0;
@@ -615,15 +549,13 @@ export function regGrep(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
         for (let f = 0; f < sortedFiles.length; f++) {
           abortIf(signal);
           const absPath = sortedFiles[f]!;
-          const allNums = rgMatches.get(absPath) ?? [];
-          const totalForFile = allNums.length;
-          const sortedNums = [...allNums].sort((a, b) => a - b);
-          const indices = sortedNums.map((n) => n - 1).filter((n) => n >= 0);
+          const fileMatches = [...(rgMatches.get(absPath) ?? [])].sort((a, b) => a.line - b.line);
+          const totalForFile = fileMatches.length;
           if (countOnly) {
             if (!matchesGlob(absPath)) continue;
             const norm = await readGrepFileShadow(absPath);
             if (!norm) continue;
-            const hit = makeHitFromIndices(norm, toDisplayPath(ctx.cwd, absPath), indices, context, validatedRegex, totalForFile, indices.length);
+            const hit = makeHitFromIndices(norm, toDisplayPath(ctx.cwd, absPath), fileMatches, context, totalForFile, fileMatches.length);
             const display = displayRowsForHit(hit);
             totalRows += display.length;
             for (const r of display) totalBytes += Buffer.byteLength(r, "utf-8") + 1;
@@ -645,7 +577,7 @@ export function regGrep(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
           if (!matchesGlob(absPath)) continue;
           const norm = await readGrepFile(absPath);
           if (!norm) continue;
-          const hit = makeHitFromIndices(norm, toDisplayPath(ctx.cwd, absPath), indices, context, validatedRegex, totalForFile, Math.min(totalForFile, remaining));
+          const hit = makeHitFromIndices(norm, toDisplayPath(ctx.cwd, absPath), fileMatches, context, totalForFile, Math.min(totalForFile, remaining));
           const display = displayRowsForHit(hit);
           const keptRows: string[] = [];
           const keptHashes: string[] = [];

package/src/hash-store.ts

@@ -161,6 +161,15 @@ function openDb(storePath: string): { db: RawDb; stmts: Prepared } {
   }
 }
 
+function addColumnIfMissing(db: RawDb, statement: string): void {
+  try {
+    db.exec(statement);
+  } catch (error) {
+    if (error instanceof Error && /duplicate column/i.test(error.message)) return;
+    throw error;
+  }
+}
+
 function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA synchronous = NORMAL");
@@ -192,18 +201,10 @@ function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
       "updated_at INTEGER NOT NULL" +
     ")"
   );
-  try {
-    db.exec("ALTER TABLE snapshots ADD COLUMN line_checksums TEXT");
-  } catch {}
-  try {
-    db.exec("ALTER TABLE undo ADD COLUMN mode INTEGER");
-  } catch {}
-  try {
-    db.exec("ALTER TABLE undo ADD COLUMN separators TEXT");
-  } catch {}
-  try {
-    db.exec("ALTER TABLE undo ADD COLUMN result_separators TEXT");
-  } catch {}
+  addColumnIfMissing(db, "ALTER TABLE snapshots ADD COLUMN line_checksums TEXT");
+  addColumnIfMissing(db, "ALTER TABLE undo ADD COLUMN mode INTEGER");
+  addColumnIfMissing(db, "ALTER TABLE undo ADD COLUMN separators TEXT");
+  addColumnIfMissing(db, "ALTER TABLE undo ADD COLUMN result_separators TEXT");
   const versionRow = db.prepare("SELECT value FROM meta WHERE key = 'version'").get() as { value?: string } | undefined;
   if (versionRow && versionRow.value !== String(HASH_STORE_VERSION)) {
     db.exec("DELETE FROM snapshots");

package/src/hashline/resolve.ts

@@ -93,7 +93,12 @@ export function fmtMismatchWithHashes(
   const out: string[] = [];
   const hashes: string[] = [];
   const servedMap = new Map<string, string>();
-  const notFound = mismatches;
+  const seen = new Set<string>();
+  const notFound = mismatches.filter((mismatch) => {
+    if (seen.has(mismatch.ref.hash)) return false;
+    seen.add(mismatch.ref.hash);
+    return true;
+  });
   if (notFound.length > 0) {
     const refList = notFound.map((m) => `"${m.ref.hash}"`).join(", ");
     out.push(
@@ -194,7 +199,13 @@ export function stripAnchorRow(
 	return match[2]!;
 }
 
-export function resEdit(edit: HTEdit | HTPayloadEdit, warnings?: string[]): HEdit {
+export type HTextInput = {
+  text: string | string[];
+  remove_from: string;
+  remove_to: string;
+};
+
+export function resEdit(edit: HTextInput, warnings?: string[]): HEdit {
 	if (typeof edit.text === "string") {
 		assertPayloadItem(edit as unknown as Record<string, unknown>);
 		return resolveParsedEdit(edit.remove_from, edit.remove_to, parsePayloadText(edit.text), warnings);