pi-hashline-edit-pro 6.2.0 → 6.3.1

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

@@ -13,6 +13,7 @@ export interface EditToolFlags {
   strictInput: boolean;
   autoRead: boolean;
   autoReadAllActive: boolean;
+  autoReadAllOutline: boolean;
   replaceMatchEnabled: boolean;
   copyMoveEnabled: boolean;
   codemode: boolean;
@@ -23,6 +24,7 @@ export const DEFAULT_EDIT_FLAGS: EditToolFlags = {
   strictInput: false,
   autoRead: true,
   autoReadAllActive: false,
+  autoReadAllOutline: false,
   replaceMatchEnabled: true,
   copyMoveEnabled: true,
   codemode: false,
@@ -35,6 +37,7 @@ export async function currentEditFlags(codemode = false): Promise<EditToolFlags>
     strictInput: config.strictInput === true,
     autoRead: config.autoRead !== false,
     autoReadAllActive: (config.autoReadAll ?? "off") !== "off",
+    autoReadAllOutline: (config.autoReadAll ?? "off") === "outline",
     replaceMatchEnabled: config.replaceMatchEnabled !== false,
     copyMoveEnabled: config.copyMoveEnabled !== false,
     codemode
@@ -66,7 +69,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; any failure once the batch runs aborts the whole batch.${script}`;
 }
 
 function diffGuideline(flags: EditToolFlags): string {
@@ -83,7 +86,7 @@ function pathGuideline(flags: EditToolFlags): string {
 
 function payloadGuideline(flags: EditToolFlags): string {
   const tools = operationNames(SHARED_PAYLOAD_OPS, flags);
-  return `${tools}: JSON decoding happens once, before the tool; the tool writes the string it receives and never decodes — \`\\uXXXX\` is the character, \`\\\\uXXXX\` the literal text.`;
+  return `${tools}: write the character itself, not an escape; the tool writes \`text\` verbatim and never decodes escapes — \`\\uXXXX\` is the character, \`\\\\uXXXX\` the literal text.`;
 }
 
 function strictInputGuideline(flags: EditToolFlags): string {
@@ -115,27 +118,34 @@ export function withReplacePrompts(base: { description: string; snippet: string;
   return finalizePrompts(description, base.snippet, guidelines, flags);
 }
 
+function readGuidelineApplies(guideline: string, flags: EditToolFlags): boolean {
+  if (!flags.autoReadAllOutline && guideline.includes("[limit N]")) return false;
+  if (!flags.replaceMatchEnabled && guideline.includes("`replace_match`")) return false;
+  return true;
+}
+
 export function withReadPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
   const preference = preferenceGuideline(flags);
   const script = flags.codemode ? [RESULT_CONTRACT_GUIDELINE] : [];
+  const baseGuidelines = base.guidelines.filter((guideline) => readGuidelineApplies(guideline, flags));
   if (flags.autoReadAllActive) {
-    const rewritten = base.guidelines
+    const rewritten = baseGuidelines
       .filter((guideline) => !guideline.includes("call again after an edit"))
     return { description: base.description, snippet: base.snippet, guidelines: [preference, ...rewritten, ...script] };
   }
-  if (flags.autoRead) return { description: base.description, snippet: base.snippet, guidelines: [preference, ...base.guidelines, ...script] };
-  const guidelines = [preference, ...base.guidelines, ...script];
+  if (flags.autoRead) return { description: base.description, snippet: base.snippet, guidelines: [preference, ...baseGuidelines, ...script] };
+  const guidelines = [preference, ...baseGuidelines, ...script];
   const mapped = guidelines.map((guideline) => guideline.startsWith("`read`: call again after an edit") ? "`read`: call again after an edit when you need anchors you lack." : guideline);
   return { description: base.description, snippet: base.snippet, guidelines: mapped };
 }
 
 export function withInsertPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
-  const guidelines = [...base.guidelines];
+  const guidelines = [preferenceGuideline(flags), ...base.guidelines];
   return finalizePrompts(base.description, base.snippet, guidelines, flags);
 }
 
 export function withReplaceMatchPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
-  const guidelines = [...base.guidelines];
+  const guidelines = [preferenceGuideline(flags), ...base.guidelines];
   return finalizePrompts(base.description, base.snippet, guidelines, flags);
 }
 
@@ -157,8 +167,8 @@ function joinOps(ops: string[], options?: { backtick?: boolean; separator?: "/"
 }
 
 export function withGrepPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
-  if (!flags.codemode && flags.copyMoveEnabled) return base;
-  const guidelines = flags.codemode ? [...base.guidelines, RESULT_CONTRACT_GUIDELINE] : base.guidelines;
+  const guidelines = [preferenceGuideline(flags), ...base.guidelines];
+  if (flags.codemode) guidelines.push(RESULT_CONTRACT_GUIDELINE);
   if (flags.copyMoveEnabled) return { ...base, guidelines };
   return { ...base, guidelines, description: base.description.replaceAll("replace, insert, copy, or move", joinOps(gatedEditOps(["replace", "insert", "copy", "move"], flags))) };
 }
@@ -168,9 +178,9 @@ export function withUndoPrompts(base: { description: string; snippet: string; gu
   let description = base.description;
   let snippet = base.snippet;
   const script = flags.codemode ? [RESULT_CONTRACT_GUIDELINE, SCRIPT_UNDO_GUIDELINE] : [];
-  let guidelines = [...base.guidelines, ...script];
+  let guidelines = [preferenceGuideline(flags), ...base.guidelines, ...script];
   if (!flags.autoRead) {
-    guidelines = guidelines.map((guideline) => guideline.includes("bad diff") ? "`undo_last_change`: only the last `replace`/`replace_match`/`insert`/`copy`/`move` per file is undoable; a `write` clears it, so undo right after a bad edit — review what you're restoring." : guideline);
+    guidelines = guidelines.map((guideline) => guideline.includes("a `write` clears the history") ? "`undo_last_change`: only the last `replace`/`replace_match`/`insert`/`copy`/`move` per file is undoable; a `write` clears it, so undo before any other edit or write." : guideline);
   }
   if (ops.length !== 5) {
     description = description.replaceAll("replace, replace_match, insert, copy, or move", joinOps(ops));
@@ -184,7 +194,7 @@ export function withUndoPrompts(base: { description: string; snippet: string; gu
 }
 
 export function withTransferPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
-  const guidelines = flags.codemode ? [...base.guidelines, SCRIPT_TRANSFER_GUIDELINE] : [...base.guidelines];
+  const guidelines = [preferenceGuideline(flags), ...base.guidelines, ...(flags.codemode ? [SCRIPT_TRANSFER_GUIDELINE] : [])];
   return finalizePrompts(base.description, base.snippet, guidelines, flags, { stringPayload: false });
 }
 
@@ -233,6 +243,7 @@ export interface PathRequirementInput {
   anchor?: string;
   providedPath?: unknown;
   cwd: string;
+  anchorTarget?: string;
 }
 
 export async function resolveEditTargetWithRequirement(input: PathRequirementInput): Promise<string> {
@@ -243,9 +254,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[] = [];