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

package/CHANGELOG.md

@@ -2,6 +2,61 @@
 
 ## [Unreleased]
 
+## [15.5.6] - 2026-05-27
+### Added
+
+- Support for multi-range line selectors on URLs (e.g., `:5-10,20-30`) to fetch and display multiple non-contiguous sections
+- Support for combining `:raw` mode with line range selectors on URLs (e.g., `:raw:1-120` or `:1-120:raw`)
+- Support for line range selectors on directory listings (e.g., `:30-40` to view lines 30–40 of a directory tree)
+- Clear error message when requesting a line offset beyond the end of a directory listing
+
+### Changed
+
+- URL selector parsing now supports multiple trailing selector tokens (e.g., `:raw:N-M`), applying them left-to-right
+
+### Fixed
+
+- Fixed `:raw` selector being ignored for JSON and feed URLs, causing them to be pretty-printed or converted to markdown instead of returning raw content
+- Fixed directory listing line selectors silently dropping the offset parameter and only applying the limit
+
+## [15.5.5] - 2026-05-27
+
+### Changed
+
+- Removed the model-facing `path` property from hashline edit tool parameters; hashline edit targets now come from `¶PATH` headers in `input`.
+
+### Fixed
+
+- Fixed legacy pi-* extension loading regression where `import { Type } from "@(scope)/pi-ai"` (e.g. `@earendil-works/pi-ai` used by `@plannotator/pi-extension`) failed with `Export named 'Type' not found` after pi-ai 15.1.0 removed the root `Type` runtime export; the legacy-pi compat layer now redirects bare `@oh-my-pi/pi-ai` root imports through a sibling shim that re-exports the canonical pi-ai surface plus the Zod-backed `Type` runtime from the same TypeBox shim served to `@sinclair/typebox` imports ([#1437](https://github.com/can1357/oh-my-pi/issues/1437))
+
+## [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
 

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,35 @@
+/**
+ * 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;
+    /**
+     * 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;
+}
+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;
+}, cwd: string, options?: HashlineDiffOptions): Promise<{
+    diff: string;
+    firstChangedLine: number | undefined;
+} | {
+    error: string;
+}>;

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

@@ -0,0 +1,28 @@
+/**
+ * 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 { 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;
+    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,11 @@
+/**
+ * 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 declare const hashlineEditParamsSchema: z.ZodPreprocess<z.ZodObject<{
+    input: 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/extensibility/legacy-pi-ai-shim.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Compatibility shim for legacy extensions importing the package root of
+ * `@oh-my-pi/pi-ai` (or one of its aliased scopes like `@earendil-works/pi-ai`
+ * or `@mariozechner/pi-ai`).
+ *
+ * pi-ai 15.1.0 removed the historical TypeBox root exports (`Type`, plus the
+ * runtime-relevant half of the `Static`/`TSchema` pair) from the package
+ * entrypoint. Legacy extensions still author parameter schemas as
+ * `Type.Object({ ... })`, so this file is served by `legacy-pi-compat.ts` in
+ * place of the real pi-ai entrypoint whenever a legacy extension imports the
+ * bare package root. Subpath imports (`@oh-my-pi/pi-ai/utils/oauth`, etc.)
+ * continue to resolve directly against the bundled pi-ai package.
+ *
+ * The `Type` runtime is borrowed from the Zod-backed TypeBox shim that
+ * already serves bare `@sinclair/typebox` imports for the same extension
+ * class, keeping the legacy-compat surface internally consistent.
+ *
+ * Type-level `Static` and `TSchema` continue to come from pi-ai's own
+ * `types.ts` via the `export *` below — pi-ai still exports both as types,
+ * only the runtime `Type` builder was removed.
+ */
+export * from "@oh-my-pi/pi-ai";
+export { Type } from "./typebox";

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/fetch.d.ts

@@ -4,12 +4,15 @@ import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from "../sdk";
 import { type OutputMeta } from "./output-meta";
+import { type LineRange } from "./path-utils";
 export declare function isReadableUrlPath(value: string): boolean;
 export interface ParsedReadUrlTarget {
     path: string;
     raw: boolean;
     offset?: number;
     limit?: number;
+    /** Populated only when the selector carries 2+ ranges. Single-range stays on offset/limit. */
+    ranges?: readonly LineRange[];
 }
 export declare function parseReadUrlTarget(readPath: string): ParsedReadUrlTarget | null;
 interface FetchImagePayload {

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

@@ -23,6 +23,13 @@ export type FindToolInput = z.infer<typeof findSchema>;
  * must pass through.
  */
 export declare function validateFindPathInputs(paths: readonly string[]): void;
+/**
+ * Group find matches by their directory so the model doesn't pay repeated
+ * tokens for shared path prefixes. Preserves the input order: groups appear in
+ * the order their first member was emitted (mtime-desc for native glob), and
+ * within a group entries keep their relative order.
+ */
+export declare function formatFindGroupedOutput(paths: readonly string[]): string;
 export interface FindToolDetails {
     truncation?: TruncationResult;
     resultLimitReached?: number;

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.3",
+	"version": "15.5.6",
 	"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.3",
-		"@oh-my-pi/pi-agent-core": "15.5.3",
-		"@oh-my-pi/pi-ai": "15.5.3",
-		"@oh-my-pi/pi-natives": "15.5.3",
-		"@oh-my-pi/pi-tui": "15.5.3",
-		"@oh-my-pi/pi-utils": "15.5.3",
+		"@oh-my-pi/hashline": "15.5.6",
+		"@oh-my-pi/omp-stats": "15.5.6",
+		"@oh-my-pi/pi-agent-core": "15.5.6",
+		"@oh-my-pi/pi-ai": "15.5.6",
+		"@oh-my-pi/pi-natives": "15.5.6",
+		"@oh-my-pi/pi-tui": "15.5.6",
+		"@oh-my-pi/pi-utils": "15.5.6",
 		"@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/scripts/build-binary.ts

@@ -56,6 +56,17 @@ async function main(): Promise<void> {
 					"../stats/src/sync-worker.ts",
 					"./src/tools/browser/tab-worker-entry.ts",
 					"./src/eval/js/worker-entry.ts",
+					// Legacy pi-* extension compat shims served by `legacy-pi-compat.ts`.
+					// Both are reached only via the computed `TYPEBOX_SHIM_PATH` /
+					// `LEGACY_PI_AI_SHIM_PATH` constants (which `--compile`'s static
+					// analyzer cannot trace), so each shim must be listed here to land
+					// in bunfs alongside the workers above. The bunfs entry path is
+					// `--root`-relative with a `.js` extension, e.g.
+					// `/$bunfs/root/packages/coding-agent/src/extensibility/typebox.js`,
+					// which is what the `isCompiledBinary()` branch in
+					// `legacy-pi-compat.ts` resolves to at runtime.
+					"./src/extensibility/typebox.ts",
+					"./src/extensibility/legacy-pi-ai-shim.ts",
 					"--outfile",
 					"dist/omp",
 				],

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,