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

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 ## [Unreleased]
 
+## [15.5.4] - 2026-05-27
+
+### Breaking Changes
+
+- Removed the package root `hashline` export so imports from the top-level entrypoint can no longer access `hashline` helpers directly
+
+### Added
+
+- Added `read.summarize.minTotalLines` setting (default 100) to set the minimum file length that triggers read summarization
+- Added `<file>:<lines>` support to `search` `paths`, allowing file-scoped constraints such as `:N-M`, `:N+K`, and comma-separated ranges
+
+### Changed
+
+- Changed multi-section hashline `edit` execution to defer LSP diagnostics flushing until the final section is written
+- Changed read to return verbatim contents for files shorter than `read.summarize.minTotalLines` instead of summarizing them
+- Changed `search` path line-range filtering to include only matches and context lines that fall inside the requested ranges
+
+### Fixed
+
+- Fixed multi-section hashline edits to reject duplicate canonical targets and preflight write guards before any section is committed
+
+### Fixed
+
+- Fixed `createAgentSession()` dropping the hidden `resolve` tool from the registry when no active tool sets `deferrable: true`, even though plan mode dispatches the plan-approval `resolve { action: "apply", ... }` call through a standing handler. Read-only plan-mode toolsets (e.g. `read`, `search`, `find`, `web_search`) silently activated plan mode without `resolve`, leaving the agent unable to submit the finalized plan and forcing the user to exit plan mode manually. `resolve` is now kept whenever `plan.enabled` is true, so the standing handler always has a callable tool ([#1428](https://github.com/can1357/oh-my-pi/issues/1428))
+
+### Fixed
+
+- Fixed `omp` startup and `/changelog` reading the host project's `CHANGELOG.md` as omp's — `getPackageDir()` no longer falls back to the user's `cwd` when no owning `package.json` is locatable, preventing spurious `lastChangelogVersion` writes ([#1423](https://github.com/can1357/oh-my-pi/issues/1423))
+
+## [15.5.3] - 2026-05-27
+### Breaking Changes
+
+- Disallowed inline payload on hashline `↑`, `↓`, and `:` operations (including BOF/EOF inserts), requiring payload text to be supplied on standalone `+` continuation rows
+
+### Changed
+
+- Warned when legacy inline `LINE:TEXT` lines are accepted as payload continuations only when inside a pending multi-line `A-B:` replacement
+
 ## [15.5.2] - 2026-05-26
 ### Breaking Changes
 

package/dist/types/config/settings-schema.d.ts

@@ -2015,6 +2015,33 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Minimum multiline block comment length before read summaries collapse it";
         };
     };
