@oh-my-pi/pi-coding-agent 15.5.11 → 15.5.13

package/src/discovery/omp-extension-roots.ts

@@ -0,0 +1,190 @@
+/**
+ * OMP extension package roots.
+ *
+ * An "extension package root" is a directory configured via either
+ * `extensions:` in user/project settings or the `--extension`/`-e` CLI flag
+ * that points to a packaged extension on disk. The package's standard
+ * sub-directories (`skills/`, `hooks/`, `tools/`, `commands/`, `rules/`,
+ * `prompts/`, `.mcp.json`) are wired into discovery by `omp-plugins.ts`.
+ *
+ * CLI-provided paths are injected via {@link injectOmpExtensionCliRoots}
+ * before discovery runs; settings paths are read lazily from
+ * `<scope>/settings.json` in {@link listOmpExtensionRoots} to mirror what
+ * `loadExtensionModules` already does.
+ *
+ * @see ./omp-plugins.ts
+ * @see ./builtin.ts `loadExtensionModules`
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { isEnoent, logger, tryParseJson } from "@oh-my-pi/pi-utils";
+import { readDirEntries, readFile } from "../capability/fs";
+import type { LoadContext } from "../capability/types";
+import { getEnabledPlugins } from "../extensibility/plugins/loader";
+import { expandTilde } from "../tools/path-utils";
+
+/** A resolved extension package directory wired into the discovery surfaces. */
+export interface OmpExtensionRoot {
+	/** Absolute path to the package directory. */
+	path: string;
+	/** Stable display name (basename of the package directory). */
+	name: string;
+	/** Scope from which the path was sourced. */
+	level: "user" | "project";
+}
+
+interface InjectedRoot {
+	path: string;
+	level: "user" | "project";
+}
+
+let injectedCliRoots: InjectedRoot[] = [];
+
+/**
+ * Register CLI-provided extension package paths (e.g. from `--extension`/`-e`)
+ * so the sub-discovery providers can find their sibling `skills/`, `hooks/`,
+ * etc. Paths that do not resolve to a directory are silently dropped — file
+ * entrypoints have no package sub-tree to scan.
+ *
+ * Call once during startup before any capability load. Repeated calls extend
+ * the registered set; {@link clearOmpExtensionCliRoots} resets for tests.
+ */
+export function injectOmpExtensionCliRoots(paths: readonly string[], home: string, cwd: string): void {
+	if (paths.length === 0) return;
+	const expanded = paths.map(raw => {
+		const tilde = expandTilde(raw, home);
+		return path.isAbsolute(tilde) ? tilde : path.resolve(cwd, tilde);
+	});
+	const merged = new Map<string, InjectedRoot>();
+	for (const root of injectedCliRoots) merged.set(root.path, root);
+	for (const resolved of expanded) {
+		// CLI scope mirrors how `--extension` is treated elsewhere — user-level overrides win.
+		if (!merged.has(resolved)) merged.set(resolved, { path: resolved, level: "user" });
+	}
+	injectedCliRoots = [...merged.values()];
+}
+
+/** Drop every CLI-injected root. Tests use this between cases. */
+export function clearOmpExtensionCliRoots(): void {
+	injectedCliRoots = [];
+}
+
+/** Inspect currently-injected CLI roots (read-only). Exposed for diagnostics + tests. */
+export function getInjectedOmpExtensionCliRoots(): readonly OmpExtensionRoot[] {
+	return injectedCliRoots.map(({ path: p, level }) => ({ path: p, level, name: path.basename(p) }));
+}
+
+interface ScopeDirs {
+	project: string;
+	user: string;
+}
+
+function scopeDirs(ctx: LoadContext): ScopeDirs {
+	return {
+		project: path.join(ctx.cwd, ".omp"),
+		user: path.join(ctx.home, ".omp", "agent"),
+	};
+}
+
+async function readSettingsExtensions(settingsPath: string): Promise<string[]> {
+	const content = await readFile(settingsPath);
+	if (!content) return [];
+	const parsed = tryParseJson<{ extensions?: unknown }>(content);
+	const raw = parsed?.extensions;
+	if (!Array.isArray(raw)) return [];
+	return raw.filter((entry): entry is string => typeof entry === "string" && entry.length > 0);
+}
+
+function resolveAgainst(raw: string, ctx: LoadContext): string {
+	const tilde = expandTilde(raw, ctx.home);
+	return path.isAbsolute(tilde) ? tilde : path.resolve(ctx.cwd, tilde);
+}
+
+async function isDirectory(p: string): Promise<boolean> {
+	const entries = await readDirEntries(p);
+	if (entries.length > 0) return true;
+	// Empty directory still counts; cache returns [] for both empty and missing.
+	// Disambiguate with a single stat — only hit when the cached listing is empty.
+	try {
+		const stat = await fs.stat(p);
+		return stat.isDirectory();
+	} catch (err) {
+		if (isEnoent(err)) return false;
+		throw err;
+	}
+}
+
+/**
+ * Resolve every configured extension package directory for the given context.
+ *
+ * Sources, in order of precedence (later entries with the same absolute path
+ * are dropped):
+ *
+ * 1. CLI roots injected via {@link injectOmpExtensionCliRoots}
+ * 2. Project `<cwd>/.omp/settings.json#extensions`
+ * 3. User `~/.omp/agent/settings.json#extensions`
+ * 4. Enabled plugins installed under `<plugins>/node_modules/` (e.g. via
+ *    `omp install <pkg>` / `omp plugin install` / `omp plugin link`)
+ *
+ * Only entries that resolve to a directory on disk are returned; file
+ * entrypoints contribute zero sub-discovery surface and are filtered out.
+ * Installed-plugin enumeration failures (missing lockfile, unreadable
+ * `package.json`, etc.) are logged at `debug` and degrade gracefully — the
+ * other sources still surface.
+ */
+export async function listOmpExtensionRoots(ctx: LoadContext): Promise<OmpExtensionRoot[]> {
+	const { project, user } = scopeDirs(ctx);
+	const [projectExtensions, userExtensions, installedPlugins] = await Promise.all([
+		readSettingsExtensions(path.join(project, "settings.json")),
+		readSettingsExtensions(path.join(user, "settings.json")),
+		listInstalledPluginRoots(ctx),
+	]);
+
+	const candidates: InjectedRoot[] = [
+		...injectedCliRoots,
+		...projectExtensions.map((raw): InjectedRoot => ({ path: resolveAgainst(raw, ctx), level: "project" })),
+		...userExtensions.map((raw): InjectedRoot => ({ path: resolveAgainst(raw, ctx), level: "user" })),
+		...installedPlugins,
+	];
+
+	// First-seen-wins dedup preserves CLI > project-settings > user-settings > installed precedence.
+	const seen = new Set<string>();
+	const unique: InjectedRoot[] = [];
+	for (const candidate of candidates) {
+		if (seen.has(candidate.path)) continue;
+		seen.add(candidate.path);
+		unique.push(candidate);
+	}
+
+	const directoryFlags = await Promise.all(unique.map(c => isDirectory(c.path)));
+	const roots: OmpExtensionRoot[] = [];
+	for (let i = 0; i < unique.length; i++) {
+		if (!directoryFlags[i]) continue;
+		const { path: p, level } = unique[i];
+		roots.push({ path: p, level, name: path.basename(p) });
+	}
+	return roots;
+}
+
+/**
+ * Enumerate every enabled installed plugin's package directory so its
+ * conventional `skills/`, `hooks/`, `tools/`, `commands/`, `rules/`,
+ * `prompts/`, and `.mcp.json` are wired into discovery — mirrors how
+ * `getAllPluginExtensionPaths` already feeds the extension factory loader.
+ *
+ * Marketplace and `omp plugin link` installs write to the plugin manager's
+ * `node_modules` (or symlink into it) rather than to `extensions:` in
+ * settings; without this branch the sub-discovery provider would still miss
+ * everything those install paths produce.
+ */
+async function listInstalledPluginRoots(ctx: LoadContext): Promise<InjectedRoot[]> {
+	try {
+		const plugins = await getEnabledPlugins(ctx.cwd, { home: ctx.home });
+		// Installed plugins are always user-scope; project disablement is already
+		// honored by `getEnabledPlugins` via `loadProjectOverrides`.
+		return plugins.map(({ path: p }) => ({ path: p, level: "user" }));
+	} catch (err) {
+		logger.debug("listInstalledPluginRoots: enumeration failed", { error: String(err) });
+		return [];
+	}
+}

