@oh-my-pi/pi-coding-agent 15.5.2 → 15.5.4

package/dist/types/hashline/diff.d.ts

@@ -1,16 +0,0 @@
-import type { HashlineApplyOptions, HashlineInputSection } from "./types";
-export declare function computeHashlineSectionDiff(section: HashlineInputSection, cwd: string, options?: HashlineApplyOptions): Promise<{
-    diff: string;
-    firstChangedLine: number | undefined;
-} | {
-    error: string;
-}>;
-export declare function computeHashlineDiff(input: {
-    input: string;
-    path?: string;
-}, cwd: string, options?: HashlineApplyOptions): Promise<{
-    diff: string;
-    firstChangedLine: number | undefined;
-} | {
-    error: string;
-}>;

package/dist/types/hashline/execute.d.ts

@@ -1,4 +0,0 @@
-import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import type { EditToolDetails } from "../edit/renderer";
-import type { ExecuteHashlineSingleOptions, hashlineEditParamsSchema } from "./types";
-export declare function executeHashlineSingle(options: ExecuteHashlineSingleOptions): Promise<AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema>>;

package/dist/types/hashline/executor.d.ts

@@ -1,56 +0,0 @@
-import { type HashlineToken } from "./tokenizer";
-import type { HashlineEdit } from "./types";
-/**
- * Token-driven state machine that turns a stream of {@link HashlineToken}s
- * into the flat list of {@link HashlineEdit}s applied downstream by the
- * apply/diff layers.
- *
- * The executor owns:
- *   - the running edit index (kept monotonic across pending flushes),
- *   - the pending-payload buffer (lines accumulated for the most recently
- *     opened insert/replace op),
- *   - all parse-time diagnostics (range order, "delete with payload",
- *     orphan payload, unrecognized op),
- *   - the {@link terminated} flag set by `envelope-end`/`abort`.
- *
- * Tokens are dispatched in the order they arrive; the matching tokenizer
- * supplies the line numbers carried inside each token so diagnostics line
- * up with the source.
- */
-export declare class HashlineExecutor {
-    #private;
-    /** True once an `envelope-end` or `abort` token has been observed. */
-    get terminated(): boolean;
-    /**
-     * Consume one token. After `terminated` flips true subsequent feeds
-     * are silently ignored so callers can keep draining their tokenizer
-     * without explicit early-exit guards.
-     */
-    feed(token: HashlineToken): void;
-    /**
-     * Flush any open pending op (with its full accumulated payload, including
-     * explicit `+` blank lines) and return the accumulated edits and warnings.
-     * The executor is single-use; reset() is required for reuse.
-     * Throws if two replace/delete ops target the same line with non-identical
-     * shapes (different ranges, replace+delete, delete+delete). Identical-range
-     * `A-B:` pairs in the same hunk are coalesced last-wins by `feed()` with a
-     * warning, so they never reach the validator.
-     */
-    end(): {
-        edits: HashlineEdit[];
-        warnings: string[];
-    };
-    /** Reset to a fresh state so the same instance can drive another parse. */
-    reset(): void;
-}
-/**
- * Drive a full hashline diff through the tokenizer + executor pipeline and
- * return the resulting edits plus any parse-time warnings. This is the
- * convenience entry point most callers want; reach for {@link
- * HashlineTokenizer}/{@link HashlineExecutor} directly only when you need
- * streaming feeds, cross-section state, or custom token handling.
- */
-export declare function parseHashline(diff: string): {
-    edits: HashlineEdit[];
-    warnings: string[];
-};

package/dist/types/hashline/hash.d.ts

