pi-hashline-edit-pro 6.5.1 → 7.1.0

package/index.ts

@@ -8,6 +8,7 @@ import { regCopy, regMove } from "./src/copy-move";
 import { regGrep, regVanillaGrep } from "./src/grep";
 import { regUndo, clearUndo } from "./src/replace-undo";
 import { regRead, fmtReadPreview } from "./src/read";
+import { regOutline } from "./src/outline-tool";
 import { ANCHOR_TOOL_NAMES, modelDisabled, type ModelLike } from "./src/model-gate";
 import { buildAutoReadAllInjection, autoReadAllBudget, isOutlineAutoReadAll } from "./src/auto-read-all";
 import type { RMetrics } from "./src/replace-response";
@@ -15,7 +16,7 @@ import type { ReplaceDetails } from "./src/replace";
 import { extractHints, extractWarnings } from "./src/replace-render";
 import { MAX_HASH_LINES } from "./src/hashline";
 import { withStructuredText } from "./src/structured";
-import type { AutoReadAllMode, ReadOnDisabledModels } from "./src/config";
+import type { AutoReadAllMode, Config, ReadOnDisabledModels } from "./src/config";
 import {
   readConfig,
   readConfigWithStatus,
@@ -25,6 +26,7 @@ import {
   toggleAnchorGrep,
   toggleCopyMove,
   toggleReplaceMatch,
+  toggleOutline,
   cycleReadOnDisabledModels,
   toggleRequirePath,
   toggleStrictInput,
@@ -38,7 +40,7 @@ import { loadHashStore, pruneExpiredUndo, pruneMissing } from "./src/hash-store"
 import { type AnchorSessionContext, initRegistry, gcRegistrySidecars, clearRegistry, freeAnchors, freeAnchorsForPaths, sessionKeyFor, sessionContextReadable, withAnchorSession, releaseRegistrySession, formatAnchorReclaimNotice, takeReclaimedPaths } from "./src/anchor-registry";
 import { serveRows } from "./src/served";
 import { finalizeTurn, planAssistantMessage } from "./src/batch";
-import { currentEditFlags } from "./src/edit-common";
+import { currentEditFlags, editToolEnabled } from "./src/edit-common";
 import { HashlineConfigOverlay } from "./src/config-ui";
 import { registerWriteHook } from "./src/write-hook";
 import { readNormFile } from "./src/file-reader";
@@ -53,8 +55,18 @@ interface PendingRegistrySession {
   alive: () => boolean;
 }
 
+function configEnablesTool(tool: string, config: Config): boolean {
+  if (tool === "grep") return config.anchorGrepEnabled === true;
+  return editToolEnabled(tool, {
+    replaceMatchEnabled: config.replaceMatchEnabled !== false,
+    copyMoveEnabled: config.copyMoveEnabled !== false,
+    outlineEnabled: config.outlineEnabled === true,
+  });
+}
+
 export default function (pi: ExtensionAPI): void {
   regRead(pi);
+  regOutline(pi);
 
   regReplace(pi);
   regReplaceMatch(pi);
@@ -82,11 +94,21 @@ export default function (pi: ExtensionAPI): void {
   let gateApplied = false;
   const pendingRegistrySessions: PendingRegistrySession[] = [];
 
+  function setAnchorToolEnabled(tools: readonly string[], enabled: boolean): void {
+    const active = pi.getActiveTools();
+    pi.setActiveTools(enabled ? [...new Set([...active, ...tools])] : active.filter((tool) => !tools.includes(tool)));
+    for (const tool of tools) {
+      if (enabled) baseAnchorTools.add(tool);
+      else baseAnchorTools.delete(tool);
+    }
+  }
+
   async function refreshEditTools(): Promise<void> {
     try {
       codemodeActive = pi.getActiveTools().includes("codemode");
       const flags = await currentEditFlags(codemodeActive);
       if (readFlavor !== "vanilla") regRead(pi, flags);
+      regOutline(pi, flags);
       regReplace(pi, flags);
       regReplaceMatch(pi, flags);
       regInsert(pi, flags);
@@ -144,10 +166,7 @@ export default function (pi: ExtensionAPI): void {
     const enabled = ANCHOR_TOOL_NAMES.filter((tool) => {
       if (tool === "read") return true;
       if (!baseAnchorTools.has(tool)) return false;
-      if (tool === "replace_match") return config.replaceMatchEnabled !== false;
-      if (tool === "copy" || tool === "move") return config.copyMoveEnabled !== false;
-      if (tool === "grep") return config.anchorGrepEnabled === true;
-      return true;
+      return configEnablesTool(tool, config);
     });
     const active = pi.getActiveTools().filter((tool) => tool !== "edit");
     const base = enabled.includes("grep") ? active.filter((tool) => tool !== "grep") : active;
@@ -216,12 +235,9 @@ export default function (pi: ExtensionAPI): void {
     autoReadAllInjected = sessionBranch.some((entry) => entry.type === "custom_message" && entry.customType === AUTO_READ_ALL_CUSTOM_TYPE);
     await refreshEditTools();
     pi.setActiveTools(
-      pi.getActiveTools().filter((t) => {
-        if (config.copyMoveEnabled === false && (t === "copy" || t === "move")) return false;
-        if (config.replaceMatchEnabled === false && t === "replace_match") return false;
-        return true;
-      }),
+      pi.getActiveTools().filter((tool) => tool === "grep" || configEnablesTool(tool, config)),
     );
+    setAnchorToolEnabled(["outline"], config.outlineEnabled === true);
     await syncModelGate(ctx.model, ctx.cwd);
     const debugValue = process.env.PI_HASHLINE_DEBUG;
     if (debugValue === "1" || debugValue === "true") {
@@ -278,7 +294,7 @@ export default function (pi: ExtensionAPI): void {
   }));
 
   pi.registerCommand("hashline-config", {
-    description: "Open the hashline settings window (auto-read, diff context, auto-read all, git repos only, ignore folders/files, grep, copy/move, replace_match, path, strict input, disable on models, read on disabled models)",
+    description: "Open the hashline settings window (auto-read, diff context, auto-read all, git repos only, ignore folders/files, grep, copy/move, replace_match, outline, path, strict input, disable on models, read on disabled models)",
     handler: async (_args, ctx) => {
       if (!ctx.hasUI) {
         ctx.ui.notify("/hashline-config requires interactive mode", "error");
@@ -307,22 +323,9 @@ export default function (pi: ExtensionAPI): void {
               if (enabled) baseAnchorTools.add("grep");
               else baseAnchorTools.delete("grep");
             }
-            else if (key === "copyMoveEnabled") {
-              const enabled = await toggleCopyMove();
-              const active = pi.getActiveTools();
-              pi.setActiveTools(enabled ? [...new Set([...active, "copy", "move"])] : active.filter((t) => t !== "copy" && t !== "move"));
-              for (const tool of ["copy", "move"]) {
-                if (enabled) baseAnchorTools.add(tool);
-                else baseAnchorTools.delete(tool);
-              }
-            }
-            else if (key === "replaceMatchEnabled") {
-              const enabled = await toggleReplaceMatch();
-              const active = pi.getActiveTools();
-              pi.setActiveTools(enabled ? [...new Set([...active, "replace_match"])] : active.filter((t) => t !== "replace_match"));
-              if (enabled) baseAnchorTools.add("replace_match");
-              else baseAnchorTools.delete("replace_match");
-            }
+            else if (key === "copyMoveEnabled") setAnchorToolEnabled(["copy", "move"], await toggleCopyMove());
+            else if (key === "replaceMatchEnabled") setAnchorToolEnabled(["replace_match"], await toggleReplaceMatch());
+            else if (key === "outlineEnabled") setAnchorToolEnabled(["outline"], await toggleOutline());
             else if (key === "requirePath") await toggleRequirePath();
             else if (key === "strictInput") await toggleStrictInput();
             await refreshEditTools();

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "6.5.1",
+  "version": "7.1.0",
   "type": "module",
-  "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 4-char tokenizer-friendly anchor that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
+  "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",
   "repository": {
     "type": "git",

package/src/anchor-registry.ts

@@ -5,7 +5,7 @@ import { createHash } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { sessionClaimsDir } from "./paths";
 import { contentChecksum } from "./hashline/hasher";
-import { ANCHOR_COUNT, anchorAt } from "./hashline/alphabet";
+import { ANCHOR_COUNT, HASH_RE, anchorAt } from "./hashline/alphabet";
 import { HASH_PROBE_STRIDE, MAX_HASH_LINES } from "./hashline/hash";
 import { assertLineCount, errCode, isRec, splitLines, spliceAll } from "./utils";
 import * as Diff from "diff";
@@ -249,8 +249,12 @@ export function foldRegistryEvents(events: RegistryEvent[], seed?: string): Sess
   return state;
 }
 
-function isStringArray(value: unknown): value is string[] {
-  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+function isAnchor(value: unknown): value is string {
+  return typeof value === "string" && HASH_RE.test(value);
+}
+
+function isAnchorList(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every(isAnchor);
 }
 
 function isRegistryEvent(value: unknown): value is RegistryEvent {
@@ -260,10 +264,10 @@ function isRegistryEvent(value: unknown): value is RegistryEvent {
   if (value.kind === "allocate") {
     return typeof value.path === "string"
       && Array.isArray(value.rows)
-      && value.rows.every((row) => Array.isArray(row) && row.length === 2 && typeof row[0] === "string" && typeof row[1] === "string");
+      && value.rows.every((row) => Array.isArray(row) && row.length === 2 && isAnchor(row[0]) && typeof row[1] === "string");
   }
-  if (value.kind === "free") return typeof value.path === "string" && (value.anchors === undefined || isStringArray(value.anchors));
-  if (value.kind === "minted") return isStringArray(value.anchors);
+  if (value.kind === "free") return typeof value.path === "string" && (value.anchors === undefined || isAnchorList(value.anchors));
+  if (value.kind === "minted") return isAnchorList(value.anchors);
   return false;
 }
 
@@ -386,7 +390,8 @@ async function loadRegistryState(key: string, sessionFile: string, token: object
   registries.set(key, folded);
   sidecarByKey.set(key, sidecar);
   if (rawLog.length > 0) {
-    await compactSidecarIfNeeded(sidecar, rawLog, sessionFile, folded, firstLineSessionFile(rawLog) !== sessionFile);
+    const loggedEvents = rawLog.split("\n").filter((line) => line.trim().length > 0).length;
+    await compactSidecarIfNeeded(sidecar, rawLog, sessionFile, folded, loggedEvents > events.length || firstLineSessionFile(rawLog) !== sessionFile);
   }
   try {
     await mkdir(sessionClaimsDir(), { recursive: true, mode: 0o700 });
@@ -709,22 +714,9 @@ export function ownerOf(anchor: string): OwnedAnchor | undefined {
   return current()?.owned.get(anchor);
 }
 
-export interface CaseFoldedOwner {
-  anchor: string;
-  path: string;
-}
-
-export function ownersDifferingOnlyByCase(anchor: string, paths?: ReadonlySet<string>): CaseFoldedOwner[] {
+export function anchorWasMinted(anchor: string): boolean {
   const state = current();
-  if (!state) return [];
-  const lower = anchor.toLowerCase();
-  const matches: CaseFoldedOwner[] = [];
-  for (const [owned, entry] of state.owned) {
-    if (owned === anchor || owned.toLowerCase() !== lower) continue;
-    if (paths && paths.size > 0 && !paths.has(entry.path)) continue;
-    matches.push({ anchor: owned, path: entry.path });
-  }
-  return matches;
+  return state !== undefined && state.everMinted.has(anchor);
 }
 
 export function ownersForPath(path: string): Map<string, string> {
@@ -1058,6 +1050,7 @@ export function adoptAnchors(path: string, entries: Map<string, string>): void {
 	}
 	const adopted: Array<[string, string]> = [];
 	for (const [anchor, checksum] of entries) {
+		if (!HASH_RE.test(anchor)) continue;
 		const existing = state.owned.get(anchor);
 		if (existing && existing.path !== path) continue;
 		state.owned.set(anchor, { path, checksum });

package/src/auto-read-all.ts

@@ -28,10 +28,10 @@ const SCAN_LIMIT_MULTIPLIER = 4;
 const MAX_REPORTED_OMISSIONS = 50;
 
 const HEADER =
-  "[hashline auto-read-all] Every non-ignored project file is attached below as `=== path ===` then `anchor│content` rows with live anchors.\nEdit directly from the attachment with replace and insert; do not call read for attached files.\nFiles listed as not attached can be read normally.\nAnchors are case-sensitive and stay valid until their line is edited.";
+  "[hashline auto-read-all] Every non-ignored project file is attached below as `=== path ===` then `anchor│content` rows with live anchors.\nEdit directly from the attachment with replace and insert; do not call read for attached files.\nFiles listed as not attached can be read normally.\nAnchors are lowercase and stay valid until their line is edited.";
 
 const OUTLINE_HEADER =
-  "[hashline auto-read-all] Every non-ignored project file is outlined below as `=== path (language) — lines ===` then `anchor│...` rows with live anchors: multi-line symbols show a label with `[limit N]`, the span to request when reading from the anchor, and single-line symbols show the line content.\nEdit a row's anchor with replace or insert, or read from it with `offset` set to that anchor (and the row's `limit` when it shows one); do not call read for attached files.\nFiles listed as not attached can be read normally.\nAnchors are case-sensitive and stay valid until their line is edited.";
+  "[hashline auto-read-all] Every non-ignored project file is outlined below as `=== path (language) — lines ===` then `anchor│content` rows with live anchors: each symbol row 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 request when reading from that anchor, a `[N nested]` line marks children hidden by the six-level depth cap, and a file the parser cannot outline falls back to a head-and-tail preview.\nEdit a row's anchor with replace or insert, or read from it with `offset` set to that anchor (and the row's `limit` when the next line shows one); the outline shows only symbol declaration lines, so read a span before editing inside a body. A row whose line is too long is clipped with a trailing `...` and is not served for editing; read that line first. Do not call read for attached files except to fetch a symbol span or a clipped row.\nFiles listed as not attached can be read normally.\nAnchors are lowercase and stay valid until their line is edited.";
 
 const IMAGE_EXTENSIONS = new Set([
   ".avif",
@@ -554,7 +554,7 @@ async function renderFile(file: string, cwd: string, outline: boolean): Promise<
     if (outline) {
       const section = await buildFileOutline({ displayPath: file, content: normalized, hashes: fileHashes });
       serveRows(absolutePath, fileHashes, fileLines, section.servedHashes);
-      return { file, text: section.text, totalLines: fileHashes.length, absolutePath, complete: !section.truncated };
+      return { file, text: section.text, totalLines: fileHashes.length, absolutePath, complete: section.complete };
     }
     const preview = await fmtReadPreview(normalized, {}, fileHashes, absolutePath, AUTO_READ_ALL_MAX_BUDGET_BYTES, MAX_HASH_LINES);
     serveRows(absolutePath, fileHashes, fileLines, preview.servedHashes);

package/src/config-ui.ts

@@ -2,7 +2,7 @@ import { Key, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { DEFAULT_UNDO_RETENTION_DAYS, readConfig, type Config } from "./config";
 
-export type ConfigToggleKey = "autoRead" | "autoReadAll" | "autoReadAllRequireGit" | "autoReadAllIgnore" | "anchorGrepEnabled" | "copyMoveEnabled" | "replaceMatchEnabled" | "requirePath" | "strictInput" | "diffContextLines" | "disableOnModels" | "readOnDisabledModels" | "undoRetentionDays";
+export type ConfigToggleKey = "autoRead" | "autoReadAll" | "autoReadAllRequireGit" | "autoReadAllIgnore" | "anchorGrepEnabled" | "copyMoveEnabled" | "replaceMatchEnabled" | "outlineEnabled" | "requirePath" | "strictInput" | "diffContextLines" | "disableOnModels" | "readOnDisabledModels" | "undoRetentionDays";
 
 export interface ConfigRow {
   key: ConfigToggleKey;
@@ -36,6 +36,7 @@ export function configRows(config: Config): ConfigRow[] {
     { key: "anchorGrepEnabled", group: "Tools", depth: 0, label: "Anchor grep", hint: "Use the anchored grep in place of pi's own grep", enabled: config.anchorGrepEnabled === true },
     { key: "copyMoveEnabled", group: "Tools", depth: 0, label: "Copy/move", hint: "Enable the copy and move tools", enabled: config.copyMoveEnabled !== false },
     { key: "replaceMatchEnabled", group: "Tools", depth: 0, label: "Replace match", hint: "Enable the replace_match tool", enabled: config.replaceMatchEnabled !== false },
+    { key: "outlineEnabled", group: "Tools", depth: 0, label: "Outline tool", hint: "Offer the outline tool for one file's structure on demand", enabled: config.outlineEnabled === true },
     { key: "requirePath", group: "Edit behavior", depth: 0, label: "Require path", hint: "Edit tools must also send a matching path", enabled: config.requirePath === true },
     { key: "strictInput", group: "Edit behavior", depth: 0, label: "Strict input", hint: "Reject auto-fixable slips instead of warnings", enabled: config.strictInput === true },
     { key: "disableOnModels", group: "Model gating", depth: 0, label: "Disable on models", hint: "Model globs that turn off anchored tools (comma-separated)", enabled: (config.disableOnModels ?? []).length > 0, entries: config.disableOnModels ?? [] },
@@ -101,6 +102,10 @@ export class HashlineConfigOverlay {
     this.rows = configRows(await readConfig());
   }
 
+  rowKeys(): ConfigToggleKey[] {
+    return this.rows.map((row) => row.key);
+  }
+
   private runToggle(row: ConfigRow, delta?: number, value?: string): void {
     this.opts.tui.requestRender(true);
     void this.opts.onToggle(row.key, delta, value).then(async () => {

package/src/config.ts

@@ -21,6 +21,7 @@ export interface Config {
   anchorGrepEnabled: boolean;
   copyMoveEnabled?: boolean;
   replaceMatchEnabled?: boolean;
+  outlineEnabled?: boolean;
   autoReadAll?: AutoReadAllMode;
   autoReadAllRequireGit?: boolean;
   autoReadAllIgnore?: string[];
@@ -37,6 +38,7 @@ const DEFAULT_CONFIG: Config = {
   anchorGrepEnabled: true,
   copyMoveEnabled: true,
   replaceMatchEnabled: true,
+  outlineEnabled: false,
   autoReadAll: "off",
   autoReadAllRequireGit: true,
   autoReadAllIgnore: [],
@@ -123,6 +125,7 @@ function parseConfig(content: string): Config {
   const anchorGrepEnabled = parsed.anchorGrepEnabled;
   const copyMoveEnabled = parsed.copyMoveEnabled;
   const replaceMatchEnabled = parsed.replaceMatchEnabled;
+  const outlineEnabled = parsed.outlineEnabled;
   const autoReadAll = parsed.autoReadAll;
   const autoReadAllRequireGit = parsed.autoReadAllRequireGit;
   const requirePath = parsed.requirePath;
@@ -138,6 +141,7 @@ function parseConfig(content: string): Config {
     anchorGrepEnabled: typeof anchorGrepEnabled === "boolean" ? anchorGrepEnabled : DEFAULT_CONFIG.anchorGrepEnabled,
     copyMoveEnabled: typeof copyMoveEnabled === "boolean" ? copyMoveEnabled : DEFAULT_CONFIG.copyMoveEnabled,
     replaceMatchEnabled: typeof replaceMatchEnabled === "boolean" ? replaceMatchEnabled : DEFAULT_CONFIG.replaceMatchEnabled,
+    outlineEnabled: typeof outlineEnabled === "boolean" ? outlineEnabled : DEFAULT_CONFIG.outlineEnabled,
     autoReadAll: parseAutoReadAllMode(autoReadAll),
     autoReadAllRequireGit: parseAutoReadAllRequireGit(autoReadAllRequireGit, autoReadAll),
     requirePath: typeof requirePath === "boolean" ? requirePath : DEFAULT_CONFIG.requirePath,
@@ -254,7 +258,7 @@ export async function writeConfig(config: Config): Promise<void> {
 }
 
 
-type ToggleKey = "autoRead" | "autoReadAllRequireGit" | "anchorGrepEnabled" | "copyMoveEnabled" | "replaceMatchEnabled" | "requirePath" | "strictInput";
+type ToggleKey = "autoRead" | "autoReadAllRequireGit" | "anchorGrepEnabled" | "copyMoveEnabled" | "replaceMatchEnabled" | "outlineEnabled" | "requirePath" | "strictInput";
 
 async function toggleFlag(key: ToggleKey): Promise<boolean> {
   const config = await updateConfig((c) => { c[key] = !(c[key] === true); });
@@ -265,6 +269,7 @@ export const toggleAutoReadAllRequireGit = (): Promise<boolean> => toggleFlag("a
 export const toggleAnchorGrep = (): Promise<boolean> => toggleFlag("anchorGrepEnabled");
 export const toggleCopyMove = (): Promise<boolean> => toggleFlag("copyMoveEnabled");
 export const toggleReplaceMatch = (): Promise<boolean> => toggleFlag("replaceMatchEnabled");
+export const toggleOutline = (): Promise<boolean> => toggleFlag("outlineEnabled");
 function steppedIndex(length: number, index: number, delta: number): number {
   return ((index + delta) % length + length) % length;
 }

package/src/constants.ts

@@ -12,7 +12,7 @@ export const TEXT_ENDING_NOTE =
   "A trailing line break sets the newline of the last line written instead of adding a blank line; a lone newline writes one blank line.";
 
 export const HASH_STORE_BUSY_TIMEOUT = 1000;
-export const HASH_STORE_VERSION = 9;
+export const HASH_STORE_VERSION = 10;
 export const NEW_CONTENT_NOT_ARRAY_MSG =
   `[E_BAD_SHAPE] "text" must be an array of strings, one per line (use [] to delete).`;
 

package/src/copy-move.ts

@@ -94,9 +94,9 @@ export function parseTransferAnchors(req: TransferReq): { refs: TransferRefs; wa
   const destination = stripAnchorRow(req.anchor.trim(), "anchor entry", warnings);
   return {
     refs: {
-      sourceFrom: parseHashRef(from),
-      sourceTo: parseHashRef(to),
-      anchor: parseHashRef(destination),
+      sourceFrom: parseHashRef(from, warnings, "source_from"),
+      sourceTo: parseHashRef(to, warnings, "source_to"),
+      anchor: parseHashRef(destination, warnings, "anchor"),
       direction: req.direction,
     },
     warnings,
@@ -890,20 +890,21 @@ function getTransferInput(args: unknown): { path?: string; source_from?: string;
 
 const transferSourceFromSchema = Type.String({
   description:
-    "4-char anchor of the FIRST source line to copy.",
+    "5-char anchor of the FIRST source line.",
 });
 const transferSourceToSchema = Type.String({
   description:
-    "4-char anchor of the LAST source line to copy.",
+    "5-char anchor of the LAST source line.",
 });
 const transferAnchorSchema = Type.String({
   description:
-    "4-char anchor of the destination line; the block lands before or after it and it may live in another file.",
+    "5-char anchor of the destination line; the block lands before or after it and it may live in another file.",
+});
+const transferDirectionSchema = Type.Unsafe<"after" | "before">({
+  type: "string",
+  enum: ["after", "before"],
+  description: '"after" places the block below the anchor line, "before" above it',
 });
-const transferDirectionSchema = Type.Union(
-  [Type.Literal("after"), Type.Literal("before")],
-  { description: '"after" places the block below the anchor line, "before" above it' },
-);
 const transferPathRequiredSchema = Type.String({
   description:
     "Path to the source or destination file the anchors were served for; required and must match anchor ownership.",

package/src/edit-common.ts

@@ -1,7 +1,7 @@
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { resolveInCwd } from "./fs-write";
 import { abortIf, makePrepareArguments } from "./utils";
-import { ownerOf, ownersDifferingOnlyByCase, type OwnedAnchor } from "./anchor-registry";
+import { anchorWasMinted, ownerOf } from "./anchor-registry";
 import { assertRangeServed, lineChecksum, parseHashRef, stripAnchorRow } from "./hashline";
 import { readConfig } from "./config";
 import { makeRenderCall, renderEditResult, type RPreview, type FgT } from "./replace-render";
@@ -17,6 +17,7 @@ export interface EditToolFlags {
   autoReadAllOutline: boolean;
   replaceMatchEnabled: boolean;
   copyMoveEnabled: boolean;
+  outlineEnabled: boolean;
   codemode: boolean;
 }
 
@@ -28,9 +29,19 @@ export const DEFAULT_EDIT_FLAGS: EditToolFlags = {
   autoReadAllOutline: false,
   replaceMatchEnabled: true,
   copyMoveEnabled: true,
+  outlineEnabled: false,
   codemode: false,
 };
 
+export type EditToolGate = Pick<EditToolFlags, "replaceMatchEnabled" | "copyMoveEnabled" | "outlineEnabled">;
+
+export function editToolEnabled(tool: string, flags: EditToolGate): boolean {
+  if (tool === "outline") return flags.outlineEnabled;
+  if (tool === "replace_match") return flags.replaceMatchEnabled;
+  if (tool === "copy" || tool === "move") return flags.copyMoveEnabled;
+  return true;
+}
+
 export async function currentEditFlags(codemode = false): Promise<EditToolFlags> {
   const config = await readConfig();
   return {
@@ -41,19 +52,20 @@ export async function currentEditFlags(codemode = false): Promise<EditToolFlags>
     autoReadAllOutline: (config.autoReadAll ?? "off") === "outline",
     replaceMatchEnabled: config.replaceMatchEnabled !== false,
     copyMoveEnabled: config.copyMoveEnabled !== false,
+    outlineEnabled: config.outlineEnabled === true,
     codemode
   };
 }
 
 function preferenceGuideline(flags: EditToolFlags): string {
-  const tools = gatedEditOps(["read", "replace", "replace_match", "insert", "copy", "move", "undo_last_change"], flags);
+  const tools = gatedEditOps(["read", "outline", "replace", "replace_match", "insert", "copy", "move", "undo_last_change"], flags);
   return `Remember to use the hashline tools for every file read and edit: ${joinOps(tools, { backtick: true })}.`;
 }
 
 const SHARED_EDIT_OPS = ["replace", "replace_match", "insert", "copy", "move"];
 const SHARED_PAYLOAD_OPS = ["replace", "replace_match", "insert"];
 const SHARED_DIFF_OPS = ["replace", "replace_match", "insert", "copy", "move", "undo_last_change"];
-const SHARED_SCRIPT_OPS = ["read", "replace", "replace_match", "insert", "copy", "move", "grep", "undo_last_change"];
+const SHARED_SCRIPT_OPS = ["read", "outline", "replace", "replace_match", "insert", "copy", "move", "grep", "undo_last_change"];
 
 function resultContractGuideline(flags: EditToolFlags): string {
   const tools = operationNames(SHARED_SCRIPT_OPS, flags);
@@ -161,11 +173,7 @@ export function withReplaceMatchPrompts(base: { description: string; snippet: st
 }
 
 function gatedEditOps(ops: string[], flags: EditToolFlags): string[] {
-  return ops.filter((op) => {
-    if (op === "replace_match") return flags.replaceMatchEnabled;
-    if (op === "copy" || op === "move") return flags.copyMoveEnabled;
-    return true;
-  });
+  return ops.filter((op) => editToolEnabled(op, flags));
 }
 
 function joinOps(ops: string[], options?: { backtick?: boolean; separator?: "/" }): string {
@@ -206,17 +214,11 @@ export function withTransferPrompts(base: { description: string; snippet: string
   return { description: base.description, snippet: base.snippet, guidelines };
 }
 
-function staleAnchorMessage(ref: string, hash: string, owners: Array<OwnedAnchor | undefined>): string {
-  const knownPaths = new Set<string>();
-  for (const owner of owners) {
-    if (owner) knownPaths.add(owner.path);
-  }
-  const folded = ownersDifferingOnlyByCase(hash, knownPaths);
-  const hint =
-    folded.length > 0
-      ? ` Anchors are case-sensitive; ${folded.map((match) => `"${match.anchor}"`).join(", ")} differs only in case.`
-      : "";
-  return `[E_STALE_ANCHOR] "${ref}" is not owned in this session.${hint} Call read() on the target file first.`;
+export function staleAnchorMessage(hash: string, next = "Call read() on the target file for fresh anchors."): string {
+  const state = anchorWasMinted(hash)
+    ? "is stale: it was valid earlier in this session, but its line was edited or its anchors were freed since."
+    : "was never served in this session, so it addresses no line here.";
+  return `[E_STALE_ANCHOR] "${hash}" ${state} ${next}`;
 }
 
 export function resolveEditTarget(removeFrom: string, removeTo?: string): string {
@@ -225,7 +227,7 @@ export function resolveEditTarget(removeFrom: string, removeTo?: string): string
   const owners = hashes.map((hash) => ownerOf(hash));
   const missing = owners.findIndex((owner) => !owner);
   if (missing >= 0) {
-    throw new Error(staleAnchorMessage(refs[missing]!, hashes[missing]!, owners));
+    throw new Error(staleAnchorMessage(hashes[missing]!));
   }
   const paths = new Set(owners.map((owner) => owner!.path));
   if (paths.size > 1) {
@@ -294,7 +296,7 @@ export async function resolveEditTargetWithRequirement(input: PathRequirementInp
   return anchorTarget;
 }
 
-const STRICT_INPUT_REJECT_CODES = ["[W_BAD_SHAPE]", "[W_BAD_REF]", "[W_INVALID_PATCH]", "[W_BARE_HASH_PREFIX]"];
+const STRICT_INPUT_REJECT_CODES = ["[W_BAD_SHAPE]", "[W_BAD_REF]", "[W_INVALID_PATCH]", "[W_BARE_HASH_PREFIX]", "[W_ANCHOR_CASE]"];
 export async function throwIfStrictInput(warnings: string[]): Promise<void> {
   const fixes = warnings.filter((warning) => STRICT_INPUT_REJECT_CODES.some((code) => warning.startsWith(code)));
   if (fixes.length === 0) return;

package/src/edit-fidelity.ts

@@ -1,5 +1,5 @@
 import { isBlankLine, splitLines } from "./utils";
-import { HASH_SEP, canon } from "./hashline";
+import { HASH_CLASS, HASH_SEP, canon } from "./hashline";
 import type { DiffSpan } from "./replace-diff";
 
 const INVISIBLE_RE = /\p{Default_Ignorable_Code_Point}/u;
@@ -397,8 +397,8 @@ export function annotateLiteralEscapeHints(
 }
 
 const LITERAL_ESCAPE_DETAIL_RE = /^\[H_LITERAL_ESCAPE\] [^:]*: "(.*?)" written as literal text(?: \((.*)\))?\.?$/;
-const LITERAL_ESCAPE_ANCHOR_RE = /([A-Za-z]{4})│/g;
-const UNICODE_LOST_DETAIL_RE = /^\[H_UNICODE_LOST\] ([A-Za-z]{4})│ missing "([^"]*)"/;
+const LITERAL_ESCAPE_ANCHOR_RE = new RegExp(`(${HASH_CLASS})│`, "g");
+const UNICODE_LOST_DETAIL_RE = new RegExp(`^\\[H_UNICODE_LOST\\] (${HASH_CLASS})│ missing "([^"]*)"`);
 
 export function dedupeLiteralEscapeHints(hints: readonly string[]): string[] {
   const suppressed = new Set<string>();

package/src/grep.ts

@@ -70,14 +70,6 @@ function regexSource(pattern: string, literal: boolean): string {
   return literal ? pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") : pattern;
 }
 
-function assertPattern(pattern: string, literal: boolean, ignoreCase: boolean): void {
-  try {
-    new RegExp(regexSource(pattern, literal), ignoreCase ? "ui" : "u");
-  } catch {
-    throw new Error(`[E_BAD_SHAPE] Invalid pattern: ${pattern}`);
-  }
-}
-
 interface RgMatchLine {
   line: number;
   start: number;
@@ -524,7 +516,6 @@ export function regGrep(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
           const globPath = toDisplayPath(globRoot, absPath);
           return globRegex.test(globPath) || globRegex.test(displayPath);
         };
-        assertPattern(req.pattern, req.literal === true, req.ignoreCase === true);
         const rgPath = await resolveRgPath();
         const hits: FileHit[] = [];
         let matches = 0;

package/src/hashline/alphabet.ts

@@ -1,16 +1,16 @@
 import anchorData from "./anchor-table.json";
 const rawAnchors: unknown = (anchorData as { anchors?: unknown }).anchors;
-if (typeof rawAnchors !== "string" || rawAnchors.length === 0 || rawAnchors.length % 4 !== 0) {
+if (typeof rawAnchors !== "string" || rawAnchors.length === 0 || rawAnchors.length % 5 !== 0) {
   throw new Error("[E_REGISTRY] Anchor table is missing or corrupt; reinstall pi-hashline-edit-pro.");
 }
 const TABLE: string = rawAnchors;
-export const HASH_LEN = 4;
+export const HASH_LEN = 5;
 export const ANCHOR_COUNT = TABLE.length / HASH_LEN;
 const LETTERS = "A-Za-z";
 
 export const ALPH_RE = new RegExp(`^[${LETTERS}]+$`);
 
-export const HASH_CLASS = `[${LETTERS}]{${HASH_LEN}}`;
+export const HASH_CLASS = `[a-z]{${HASH_LEN}}`;
 
 export const HASH_RUN = `[${LETTERS}]{${HASH_LEN},${HASH_LEN + 1}}`;