package/src/discovery/omp-plugins.ts

@@ -0,0 +1,383 @@
+/**
+ * OMP extension-package sub-discovery provider.
+ *
+ * When a user configures an extension via `extensions:` (in settings) or
+ * `--extension`/`-e` (on the CLI), the docs promise that the package's
+ * sibling directories — `skills/`, `hooks/pre|post/`, `tools/`, `commands/`,
+ * `rules/`, `prompts/`, and `.mcp.json` — are picked up by omp's standard
+ * discovery surfaces. The native `omp` provider in `builtin.ts` only walks
+ * `.omp/` and `~/.omp/agent/`, so without this provider those sub-trees are
+ * silently ignored.
+ *
+ * Provider priority is set below the native `omp` provider (100) so an
+ * extension package never shadows the user's own `.omp/` configuration on
+ * dedup.
+ *
+ * @see ./omp-extension-roots.ts
+ * @see ../../docs/extension-loading.md
+ */
+import * as path from "node:path";
+import { logger, parseFrontmatter, tryParseJson } from "@oh-my-pi/pi-utils";
+import { registerProvider } from "../capability";
+import { readDirEntries, readFile } from "../capability/fs";
+import { type Hook, hookCapability } from "../capability/hook";
+import { type MCPServer, mcpCapability } from "../capability/mcp";
+import { type Prompt, promptCapability } from "../capability/prompt";
+import { type Rule, ruleCapability } from "../capability/rule";
+import { type Skill, skillCapability } from "../capability/skill";
+import { type SlashCommand, slashCommandCapability } from "../capability/slash-command";
+import { type CustomTool, toolCapability } from "../capability/tool";
+import type { LoadContext, LoadResult } from "../capability/types";
+import { buildRuleFromMarkdown, createSourceMeta, loadFilesFromDir, scanSkillsFromDir } from "./helpers";
+import { listOmpExtensionRoots, type OmpExtensionRoot } from "./omp-extension-roots";
+
+const PROVIDER_ID = "omp-plugins";
+const DISPLAY_NAME = "OMP Extension Packages";
+const DESCRIPTION =
+	"Sub-discovery (skills, hooks, tools, commands, rules, prompts, .mcp.json) inside extension packages";
+const PRIORITY = 90;
+
+// =============================================================================
+// Skills
+// =============================================================================
+
+async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
+	const roots = await listOmpExtensionRoots(ctx);
+	const results = await Promise.all(
+		roots.map(root =>
+			scanSkillsFromDir(ctx, {
+				dir: path.join(root.path, "skills"),
+				providerId: PROVIDER_ID,
+				level: root.level,
+				requireDescription: true,
+			}),
+		),
+	);
+	return {
+		items: results.flatMap(r => r.items),
+		warnings: results.flatMap(r => r.warnings ?? []),
+	};
+}
+
+// =============================================================================
+// Slash Commands
+// =============================================================================
+
+async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashCommand>> {
+	const roots = await listOmpExtensionRoots(ctx);
+	const results = await Promise.all(
+		roots.map(root =>
+			loadFilesFromDir<SlashCommand>(ctx, path.join(root.path, "commands"), PROVIDER_ID, root.level, {
+				extensions: ["md"],
+				transform: (name, content, filePath, source) => ({
+					name: name.replace(/\.md$/, ""),
+					path: filePath,
+					content,
+					level: root.level,
+					_source: source,
+				}),
+			}),
+		),
+	);
+	return {
+		items: results.flatMap(r => r.items),
+		warnings: results.flatMap(r => r.warnings ?? []),
+	};
+}
+
+// =============================================================================
+// Rules
+// =============================================================================
+
+async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
+	const roots = await listOmpExtensionRoots(ctx);
+	const results = await Promise.all(
+		roots.map(root =>
+			loadFilesFromDir<Rule>(ctx, path.join(root.path, "rules"), PROVIDER_ID, root.level, {
+				extensions: ["md", "mdc"],
+				transform: (name, content, filePath, source) =>
+					buildRuleFromMarkdown(name, content, filePath, source, { stripNamePattern: /\.(md|mdc)$/ }),
+			}),
+		),
+	);
+	return {
+		items: results.flatMap(r => r.items),
+		warnings: results.flatMap(r => r.warnings ?? []),
+	};
+}
+
+// =============================================================================
+// Prompts
+// =============================================================================
+
+async function loadPrompts(ctx: LoadContext): Promise<LoadResult<Prompt>> {
+	const roots = await listOmpExtensionRoots(ctx);
+	const results = await Promise.all(
+		roots.map(root =>
+			loadFilesFromDir<Prompt>(ctx, path.join(root.path, "prompts"), PROVIDER_ID, root.level, {
+				extensions: ["md"],
+				transform: (name, content, filePath, source) => ({
+					name: name.replace(/\.md$/, ""),
+					path: filePath,
+					content,
+					_source: source,
+				}),
+			}),
+		),
+	);
+	return {
+		items: results.flatMap(r => r.items),
+		warnings: results.flatMap(r => r.warnings ?? []),
+	};
+}
+
+// =============================================================================
+// Hooks
+// =============================================================================
+
+const HOOK_TYPES: ReadonlyArray<"pre" | "post"> = ["pre", "post"];
+
+async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
+	const roots = await listOmpExtensionRoots(ctx);
+	const tasks: Array<{ root: OmpExtensionRoot; hookType: "pre" | "post" }> = [];
+	for (const root of roots) {
+		for (const hookType of HOOK_TYPES) {
+			tasks.push({ root, hookType });
+		}
+	}
+	const results = await Promise.all(
+		tasks.map(({ root, hookType }) =>
+			loadFilesFromDir<Hook>(ctx, path.join(root.path, "hooks", hookType), PROVIDER_ID, root.level, {
+				transform: (name, _content, filePath, source) => {
+					const baseName = name.includes(".") ? name.slice(0, name.lastIndexOf(".")) : name;
+					const tool = baseName === "*" ? "*" : baseName;
+					return {
+						name,
+						path: filePath,
+						type: hookType,
+						tool,
+						level: root.level,
+						_source: source,
+					};
+				},
+			}),
+		),
+	);
+	return {
+		items: results.flatMap(r => r.items),
+		warnings: results.flatMap(r => r.warnings ?? []),
+	};
+}
+
+// =============================================================================
+// Custom Tools
+// =============================================================================
+
+const TOOL_EXTENSIONS = ["json", "md", "ts", "js", "sh", "bash", "py"];
+
+async function loadTools(ctx: LoadContext): Promise<LoadResult<CustomTool>> {
+	const roots = await listOmpExtensionRoots(ctx);
+	const perRoot = await Promise.all(
+		roots.map(async root => {
+			const toolsDir = path.join(root.path, "tools");
+			const [filesResult, entries] = await Promise.all([
+				loadFilesFromDir<CustomTool>(ctx, toolsDir, PROVIDER_ID, root.level, {
+					extensions: TOOL_EXTENSIONS,
+					transform: (name, content, filePath, source) => {
+						if (name.endsWith(".json")) {
+							const data = tryParseJson<{ name?: string; description?: string }>(content);
+							const toolName = data?.name || name.replace(/\.json$/, "");
+							const description =
+								typeof data?.description === "string" && data.description.trim()
+									? data.description
+									: `${toolName} custom tool`;
+							return { name: toolName, path: filePath, description, level: root.level, _source: source };
+						}
+						if (name.endsWith(".md")) {
+							const { frontmatter } = parseFrontmatter(content, { source: filePath });
+							const toolName = (frontmatter.name as string) || name.replace(/\.md$/, "");
+							const description =
+								typeof frontmatter.description === "string" && frontmatter.description.trim()
+									? String(frontmatter.description)
+									: `${toolName} custom tool`;
+							return { name: toolName, path: filePath, description, level: root.level, _source: source };
+						}
+						const toolName = name.replace(/\.(ts|js|sh|bash|py)$/, "");
+						return {
+							name: toolName,
+							path: filePath,
+							description: `${toolName} custom tool`,
+							level: root.level,
+							_source: source,
+						};
+					},
+				}),
+				readDirEntries(toolsDir),
+			]);
+
+			// `<tools>/<name>/index.ts` sub-directory tools, mirroring `builtin.ts:loadTools`.
+			const indexCandidates = entries
+				.filter(e => !e.name.startsWith(".") && e.isDirectory())
+				.map(e => path.join(toolsDir, e.name, "index.ts"));
+			const indexContents = await Promise.all(indexCandidates.map(p => readFile(p)));
+			const indexItems: CustomTool[] = [];
+			for (let i = 0; i < indexCandidates.length; i++) {
+				if (indexContents[i] === null) continue;
+				const indexPath = indexCandidates[i];
+				const toolName = path.basename(path.dirname(indexPath));
+				indexItems.push({
+					name: toolName,
+					path: indexPath,
+					description: `${toolName} custom tool`,
+					level: root.level,
+					_source: createSourceMeta(PROVIDER_ID, indexPath, root.level),
+				});
+			}
+
+			return { filesResult, indexItems };
+		}),
+	);
+
+	const items: CustomTool[] = [];
+	const warnings: string[] = [];
+	for (const { filesResult, indexItems } of perRoot) {
+		items.push(...filesResult.items, ...indexItems);
+		if (filesResult.warnings) warnings.push(...filesResult.warnings);
+	}
+	return { items, warnings };
+}
+
+// =============================================================================
+// MCP Servers
+// =============================================================================
+
+const MCP_FILENAMES = [".mcp.json", "mcp.json"] as const;
+
+interface RawMcpServer {
+	enabled?: boolean;
+	timeout?: number;
+	command?: string;
+	args?: string[];
+	env?: Record<string, string>;
+	cwd?: string;
+	url?: string;
+	headers?: Record<string, string>;
+	auth?: MCPServer["auth"];
+	oauth?: MCPServer["oauth"];
+	type?: MCPServer["transport"];
+}
+
+async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
+	const roots = await listOmpExtensionRoots(ctx);
+	const items: MCPServer[] = [];
+	const warnings: string[] = [];
+
+	const tasks: Array<{ root: OmpExtensionRoot; mcpPath: string }> = [];
+	for (const root of roots) {
+		for (const filename of MCP_FILENAMES) {
+			tasks.push({ root, mcpPath: path.join(root.path, filename) });
+		}
+	}
+	const contents = await Promise.all(tasks.map(({ mcpPath }) => readFile(mcpPath)));
+
+	for (let i = 0; i < tasks.length; i++) {
+		const raw = contents[i];
+		if (raw === null) continue;
+		const { root, mcpPath } = tasks[i];
+
+		const parsed = tryParseJson<{ mcpServers?: Record<string, unknown> }>(raw);
+		if (!parsed) {
+			warnings.push(`[omp-plugins] Invalid JSON in ${mcpPath}`);
+			logger.warn(`[omp-plugins] Invalid JSON in ${mcpPath}`);
+			continue;
+		}
+		const servers = parsed.mcpServers;
+		if (!servers || typeof servers !== "object" || Array.isArray(servers)) continue;
+
+		for (const [serverName, serverCfg] of Object.entries(servers)) {
+			if (!serverCfg || typeof serverCfg !== "object" || Array.isArray(serverCfg)) continue;
+			const cfg = serverCfg as RawMcpServer;
+			if (typeof cfg.command !== "string" && typeof cfg.url !== "string") {
+				warnings.push(`[omp-plugins] Skipping MCP server "${serverName}" in ${mcpPath}: missing command or url`);
+				continue;
+			}
+			items.push({
+				name: serverName,
+				...(cfg.enabled !== undefined && { enabled: cfg.enabled }),
+				...(cfg.timeout !== undefined && { timeout: cfg.timeout }),
+				...(cfg.command !== undefined && { command: cfg.command }),
+				...(cfg.args !== undefined && { args: cfg.args }),
+				...(cfg.env !== undefined && { env: cfg.env }),
+				...(cfg.cwd !== undefined && { cwd: cfg.cwd }),
+				...(cfg.url !== undefined && { url: cfg.url }),
+				...(cfg.headers !== undefined && { headers: cfg.headers }),
+				...(cfg.auth !== undefined && { auth: cfg.auth }),
+				...(cfg.oauth !== undefined && { oauth: cfg.oauth }),
+				...(cfg.type !== undefined && { transport: cfg.type }),
+				_source: createSourceMeta(PROVIDER_ID, mcpPath, root.level),
+			});
+		}
+	}
+
+	return { items, warnings };
+}
+
+// =============================================================================
+// Provider Registration
+// =============================================================================
+
+registerProvider<Skill>(skillCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: DESCRIPTION,
+	priority: PRIORITY,
+	load: loadSkills,
+});
+
+registerProvider<SlashCommand>(slashCommandCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: DESCRIPTION,
+	priority: PRIORITY,
+	load: loadSlashCommands,
+});
+
+registerProvider<Rule>(ruleCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: DESCRIPTION,
+	priority: PRIORITY,
+	load: loadRules,
+});
+
+registerProvider<Prompt>(promptCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: DESCRIPTION,
+	priority: PRIORITY,
+	load: loadPrompts,
+});
+
+registerProvider<Hook>(hookCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: DESCRIPTION,
+	priority: PRIORITY,
+	load: loadHooks,
+});
+
+registerProvider<CustomTool>(toolCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: DESCRIPTION,
+	priority: PRIORITY,
+	load: loadTools,
+});
+
+registerProvider<MCPServer>(mcpCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: DESCRIPTION,
+	priority: PRIORITY,
+	load: loadMCPServers,
+});