@@ -1,76 +0,0 @@
-/**
- * Core hash utilities shared by hashline edit mode, read/search output,
- * and prompt helpers.
- */
-/**
- * Decoration prefix that may precede a line number in tool output:
- * `>` (context line in grep), `-` (removed line), `*` (match line).
- * Any combination, in any order, surrounded by optional
- * whitespace. Output formatters emit at most one decoration per line; the
- * parser stays liberal because it accepts whatever the model echoes back.
- */
-export declare const HL_ANCHOR_DECORATION_RE_RAW = "\\s*[>\\-*]*\\s*";
-/** Capture-group regex source for a decorated bare line-number anchor. */
-export declare const HL_ANCHOR_RE_RAW = "\\s*[>\\-*]*\\s*(\\d+)";
-/** Bare positive line-number Lid (no decorations, no captures, no anchors). */
-export declare const HL_LINE_RE_RAW = "[1-9]\\d*";
-/** Capture-group form of {@link HL_LINE_RE_RAW}. */
-export declare const HL_LINE_CAPTURE_RE_RAW = "([1-9]\\d*)";
-/** Four-hex-character file hash carried by a hashline section header. */
-export declare const HL_FILE_HASH_RE_RAW = "[0-9a-f]{4}";
-/** Capture-group form of {@link HL_FILE_HASH_RE_RAW}. */
-export declare const HL_FILE_HASH_CAPTURE_RE_RAW = "([0-9a-f]{4})";
-/** Separator between a hashline file path and its file hash. */
-export declare const HL_FILE_HASH_SEP = "#";
-/** Separator between a line number and displayed line content in hashline mode. */
-export declare const HL_LINE_BODY_SEP = ":";
-/** Regex-escaped form of {@link HL_LINE_BODY_SEP}, safe for embedding inside a regex. */
-export declare const HL_LINE_BODY_SEP_RE_RAW: string;
-/**
- * Representative file hashes for use in user-facing error messages and prompt
- * examples.
- */
-export declare const HL_FILE_HASH_EXAMPLES: readonly ["1a2b", "3c4d", "9f3e"];
-/**
- * Format a comma-separated list of example anchors with an optional line-number
- * prefix, quoted for inclusion in error messages: `"160", "42", "7"`.
- */
-export declare function describeAnchorExamples(linePrefix?: string): string;
-/**
- * Substitute every grammar placeholder with the value derived from its
- * TypeScript counterpart. Grammars that don't reference these placeholders
- * pass through unchanged.
- */
-export declare function resolveHashlineGrammarPlaceholders(grammar: string): string;
-/**
- * op lines have an `ANCHOR<SIGIL>[INLINE_PAYLOAD]` shape, where SIGIL is one of
- * {@link HL_OP_INSERT_BEFORE}, {@link HL_OP_INSERT_AFTER}, {@link HL_OP_REPLACE},
- * or {@link HL_OP_DELETE}. Multi-line payloads follow on subsequent lines
- * prefixed with {@link HL_PAYLOAD_PREFIX}; that prefix is stripped before the
- * payload is written.
- *
- * These constants are the single source of truth for the edit parser, grammar,
- * renderer, and prompt.
- */
-export declare const HL_OP_INSERT_BEFORE = "\u2191";
-export declare const HL_OP_INSERT_AFTER = "\u2193";
-export declare const HL_OP_REPLACE = ":";
-export declare const HL_OP_DELETE = "!";
-/** Prefix for payload continuation lines. The prefix itself is not written. */
-export declare const HL_PAYLOAD_PREFIX = "+";
-/** All hashline edit op sigils, concatenated for fast membership tests. */
-export declare const HL_OP_CHARS = "\u2191\u2193:!";
-/** Hashline edit file section header marker. */
-export declare const HL_FILE_PREFIX = "\u00B6";
-/**
- * Compute the 4-hex-character hash carried by a hashline section header.
- * The hash normalizes CR characters and trailing whitespace before hashing so
- * platform line endings and display-trimmed lines do not invalidate anchors.
- */
-export declare function computeFileHash(text: string): string;
-/** Format a hashline section header for a file path and file hash. */
-export declare function formatHashlineHeader(filePath: string, fileHash: string): string;
-/** Formats a single numbered line as `LINE:TEXT`. */
-export declare function formatNumberedLine(lineNumber: number, line: string): string;
-/** Format file text with hashline-mode line-number prefixes for display. */
-export declare function formatNumberedLines(text: string, startLine?: number): string;

