pi-hashline-edit-pro 7.1.0 → 7.1.1

package/README.md

@@ -88,7 +88,7 @@ pi install /path/to/pi-hashline-edit-pro
 | Built-in | Effect |
 | --- | --- |
 | `read` | overridden, returns `anchor│content` rows |
-| `outline` | new opt-in tool; returns one file's structural outline |
+| `outline` | new opt-in tool; returns the structural outline of a file, a directory, or a glob |
 | `edit` | disabled |
 | `grep` | replaced by an anchored `grep`; pi's own `grep` returns when Anchor grep is off |
 | `copy`, `move` | disabled while Copy/move is off |
@@ -184,11 +184,13 @@ Edge cases:
 
 ### outline
 
-`outline` returns the structural outline of one file: a `=== path (language) — N lines ===` header, then one `anchor│content` row per symbol whose content is the first line of that symbol's declaration (annotations and attributes excluded). A `[limit N]` line under a multi-line symbol is the span to pass as `read`'s `limit` when reading the body from that anchor, and an `[N nested]` line marks children hidden by `depth`. Hiding children that way is a view choice rather than truncation, so `truncated` stays false and the section still counts as complete. The structured result reports `complete`, which is true only when no row or byte cap cut the outline, every rendered row was served, and no line was skipped for a missing anchor; a head-and-tail preview that omits lines is incomplete. Files the parser cannot outline fall back to the same head-and-tail preview auto-read all uses. A row whose line is longer than 200 characters is clipped and is not served for editing, so read that line first. The tool is offered only while Outline tool is on in `/hashline-config`.
+`outline` returns the structural outline of a file, a directory, or a glob: a `=== path (language) — N lines ===` header per file, then one `anchor│content` row per symbol whose content is the first line of that symbol's declaration (annotations, decorators, and attributes excluded, and outside the symbol's span). Rows cover top-level declarations and the members of a type or module; a declaration inside a function body is never a row, whatever `depth` you pass. A `[limit N]` line under a multi-line symbol is the span to pass as `read`'s `limit` when reading the body from that anchor, and an `[N nested]` line marks children hidden by `depth`. Hiding children that way is a view choice rather than truncation, so `truncated` stays false and the section still counts as complete. The structured result reports `complete`, which is true only when no row or byte cap cut the outline, every rendered row was served, no line was skipped for a missing anchor, and no outlined file's anchors were reclaimed; a head-and-tail preview that omits lines is incomplete. Files the parser cannot outline, and supported files with no symbols, fall back to the same head-and-tail preview auto-read all uses, followed by a note that names the reason. Another note says when the parser could not read part of a file (a syntax error, or syntax the vendored grammar does not cover), since symbols in that part may be missing. A row whose line is longer than 200 characters is clipped and is not served for editing, even when an `E_RANGE_STALE` or `E_STALE_ANCHOR` error shows it again, so read that line first. The tool is offered only while Outline tool is on in `/hashline-config`.
+
+A directory or glob outlines every supported source file it matches, sorted by path, with files separated by a blank line. Listing starts at the named folder (or the glob's literal prefix): inside a Git work tree it uses tracked and untracked-but-not-ignored files, otherwise a filesystem walk, and it skips the folders and files auto-read all excludes plus your `autoReadAllIgnore` list. `*` and `**` both cross folders, as in `grep`'s `glob`. All files share the 400-row cap and the 50KB budget; each file gets at least 20 rows, or an equal share of what is left, so one large file does not hide the rest. Files over 200KB are skipped before reading, and a batch stops once it has read 400,000 source lines so files the output would not show cannot exhaust the session's anchor pool. When the budget runs out, a footer names how many files were not outlined and how to narrow the request. Listed paths that are no longer regular files (deleted, or symlinks) are dropped silently; a file that fails to read (binary, oversized, or unreadable) is skipped with a notice. All notices count against the budget, and each outlined file's own notes are always kept. A path that exists is never read as a glob, so `app/[id].ts` names that file; otherwise `*`, `?`, `[...]`, or `{a,b}` makes it a glob. A pattern that matches no supported file returns `[E_NOT_FOUND]`, and an invalid glob returns `[E_BAD_SHAPE]`.
 
 | Parameter | Description |
 | --- | --- |
-| `path` | Path to the file to outline (relative or absolute). |
+| `path` | A file (relative or absolute), a directory, or a glob such as `src/**/*.ts`, relative to the working directory. |
 | `depth` | Nesting depth: `0` lists top-level symbols only, `1` adds their members, and the default is `2` (maximum `10`). |
 
 Rows are the file's real lines, so an outline anchor is editable with `replace` or `insert` without a separate `read`, exactly like an auto-read-all outline row. The outline shows only each symbol's declaration line, so an edit inside a body still needs a `read` of that span.
@@ -273,7 +275,7 @@ Example: read served `hasux│old` in `a.ts` and `qwerx│top` in `b.ts`; to cop
 { "source_from": "hasux", "source_to": "hasux", "anchor": "qwerx", "direction": "after" }
 ```
 
-The source lines stay in place and keep their anchors; the copied lines are minted fresh anchors in the destination's post-edit diff and keep their source line endings. A cross-file copy writes only the destination, so one `undo_last_change` on it reverts the copy. In a same-message batch, a same-file copy and a cross-file copy join the destination file's batch; the copy still duplicates the content its source anchors were served from, not the result of a sibling edit. Anchoring the block's last line with `direction: "after"` (or its first line with `direction: "before"`) duplicates the block right beside itself.
+The source lines stay in place and keep their anchors; the copied lines are minted fresh anchors in the destination's post-edit diff and carry the source's line endings. The destination's end-of-file state is preserved either way: a destination that ended without a newline still does, and one that ended with a newline still does. A cross-file copy writes only the destination, so one `undo_last_change` on it reverts the copy. In a same-message batch, a same-file copy and a cross-file copy join the destination file's batch; the copy still duplicates the content its source anchors were served from, not the result of a sibling edit. Anchoring the block's last line with `direction: "after"` (or its first line with `direction: "before"`) duplicates the block right beside itself.
 
 ### move
 
@@ -303,6 +305,10 @@ Patterns are evaluated by ripgrep's linear-time regex engine, so shapes that sta
 
 Output is capped at `limit` matched lines, 2000 rows, and 50KB of text, whichever comes first, with a note naming the caps that cut the results (the exact one is in `details.truncation`). A matched line whose `anchor│content` row exceeds 500 bytes is shown as a fragment around the match, with `...` marking the truncated sides; a context row over 500 bytes is shown as its head with a trailing `...`. Fragments keep the line's anchor (long lines are hashed from their first 500 bytes) and are served like full rows, so a fragmented match is still editable, and `replace` always replaces the whole line.
 
+A path ripgrep cannot read does not abort the search. ripgrep reports the error and keeps scanning, so directory searches return every match from the readable files and add a `[grep: some paths could not be searched, so these results are partial: ...]` note naming the failure. `[E_GREP_FAILED]` is reserved for a search that produced nothing: an unusable pattern or glob, ripgrep failing to start, or an exit that left no matches at all.
+
+Matching uses the same line model as `read`, so `^` and `$` address the file's own line boundaries: in a CRLF file `TWO$` matches the second line, and a byte order mark does not keep `^` from matching line 1. A file with lone-CR (classic Mac) endings is still read, displayed, and anchored by its real lines, and every match is attributed to the line it is on, but ripgrep only breaks lines at `\n` there, so `^` and `$` see such a file as a single line: unanchored patterns work, `^` matches only at the start of the file, and `$` only at its end. Use `read` when line anchoring matters for a lone-CR file.
+
 ### undo_last_change
 
 `undo_last_change` reverts the most recent successful `replace`, `replace_match`, `insert`, `copy`, or `move` on a file, restoring the exact previous content, BOM and line endings included, plus the previous anchors.
@@ -315,6 +321,7 @@ Output is capped at `limit` matched lines, 2000 rows, and 50KB of text, whicheve
 - A successful `write` clears the history for that file.
 - If the file was modified since the last edit, the undo is refused with `[E_UNDO_STALE]` rather than overwriting those changes, and the record is kept. Once the file matches the edited state again, `undo_last_change` succeeds.
 - If the file was deleted since the last edit, `undo_last_change` restores it from the recorded pre-edit content.
+- A path with no undo record reports `[E_UNDO_NONE]`, and `[E_NOT_FOUND]` when that path does not exist either. The record is looked up first, so a file deleted since its last edit is still restored.
 - Missing-file cleanup never touches the undo record. The per-session prune removes snapshots and served records of files that no longer exist (both are recomputed on the next read), but the undo history survives, even when the file is temporarily absent during a branch switch.
 - Records are keyed by file path, not by session, so in a multi-conversation host any conversation that names the file can revert its most recent edit, even one made by another conversation.
 
@@ -394,7 +401,7 @@ Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created when a se
 | `anchorGrepEnabled` | Anchor grep | `true` | Register an anchored `grep` in place of pi's own `grep` while it is on. |
 | `copyMoveEnabled` | Copy/move | `true` | Offer the `copy` and `move` tools; when off, both are removed from the active tools. |
 | `replaceMatchEnabled` | Replace match | `true` | Offer the `replace_match` tool; when off, it is removed from the active tools. |
-| `outlineEnabled` | Outline tool | `false` | Register the `outline` tool for one file's structure on demand; when off, it is removed from the active tools. |
+| `outlineEnabled` | Outline tool | `false` | Register the `outline` tool for the structure of a file, directory, or glob on demand; when off, it is removed from the active tools. |
 | `requirePath` | Require path | `false` | `replace`, `replace_match`, `insert`, `copy`, and `move` require a `path` argument that must match anchor ownership. |
 | `strictInput` | Strict input | `false` | Reject auto-fixable slips (`[W_BAD_SHAPE]`, `[W_BAD_REF]`, `[W_INVALID_PATCH]`, `[W_BARE_HASH_PREFIX]`, `[W_ANCHOR_CASE]`) with `[E_BAD_SHAPE]` instead of applying them with a warning. |
 | `diffContextLines` | Diff context | `1` | Surrounding lines in post-edit diffs, 0-10 (needs Auto-read). |
@@ -420,7 +427,9 @@ When `PI_HASHLINE_DIR` is unset or empty, non-Windows platforms honor `XDG_CONFI
 | Grep output | 2000 rows and 50KB | `grep` |
 | Grep row fragment | 500 bytes | long match and context rows shown as `...` fragments |
 | Auto-read all files | 500 files, 200KB per file | files larger than 200KB and files past the cap are omitted |
-| Outline rows | 400 symbol rows and 50KB of content per file (a truncation footer may follow) | `outline`, auto-read all `outline` mode |
+| Outline rows | 400 symbol rows and 50KB of content per file, shared across files for a directory or glob (a truncation footer may follow) | `outline`, auto-read all `outline` mode |
+| Outline directory file | 200KB per file | `outline` directory/glob; larger files are skipped with a notice |
+| Outline source lines | 400,000 lines | `outline` directory/glob; stops early to protect the session anchor pool |
 | Auto-read all budget | 200KB floor; 2MB ceiling in `full` | total injection size derived from the model context window; `outline` is not capped at 2MB |
 | Stale-range feedback | first 100 lines | rows returned with `[E_RANGE_STALE]` |
 | Session anchors | 1,353,139 anchors in use | all tools; the least recently read or edited files are freed when the quota is exhausted (`[W_ANCHOR_RECLAIMED]`) |
@@ -438,7 +447,7 @@ All nine tools also declare an `outputSchema` and return `structuredContent`, so
 
 `replace`, `replace_match`, `insert`, `copy`, `move`, and `undo_last_change` return `{ kind: "edit", verb, classification, path, text, diff, warnings, hints, firstChangedLine, anchors, anchorsOmitted }`, where `verb` is `"replaced"`, `"inserted"`, `"copied"`, `"moved"`, or `"undone"`, `anchors` are the live rows of the post-edit diff, and `anchorsOmitted` is true when the diff was truncated or carried no rows, meaning a fresh read is needed. A cross-file move reports the destination file and its anchors.
 
-`outline` returns `{ kind: "outline", path, text, totalLines, depth, lines, truncated, complete, notices }`, where `text` is the outline body without the notices, `lines` is the anchored rows it served, `complete` is true only when no cap cut the outline, every rendered row was served, and no line was skipped for a missing anchor; `notices` carries non-file notes such as the UTF-8 rewrite note and `[W_ANCHOR_RECLAIMED]`; in a codemode session `tools.outline()` resolves to the served outline text (with notices) unless `anchors: true` is passed.
+`outline` returns `{ kind: "outline", path, text, totalLines, depth, lines, truncated, complete, notices }`, where `text` is the outline body without the notices, `lines` is the anchored rows it served, `complete` is true only when no cap cut the outline, every rendered row was served, and no line was skipped for a missing anchor; `notices` carries notes such as the preview reason, the UTF-8 rewrite note, and `[W_ANCHOR_RECLAIMED]`; for a directory or glob, `lines` is replaced by `files: [{ path, lines, totalLines, truncated, complete }]`, one entry per outlined file, and `totalLines` is their sum; in a codemode session `tools.outline()` resolves to the served outline text (with notices) unless `anchors: true` is passed.
 
 `grep` returns `{ kind: "grep", text, matches, files, truncated, results }`, where each entry of `results` is `{ path, matchLines, lines, hadUtf8DecodeErrors }` and `lines` uses the same `{ line, text, anchor, rendered }` shape as `read`.
 
@@ -504,7 +513,7 @@ Full reference:
 | `[E_PATH_CHANGED]` | A write target changed identity after it was read; the write was refused to avoid following a swapped symlink or overwriting a replacement file. |
 | `[E_BATCH_OVERLAP]` | Batched edit calls target overlapping ranges; the whole batch was refused. One `before` plus one `after` insert on the same anchor line is not an overlap. Retry with disjoint ranges. |
 | `[E_OP_ABORTED]` | The edit was aborted before writing: the file changed or was deleted after it was read (a single edit or a cross-file move reports the file; a batch reports the batch and the failing call), the base read failed, a cross-file member could not be prepared, or the composed result exceeded a limit. Nothing was written; a call whose own request is invalid is left out of the batch instead. Fix the cause and retry, otherwise call `read` for fresh anchors and retry. The batch abort names the failing call and its error code when one is known. |
-| `[E_GREP_FAILED]` | `grep` could not start ripgrep or ripgrep exited with an error (for example a pattern with backreferences, look-around, or invalid regex syntax, which ripgrep's regex engine does not support); the message carries ripgrep's output. Retry with `literal: true` or simplify the pattern. |
+| `[E_GREP_FAILED]` | `grep` could not start ripgrep or ripgrep exited with an error (for example a pattern with backreferences, look-around, or invalid regex syntax, which ripgrep's regex engine does not support); the message carries ripgrep's output. Retry with `literal: true` or simplify the pattern. A path ripgrep cannot read is not one of these: the search returns the readable matches with a partial-results note. |
 | `[E_GREP_TIMEOUT]` | `grep` timed out after 10 seconds; narrow `path` or simplify `pattern` and retry. |
 
 ## Troubleshooting

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "7.1.0",
+  "version": "7.1.1",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 5-character lowercase tokenizer-friendly anchor that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/src/auto-read-all.ts

@@ -88,7 +88,7 @@ export const AUTO_READ_ALL_EXCLUDED_NAMES = [
 ];
 const EXCLUDED_NAME_SET = new Set(AUTO_READ_ALL_EXCLUDED_NAMES);
 const EXCLUDED_SEGMENT_SET = new Set(AUTO_READ_ALL_EXCLUDED_SEGMENTS);
-function isExcludedBySegment(path: string): boolean {
+export function isExcludedBySegment(path: string): boolean {
   const lower = path.toLowerCase();
   const vendorViews = lower.startsWith("resources/views/vendor/");
   for (const segment of lower.split("/")) {
@@ -103,7 +103,7 @@ const EXCLUDED_PATTERN_SUFFIXES = [
 ];
 const EXCLUDED_PATTERN_INFIXES = [".bundle.", ".chunk.", ".generated.", ".gen."];
 
-function isExcludedByPattern(baseLower: string): boolean {
+export function isExcludedByPattern(baseLower: string): boolean {
   return EXCLUDED_PATTERN_SUFFIXES.some((suffix) => baseLower.endsWith(suffix))
     || EXCLUDED_PATTERN_INFIXES.some((infix) => baseLower.includes(infix))
     || baseLower.startsWith("coreui-icons.")
@@ -256,7 +256,7 @@ const GLOB_CHARS_RE = /[*?[\]{}]/;
 const GLOB_CACHE_LIMIT = 256;
 const globRegexCache = new Map<string, RegExp | null>();
 
-function globRegexFor(entry: string): RegExp | null {
+export function globRegexFor(entry: string): RegExp | null {
   const cached = globRegexCache.get(entry);
   if (cached !== undefined) return cached;
   let compiled: RegExp | null;
@@ -354,7 +354,7 @@ function runCommand(command: string, args: string[], cwd: string): Promise<{ std
   });
 }
 
-async function listFromGit(cwd: string): Promise<string[] | undefined> {
+export async function listFromGit(cwd: string): Promise<string[] | undefined> {
   const result = await runCommand("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], cwd);
   if (result.code !== 0) return undefined;
   return result.stdout.split("\0").filter((entry) => entry.length > 0);
@@ -403,7 +403,7 @@ async function listFromRg(cwd: string): Promise<string[] | undefined> {
   return result.stdout.split("\0").filter((entry) => entry.length > 0);
 }
 
-async function walkDir(dir: string, base: string, out: string[], customIgnore: readonly string[] = []): Promise<void> {
+export async function walkDir(dir: string, base: string, out: string[], customIgnore: readonly string[] = []): Promise<void> {
   let entries;
   try {
     entries = await readdir(dir, { withFileTypes: true });

package/src/edit-common.ts

@@ -69,7 +69,7 @@ const SHARED_SCRIPT_OPS = ["read", "outline", "replace", "replace_match", "inser
 
 function resultContractGuideline(flags: EditToolFlags): string {
   const tools = operationNames(SHARED_SCRIPT_OPS, flags);
-  return `${tools}: when called from a codemode script, failures resolve to \`{ ok: false, kind: "error", error: { code, message } }\`; branch on \`ok\` instead of \`try\`/\`catch\`.`;
+  return `${tools}: when called from a codemode script, failures resolve to \`{ ok: false, kind: "error", error: { code, message } }\`; branch on \`ok\` instead of \`try\`/\`catch\`. Arguments that fail the tool's schema still throw before the tool runs.`;
 }
 const READ_SCRIPT_GUIDELINE =
   '`read` in a codemode script resolves to the file\'s text, like the built-in `read`; pass `anchors: true` to receive `{ text, lines, notices }` with the raw file content and `lines[].anchor` for chained edits. An image read resolves to an image block.';

package/src/grep.ts

@@ -15,6 +15,7 @@ import { loadP, loadGuidelines } from "./prompts";
 import { normReq } from "./payload-contract";
 import { DEFAULT_EDIT_FLAGS, withGrepPrompts, type EditToolFlags } from "./edit-common";
 import { abortIf, clipLine, errCode, isRec, makePrepareArguments, rejectUnknownFields, truncateToBytes, visLines, gutterWidth } from "./utils";
+import type { LineEnding } from "./normalize";
 import { withAnchorSession, formatAnchorReclaimNotice, takeReclaimedPaths } from "./anchor-registry";
 import { serveRows } from "./served";
 import { Text } from "@earendil-works/pi-tui";
@@ -139,6 +140,62 @@ function grepHeadFragment(line: string): string {
   return head.length < line.length ? `${head}...` : head;
 }
 
+function lineStartsOf(text: string): number[] {
+  const starts = [0];
+  for (let index = 0; index < text.length; index += 1) {
+    if (text.charCodeAt(index) === 10 && index + 1 < text.length) starts.push(index + 1);
+  }
+  return starts;
+}
+
+function physicalStartsOf(text: string, separators: readonly LineEnding[]): number[] {
+  const starts = [0];
+  let separatorIndex = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    if (text.charCodeAt(index) !== 10) continue;
+    const separator = separators[separatorIndex] ?? "\n";
+    separatorIndex += 1;
+    if (separator === "\n" || separator === "\r\n") starts.push(index + 1);
+  }
+  return starts;
+}
+
+function lineIndexOf(starts: readonly number[], position: number): number {
+  let low = 0;
+  let high = starts.length - 1;
+  while (low < high) {
+    const mid = (low + high + 1) >>> 1;
+    if (starts[mid]! <= position) low = mid;
+    else high = mid - 1;
+  }
+  return low;
+}
+
+function toNormalizedMatches(
+  norm: { normalized: string; endingSeparators: readonly LineEnding[] },
+  matches: RgMatchLine[],
+): RgMatchLine[] {
+  if (!norm.endingSeparators.includes("\r")) return matches;
+  const text = norm.normalized;
+  const starts = lineStartsOf(text);
+  const physical = physicalStartsOf(text, norm.endingSeparators);
+  const lines = visLines(text);
+  return matches.map((match) => {
+    const base = physical[match.line - 1] ?? 0;
+    const physicalLine = text.slice(base, physical[match.line] ?? text.length);
+    const position = base + byteOffsetToCharIndex(physicalLine, match.start);
+    const index = lineIndexOf(starts, position);
+    const lineText = lines[index] ?? "";
+    const columnStart = Math.min(position - starts[index]!, lineText.length);
+    const columnEnd = Math.min(base + byteOffsetToCharIndex(physicalLine, match.end) - starts[index]!, lineText.length);
+    return {
+      line: index + 1,
+      start: Buffer.byteLength(lineText.slice(0, columnStart), "utf-8"),
+      end: Buffer.byteLength(lineText.slice(0, Math.max(columnStart, columnEnd)), "utf-8"),
+    };
+  });
+}
+
 function makeHitFromIndices(
   norm: { normalized: string; fileHashes: string[]; absolutePath: string; hadUtf8DecodeErrors: boolean },
   displayPath: string,
@@ -247,6 +304,11 @@ async function insideGitRepo(start: string): Promise<boolean> {
   }
 }
 
+interface RgSearch {
+  matches: Map<string, RgMatchLine[]>;
+  skipped?: string;
+}
+
 async function collectRgMatches(
   rgPath: string,
   pattern: string,
@@ -254,8 +316,8 @@ async function collectRgMatches(
   req: GrepReq,
   signal: AbortSignal | undefined,
   repoRooted: boolean,
-): Promise<Map<string, RgMatchLine[]>> {
-  const args = ["--json", "--line-number", "--color=never", "--hidden", "--glob", "!.git"];
+): Promise<RgSearch> {
+  const args = ["--json", "--line-number", "--color=never", "--hidden", "--crlf", "--glob", "!.git"];
   if (!repoRooted) args.push("--no-require-git");
   const wanted = req.limit ?? 100;
   args.push("--max-count", String(wanted + 1));
@@ -267,7 +329,7 @@ async function collectRgMatches(
   if (req.literal) args.push("--fixed-strings");
   args.push("--", pattern, searchPath);
   const result = new Map<string, RgMatchLine[]>();
-  return await new Promise<Map<string, RgMatchLine[]>>((resolve, reject) => {
+  return await new Promise<RgSearch>((resolve, reject) => {
     const child = spawn(rgPath, args, { stdio: ["ignore", "pipe", "pipe"] });
     const rl = createInterface({ input: child.stdout });
     let stderr = "";
@@ -331,12 +393,16 @@ async function collectRgMatches(
       }
       if (code !== 0 && code !== 1) {
         const detail = clipLine(stderr.trim(), 300);
-        reject(new Error(detail
-          ? `[E_GREP_FAILED] ripgrep exited with code ${code}: ${detail}`
-          : `[E_GREP_FAILED] ripgrep exited with code ${code}.`));
+        if (result.size === 0) {
+          reject(new Error(detail
+            ? `[E_GREP_FAILED] ripgrep exited with code ${code}: ${detail}`
+            : `[E_GREP_FAILED] ripgrep exited with code ${code}.`));
+          return;
+        }
+        resolve({ matches: result, ...(detail ? { skipped: detail } : {}) });
         return;
       }
-      resolve(result);
+      resolve({ matches: result });
     });
   });
 }
@@ -541,7 +607,8 @@ export function regGrep(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
         const readGrepFile = makeGrepReader("real");
         const readGrepFileShadow = makeGrepReader("shadow");
         const repoRooted = await insideGitRepo(globRoot);
-        const rgMatches = await collectRgMatches(rgPath, req.pattern, base, req, signal, repoRooted);
+        const rgSearch = await collectRgMatches(rgPath, req.pattern, base, req, signal, repoRooted);
+        const rgMatches = rgSearch.matches;
         const sortedFiles = [...rgMatches.keys()].sort(cmp);
         for (let f = 0; f < sortedFiles.length; f++) {
           abortIf(signal);
@@ -552,7 +619,7 @@ export function regGrep(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
             if (!matchesGlob(absPath)) continue;
             const norm = await readGrepFileShadow(absPath);
             if (!norm) continue;
-            const hit = makeHitFromIndices(norm, toDisplayPath(ctx.cwd, absPath), fileMatches, context, totalForFile, fileMatches.length);
+            const hit = makeHitFromIndices(norm, toDisplayPath(ctx.cwd, absPath), toNormalizedMatches(norm, fileMatches), context, totalForFile, fileMatches.length);
             const display = displayRowsForHit(hit);
             totalRows += display.length;
             for (const r of display) totalBytes += Buffer.byteLength(r, "utf-8") + 1;
@@ -574,7 +641,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), fileMatches, context, totalForFile, Math.min(totalForFile, remaining));
+          const hit = makeHitFromIndices(norm, toDisplayPath(ctx.cwd, absPath), toNormalizedMatches(norm, fileMatches), context, totalForFile, Math.min(totalForFile, remaining));
           const display = displayRowsForHit(hit);
           const keptRows: string[] = [];
           const keptHashes: string[] = [];
@@ -624,6 +691,7 @@ export function regGrep(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
         if (limitTruncated) notes.push(`[grep: showing first ${limit} matches; increase limit to see more.]`);
         if (linesReplaced > 0) notes.push(`[grep: ${linesReplaced} line(s) exceed ${formatSize(MAX_GREP_LINE_BYTES)} and are shown as truncated fragments; use read to see the full lines.]`);
         if (poolSkipped > 0) notes.push(`[grep: ${poolSkipped} file(s) skipped because the session's anchor pool is exhausted; narrow the search.]`);
+        if (rgSearch.skipped !== undefined) notes.push(`[grep: some paths could not be searched, so these results are partial: ${rgSearch.skipped}]`);
         const truncated = limitTruncated || rowTruncated;
         const truncation: TruncationResult | undefined = rowTruncated
           ? {

package/src/hashline/resolve.ts

@@ -113,9 +113,12 @@ export function fmtMismatchWithHashes(
       for (let ln = from; ln <= to; ln++) {
         const h = fileHashes[ln - 1]!;
         const c = fileLines[ln - 1] ?? "";
-        hashes.push(h);
-        servedMap.set(h, lineChecksum(c));
-        rows.push(`    ${ln}: ${h}│${clipLine(c)}`);
+        const shown = clipLine(c);
+        if (shown === c) {
+          hashes.push(h);
+          servedMap.set(h, lineChecksum(c));
+        }
+        rows.push(`    ${ln}: ${h}│${shown}`);
       }
       out.push("");
       out.push(`  Current context around resolved anchor "${ctx.hash}" (line ${ctx.line}):\n${rows.join("\n")}`);
@@ -441,12 +444,18 @@ export function assertRangeServed(
   const rows: string[] = [];
   const shownHashes: string[] = [];
   const shownMap = new Map<string, string>();
+  const clippedLines: number[] = [];
   for (let line = startLine; line < startLine + shownLength; line++) {
     const hash = fileHashes[line - 1]!;
     const content = fileLines[line - 1]!;
+    const shown = clipLine(content);
+    rows.push(fmtRow(hash, shown));
+    if (shown !== content) {
+      clippedLines.push(line);
+      continue;
+    }
     shownHashes.push(hash);
     shownMap.set(hash, lineChecksum(content));
-    rows.push(fmtRow(hash, clipLine(content)));
   }
   const location = filePath ? ` in ${filePath}` : "";
   const rangeDescription = `the replaced range (lines ${startLine}-${endLine})${location}`;
@@ -457,7 +466,9 @@ export function assertRangeServed(
   const capHint =
     rangeLength > shownLength
       ? `\n\n[The range has ${rangeLength} lines; showing the first ${shownLength}. Call read()${filePath ? ` on ${filePath}` : ""} with offset=${startLine + shownLength} to see the rest.]`
-      : "\n\nRetry with the fresh anchors above without a read.";
+      : clippedLines.length > 0
+        ? `\n\n[${clippedLines.length === 1 ? `Line ${clippedLines[0]} is` : `Lines ${clippedLines.join(", ")} are`} clipped above and not editable from here; call read()${filePath ? ` on ${filePath}` : ""} before editing.]`
+        : "\n\nRetry with the fresh anchors above without a read.";
   const message =
     `[E_RANGE_STALE] ${mismatchText}. Current range with fresh anchors:\n\n${rows.join("\n")}${capHint}`;
   throw new RangeStaleError(message, shownHashes, shownMap);

package/src/outline/index.ts

@@ -18,7 +18,7 @@ export async function buildFileOutline(input: FileOutlineInput): Promise<Outline
 	const parser = await loadOutlineParser();
 	const parsed = parser === undefined ? undefined : await parser.parse(input.displayPath, input.content);
 	if (parsed !== undefined && parsed.symbols.length > 0) {
-		return renderSymbolOutline({
+		const outline = renderSymbolOutline({
 			displayPath: input.displayPath,
 			languageName: parsed.languageName,
 			totalLines: lines.length,
@@ -29,8 +29,9 @@ export async function buildFileOutline(input: FileOutlineInput): Promise<Outline
 			...(input.maxDepth !== undefined ? { maxDepth: input.maxDepth } : {}),
 			...(input.maxBytes !== undefined ? { maxBytes: input.maxBytes } : {}),
 		});
+		return parsed.hasSyntaxErrors ? { ...outline, hasSyntaxErrors: true } : outline;
 	}
-	return renderPreviewOutline({
+	const preview = renderPreviewOutline({
 		displayPath: input.displayPath,
 		lines,
 		hashes: input.hashes,
@@ -38,6 +39,8 @@ export async function buildFileOutline(input: FileOutlineInput): Promise<Outline
 		...(input.previewTailLines !== undefined ? { tailLines: input.previewTailLines } : {}),
 		...(input.maxBytes !== undefined ? { maxBytes: input.maxBytes } : {}),
 	});
+	if (lines.length === 0) return preview;
+	return { ...preview, preview: parsed === undefined ? "unsupported" : "no-symbols", ...(parsed?.hasSyntaxErrors ? { hasSyntaxErrors: true } : {}) };
 }
 
 export { loadOutlineParser } from "./parsers";

package/src/outline/parsers.ts

@@ -9,6 +9,7 @@ export interface OutlineSymbol {
 export interface OutlineParse {
 	symbols: OutlineSymbol[];
 	languageName: string;
+	hasSyntaxErrors: boolean;
 }
 
 export interface OutlineParser {
@@ -24,7 +25,7 @@ async function load(): Promise<OutlineParser | undefined> {
 			parse: async (path, content) => {
 				if (parsers.detectLanguage(path) === null) return undefined;
 				const parsed = await parsers.parseSourceFile(path, content);
-				return { symbols: parsed.symbols, languageName: parsed.languageName };
+				return { symbols: parsed.symbols, languageName: parsed.languageName, hasSyntaxErrors: parsed.hasError === true };
 			},
 		};
 	} catch (error) {

package/src/outline/render.ts

@@ -25,6 +25,8 @@ export interface OutlineRender {
 	servedHashes: string[];
 	truncated: boolean;
 	complete: boolean;
+	preview?: "unsupported" | "no-symbols";
+	hasSyntaxErrors?: boolean;
 }
 
 export interface SymbolOutlineInput {

package/src/outline/vendor/parsers/blade.ts

@@ -62,8 +62,13 @@ function bodyStart(node: Node): number {
 }
 
 function blockSymbol(node: Node, source: string): SymbolInfo | null {
+  const directive = node.namedChildren[0];
+  if (directive?.type === "directive_start" && (node.type === "conditional" || node.type === "loop")) {
+    const [startLine, endLine] = rangeOf(node);
+    return { name: parameterName(node, source), type: textOf(directive, source).slice(1), startLine, endLine };
+  }
   const label = BLOCK_LABELS[node.type];
-  if (label === undefined) return null;
+  if (label === undefined || (node.type === "php_statement" && directive?.type !== "directive_start")) return null;
   const [startLine, endLine] = rangeOf(node);
   return { name: parameterName(node, source), type: label, startLine, endLine };
 }

package/src/outline/vendor/parsers/index.ts

@@ -21,6 +21,7 @@ export interface ParseFileResult {
   symbols: SymbolInfo[];
   language: string | null;
   languageName: string;
+  hasError?: boolean;
 }
 
 /**
@@ -38,8 +39,8 @@ export async function parseSourceFile(
   }
 
   try {
-    const symbols = await parseCode(lang, content);
-    return { symbols, language: lang, languageName: languageLabel(lang) };
+    const { symbols, hasError } = await parseCode(lang, content);
+    return { symbols, language: lang, languageName: languageLabel(lang), hasError };
   } catch (err) {
     console.warn(
       `[codebase-reader] Parse failed for ${filePath}:`,