@oh-my-pi/pi-coding-agent 15.5.3 → 15.5.6

package/src/config.ts

@@ -18,30 +18,57 @@ const priorityList = [
 // =============================================================================
 
 /**
- * Get the base directory for resolving optional package assets (docs, examples).
- * Walk up from import.meta.dir until we find package.json, or fall back to cwd.
+ * Walk up from `startDir` looking for a `package.json`. Returns the directory
+ * containing the marker, or `undefined` when the walk hits the filesystem root
+ * without finding one.
+ *
+ * Exported for unit-testing the resolution contract from arbitrary start
+ * directories (notably the `bun --compile` case where `import.meta.dir`
+ * resolves to `/$bunfs/root` and no owning package is locatable — issue
+ * #1423). Production callers should use {@link getPackageDir} instead.
  */
-export function getPackageDir(): string {
-	// Allow override via environment variable (useful for Nix/Guix where store paths tokenize poorly)
-	const envDir = process.env.PI_PACKAGE_DIR;
-	if (envDir) {
-		return expandTilde(envDir);
-	}
-
-	let dir = import.meta.dir;
+export function walkUpForPackageDir(startDir: string): string | undefined {
+	let dir = startDir;
 	while (dir !== path.dirname(dir)) {
 		if (fs.existsSync(path.join(dir, "package.json"))) {
 			return dir;
 		}
 		dir = path.dirname(dir);
 	}
-	// Fallback to project dir (docs/examples won't be found, but that's fine)
-	return getProjectDir();
+	return undefined;
 }
 
-/** Get path to CHANGELOG.md (optional, may not exist in binary) */
-export function getChangelogPath(): string {
-	return path.resolve(path.join(getPackageDir(), "CHANGELOG.md"));
+/**
+ * Get the base directory for resolving optional package assets (docs, examples, CHANGELOG.md).
+ *
+ * Honors the `PI_PACKAGE_DIR` override (useful for Nix/Guix store paths);
+ * otherwise walks up from `import.meta.dir` looking for a `package.json`.
+ * Returns `undefined` when no owning package is locatable — notably inside
+ * `bun --compile` binaries where `import.meta.dir` resolves to `/$bunfs/root`
+ * and the walk hits the filesystem root with nothing found.
+ *
+ * Callers MUST treat `undefined` as "no package assets available" and skip the
+ * lookup. NEVER fall back to the user's `cwd` here: that conflates the host
+ * project with omp's own assets and was the source of issue #1423 (the host
+ * project's `CHANGELOG.md` rendered as omp's startup changelog).
+ */
+export function getPackageDir(): string | undefined {
+	const envDir = process.env.PI_PACKAGE_DIR;
+	if (envDir) {
+		return expandTilde(envDir);
+	}
+	return walkUpForPackageDir(import.meta.dir);
+}
+
+/**
+ * Path to omp's own `CHANGELOG.md`, or `undefined` when the package directory
+ * cannot be resolved (e.g. inside `bun --compile` binaries that don't bundle
+ * package assets). Callers MUST skip changelog parsing when this is undefined;
+ * see issue #1423.
+ */
+export function getChangelogPath(): string | undefined {
+	const packageDir = getPackageDir();
+	return packageDir ? path.resolve(packageDir, "CHANGELOG.md") : undefined;
 }
 
 // =============================================================================

package/src/edit/diff.ts

@@ -58,7 +58,7 @@ function formatNumberedDiffLine(prefix: "+" | "-" | " ", lineNum: number, conten
  * Generate a unified diff string with line numbers and context.
  * Returns both the diff string and the first changed line number (in the new file).
  */
-export function generateDiffString(oldContent: string, newContent: string, contextLines = 4): DiffResult {
+export function generateDiffString(oldContent: string, newContent: string, contextLines = 2): DiffResult {
 	const parts = Diff.diffLines(oldContent, newContent);
 	const output: string[] = [];
 
@@ -119,8 +119,9 @@ export function generateDiffString(oldContent: string, newContent: string, conte
 					linesToShow = raw.slice(0, contextLimit);
 				}
 
+				// Leading-skip placeholder is omitted: the first emitted line's
+				// number already conveys that earlier lines were trimmed.
 				if (leadingSkip > 0) {
-					output.push(formatNumberedDiffLine(" ", oldLineNum, "..."));
 					oldLineNum += leadingSkip;
 					newLineNum += leadingSkip;
 				}
@@ -143,8 +144,9 @@ export function generateDiffString(oldContent: string, newContent: string, conte
 					}
 				}
 
+				// Trailing-skip placeholder is omitted for the same reason: the
+				// final emitted line's number tells the reader the file continues.
 				if (trailingSkip > 0) {
-					output.push(formatNumberedDiffLine(" ", oldLineNum, "..."));
 					oldLineNum += trailingSkip;
 					newLineNum += trailingSkip;
 				}

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

@@ -0,0 +1,22 @@
+/**
+ * Session-bound file snapshot store.
+ *
+ * Used by `read` and `search` to record exactly what the model saw, and by
+ * the hashline patcher to recover from stale section hashes (file changed
+ * externally between read and edit, or a prior in-session edit advanced
+ * the hash). The store is the {@link InMemorySnapshotStore} implementation
+ * from `@oh-my-pi/hashline`; the only coding-agent-specific concern here
+ * is wiring it onto the per-session {@link ToolSession} object.
+ */
+import { InMemorySnapshotStore } from "@oh-my-pi/hashline";
+import type { ToolSession } from "../tools";
+
+/**
+ * Look up (or lazily create) the file snapshot store attached to a session.
+ * Storage lives on `session.fileSnapshotStore` so it ages out exactly with
+ * the session itself.
+ */
+export function getFileSnapshotStore(session: ToolSession): InMemorySnapshotStore {
+	if (!session.fileSnapshotStore) session.fileSnapshotStore = new InMemorySnapshotStore();
+	return session.fileSnapshotStore;
+}

package/src/edit/hashline/diff.ts

@@ -0,0 +1,95 @@
+/**
+ * Read-only hashline diff preview helpers used by the streaming edit
+ * renderer. Reads the target file, parses + applies the section's edits in
+ * memory (no FS write, no LSP writethrough), then hands the before/after
+ * pair to {@link generateDiffString} so the renderer can show the diff
+ * while the tool call is still streaming.
+ *
+ * Validation is intentionally light: only the section file hash is checked
+ * (so the preview goes red when anchors are stale), no plan-mode guards
+ * and no auto-generated-file refusal — those belong on the write path.
+ */
+import {
+	computeFileHash,
+	Patch as HashlinePatch,
+	normalizeToLF,
+	type Patch,
+	type PatchSection,
+	stripBom,
+} from "@oh-my-pi/hashline";
+import { resolveToCwd } from "../../tools/path-utils";
+import { generateDiffString } from "../diff";
+import { readEditFileText } from "../read-file";
+
+export interface HashlineDiffOptions {
+	autoDropPureInsertDuplicates?: boolean;
+	/**
+	 * Use the streaming-tolerant applier ({@link PatchSection.applyPartialTo})
+	 * so trailing in-flight ops do not throw or emit phantom edits. Streaming
+	 * preview path only.
+	 */
+	streaming?: boolean;
+}
+
+async function readSectionText(absolutePath: string, sectionPath: string): Promise<string> {
+	try {
+		return await readEditFileText(absolutePath, sectionPath);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(message || `Unable to read ${sectionPath}`);
+	}
+}
+
+function hasAnchorScoped(section: PatchSection): boolean {
+	return section.hasAnchorScopedEdit;
+}
+
+function validateSectionHash(section: PatchSection, text: string): string | null {
+	if (section.fileHash === undefined) {
+		return hasAnchorScoped(section)
+			? `Missing hashline file hash for anchored edit to ${section.path}; use \`¶${section.path}#hash\` from your latest read.`
+			: null;
+	}
+	const currentHash = computeFileHash(text);
+	if (currentHash === section.fileHash) return null;
+	return `Hashline file hash mismatch for ${section.path}: section is bound to #${section.fileHash}, but current file hashes to #${currentHash}; re-read and try again.`;
+}
+
+export async function computeHashlineSectionDiff(
+	section: PatchSection,
+	cwd: string,
+	options: HashlineDiffOptions = {},
+): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
+	try {
+		const absolutePath = resolveToCwd(section.path, cwd);
+		const rawContent = await readSectionText(absolutePath, section.path);
+		const { text: content } = stripBom(rawContent);
+		const normalized = normalizeToLF(content);
+		const hashError = validateSectionHash(section, normalized);
+		if (hashError) return { error: hashError };
+		const result = options.streaming
+			? section.applyPartialTo(normalized, options)
+			: section.applyTo(normalized, options);
+		if (normalized === result.text) return { error: `No changes would be made to ${section.path}.` };
+		return generateDiffString(normalized, result.text);
+	} catch (err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+}
+
+export async function computeHashlineDiff(
+	input: { input: string },
+	cwd: string,
+	options: HashlineDiffOptions = {},
+): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
+	let patch: Patch;
+	try {
+		patch = HashlinePatch.parse(input.input, { cwd });
+	} catch (err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+	if (patch.sections.length !== 1) {
+		return { error: "Streaming diff preview supports exactly one hashline section." };
+	}
+	return computeHashlineSectionDiff(patch.sections[0], cwd, options);
+}

package/src/edit/hashline/execute.ts

@@ -0,0 +1,181 @@
+/**
+ * Coding-agent runner that drives the hashline {@link Patcher} on behalf of
+ * the `edit` tool. Converts a `{input}` tool-call payload into a
+ * fully-applied patch, wraps the result in the agent's
+ * {@link AgentToolResult} shape, and attaches LSP diagnostics + `outputMeta`
+ * for the renderer.
+ *
+ * Multi-section patches are preflighted up front via {@link Patcher.prepare}
+ * so a partial batch never lands; the commit loop then narrows the LSP
+ * batch's `flush` flag to true only for the final write so diagnostics
+ * round-trip once.
+ */
+import {
+	buildCompactDiffPreview,
+	MismatchError as HashlineMismatchError,
+	Patch,
+	Patcher,
+	type PatchSectionResult,
+	type PreparedSection,
+} from "@oh-my-pi/hashline";
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { FileDiagnosticsResult, WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
+import type { ToolSession } from "../../tools";
+import { outputMeta } from "../../tools/output-meta";
+import { generateDiffString } from "../diff";
+import { getFileSnapshotStore } from "../file-snapshot-store";
+import type { EditToolDetails, EditToolPerFileResult, LspBatchRequest } from "../renderer";
+import { HashlineFilesystem } from "./filesystem";
+import { type HashlineParams, hashlineEditParamsSchema } from "./params";
+
+export interface ExecuteHashlineSingleOptions {
+	session: ToolSession;
+	input: string;
+	signal?: AbortSignal;
+	batchRequest?: LspBatchRequest;
+	writethrough: WritethroughCallback;
+	beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
+}
+
+function getHashlineApplyOptions(session: ToolSession): { autoDropPureInsertDuplicates: boolean } {
+	return {
+		autoDropPureInsertDuplicates: session.settings.get("edit.hashlineAutoDropPureInsertDuplicates"),
+	};
+}
+
+function noChangeDiagnostic(path: string): string {
+	return `Edits to ${path} resulted in no changes being made.`;
+}
+
+function assertUniqueCanonicalPaths(prepared: readonly PreparedSection[]): void {
+	const seen = new Map<string, string>();
+	for (const entry of prepared) {
+		const previous = seen.get(entry.canonicalPath);
+		if (previous !== undefined) {
+			throw new Error(
+				`Multiple hashline sections resolve to the same file (${previous} and ${entry.section.path}). Merge their ops under one header before applying.`,
+			);
+		}
+		seen.set(entry.canonicalPath, entry.section.path);
+	}
+}
+
+function narrowBatchRequest(outer: LspBatchRequest | undefined, isLast: boolean): LspBatchRequest | undefined {
+	if (!outer) return undefined;
+	return { id: outer.id, flush: isLast && outer.flush };
+}
+
+interface RenderedSection {
+	toolResult: AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema>;
+	perFileResult: EditToolPerFileResult;
+}
+
+function renderSection(result: PatchSectionResult, diagnostics: FileDiagnosticsResult | undefined): RenderedSection {
+	if (result.op === "noop") {
+		const toolResult: AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema> = {
+			content: [{ type: "text", text: noChangeDiagnostic(result.path) }],
+			details: { diff: "", op: "update", meta: outputMeta().get() },
+		};
+		return {
+			toolResult,
+			perFileResult: { path: result.path, diff: "", op: "update" },
+		};
+	}
+
+	const diff = generateDiffString(result.before, result.after);
+	const preview = buildCompactDiffPreview(diff.diff);
+	const meta = outputMeta()
+		.diagnostics(diagnostics?.summary ?? "", diagnostics?.messages ?? [])
+		.get();
+
+	const warningsBlock = result.warnings.length > 0 ? `\n\nWarnings:\n${result.warnings.join("\n")}` : "";
+	const previewBlock = preview.preview ? `\n${preview.preview}` : "";
+	const firstChangedLine = result.firstChangedLine ?? diff.firstChangedLine;
+	return {
+		toolResult: {
+			content: [{ type: "text", text: `${result.header}${previewBlock}${warningsBlock}` }],
+			details: {
+				diff: diff.diff,
+				firstChangedLine,
+				diagnostics,
+				op: result.op,
+				meta,
+			},
+		},
+		perFileResult: {
+			path: result.path,
+			diff: diff.diff,
+			firstChangedLine,
+			diagnostics,
+			op: result.op,
+		},
+	};
+}
+
+export async function executeHashlineSingle(
+	options: ExecuteHashlineSingleOptions,
+): Promise<AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema>> {
+	const patch = Patch.parse(options.input, { cwd: options.session.cwd });
+	if (patch.sections.length === 0) {
+		throw new Error("No hashline sections found in input.");
+	}
+
+	const fs = new HashlineFilesystem({
+		session: options.session,
+		writethrough: options.writethrough,
+		beginDeferredDiagnosticsForPath: options.beginDeferredDiagnosticsForPath,
+		signal: options.signal,
+		batchRequest: options.batchRequest,
+	});
+	const snapshots = getFileSnapshotStore(options.session);
+	const applyOptions = getHashlineApplyOptions(options.session);
+	const patcher = new Patcher({ fs, snapshots, applyOptions });
+
+	// Single-section fast path: prepare, commit, render.
+	if (patch.sections.length === 1) {
+		fs.setBatchRequest(narrowBatchRequest(options.batchRequest, true));
+		const prepared = await patcher.prepare(patch.sections[0]);
+		const sectionResult = await patcher.commit(prepared);
+		if (sectionResult.op === "noop") {
+			return renderSection(sectionResult, undefined).toolResult;
+		}
+		return renderSection(sectionResult, fs.consumeDiagnostics(sectionResult.path)).toolResult;
+	}
+
+	// Multi-section: prepare every section up front so we fail fast before
+	// any write hits the filesystem.
+	const prepared: PreparedSection[] = [];
+	for (const section of patch.sections) prepared.push(await patcher.prepare(section));
+	assertUniqueCanonicalPaths(prepared);
+	for (const entry of prepared) {
+		if (entry.isNoop) throw new Error(noChangeDiagnostic(entry.section.path));
+	}
+	// Then commit each one, narrowing the LSP batch flush flag to the final
+	// section only. A no-op apply mid-batch is treated as a hard failure —
+	// the model authored anchors that match the current file content.
+	const rendered: RenderedSection[] = [];
+	for (let i = 0; i < prepared.length; i++) {
+		const isLast = i === prepared.length - 1;
+		fs.setBatchRequest(narrowBatchRequest(options.batchRequest, isLast));
+		const sectionResult = await patcher.commit(prepared[i]);
+		if (sectionResult.op === "noop") throw new Error(noChangeDiagnostic(sectionResult.path));
+		rendered.push(renderSection(sectionResult, fs.consumeDiagnostics(sectionResult.path)));
+	}
+
+	return {
+		content: [
+			{
+				type: "text",
+				text: rendered
+					.map(r => r.toolResult.content.map(part => (part.type === "text" ? part.text : "")).join("\n"))
+					.join("\n\n"),
+			},
+		],
+		details: {
+			diff: rendered.map(r => r.toolResult.details?.diff ?? "").join("\n"),
+			perFileResults: rendered.map(r => r.perFileResult),
+		},
+	};
+}
+
+export { HashlineMismatchError, type HashlineParams, hashlineEditParamsSchema };

package/src/edit/hashline/filesystem.ts

@@ -0,0 +1,129 @@
+/**
+ * Coding-agent specific {@link Filesystem} adapter for the hashline patcher.
+ *
+ * Wires hashline's storage abstraction to the agent runtime:
+ *
+ * - Section paths are resolved through the plan-mode redirect so a bare
+ *   `PLAN.md` lands at the canonical session artifact location.
+ * - Reads go through `readEditFileText` (notebook-aware) and the
+ *   auto-generated-file guard.
+ * - Writes go through `serializeEditFileText` (notebook-aware) and the
+ *   LSP writethrough, with FS-scan cache invalidation on success. The
+ *   resulting `FileDiagnosticsResult` is captured per-path so the
+ *   orchestrator can attach it to the tool result.
+ *
+ * Construct one per `executeHashlineSingle` call: per-section state
+ * (batch request, diagnostics) lives on the instance and isn't safe to
+ * share across concurrent edit tools.
+ */
+import { Filesystem, NotFoundError, type WriteResult } from "@oh-my-pi/hashline";
+import { isEnoent } from "@oh-my-pi/pi-utils";
+import type { FileDiagnosticsResult, WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
+import type { ToolSession } from "../../tools";
+import { assertEditableFileContent } from "../../tools/auto-generated-guard";
+import { invalidateFsScanAfterWrite } from "../../tools/fs-cache-invalidation";
+import { enforcePlanModeWrite, resolvePlanPath } from "../../tools/plan-mode-guard";
+import { readEditFileText, serializeEditFileText } from "../read-file";
+import type { LspBatchRequest } from "../renderer";
+
+export interface HashlineFilesystemOptions {
+	session: ToolSession;
+	writethrough: WritethroughCallback;
+	beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
+	signal?: AbortSignal;
+	/**
+	 * Outer LSP batch request inherited from the tool-call context. The
+	 * orchestrator narrows this per-section (flush only on the final write)
+	 * via {@link HashlineFilesystem.setBatchRequest}.
+	 */
+	batchRequest?: LspBatchRequest;
+}
+
+export class HashlineFilesystem extends Filesystem {
+	readonly session: ToolSession;
+	readonly #writethrough: WritethroughCallback;
+	readonly #beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
+	readonly #signal: AbortSignal | undefined;
+	#batchRequest: LspBatchRequest | undefined;
+	#diagnosticsByPath = new Map<string, FileDiagnosticsResult | undefined>();
+
+	constructor(options: HashlineFilesystemOptions) {
+		super();
+		this.session = options.session;
+		this.#writethrough = options.writethrough;
+		this.#beginDeferredDiagnosticsForPath = options.beginDeferredDiagnosticsForPath;
+		this.#signal = options.signal;
+		this.#batchRequest = options.batchRequest;
+	}
+
+	/**
+	 * Set the LSP batch request used for the next {@link writeText} call.
+	 * Multi-section orchestrators flip the `flush` flag to true before the
+	 * final section so LSP diagnostics flush in one round-trip.
+	 */
+	setBatchRequest(batchRequest: LspBatchRequest | undefined): void {
+		this.#batchRequest = batchRequest;
+	}
+
+	/**
+	 * Look up (and clear) the diagnostics captured by the most-recent
+	 * {@link writeText} call for `path`. Returns `undefined` if no write
+	 * has happened or the writethrough returned no diagnostics.
+	 */
+	consumeDiagnostics(path: string): FileDiagnosticsResult | undefined {
+		const value = this.#diagnosticsByPath.get(path);
+		this.#diagnosticsByPath.delete(path);
+		return value;
+	}
+
+	resolveAbsolute(relativePath: string): string {
+		return resolvePlanPath(this.session, relativePath);
+	}
+
+	canonicalPath(relativePath: string): string {
+		return this.resolveAbsolute(relativePath);
+	}
+
+	async readText(relativePath: string): Promise<string> {
+		const absolutePath = this.resolveAbsolute(relativePath);
+		let content: string;
+		try {
+			content = await readEditFileText(absolutePath, relativePath);
+		} catch (error) {
+			if (isEnoent(error)) throw new NotFoundError(relativePath, error);
+			if (error instanceof Error && error.message === `File not found: ${relativePath}`) {
+				throw new NotFoundError(relativePath, error);
+			}
+			throw error;
+		}
+		// Refuse edits against generated files (lockfiles, models.json, …).
+		assertEditableFileContent(content, relativePath);
+		return content;
+	}
+
+	async preflightWrite(relativePath: string): Promise<void> {
+		enforcePlanModeWrite(this.session, relativePath, { op: "update" });
+	}
+
+	async writeText(relativePath: string, content: string): Promise<WriteResult> {
+		await this.preflightWrite(relativePath);
+		const absolutePath = this.resolveAbsolute(relativePath);
+		const finalContent = await serializeEditFileText(absolutePath, relativePath, content);
+		const diagnostics = await this.#writethrough(
+			absolutePath,
+			finalContent,
+			this.#signal,
+			Bun.file(absolutePath),
+			this.#batchRequest,
+			dst => (dst === absolutePath ? this.#beginDeferredDiagnosticsForPath(absolutePath) : undefined),
+		);
+		invalidateFsScanAfterWrite(absolutePath);
+		this.#diagnosticsByPath.set(relativePath, diagnostics);
+		return { text: finalContent };
+	}
+
+	async exists(relativePath: string): Promise<boolean> {
+		const absolutePath = this.resolveAbsolute(relativePath);
+		return Bun.file(absolutePath).exists();
+	}
+}

package/src/edit/hashline/index.ts

@@ -0,0 +1,4 @@
+export * from "./diff";
+export * from "./execute";
+export * from "./filesystem";
+export * from "./params";

package/src/edit/hashline/params.ts

@@ -0,0 +1,18 @@
+/**
+ * Zod schema for the `edit` tool's hashline mode payload. The schema is
+ * deliberately permissive (`.passthrough()`) so providers can attach extra
+ * keys without rejection; only `input` is required. `_input` is accepted as a
+ * provider-emitted alias for `input`.
+ */
+import * as z from "zod/v4";
+
+export const hashlineEditParamsSchema = z.preprocess(raw => {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+
+	const record = raw as Record<string, unknown>;
+	if (typeof record.input === "string" || typeof record._input !== "string") return raw;
+
+	return { ...record, input: record._input };
+}, z.object({ input: z.string() }).passthrough());
+
+export type HashlineParams = z.infer<typeof hashlineEditParamsSchema>;

package/src/edit/index.ts

@@ -1,13 +1,8 @@
+import { MismatchError as HashlineMismatchError } from "@oh-my-pi/hashline";
+import hashlineGrammar from "@oh-my-pi/hashline/grammar.lark" with { type: "text" };
+import hashlineDescription from "@oh-my-pi/hashline/prompt.md" with { type: "text" };
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { prompt } from "@oh-my-pi/pi-utils";
-import {
-	executeHashlineSingle,
-	HashlineMismatchError,
-	type HashlineParams,
-	hashlineEditParamsSchema,
-} from "../hashline";
-import hashlineGrammarTemplate from "../hashline/grammar.lark" with { type: "text" };
-import { resolveHashlineGrammarPlaceholders } from "../hashline/hash";
 import {
 	createLspWritethrough,
 	type FileDiagnosticsResult,
@@ -16,28 +11,25 @@ import {
 	writethroughNoop,
 } from "../lsp";
 import applyPatchDescription from "../prompts/tools/apply-patch.md" with { type: "text" };
-import hashlineDescription from "../prompts/tools/hashline.md" with { type: "text" };
 import patchDescription from "../prompts/tools/patch.md" with { type: "text" };
 import replaceDescription from "../prompts/tools/replace.md" with { type: "text" };
 import type { ToolSession } from "../tools";
 import { truncateForPrompt } from "../tools/approval";
 import { isInternalUrlPath } from "../tools/path-utils";
 import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit-mode";
+import { executeHashlineSingle, type HashlineParams, hashlineEditParamsSchema } from "./hashline";
 import { type ApplyPatchParams, applyPatchSchema, expandApplyPatchToEntries } from "./modes/apply-patch";
 import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
 import { executePatchSingle, type PatchEditEntry, type PatchParams, patchEditSchema } from "./modes/patch";
 import { executeReplaceSingle, type ReplaceEditEntry, type ReplaceParams, replaceEditSchema } from "./modes/replace";
 import { type EditToolDetails, type EditToolPerFileResult, getLspBatchRequest, type LspBatchRequest } from "./renderer";
 
+export * from "@oh-my-pi/hashline";
 export { DEFAULT_EDIT_MODE, type EditMode, normalizeEditMode } from "../utils/edit-mode";
 export * from "./apply-patch";
 export * from "./diff";
-export * from "./file-read-cache";
-
-// Resolve hashline grammar placeholders from the TypeScript constants.
-const hashlineGrammar = resolveHashlineGrammarPlaceholders(hashlineGrammarTemplate);
-
-export * from "../hashline";
+export * from "./file-snapshot-store";
+export * from "./hashline";
 export * from "./modes/apply-patch";
 export * from "./modes/patch";
 export * from "./modes/replace";
@@ -270,19 +262,17 @@ async function executeSinglePathEntries(
 
 function extractApprovalPath(args: unknown): string {
 	const record = args && typeof args === "object" ? (args as Record<string, unknown>) : {};
-	const targetPath = record.path;
-	if (typeof targetPath === "string" && targetPath.length > 0) {
-		return targetPath;
-	}
-
 	const input = typeof record.input === "string" ? record.input : undefined;
-	if (!input) return "(unknown)";
+	if (input) {
+		const hashlineMatch = /^(?:¶|§|@)([^\s#]+)/m.exec(input);
+		if (hashlineMatch?.[1]) return hashlineMatch[1];
 
-	const hashlineMatch = /^(?:¶|§|@)([^\s#]+)/m.exec(input);
-	if (hashlineMatch?.[1]) return hashlineMatch[1];
+		const applyPatchMatch = /^\*\*\* (?:Add|Update|Delete) File:\s*(.+)$/m.exec(input);
+		if (applyPatchMatch?.[1]) return applyPatchMatch[1].trim();
+	}
 
-	const applyPatchMatch = /^\*\*\* (?:Add|Update|Delete) File:\s*(.+)$/m.exec(input);
-	return applyPatchMatch?.[1]?.trim() || "(unknown)";
+	const targetPath = record.path;
+	return typeof targetPath === "string" && targetPath.length > 0 ? targetPath : "(unknown)";
 }
 
 export class EditTool implements AgentTool<TInput> {
@@ -438,11 +428,10 @@ export class EditTool implements AgentTool<TInput> {
 					batchRequest: LspBatchRequest | undefined,
 					_onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
-					const { input, path } = params as HashlineParams & { path?: string };
+					const { input } = params as HashlineParams;
 					return executeHashlineSingle({
 						session: tool.session,
 						input,
-						path,
 						signal,
 						batchRequest,
 						writethrough: tool.#writethrough,