package/dist/types/hashline/index.d.ts

@@ -1,14 +0,0 @@
-export * from "./anchors";
-export * from "./apply";
-export * from "./constants";
-export * from "./diff";
-export * from "./diff-preview";
-export * from "./execute";
-export * from "./executor";
-export * from "./hash";
-export * from "./input";
-export * from "./prefixes";
-export * from "./recovery";
-export * from "./stream";
-export * from "./tokenizer";
-export * from "./types";

package/dist/types/hashline/input.d.ts

@@ -1,4 +0,0 @@
-import type { HashlineInputSection, SplitHashlineOptions } from "./types";
-export declare function containsRecognizableHashlineOperations(input: string): boolean;
-export declare function splitHashlineInput(input: string, options?: SplitHashlineOptions): HashlineInputSection;
-export declare function splitHashlineInputs(input: string, options?: SplitHashlineOptions): HashlineInputSection[];

package/dist/types/hashline/prefixes.d.ts

@@ -1,7 +0,0 @@
-export declare function stripNewLinePrefixes(lines: string[]): string[];
-export declare function stripHashlinePrefixes(lines: string[]): string[];
-/**
- * Normalize line payloads by stripping read/search line prefixes. `null` /
- * `undefined` yield `[]`; a single multiline string is split on `\n`.
- */
-export declare function hashlineParseText(edit: string[] | string | null | undefined): string[];

package/dist/types/hashline/recovery.d.ts

@@ -1,21 +0,0 @@
-import type { FileReadCache } from "../edit/file-read-cache";
-import type { HashlineApplyOptions, HashlineEdit } from "./types";
-export interface HashlineRecoveryArgs {
-    cache: FileReadCache;
-    absolutePath: string;
-    currentText: string;
-    fileHash: string;
-    edits: HashlineEdit[];
-    options: HashlineApplyOptions;
-}
-export interface HashlineRecoveryResult {
-    lines: string;
-    firstChangedLine: number | undefined;
-    warnings: string[];
-}
-/**
- * Attempt to recover from a section file-hash mismatch by replaying the edits
- * against a cached pre-edit snapshot of the file and 3-way-merging the result
- * onto the current on-disk content. Returns `null` when no recovery is possible.
- */
-export declare function tryRecoverHashlineWithCache(args: HashlineRecoveryArgs): HashlineRecoveryResult | null;

package/dist/types/hashline/stream.d.ts

@@ -1,2 +0,0 @@
-import type { HashlineStreamOptions } from "./types";
-export declare function streamHashLinesFromUtf8(source: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>, options?: HashlineStreamOptions): AsyncGenerator<string>;

package/dist/types/hashline/tokenizer.d.ts