package/src/edit/file-snapshot-store.ts

@@ -9,6 +9,15 @@
  * is wiring it onto the per-session owner object.
  */
 import { InMemorySnapshotStore } from "@oh-my-pi/hashline";
+import { normalizeToLF } from "./normalize";
+
+/**
+ * Upper bound on the file size we snapshot. A section tag is a content hash of
+ * the *whole* file, so minting one means holding the full normalized text in
+ * the store. Files above this cap emit no `¶path#tag` header — line-anchored
+ * editing of multi-megabyte files is out of scope under the full-content model.
+ */
+export const SNAPSHOT_MAX_BYTES = 4 * 1024 * 1024;
 
 interface FileSnapshotStoreOwner {
 	fileSnapshotStore?: InMemorySnapshotStore;
@@ -23,3 +32,28 @@ export function getFileSnapshotStore(session: FileSnapshotStoreOwner): InMemoryS
 	if (!session.fileSnapshotStore) session.fileSnapshotStore = new InMemorySnapshotStore();
 	return session.fileSnapshotStore;
 }
+
+/**
+ * Read the full text of `absolutePath` (within {@link SNAPSHOT_MAX_BYTES}),
+ * record it as a version snapshot, and return its content-hash tag. Returns
+ * `undefined` when the file exceeds the cap or cannot be read — callers then
+ * omit the section header so the model never sees a tag it can't anchor against.
+ *
+ * Producers that only displayed a slice of the file (range reads, search hits)
+ * use this to mint a whole-file tag: the displayed lines stay partial, but the
+ * tag fingerprints the entire file so a follow-up edit anchored at any line
+ * validates whenever the live file is byte-identical to what was read.
+ */
+export async function recordFileSnapshot(
+	session: FileSnapshotStoreOwner,
+	absolutePath: string,
+): Promise<string | undefined> {
+	try {
+		const file = Bun.file(absolutePath);
+		if (file.size > SNAPSHOT_MAX_BYTES) return undefined;
+		const normalized = normalizeToLF(await file.text());
+		return getFileSnapshotStore(session).record(absolutePath, normalized);
+	} catch {
+		return undefined;
+	}
+}