+    readonly "read.summarize.minTotalLines": {
+        readonly type: "number";
+        readonly default: 100;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Read Summary Minimum File Length";
+            readonly description: "Files with fewer total lines are read verbatim instead of structurally summarized";
+        };
+    };
+    readonly "read.summarize.unfoldUntil": {
+        readonly type: "number";
+        readonly default: 50;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Read Summary Unfold Target";
+            readonly description: "BFS-unfold elidable spans until the summary is at least this many visible lines. 0 keeps only the outermost elisions.";
+        };
+    };
+    readonly "read.summarize.unfoldLimit": {
+        readonly type: "number";
+        readonly default: 100;
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Read Summary Unfold Ceiling";
+            readonly description: "Hard ceiling on summary size while BFS-unfolding. An unfold that would exceed this is reverted and unfolding stops.";
+        };
+    };
     readonly "read.toolResultPreview": {
         readonly type: "boolean";
         readonly default: false;

package/dist/types/config.d.ts

@@ -1,11 +1,37 @@
 export * from "./config/config-file";
 /**
- * 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 declare function walkUpForPackageDir(startDir: string): string | undefined;
+/**
+ * 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 declare function getPackageDir(): string | undefined;
+/**
+ * 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 declare function getPackageDir(): string;
-/** Get path to CHANGELOG.md (optional, may not exist in binary) */
-export declare function getChangelogPath(): string;
+export declare function getChangelogPath(): string | undefined;
 export interface ConfigDirEntry {
     path: string;
     source: string;

package/dist/types/edit/file-snapshot-store.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 declare function getFileSnapshotStore(session: ToolSession): InMemorySnapshotStore;

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

@@ -0,0 +1,30 @@
+/**
+ * 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 { type PatchSection } from "@oh-my-pi/hashline";
+export interface HashlineDiffOptions {
+    autoDropPureInsertDuplicates?: boolean;
+}
+export declare function computeHashlineSectionDiff(section: PatchSection, cwd: string, options?: HashlineDiffOptions): Promise<{
+    diff: string;
+    firstChangedLine: number | undefined;
+} | {
+    error: string;
+}>;
+export declare function computeHashlineDiff(input: {
+    input: string;
+    path?: string;
+}, cwd: string, options?: HashlineDiffOptions): Promise<{
+    diff: string;
+    firstChangedLine: number | undefined;
+} | {
+    error: string;
+}>;

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

@@ -0,0 +1,29 @@
+/**
+ * Coding-agent runner that drives the hashline {@link Patcher} on behalf of
+ * the `edit` tool. Converts a `{input, path?}` 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 { MismatchError as HashlineMismatchError } from "@oh-my-pi/hashline";
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
+import type { ToolSession } from "../../tools";
+import type { EditToolDetails, LspBatchRequest } from "../renderer";
+import { type HashlineParams, hashlineEditParamsSchema } from "./params";
+export interface ExecuteHashlineSingleOptions {
+    session: ToolSession;
+    input: string;
+    path?: string;
+    signal?: AbortSignal;
+    batchRequest?: LspBatchRequest;
+    writethrough: WritethroughCallback;
+    beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
+}
+export declare function executeHashlineSingle(options: ExecuteHashlineSingleOptions): Promise<AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema>>;
+export { HashlineMismatchError, type HashlineParams, hashlineEditParamsSchema };

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

@@ -0,0 +1,57 @@
+/**
+ * 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, type WriteResult } from "@oh-my-pi/hashline";
+import type { FileDiagnosticsResult, WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
+import type { ToolSession } from "../../tools";
+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 declare class HashlineFilesystem extends Filesystem {
+    #private;
+    readonly session: ToolSession;
+    constructor(options: HashlineFilesystemOptions);
+    /**
+     * 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;
+    /**
+     * 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;
+    resolveAbsolute(relativePath: string): string;
+    canonicalPath(relativePath: string): string;
+    readText(relativePath: string): Promise<string>;
+    preflightWrite(relativePath: string): Promise<void>;
+    writeText(relativePath: string, content: string): Promise<WriteResult>;
+    exists(relativePath: string): Promise<boolean>;
+}

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

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

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

@@ -0,0 +1,12 @@
+/**
+ * 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 and `path` is an
+ * optional fallback used when the input lacks a `¶PATH#HASH` header.
+ */
+import * as z from "zod/v4";
+export declare const hashlineEditParamsSchema: z.ZodObject<{
+    input: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type HashlineParams = z.infer<typeof hashlineEditParamsSchema>;

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

@@ -1,16 +1,17 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { type HashlineParams, hashlineEditParamsSchema } from "../hashline";
 import type { ToolSession } from "../tools";
 import { type EditMode } from "../utils/edit-mode";
+import { type HashlineParams, hashlineEditParamsSchema } from "./hashline";
 import { type ApplyPatchParams, applyPatchSchema } from "./modes/apply-patch";
 import { type PatchParams, patchEditSchema } from "./modes/patch";
 import { type ReplaceParams, replaceEditSchema } from "./modes/replace";
 import { type EditToolDetails } 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";
-export * from "../hashline";
+export * from "./file-snapshot-store";
+export * from "./hashline";
 export * from "./modes/apply-patch";
 export * from "./modes/patch";
 export * from "./modes/replace";

package/dist/types/edit/normalize.d.ts

@@ -1,23 +1,11 @@
 /**
  * Text normalization utilities for the edit tool.
  *
- * Handles line endings, BOM, whitespace, and Unicode normalization.
+ * Whitespace, Unicode, and indentation helpers. Line-ending and BOM
+ * primitives live in `@oh-my-pi/hashline` and are re-exported here so
+ * existing consumers see one stable surface.
  */
-export type LineEnding = "\r\n" | "\n";
-/** Detect the predominant line ending in content */
-export declare function detectLineEnding(content: string): LineEnding;
-/** Normalize all line endings to LF */
-export declare function normalizeToLF(text: string): string;
-/** Restore line endings to the specified type */
-export declare function restoreLineEndings(text: string, ending: LineEnding): string;
-export interface BomResult {
-    /** The BOM character if present, empty string otherwise */
-    bom: string;
-    /** The text without the BOM */
-    text: string;
-}
-/** Strip UTF-8 BOM if present */
-export declare function stripBom(content: string): BomResult;
+export { type BomResult, detectLineEnding, type LineEnding, normalizeToLF, restoreLineEndings, stripBom, } from "@oh-my-pi/hashline";
 /** Count leading whitespace characters in a line */
 export declare function countLeadingWhitespace(line: string): number;
 /** Get the leading whitespace string from a line */

package/dist/types/index.d.ts

@@ -14,7 +14,6 @@ export type * from "./extensibility/extensions";
 export * from "./extensibility/extensions";
 export * from "./extensibility/skills";
 export { type FileSlashCommand, loadSlashCommands as discoverSlashCommands } from "./extensibility/slash-commands";
-export * from "./hashline";
 export type * from "./lsp";
 export * from "./main";
 export * from "./modes";

package/dist/types/tools/bash.d.ts

@@ -42,6 +42,7 @@ export interface BashToolDetails {
     meta?: OutputMeta;
     timeoutSeconds?: number;
     requestedTimeoutSeconds?: number;
+    wallTimeMs?: number;
     terminalId?: string;
     async?: {
         state: "running" | "completed" | "failed";

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

@@ -1,3 +1,4 @@
+import type { InMemorySnapshotStore } from "@oh-my-pi/hashline";
 import type { AgentTelemetryConfig, AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { ToolChoice } from "@oh-my-pi/pi-ai";
 import type { PromptTemplate } from "../config/prompt-templates";
@@ -188,11 +189,11 @@ export interface ToolSession {
     getCheckpointState?: () => CheckpointState | undefined;
     /** Set or clear active checkpoint state. */
     setCheckpointState?: (state: CheckpointState | null) => void;
-    /** Per-session cache of file contents as last shown to the model by
-     *  `read`/`search`. Used by hashline anchor-stale recovery to reconstruct
-     *  the version the model authored anchors against when the file changed
-     *  out-of-band. Lazily initialized by `getFileReadCache`. */
-    fileReadCache?: import("../edit/file-read-cache").FileReadCache;
+    /** Per-session snapshot store of file contents as last shown to the model
+     *  by `read`/`search`. Used by hashline anchor-stale recovery to
+     *  reconstruct the version the model authored anchors against when the
+     *  file changed out-of-band. Lazily initialized by `getFileSnapshotStore`. */
+    fileSnapshotStore?: InMemorySnapshotStore;
     /** Per-session log of unresolved git merge conflict regions surfaced by
      *  `read`. Each entry gets a stable id N referenced by `write conflict://N`
      *  to splice the recorded region with replacement content. Lazily initialized

package/dist/types/tools/path-utils.d.ts

@@ -1,5 +1,23 @@
 export declare function expandTilde(filePath: string, home?: string): string;
 export declare function expandPath(filePath: string): string;
+/**
+ * Inclusive line range describing one selector segment (e.g. `50-100`,
+ * `301-`, or `50+10`). `endLine` is `undefined` for open-ended ranges.
+ */
+export interface LineRange {
+    startLine: number;
+    endLine: number | undefined;
+}
+/** Parse a single `N`, `N-M`, `N-`, or `N+K` chunk. Throws via {@link ToolError} on invalid bounds. */
+export declare function parseLineRangeChunk(sel: string): LineRange | null;
+/**
+ * Parse a comma-separated list of line ranges (e.g. `5-16,960-973`). Returns
+ * the ranges in ascending order with overlapping/adjacent ranges merged so
+ * downstream consumers can stream the file in a single forward pass per range.
+ */
+export declare function parseLineRanges(sel: string): [LineRange, ...LineRange[]] | null;
+/** Return `true` when `lineNumber` (1-indexed) falls in any of the supplied ranges. */
+export declare function isLineInRanges(lineNumber: number, ranges: readonly LineRange[]): boolean;
 export declare function splitPathAndSel(rawPath: string): {
     path: string;
     sel?: string;

package/dist/types/utils/changelog.d.ts

@@ -5,10 +5,15 @@ export interface ChangelogEntry {
     content: string;
 }
 /**
- * Parse changelog entries from CHANGELOG.md
- * Scans for ## lines and collects content until next ## or EOF
+ * Parse changelog entries from the file at `changelogPath`. Scans for `## [x.y.z]`
+ * headings and collects each block until the next heading or EOF.
+ *
+ * Returns `[]` when `changelogPath` is `undefined` (package directory not
+ * resolvable — see `getChangelogPath`) or the file is missing. Callers MUST NOT
+ * synthesize a fallback path from the host project's cwd; doing so caused issue
+ * #1423 (the host project's `CHANGELOG.md` was rendered as omp's).
  */
-export declare function parseChangelog(changelogPath: string): Promise<ChangelogEntry[]>;
+export declare function parseChangelog(changelogPath: string | undefined): Promise<ChangelogEntry[]>;
 /**
  * Compare versions. Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
  */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.5.2",
+	"version": "15.5.4",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,12 +47,13 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "15.5.2",
-		"@oh-my-pi/pi-agent-core": "15.5.2",
-		"@oh-my-pi/pi-ai": "15.5.2",
-		"@oh-my-pi/pi-natives": "15.5.2",
-		"@oh-my-pi/pi-tui": "15.5.2",
-		"@oh-my-pi/pi-utils": "15.5.2",
+		"@oh-my-pi/hashline": "15.5.4",
+		"@oh-my-pi/omp-stats": "15.5.4",
+		"@oh-my-pi/pi-agent-core": "15.5.4",
+		"@oh-my-pi/pi-ai": "15.5.4",
+		"@oh-my-pi/pi-natives": "15.5.4",
+		"@oh-my-pi/pi-tui": "15.5.4",
+		"@oh-my-pi/pi-utils": "15.5.4",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",
@@ -227,14 +228,6 @@
 			"types": "./dist/types/edit/modes/*.d.ts",
 			"import": "./src/edit/modes/*.ts"
 		},
-		"./hashline": {
-			"types": "./dist/types/hashline/index.d.ts",
-			"import": "./src/hashline/index.ts"
-		},
-		"./hashline/*": {
-			"types": "./dist/types/hashline/*.d.ts",
-			"import": "./src/hashline/*.ts"
-		},
 		"./exa": {
 			"types": "./dist/types/exa/index.d.ts",
 			"import": "./src/exa/index.ts"

package/src/config/settings-schema.ts

@@ -1666,6 +1666,38 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"read.summarize.minTotalLines": {
+		type: "number",
+		default: 100,
+		ui: {
+			tab: "editing",
+			label: "Read Summary Minimum File Length",
+			description: "Files with fewer total lines are read verbatim instead of structurally summarized",
+		},
+	},
+
+	"read.summarize.unfoldUntil": {
+		type: "number",
+		default: 50,
+		ui: {
+			tab: "editing",
+			label: "Read Summary Unfold Target",
+			description:
+				"BFS-unfold elidable spans until the summary is at least this many visible lines. 0 keeps only the outermost elisions.",
+		},
+	},
+
+	"read.summarize.unfoldLimit": {
+		type: "number",
+		default: 100,
+		ui: {
+			tab: "editing",
+			label: "Read Summary Unfold Ceiling",
+			description:
+				"Hard ceiling on summary size while BFS-unfolding. An unfold that would exceed this is reverted and unfolding stops.",
+		},
+	},
+
 	"read.toolResultPreview": {
 		type: "boolean",
 		default: false,

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/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;
+}