@@ -1,94 +0,0 @@
-import type { Anchor, HashlineCursor } from "./types";
-/**
- * Split a hashline diff into individual lines without losing the trailing
- * empty line that callers may rely on for explicit blank payloads. CRLF pairs
- * are normalized to a single line break.
- *
- * This mirrors the line-splitting performed by {@link HashlineTokenizer}'s
- * streaming drain loop and is kept for non-streaming callers that prefer
- * a single-shot split.
- */
-export declare function splitHashlineLines(text: string): string[];
-export declare function cloneCursor(cursor: HashlineCursor): HashlineCursor;
-/** Parse a bare line-number anchor (used by insert ops). Throws on malformed input. */
-export declare function parseLid(raw: string, lineNum: number): Anchor;
-export interface ParsedRange {
-    start: Anchor;
-    end: Anchor;
-}
-/**
- * Returns true when the line scans as `LINE!payload` (delete sigil followed by
- * additional content). The executor uses this for the dedicated "deletes only"
- * diagnostic, separate from the standard "unrecognized op" path.
- */
-export declare function isDeleteOpWithPayload(line: string): boolean;
-interface TokenBase {
-    /** 1-indexed line number in the original input stream. */
-    lineNum: number;
-}
-export type HashlineToken = (TokenBase & {
-    kind: "blank";
-}) | (TokenBase & {
-    kind: "envelope-begin";
-}) | (TokenBase & {
-    kind: "envelope-end";
-}) | (TokenBase & {
-    kind: "abort";
-}) | (TokenBase & {
-    kind: "header";
-    path: string;
-    fileHash?: string;
-}) | (TokenBase & {
-    kind: "op-insert";
-    cursor: HashlineCursor;
-    inlineBody: string | undefined;
-}) | (TokenBase & {
-    kind: "op-replace";
-    range: ParsedRange;
-    inlineBody: string | undefined;
-}) | (TokenBase & {
-    kind: "op-delete";
-    range: ParsedRange;
-    trailingPayload: boolean;
-}) | (TokenBase & {
-    kind: "payload";
-    text: string;
-}) | (TokenBase & {
-    kind: "raw";
-    text: string;
-});
-/**
- * Stateful, line-oriented classifier for hashline diff text. Use the streaming
- * {@link feed}/{@link end} pair to ingest text in chunks (each completed line
- * emits exactly one token; a trailing partial line stays buffered until the
- * next chunk or {@link end}). Use the stateless {@link tokenize}/predicate
- * methods for callers that already hold whole lines and only need
- * classification without buffering.
- */
-export declare class HashlineTokenizer {
-    #private;
-    /**
-     * Ingest a chunk of input text. Each newline-terminated line in the
-     * combined buffer produces one token. A trailing partial line (no `\n`
-     * yet, possibly ending in a lone `\r`) stays buffered until the next
-     * `feed`/`end` call so CRLF pairs that straddle chunk boundaries are
-     * still normalized correctly.
-     */
-    feed(chunk: string): HashlineToken[];
-    /**
-     * Flush any buffered residual line (the last line of input when it lacks
-     * a trailing newline) and mark the tokenizer closed. Calling `end` a
-     * second time returns `[]`; reuse requires `reset`.
-     */
-    end(): HashlineToken[];
-    /** Discard any buffered text and reset the line counter to 1. */
-    reset(): void;
-    /** Convenience: feed an entire text and immediately flush. */
-    tokenizeAll(text: string): HashlineToken[];
-    /** Stateless one-shot classification. Does not touch the streaming buffer. */
-    tokenize(line: string, lineNum?: number): HashlineToken;
-    isOp(line: string): boolean;
-    isHeader(line: string): boolean;
-    isEnvelopeMarker(line: string): boolean;
-}
-export {};

package/dist/types/hashline/types.d.ts

@@ -1,75 +0,0 @@
-import * as z from "zod/v4";
-import type { LspBatchRequest } from "../edit/renderer";
-import type { WritethroughCallback, WritethroughDeferredHandle } from "../lsp";
-import type { ToolSession } from "../tools";
-export type Anchor = {
-    line: number;
-};
-export type HashlineCursor = {
-    kind: "bof";
-} | {
-    kind: "eof";
-} | {
-    kind: "before_anchor";
-    anchor: Anchor;
-} | {
-    kind: "after_anchor";
-    anchor: Anchor;
-};
-export type HashlineEdit = {
-    kind: "insert";
-    cursor: HashlineCursor;
-    text: string;
-    lineNum: number;
-    index: number;
-} | {
-    kind: "delete";
-    anchor: Anchor;
-    lineNum: number;
-    index: number;
-    oldAssertion?: string;
-};
-export interface HashlineInputSection {
-    path: string;
-    fileHash?: string;
-    diff: string;
-}
-/** `path` is accepted by the edit tool runtime; other extra keys are preserved. */
-export declare const hashlineEditParamsSchema: z.ZodObject<{
-    input: z.ZodString;
-    path: z.ZodOptional<z.ZodString>;
-}, z.core.$loose>;
-export type HashlineParams = z.infer<typeof hashlineEditParamsSchema>;
-export interface HashlineStreamOptions {
-    /** First line number to use when formatting (1-indexed). */
-    startLine?: number;
-    /** Maximum formatted lines per yielded chunk (default: 200). */
-    maxChunkLines?: number;
-    /** Maximum UTF-8 bytes per yielded chunk (default: 64 KiB). */
-    maxChunkBytes?: number;
-}
-export interface CompactHashlineDiffPreview {
-    preview: string;
-    addedLines: number;
-    removedLines: number;
-}
-export interface CompactHashlineDiffOptions {
-    /** Maximum entries kept on each side of an unchanged-context truncation (default: 2). */
-    maxUnchangedRun?: number;
-}
-export interface HashlineApplyOptions {
-    autoDropPureInsertDuplicates?: boolean;
-}
-export interface SplitHashlineOptions {
-    cwd?: string;
-    path?: string;
-}
-export interface ExecuteHashlineSingleOptions {
-    session: ToolSession;
-    input: string;
-    path?: string;
-    signal?: AbortSignal;
-    batchRequest?: LspBatchRequest;
-    writethrough: WritethroughCallback;
-    beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
-}