package/src/edit/hashline/diff.ts

@@ -44,14 +44,9 @@ function hasAnchorScoped(section: PatchSection): boolean {
 	return section.hasAnchorScopedEdit;
 }
 
-function snapshotMatchesCurrent(snapshot: Snapshot, currentText: string, anchorLines: readonly number[]): boolean {
-	if (snapshot.fullText !== undefined) return snapshot.fullText === currentText;
-	for (const lineNumber of anchorLines) {
-		if (snapshot.get(lineNumber) === undefined) return false;
-	}
-	return snapshot.matchesLiveFile(currentText.split("\n"));
+function snapshotMatchesCurrent(snapshot: Snapshot, currentText: string): boolean {
+	return snapshot.text === currentText;
 }
-
 function validateSectionHash(
 	section: PatchSection,
 	absolutePath: string,
@@ -64,7 +59,7 @@ function validateSectionHash(
 			: null;
 	}
 	const snapshot = snapshots.byHash(absolutePath, section.fileHash);
-	if (snapshot && snapshotMatchesCurrent(snapshot, text, section.collectAnchorLines())) return null;
+	if (snapshot && snapshotMatchesCurrent(snapshot, text)) return null;
 	return `Hashline snapshot tag mismatch for ${section.path}: section is bound to #${section.fileHash}, but current file does not match that snapshot; re-read and try again.`;
 }
 

package/src/edit/renderer.ts

@@ -312,7 +312,7 @@ const MISSING_APPLY_PATCH_END_ERROR = "The last line of the patch must be '*** E
 
 function normalizeHashlineInputPreviewPath(rawPath: string): string {
 	const trimmed = rawPath.trim();
-	const hashStart = /#[0-9a-fA-F]{3}$/u.exec(trimmed)?.index;
+	const hashStart = /#[0-9a-fA-F]{4}$/u.exec(trimmed)?.index;
 	const withoutHash = hashStart === undefined ? trimmed : trimmed.slice(0, hashStart);
 	if (withoutHash.length < 2) return withoutHash;
 	const first = withoutHash[0];