open-hashline 0.4.0 → 0.6.1

package/README.md

@@ -69,6 +69,22 @@ No modifications are made to any built-in tools. Everything works through hooks.
 { "afterHash": "7:e2c", "content": "  \"newField\": \"value\"," }
 ```
 
+### 4. Multi-file edit (Codex / `apply_patch`)
+
+Codex models use the `apply_patch` tool which accepts an `edits` array — multiple files and multiple edits per file in a single call:
+
+```json
+{
+  "edits": [
+    { "filePath": "/project/src/config.ts", "startHash": "3:cc7", "content": "  version: \"2.0.0\"," },
+    { "filePath": "/project/src/config.ts", "afterHash": "5:e60", "content": "  debug: true," },
+    { "filePath": "/project/src/index.ts", "startHash": "10:a1b", "endHash": "12:f3d", "content": "// refactored" }
+  ]
+}
+```
+
+Edits to the same file are grouped into a single patch section with multiple `@@` chunks, sorted by line number.
+
 ---
 
 ## Installation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-hashline",
-  "version": "0.4.0",
+  "version": "0.6.1",
   "description": "OpenCode plugin that tags lines with content hashes for reliable LLM edits",
   "type": "module",
   "license": "MIT",

package/src/index.ts

@@ -5,6 +5,13 @@ import * as path from "path"
 
 const z = tool.schema
 
+/**
+ * Max line length — must match OpenCode's read tool truncation.
+ * Lines longer than this are displayed as `line.substring(0, 2000) + "..."`.
+ * We must hash the truncated form so computeFileHashes matches the read hook.
+ */
+const MAX_LINE_LENGTH = 2000
+
 /**
  * djb2 hash of trimmed line content, truncated to 3 hex chars.
  * 3 hex chars = 4096 values. Collisions are rare and disambiguated by line number.
@@ -18,11 +25,46 @@ function hashLine(content: string): string {
   return (h >>> 0).toString(16).slice(-3).padStart(3, "0")
 }
 
+/**
+ * Normalize a hash reference from model output.
+ * Handles: extra whitespace, trailing "|", spaces around ":"
+ * e.g. " 141:d81 " → "141:d81", "141:d81|" → "141:d81", "141: d81" → "141:d81"
+ */
+function normalizeHashRef(ref: string): string {
+  ref = ref.trim()
+  if (ref.endsWith("|")) ref = ref.slice(0, -1).trimEnd()
+  const colonIdx = ref.indexOf(":")
+  if (colonIdx > 0) {
+    const lineNum = ref.slice(0, colonIdx).trim()
+    const hash = ref.slice(colonIdx + 1).trim()
+    return `${lineNum}:${hash}`
+  }
+  return ref
+}
+
 /** Per-file mapping: hash ref (e.g. "42:a3f") → line content */
 const fileHashes = new Map<string, Map<string, string>>()
 
-/** Track file path for apply_patch hash invalidation across before/after hooks */
-let pendingPatchFilePath: string | undefined
+/** Track file paths for apply_patch hash invalidation across before/after hooks */
+let pendingPatchFilePaths: string[] = []
+
+interface HashlineEdit {
+  filePath: string
+  startHash?: string
+  endHash?: string
+  afterHash?: string
+  content: string
+}
+
+/** Normalize all hash refs in an edit object */
+function normalizeEdit(edit: HashlineEdit): HashlineEdit {
+  return {
+    ...edit,
+    startHash: edit.startHash ? normalizeHashRef(edit.startHash) : undefined,
+    endHash: edit.endHash ? normalizeHashRef(edit.endHash) : undefined,
+    afterHash: edit.afterHash ? normalizeHashRef(edit.afterHash) : undefined,
+  }
+}
 
 export const HashlinePlugin: Plugin = async ({ directory }) => {
   function resolvePath(filePath: string): string {
@@ -30,13 +72,22 @@ export const HashlinePlugin: Plugin = async ({ directory }) => {
     return path.resolve(directory, filePath)
   }
 
-  /** Read file from disk and compute fresh hashes */
+  /**
+   * Read file from disk and compute fresh hashes.
+   * Lines are truncated before hashing to match OpenCode's read tool output.
+   * Full (untruncated) content is stored for building oldString/patchText.
+   */
   function computeFileHashes(filePath: string): Map<string, string> {
     const content = fs.readFileSync(filePath, "utf-8")
     const lines = content.split("\n")
     const hashes = new Map<string, string>()
     for (let i = 0; i < lines.length; i++) {
-      const hash = hashLine(lines[i])
+      // Truncate to match OpenCode's read tool (read.ts MAX_LINE_LENGTH)
+      const displayed =
+        lines[i].length > MAX_LINE_LENGTH
+          ? lines[i].substring(0, MAX_LINE_LENGTH) + "..."
+          : lines[i]
+      const hash = hashLine(displayed)
       hashes.set(`${i + 1}:${hash}`, lines[i])
     }
     fileHashes.set(filePath, hashes)
@@ -54,6 +105,17 @@ export const HashlinePlugin: Plugin = async ({ directory }) => {
     return undefined
   }
 
+  /** Find the actual hash ref for a line number (if it exists) */
+  function getHashRefByLineNumber(
+    hashes: Map<string, string>,
+    lineNum: number,
+  ): string | undefined {
+    for (const ref of hashes.keys()) {
+      if (ref.startsWith(`${lineNum}:`)) return ref
+    }
+    return undefined
+  }
+
   /** Validate a hash reference exists, re-reading file once if stale */
   function validateHash(
     filePath: string,
@@ -61,6 +123,8 @@ export const HashlinePlugin: Plugin = async ({ directory }) => {
     hashes: Map<string, string>,
   ): Map<string, string> {
     if (hashes.has(hashRef)) return hashes
+
+    // Re-read file and recompute hashes
     try {
       hashes = computeFileHashes(filePath)
     } catch {
@@ -68,13 +132,28 @@ export const HashlinePlugin: Plugin = async ({ directory }) => {
         `Cannot read file "${filePath}" to verify hash references.`,
       )
     }
-    if (!hashes.has(hashRef)) {
-      fileHashes.delete(filePath)
+    if (hashes.has(hashRef)) return hashes
+
+    // Hash not found — provide a diagnostic error message
+    const lineNum = parseInt(hashRef.split(":")[0], 10)
+    const actualRef = getHashRefByLineNumber(hashes, lineNum)
+
+    if (actualRef) {
       throw new Error(
-        `Hash reference "${hashRef}" not found. The file may have changed since last read. Please re-read the file.`,
+        [
+          `Hash reference "${hashRef}" not found.`,
+          `Line ${lineNum} now has hash "${actualRef}".`,
+          `The file has changed since last read. Please re-read the file.`,
+        ].join(" "),
       )
     }
-    return hashes
+    throw new Error(
+      [
+        `Hash reference "${hashRef}" not found.`,
+        `Line ${lineNum} does not exist in the file (${hashes.size} lines total).`,
+        `Please re-read the file.`,
+      ].join(" "),
+    )
   }
 
   /** Ensure hashes exist for a file, computing them if needed */
@@ -111,8 +190,118 @@ export const HashlinePlugin: Plugin = async ({ directory }) => {
     return lines
   }
 
-  /** Build hashline parameter schema (shared between edit and apply_patch) */
-  const hashlineParams = z.object({
+  /** Generate patch @@ chunk lines for a single hashline edit */
+  function generatePatchChunk(
+    filePath: string,
+    edit: HashlineEdit,
+    hashes: Map<string, string>,
+  ): string[] {
+    const chunk: string[] = []
+
+    if (edit.afterHash) {
+      hashes = validateHash(filePath, edit.afterHash, hashes)
+      const anchorContent = hashes.get(edit.afterHash)!
+      const anchorLine = parseInt(edit.afterHash.split(":")[0], 10)
+      const ctx =
+        anchorLine > 1
+          ? (getLineByNumber(hashes, anchorLine - 1) ?? "")
+          : ""
+      chunk.push(`@@ ${ctx}`)
+      chunk.push(` ${anchorContent}`)
+      for (const line of edit.content.split("\n")) {
+        chunk.push(`+${line}`)
+      }
+    } else if (edit.startHash) {
+      hashes = validateHash(filePath, edit.startHash, hashes)
+      if (edit.endHash) {
+        hashes = validateHash(filePath, edit.endHash, hashes)
+      }
+
+      const startLine = parseInt(edit.startHash.split(":")[0], 10)
+      const endLine = edit.endHash
+        ? parseInt(edit.endHash.split(":")[0], 10)
+        : startLine
+
+      if (endLine < startLine) {
+        throw new Error(
+          `endHash line (${endLine}) must be >= startHash line (${startLine})`,
+        )
+      }
+
+      const ctx =
+        startLine > 1
+          ? (getLineByNumber(hashes, startLine - 1) ?? "")
+          : ""
+      chunk.push(`@@ ${ctx}`)
+
+      const oldLines = collectRange(filePath, hashes, startLine, endLine)
+      for (const line of oldLines) {
+        chunk.push(`-${line}`)
+      }
+      for (const line of edit.content.split("\n")) {
+        chunk.push(`+${line}`)
+      }
+    }
+
+    return chunk
+  }
+
+  /**
+   * Apply multiple hashline edits to a file's lines array (in-place).
+   * Edits are sorted descending by line number and applied bottom-to-top
+   * so earlier indices aren't affected by insertions/deletions.
+   */
+  function applyEditsToLines(
+    filePath: string,
+    edits: HashlineEdit[],
+    lines: string[],
+    hashes: Map<string, string>,
+  ): void {
+    // Sort descending by line number (apply from bottom to top)
+    const sorted = [...edits].sort((a, b) => {
+      const lineA = parseInt(
+        (a.startHash || a.afterHash || "0").split(":")[0],
+        10,
+      )
+      const lineB = parseInt(
+        (b.startHash || b.afterHash || "0").split(":")[0],
+        10,
+      )
+      return lineB - lineA
+    })
+
+    for (const edit of sorted) {
+      if (edit.afterHash) {
+        hashes = validateHash(filePath, edit.afterHash, hashes)
+        const anchorLine = parseInt(edit.afterHash.split(":")[0], 10)
+        const newLines = edit.content.split("\n")
+        // Insert after anchorLine (1-indexed → splice at anchorLine)
+        lines.splice(anchorLine, 0, ...newLines)
+      } else if (edit.startHash) {
+        hashes = validateHash(filePath, edit.startHash, hashes)
+        if (edit.endHash) {
+          hashes = validateHash(filePath, edit.endHash, hashes)
+        }
+        const startLine = parseInt(edit.startHash.split(":")[0], 10)
+        const endLine = edit.endHash
+          ? parseInt(edit.endHash.split(":")[0], 10)
+          : startLine
+
+        if (endLine < startLine) {
+          throw new Error(
+            `endHash line (${endLine}) must be >= startHash line (${startLine})`,
+          )
+        }
+
+        const newLines = edit.content.split("\n")
+        // Replace lines startLine..endLine (1-indexed)
+        lines.splice(startLine - 1, endLine - startLine + 1, ...newLines)
+      }
+    }
+  }
+
+  /** Hashline edit schema — shared shape for individual edits */
+  const editShape = {
     filePath: z
       .string()
       .describe("The absolute path to the file to modify"),
@@ -137,13 +326,43 @@ export const HashlinePlugin: Plugin = async ({ directory }) => {
     content: z
       .string()
       .describe("The new content to insert or replace with"),
+  }
+
+  /** Schema for edit tool — edits array, single file per call */
+  const editParams = z.object({
+    edits: z
+      .array(z.object(editShape))
+      .describe(
+        "Array of edits to apply. All edits must target the same file.",
+      ),
+  })
+
+  /** Schema for apply_patch tool — edits array, multi-file supported */
+  const patchParams = z.object({
+    edits: z
+      .array(z.object(editShape))
+      .describe(
+        "Array of edits to apply. Multiple files and multiple edits per file are supported.",
+      ),
   })
 
-  const hashlineDescription = [
+  const editDescription = [
     "Edit a file using hashline references from the most recent read output.",
     "Each line is tagged as `<line>:<hash>| <content>`.",
+    "Pass an `edits` array with one or more edits (all must target the same file).",
+    "",
+    "Three operations per edit:",
+    "1. Replace line:  startHash only → replaces that single line",
+    "2. Replace range: startHash + endHash → replaces all lines in range",
+    "3. Insert after:  afterHash → inserts content after that line (no replacement)",
+  ].join("\n")
+
+  const patchDescription = [
+    "Edit one or more files using hashline references from read output.",
+    "Each line is tagged as `<line>:<hash>| <content>`.",
+    "Pass an `edits` array — multiple files and multiple edits per file are supported.",
     "",
-    "Three operations:",
+    "Three operations per edit:",
     "1. Replace line:  startHash only → replaces that single line",
     "2. Replace range: startHash + endHash → replaces all lines in range",
     "3. Insert after:  afterHash → inserts content after that line (no replacement)",
@@ -153,16 +372,27 @@ export const HashlinePlugin: Plugin = async ({ directory }) => {
     // ── Read: tag each line with its content hash ──────────────────────
     "tool.execute.after": async (input, output) => {
       if (input.tool === "edit") {
+        // Recompute hashes from the edited file so subsequent edits
+        // get diagnostic "line N now has hash X" errors instead of
+        // a generic "not found" when using stale refs.
         const filePath = resolvePath(input.args.filePath)
-        fileHashes.delete(filePath)
+        try {
+          computeFileHashes(filePath)
+        } catch {
+          fileHashes.delete(filePath)
+        }
         return
       }
 
       if (input.tool === "apply_patch") {
-        if (pendingPatchFilePath) {
-          fileHashes.delete(pendingPatchFilePath)
-          pendingPatchFilePath = undefined
+        for (const fp of pendingPatchFilePaths) {
+          try {
+            computeFileHashes(fp)
+          } catch {
+            fileHashes.delete(fp)
+          }
         }
+        pendingPatchFilePaths = []
         return
       }
 
@@ -212,9 +442,13 @@ export const HashlinePlugin: Plugin = async ({ directory }) => {
     // Requires PR #4956 (tool.definition hook) to take effect.
     // OpenCode shows `edit` for Anthropic models, `apply_patch` for Codex.
     "tool.definition": async (input: any, output: any) => {
-      if (input.toolID !== "edit" && input.toolID !== "apply_patch") return
-      output.description = hashlineDescription
-      output.parameters = hashlineParams
+      if (input.toolID === "edit") {
+        output.description = editDescription
+        output.parameters = editParams
+      } else if (input.toolID === "apply_patch") {
+        output.description = patchDescription
+        output.parameters = patchParams
+      }
     },
 
     // ── System prompt: instruct the model to use hashline edits ────────
@@ -226,18 +460,25 @@ export const HashlinePlugin: Plugin = async ({ directory }) => {
           "When you read a file, each line is tagged with a hash: `<lineNumber>:<hash>| <content>`.",
           "You MUST use these hash references when editing files. Do NOT use oldString/newString or patchText.",
           "",
-          "Three operations:",
+          "Pass an `edits` array with one or more edits. Each edit has: filePath, and one of:",
+          "",
+          "1. **Replace line** — `startHash` + `content`:",
+          '   `{ filePath: "...", startHash: "3:cc7", content: "new line" }`',
+          "",
+          "2. **Replace range** — `startHash` + `endHash` + `content`:",
+          '   `{ filePath: "...", startHash: "3:cc7", endHash: "5:e60", content: "line3\\nline4\\nline5" }`',
           "",
-          "1. **Replace line** — replace a single line:",
-          '   `startHash: "3:cc7", content: "  \\"version\\": \\"1.0.0\\","` ',
+          "3. **Insert after** — `afterHash` + `content`:",
+          '   `{ filePath: "...", afterHash: "3:cc7", content: "  inserted line" }`',
           "",
-          "2. **Replace range** — replace lines startHash through endHash:",
-          '   `startHash: "3:cc7", endHash: "5:e60", content: "line3\\nline4\\nline5"`',
+          "Multiple edits can be batched in a single call:",
+          '   `{ edits: [{ filePath: "...", startHash: "3:cc7", content: "..." }, { filePath: "...", afterHash: "7:e2c", content: "..." }] }`',
           "",
-          "3. **Insert after** — insert new content after a line (without replacing it):",
-          '   `afterHash: "3:cc7", content: "  \\"newKey\\": \\"newValue\\","` ',
+          "IMPORTANT: The hash value (e.g. `cc7`) is the EXACT 3-character code shown after the line number and colon.",
+          "Copy it exactly as shown — do NOT include the `|` separator or any surrounding spaces.",
+          "Example: for line `42:a3f| function hello()`, the hash reference is `42:a3f` (not `42:a3f|`).",
           "",
-          "NEVER pass oldString, newString, or patchText. ALWAYS use startHash/afterHash + content.",
+          "NEVER pass oldString, newString, or patchText. ALWAYS use the edits array with hash references.",
         ].join("\n"),
       )
     },
@@ -249,13 +490,82 @@ export const HashlinePlugin: Plugin = async ({ directory }) => {
         const args = output.args
 
         // Raw patchText with no hashline args → let normal patch through
-        if (args.patchText && !args.startHash && !args.afterHash) return
+        if (
+          args.patchText &&
+          !args.edits &&
+          !args.startHash &&
+          !args.afterHash
+        )
+          return
+
+        // ── Multi-file edits array ──
+        if (args.edits && Array.isArray(args.edits)) {
+          // Normalize all hash refs up front
+          const edits = (args.edits as HashlineEdit[]).map(normalizeEdit)
+
+          // Group edits by file path (preserving order within each file)
+          const editsByFile = new Map<
+            string,
+            { absPath: string; relPath: string; edits: HashlineEdit[] }
+          >()
+
+          for (const edit of edits) {
+            const absPath = resolvePath(edit.filePath)
+            let entry = editsByFile.get(absPath)
+            if (!entry) {
+              const relPath = path
+                .relative(directory, absPath)
+                .split(path.sep)
+                .join("/")
+              entry = { absPath, relPath, edits: [] }
+              editsByFile.set(absPath, entry)
+            }
+            entry.edits.push(edit)
+          }
+
+          const patchLines: string[] = ["*** Begin Patch"]
+          const editedPaths: string[] = []
+
+          for (const [absPath, { relPath, edits }] of editsByFile) {
+            editedPaths.push(absPath)
+            let hashes = ensureHashes(absPath)
+            if (!hashes) continue
+
+            // Sort edits by line number so chunks apply top-to-bottom
+            edits.sort((a, b) => {
+              const lineA = parseInt(
+                (a.startHash || a.afterHash || "0").split(":")[0],
+                10,
+              )
+              const lineB = parseInt(
+                (b.startHash || b.afterHash || "0").split(":")[0],
+                10,
+              )
+              return lineA - lineB
+            })
+
+            // One *** Update File section with multiple @@ chunks
+            patchLines.push(`*** Update File: ${relPath}`)
+
+            for (const edit of edits) {
+              const chunkLines = generatePatchChunk(absPath, edit, hashes)
+              patchLines.push(...chunkLines)
+            }
+          }
 
-        // No hashline args at all → nothing to do
+          patchLines.push("*** End Patch")
+
+          pendingPatchFilePaths = editedPaths
+          args.patchText = patchLines.join("\n")
+          delete args.edits
+          return
+        }
+
+        // ── Single-file fallback (backwards compat) ──
         if (!args.startHash && !args.afterHash) return
 
         const filePath = resolvePath(args.filePath)
-        pendingPatchFilePath = filePath
+        pendingPatchFilePaths = [filePath]
         const relativePath = path
           .relative(directory, filePath)
           .split(path.sep)
@@ -264,68 +574,22 @@ export const HashlinePlugin: Plugin = async ({ directory }) => {
         let hashes = ensureHashes(filePath)
         if (!hashes) return
 
+        const edit: HashlineEdit = normalizeEdit({
+          filePath: args.filePath,
+          startHash: args.startHash,
+          endHash: args.endHash,
+          afterHash: args.afterHash,
+          content: args.content,
+        })
         const patchLines: string[] = [
           "*** Begin Patch",
           `*** Update File: ${relativePath}`,
         ]
-
-        if (args.afterHash) {
-          // ── Insert after ──
-          hashes = validateHash(filePath, args.afterHash, hashes)
-          const anchorContent = hashes.get(args.afterHash)!
-          const anchorLine = parseInt(args.afterHash.split(":")[0], 10)
-
-          // Use line before anchor as @@ context for positioning
-          const ctx =
-            anchorLine > 1
-              ? (getLineByNumber(hashes, anchorLine - 1) ?? "")
-              : ""
-          patchLines.push(`@@ ${ctx}`)
-          patchLines.push(` ${anchorContent}`) // space = keep line
-          for (const line of args.content.split("\n")) {
-            patchLines.push(`+${line}`)
-          }
-        } else {
-          // ── Replace (single line or range) ──
-          hashes = validateHash(filePath, args.startHash, hashes)
-          if (args.endHash) {
-            hashes = validateHash(filePath, args.endHash, hashes)
-          }
-
-          const startLine = parseInt(args.startHash.split(":")[0], 10)
-          const endLine = args.endHash
-            ? parseInt(args.endHash.split(":")[0], 10)
-            : startLine
-
-          if (endLine < startLine) {
-            throw new Error(
-              `endHash line (${endLine}) must be >= startHash line (${startLine})`,
-            )
-          }
-
-          // Use line before range as @@ context for positioning
-          const ctx =
-            startLine > 1
-              ? (getLineByNumber(hashes, startLine - 1) ?? "")
-              : ""
-          patchLines.push(`@@ ${ctx}`)
-
-          // Old lines (-)
-          const oldLines = collectRange(filePath, hashes, startLine, endLine)
-          for (const line of oldLines) {
-            patchLines.push(`-${line}`)
-          }
-
-          // New lines (+)
-          for (const line of args.content.split("\n")) {
-            patchLines.push(`+${line}`)
-          }
-        }
-
+        patchLines.push(...generatePatchChunk(filePath, edit, hashes))
         patchLines.push("*** End Patch")
+
         args.patchText = patchLines.join("\n")
 
-        // Clean up hashline fields — apply_patch only reads patchText
         delete args.filePath
         delete args.startHash
         delete args.endHash
@@ -339,6 +603,50 @@ export const HashlinePlugin: Plugin = async ({ directory }) => {
 
       const args = output.args
 
+      // ── Multi-edit via edits array ──
+      if (args.edits && Array.isArray(args.edits)) {
+        // Normalize all hash refs up front
+        const edits = (args.edits as HashlineEdit[]).map(normalizeEdit)
+        if (edits.length === 0) return
+
+        // All edits must target the same file (edit tool is single-file)
+        const filePath = resolvePath(edits[0].filePath)
+        const uniqueFiles = new Set(edits.map((e) => resolvePath(e.filePath)))
+        if (uniqueFiles.size > 1) {
+          throw new Error(
+            "The edit tool supports one file per call. Make separate calls for each file.",
+          )
+        }
+
+        let hashes = ensureHashes(filePath)
+        if (!hashes) return
+
+        // Validate all hashes up front
+        for (const edit of edits) {
+          if (edit.afterHash) {
+            hashes = validateHash(filePath, edit.afterHash, hashes)
+          } else if (edit.startHash) {
+            hashes = validateHash(filePath, edit.startHash, hashes)
+            if (edit.endHash)
+              hashes = validateHash(filePath, edit.endHash, hashes)
+          }
+        }
+
+        // Read original file, apply all edits, produce oldString/newString
+        const originalContent = fs.readFileSync(filePath, "utf-8")
+        const lines = originalContent.split("\n")
+        applyEditsToLines(filePath, edits, lines, hashes)
+        const newContent = lines.join("\n")
+
+        args.filePath = filePath
+        args.oldString = originalContent
+        args.newString = newContent
+        delete args.edits
+        return
+      }
+
+      // ── Single-edit fallback (backwards compat) ──
+
       // Reject oldString edits for files we have hashes for — force hashline usage
       if (args.oldString && !args.startHash) {
         const filePath = resolvePath(args.filePath)
@@ -351,14 +659,18 @@ export const HashlinePlugin: Plugin = async ({ directory }) => {
             ].join(" "),
           )
         }
-        // No hashes for this file — allow normal edit
         return
       }
 
       // Only intercept hashline edits; fall through for normal edits
       if (!args.startHash && !args.afterHash) return
 
-      // ── Insert after: append content after the referenced line ──
+      // Normalize hash refs
+      if (args.startHash) args.startHash = normalizeHashRef(args.startHash)
+      if (args.endHash) args.endHash = normalizeHashRef(args.endHash)
+      if (args.afterHash) args.afterHash = normalizeHashRef(args.afterHash)
+
+      // Insert after
       if (args.afterHash) {
         const filePath = resolvePath(args.filePath)
         let hashes = ensureHashes(filePath)
@@ -374,11 +686,11 @@ export const HashlinePlugin: Plugin = async ({ directory }) => {
         return
       }
 
+      // Replace (single line or range)
       const filePath = resolvePath(args.filePath)
       let hashes = ensureHashes(filePath)
       if (!hashes) return
 
-      // Validate startHash
       hashes = validateHash(filePath, args.startHash, hashes)
 
       const startLine = parseInt(args.startHash.split(":")[0], 10)
@@ -386,12 +698,8 @@ export const HashlinePlugin: Plugin = async ({ directory }) => {
         ? parseInt(args.endHash.split(":")[0], 10)
         : startLine
 
-      // Validate endHash
-      if (args.endHash && !hashes.has(args.endHash)) {
-        fileHashes.delete(filePath)
-        throw new Error(
-          `Hash reference "${args.endHash}" not found. The file may have changed since last read. Please re-read the file.`,
-        )
+      if (args.endHash) {
+        hashes = validateHash(filePath, args.endHash, hashes)
       }
 
       if (endLine < startLine) {
@@ -400,15 +708,10 @@ export const HashlinePlugin: Plugin = async ({ directory }) => {
         )
       }
 
-      // Build oldString from the line range
       const rangeLines = collectRange(filePath, hashes, startLine, endLine)
-      const oldString = rangeLines.join("\n")
-
-      // Set resolved args for the built-in edit tool
-      args.oldString = oldString
+      args.oldString = rangeLines.join("\n")
       args.newString = args.content
 
-      // Remove hashline-specific fields so the built-in edit doesn't choke
       delete args.startHash
       delete args.endHash
       delete args.content