package/src/edit/file-read-cache.ts

@@ -1,138 +0,0 @@
-/**
- * Per-session cache of file contents as they were rendered to the model by
- * the `read` and `search` tools in the current agent session.
- *
- * Used by hashline-mode anchor-stale recovery: if the model authored anchors
- * against a version of the file that no longer matches what is on disk —
- * because a subagent, the user, a linter, or a formatter modified the file
- * between the read and the edit — we replay the edits against the cached
- * pre-edit snapshot and 3-way-merge the result onto the live file.
- *
- * Scoped per `ToolSession`: the cache lives on the session object itself, so
- * different sessions never share snapshots and entries get reclaimed when
- * the session goes out of scope. Each session keeps a small LRU window of
- * paths; each path keeps a short ring of recent snapshots so follow-up edits
- * can recover from the agent's own prior writes as well as stale reads.
- */
-import { LRUCache } from "lru-cache/raw";
-import type { ToolSession } from "../tools";
-
-const MAX_PATHS_PER_SESSION = 30;
-const MAX_SNAPSHOTS_PER_PATH = 4;
-
-export interface FileReadSnapshot {
-	/** 1-indexed line number → exact line content as observed by `read`/`search`. */
-	lines: Map<number, string>;
-	/** Full normalized text when the read path observed the whole file. */
-	fullText?: string;
-	/** 4-hex hash of `fullText`, or a sparse snapshot hash supplied by search. */
-	fileHash?: string;
-	recordedAt: number;
-}
-
-interface FileReadSnapshotMetadata {
-	fullText?: string;
-	fileHash?: string;
-}
-
-export class FileReadCache {
-	#snapshots = new LRUCache<string, FileReadSnapshot[]>({ max: MAX_PATHS_PER_SESSION });
-
-	/** Look up the most recent snapshot for `absPath`, or `null` if absent. */
-	get(absPath: string): FileReadSnapshot | null {
-		return this.#snapshots.get(absPath)?.[0] ?? null;
-	}
-
-	/** Look up the most recent snapshot for `absPath` whose file hash matches. */
-	getByHash(absPath: string, fileHash: string): FileReadSnapshot | null {
-		const history = this.#snapshots.get(absPath);
-		return history?.find(snapshot => snapshot.fileHash === fileHash) ?? null;
-	}
-
-	/** Record a contiguous run of lines (e.g. from a `read` tool). `startLine` is 1-indexed. */
-	recordContiguous(
-		absPath: string,
-		startLine: number,
-		lines: readonly string[],
-		metadata: FileReadSnapshotMetadata = {},
-	): void {
-		if (lines.length === 0 && metadata.fullText === undefined) return;
-		const entries: Array<readonly [number, string]> = lines.map((line, idx) => [startLine + idx, line] as const);
-		this.#record(absPath, entries, metadata);
-	}
-
-	/** Record sparse `(lineNumber, content)` pairs (e.g. `search` matches plus context). */
-	recordSparse(
-		absPath: string,
-		entries: Iterable<readonly [number, string]>,
-		metadata: FileReadSnapshotMetadata = {},
-	): void {
-		const arr = Array.from(entries);
-		if (arr.length === 0 && metadata.fullText === undefined) return;
-		this.#record(absPath, arr, metadata);
-	}
-
-	/** Drop the snapshot history for a single path. */
-	invalidate(absPath: string): void {
-		this.#snapshots.delete(absPath);
-	}
-
-	/** Drop every snapshot history. */
-	clear(): void {
-		this.#snapshots.clear();
-	}
-
-	#record(
-		absPath: string,
-		entries: ReadonlyArray<readonly [number, string]>,
-		metadata: FileReadSnapshotMetadata,
-	): void {
-		const history = this.#snapshots.get(absPath) ?? [];
-		const head = history[0];
-		const now = Date.now();
-		if (head && !hasConflict(head.lines, entries) && !hasHashConflict(head, metadata)) {
-			for (const [lineNum, content] of entries) head.lines.set(lineNum, content);
-			if (metadata.fullText !== undefined) head.fullText = metadata.fullText;
-			if (metadata.fileHash !== undefined) head.fileHash = metadata.fileHash;
-			head.recordedAt = now;
-			// `get` above already touched LRU recency for this key.
-			return;
-		}
-
-		const nextSnapshot: FileReadSnapshot = {
-			lines: new Map(entries),
-			...metadata,
-			recordedAt: now,
-		};
-		const dedupedHistory = history.filter(snapshot => !isSameSnapshotIdentity(snapshot, nextSnapshot));
-		this.#snapshots.set(absPath, [nextSnapshot, ...dedupedHistory].slice(0, MAX_SNAPSHOTS_PER_PATH));
-	}
-}
-
-function hasConflict(existing: Map<number, string>, incoming: ReadonlyArray<readonly [number, string]>): boolean {
-	for (const [lineNum, content] of incoming) {
-		const prior = existing.get(lineNum);
-		if (prior !== undefined && prior !== content) return true;
-	}
-	return false;
-}
-
-function hasHashConflict(existing: FileReadSnapshot, metadata: FileReadSnapshotMetadata): boolean {
-	return metadata.fileHash !== undefined && existing.fileHash !== undefined && metadata.fileHash !== existing.fileHash;
-}
-
-function isSameSnapshotIdentity(left: FileReadSnapshot, right: FileReadSnapshot): boolean {
-	if (left.fileHash !== undefined && right.fileHash !== undefined) return left.fileHash === right.fileHash;
-	if (left.fullText !== undefined && right.fullText !== undefined) return left.fullText === right.fullText;
-	return false;
-}
-
-/**
- * Look up (or lazily create) the file-read cache attached to a session. The
- * cache is stored as `session.fileReadCache` so it lives exactly as long as
- * the session itself.
- */
-export function getFileReadCache(session: ToolSession): FileReadCache {
-	if (!session.fileReadCache) session.fileReadCache = new FileReadCache();
-	return session.fileReadCache;
-}

package/src/hashline/anchors.ts

@@ -1,104 +0,0 @@
-import { MISMATCH_CONTEXT } from "./constants";
-import { formatNumberedLine, HL_FILE_HASH_SEP, HL_FILE_PREFIX } from "./hash";
-
-const LINE_REF_RE = /^\s*[>+\-*]*\s*(\d+)(?::.*)?\s*$/;
-
-export function formatFullAnchorRequirement(raw?: string): string {
-	const received = raw === undefined ? "" : ` Received ${JSON.stringify(raw)}.`;
-	return (
-		`a bare line number from read/search output plus the section header file hash ` +
-		`(for example ${HL_FILE_PREFIX}src/foo.ts${HL_FILE_HASH_SEP}1a2b and line "160")${received}`
-	);
-}
-
-export function parseTag(ref: string): { line: number } {
-	const match = ref.match(LINE_REF_RE);
-	if (!match) {
-		throw new Error(`Invalid line reference. Expected ${formatFullAnchorRequirement(ref)}.`);
-	}
-	const line = Number.parseInt(match[1], 10);
-	if (line < 1) throw new Error(`Line number must be >= 1, got ${line} in "${ref}".`);
-	return { line };
-}
-
-export interface HashlineMismatchDetails {
-	path?: string;
-	expectedFileHash: string;
-	actualFileHash: string;
-	fileLines: string[];
-	anchorLines?: readonly number[];
-}
-
-function getMismatchDisplayLines(anchorLines: readonly number[], fileLines: string[]): number[] {
-	const displayLines = new Set<number>();
-	for (const line of anchorLines) {
-		if (line < 1 || line > fileLines.length) continue;
-		const lo = Math.max(1, line - MISMATCH_CONTEXT);
-		const hi = Math.min(fileLines.length, line + MISMATCH_CONTEXT);
-		for (let lineNum = lo; lineNum <= hi; lineNum++) displayLines.add(lineNum);
-	}
-	return [...displayLines].sort((a, b) => a - b);
-}
-
-export class HashlineMismatchError extends Error {
-	readonly path: string | undefined;
-	readonly expectedFileHash: string;
-	readonly actualFileHash: string;
-	readonly fileLines: string[];
-	readonly anchorLines: readonly number[];
-
-	constructor(details: HashlineMismatchDetails) {
-		super(HashlineMismatchError.formatMessage(details));
-		this.name = "HashlineMismatchError";
-		this.path = details.path;
-		this.expectedFileHash = details.expectedFileHash;
-		this.actualFileHash = details.actualFileHash;
-		this.fileLines = details.fileLines;
-		this.anchorLines = details.anchorLines ?? [];
-	}
-
-	get displayMessage(): string {
-		return HashlineMismatchError.formatDisplayMessage({
-			path: this.path,
-			expectedFileHash: this.expectedFileHash,
-			actualFileHash: this.actualFileHash,
-			fileLines: this.fileLines,
-			anchorLines: this.anchorLines,
-		});
-	}
-
-	static rejectionHeader(details: HashlineMismatchDetails): string[] {
-		const pathText = details.path ? ` for ${details.path}` : "";
-		return [
-			`Edit rejected${pathText}: file changed between read and edit.`,
-			`Section is bound to ${HL_FILE_HASH_SEP}${details.expectedFileHash}, but the current file hashes to ${HL_FILE_HASH_SEP}${details.actualFileHash}. If your previous edit in this session modified this file, copy the ${HL_FILE_PREFIX}path${HL_FILE_HASH_SEP}newhash from that edit's response. Otherwise re-read the file before retrying.`,
-		];
-	}
-
-	static formatDisplayMessage(details: HashlineMismatchDetails): string {
-		return HashlineMismatchError.formatMessage(details);
-	}
-
-	static formatMessage(details: HashlineMismatchDetails): string {
-		const anchorSet = new Set(details.anchorLines ?? []);
-		const lines = HashlineMismatchError.rejectionHeader(details);
-		const displayLines = getMismatchDisplayLines(details.anchorLines ?? [], details.fileLines);
-		if (displayLines.length === 0) return lines.join("\n");
-		lines.push("");
-		let previous = -1;
-		for (const lineNum of displayLines) {
-			if (previous !== -1 && lineNum > previous + 1) lines.push("...");
-			previous = lineNum;
-			const text = details.fileLines[lineNum - 1] ?? "";
-			const marker = anchorSet.has(lineNum) ? "*" : " ";
-			lines.push(`${marker}${formatNumberedLine(lineNum, text)}`);
-		}
-		return lines.join("\n");
-	}
-}
-
-export function validateLineRef(ref: { line: number }, fileLines: string[]): void {
-	if (ref.line < 1 || ref.line > fileLines.length) {
-		throw new Error(`Line ${ref.line} does not exist (file has ${fileLines.length} lines)`);
-	}
-}