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

package/CHANGELOG.md

@@ -2,10 +2,36 @@
 
 ## [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

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

@@ -12,6 +12,12 @@
 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;
@@ -21,7 +27,6 @@ export declare function computeHashlineSectionDiff(section: PatchSection, cwd: s
 }>;
 export declare function computeHashlineDiff(input: {
     input: string;
-    path?: string;
 }, cwd: string, options?: HashlineDiffOptions): Promise<{
     diff: string;
     firstChangedLine: number | undefined;

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

@@ -1,6 +1,6 @@
 /**
  * Coding-agent runner that drives the hashline {@link Patcher} on behalf of
- * the `edit` tool. Converts a `{input, path?}` tool-call payload into a
+ * 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.
@@ -19,7 +19,6 @@ import { type HashlineParams, hashlineEditParamsSchema } from "./params";
 export interface ExecuteHashlineSingleOptions {
     session: ToolSession;
     input: string;
-    path?: string;
     signal?: AbortSignal;
     batchRequest?: LspBatchRequest;
     writethrough: WritethroughCallback;

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

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

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/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/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.5.4",
+	"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,13 +47,13 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@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",
+		"@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",

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/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/hashline/diff.ts

@@ -10,7 +10,6 @@
  * and no auto-generated-file refusal — those belong on the write path.
  */
 import {
-	applyEdits,
 	computeFileHash,
 	Patch as HashlinePatch,
 	normalizeToLF,
@@ -24,6 +23,12 @@ 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> {
@@ -62,7 +67,9 @@ export async function computeHashlineSectionDiff(
 		const normalized = normalizeToLF(content);
 		const hashError = validateSectionHash(section, normalized);
 		if (hashError) return { error: hashError };
-		const result = applyEdits(normalized, [...section.edits], options);
+		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) {
@@ -71,13 +78,13 @@ export async function computeHashlineSectionDiff(
 }
 
 export async function computeHashlineDiff(
-	input: { input: string; path?: string },
+	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, path: input.path });
+		patch = HashlinePatch.parse(input.input, { cwd });
 	} catch (err) {
 		return { error: err instanceof Error ? err.message : String(err) };
 	}

package/src/edit/hashline/execute.ts

@@ -1,6 +1,6 @@
 /**
  * Coding-agent runner that drives the hashline {@link Patcher} on behalf of
- * the `edit` tool. Converts a `{input, path?}` tool-call payload into a
+ * 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.
@@ -31,7 +31,6 @@ import { type HashlineParams, hashlineEditParamsSchema } from "./params";
 export interface ExecuteHashlineSingleOptions {
 	session: ToolSession;
 	input: string;
-	path?: string;
 	signal?: AbortSignal;
 	batchRequest?: LspBatchRequest;
 	writethrough: WritethroughCallback;
@@ -91,16 +90,10 @@ function renderSection(result: PatchSectionResult, diagnostics: FileDiagnosticsR
 
 	const warningsBlock = result.warnings.length > 0 ? `\n\nWarnings:\n${result.warnings.join("\n")}` : "";
 	const previewBlock = preview.preview ? `\n${preview.preview}` : "";
-	const headline = preview.preview
-		? `${result.path}:`
-		: result.op === "create"
-			? `Created ${result.path}`
-			: `Updated ${result.path}`;
-
 	const firstChangedLine = result.firstChangedLine ?? diff.firstChangedLine;
 	return {
 		toolResult: {
-			content: [{ type: "text", text: `${headline}\n${result.header}${previewBlock}${warningsBlock}` }],
+			content: [{ type: "text", text: `${result.header}${previewBlock}${warningsBlock}` }],
 			details: {
 				diff: diff.diff,
 				firstChangedLine,
@@ -122,7 +115,7 @@ function renderSection(result: PatchSectionResult, diagnostics: FileDiagnosticsR
 export async function executeHashlineSingle(
 	options: ExecuteHashlineSingleOptions,
 ): Promise<AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema>> {
-	const patch = Patch.parse(options.input, { cwd: options.session.cwd, path: options.path });
+	const patch = Patch.parse(options.input, { cwd: options.session.cwd });
 	if (patch.sections.length === 0) {
 		throw new Error("No hashline sections found in input.");
 	}

package/src/edit/hashline/params.ts

@@ -1,11 +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 and `path` is an
- * optional fallback used when the input lacks a `¶PATH#HASH` header.
+ * 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.object({ input: z.string(), path: z.string().optional() }).passthrough();
+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

@@ -262,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> {
@@ -430,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,

package/src/edit/renderer.ts

@@ -235,14 +235,21 @@ function renderPlainTextPreview(text: string, uiTheme: Theme, filePath?: string)
 
 function formatStreamingDiff(diff: string, rawPath: string, uiTheme: Theme, label = "streaming"): string {
 	if (!diff) return "";
-	const lines = diff.split("\n");
-	const total = lines.length;
-	const displayLines = lines.slice(-EDIT_STREAMING_PREVIEW_LINES);
-	const hidden = total - displayLines.length;
+	// Hunk-aware truncation keeps the change rows themselves visible and
+	// trims surrounding context proportionally so a multi-hunk diff doesn't
+	// turn into just the tail of the last hunk while streaming.
+	const {
+		text: truncatedDiff,
+		hiddenHunks,
+		hiddenLines,
+	} = truncateDiffByHunk(diff, PREVIEW_LIMITS.DIFF_COLLAPSED_HUNKS, EDIT_STREAMING_PREVIEW_LINES);
 	let text = "\n\n";
-	text += renderDiffColored(displayLines.join("\n"), { filePath: rawPath });
-	if (hidden > 0) {
-		text += uiTheme.fg("dim", `\n… (${label} +${hidden} lines)`);
+	text += renderDiffColored(truncatedDiff, { filePath: rawPath });
+	if (hiddenHunks > 0 || hiddenLines > 0) {
+		const remainder: string[] = [];
+		if (hiddenHunks > 0) remainder.push(`${hiddenHunks} more hunks`);
+		if (hiddenLines > 0) remainder.push(`${hiddenLines} more lines`);
+		text += uiTheme.fg("dim", `\n… (${label} +${remainder.join(", ")})`);
 	} else {
 		text += uiTheme.fg("dim", `\n(${label})`);
 	}

package/src/edit/streaming.ts

@@ -20,11 +20,8 @@ import {
 	END_PATCH_MARKER,
 	type PatchSection as HashlineInputSection,
 	Patch as HashlinePatch,
-	Tokenizer as HashlineTokenizer,
 } from "@oh-my-pi/hashline";
-import { sanitizeText } from "@oh-my-pi/pi-utils";
 import type { Theme } from "../modes/theme/theme";
-import { replaceTabs, truncateToWidth } from "../tools/render-utils";
 import { type EditMode, resolveEditMode } from "../utils/edit-mode";
 import { computeEditDiff, type DiffError, type DiffResult } from "./diff";
 import { computeHashlineDiff, computeHashlineSectionDiff } from "./hashline/diff";
@@ -73,48 +70,6 @@ export interface EditStreamingStrategy<Args = unknown> {
 	renderStreamingFallback(args: Args, uiTheme: Theme): string;
 }
 
-const STREAMING_FALLBACK_LINES = 12;
-const STREAMING_FALLBACK_WIDTH = 80;
-
-// Streaming-preview classification reuses one tokenizer instance for the
-// stateless predicates and `tokenize`/`tokenizeAll` helpers; instances are
-// cheap, but keeping a single module-level reference matches the rest of
-// the hashline package.
-const HASHLINE_TOKENIZER = new HashlineTokenizer();
-
-function trimHashlineStreamingSyntax(lines: string[]): string[] {
-	let index = lines.findIndex(line => line.trim().length > 0);
-	if (index === -1) return [];
-
-	if (HASHLINE_TOKENIZER.tokenize(lines[index]).kind === "envelope-begin") {
-		index++;
-		while (index < lines.length && lines[index].trim().length === 0) index++;
-	}
-	if (index < lines.length && HASHLINE_TOKENIZER.tokenize(lines[index]).kind === "header") {
-		index++;
-	}
-
-	return lines.slice(index).filter(line => !HASHLINE_TOKENIZER.isEnvelopeMarker(line));
-}
-
-function renderHashlineInputFallback(input: string, uiTheme: Theme): string {
-	const lines = trimHashlineStreamingSyntax(sanitizeText(input).split("\n"));
-	if (!lines.some(line => line.trim().length > 0)) return "";
-
-	const displayLines = lines.slice(-STREAMING_FALLBACK_LINES);
-	const hidden = lines.length - displayLines.length;
-	let text = "\n\n";
-	text += displayLines
-		.map(line => uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line), STREAMING_FALLBACK_WIDTH)))
-		.join("\n");
-	if (hidden > 0) {
-		text += uiTheme.fg("dim", `\n… (streaming +${hidden} lines)`);
-	} else {
-		text += uiTheme.fg("dim", "\n(streaming)");
-	}
-	return text;
-}
-
 // -----------------------------------------------------------------------------
 // Partial-JSON handling
 // -----------------------------------------------------------------------------
@@ -273,7 +228,6 @@ const patchStrategy: EditStreamingStrategy<PatchArgs> = {
 
 interface HashlineArgs {
 	input?: string;
-	path?: string;
 	__partialJson?: string;
 }
 
@@ -353,75 +307,6 @@ function buildApplyPatchNaturalOrderPreviews(input: string): PerFileDiffPreview[
 	return previews.length > 0 ? previews : null;
 }
 
-/**
- * Hashline equivalent: emit each payload line as a `+added` line in the
- * order the model typed it. We deliberately omit op headers and removal
- * targets from the streaming preview because their content lives in the file
- * and would require a costly re-apply per tick; the complete unified diff is
- * shown once streaming finishes.
- */
-function buildHashlineNaturalOrderPreviews(
-	input: string,
-	defaultPath: string | undefined,
-): PerFileDiffPreview[] | null {
-	const groups = new Map<string, string[]>();
-	let currentPath = defaultPath ?? "";
-	const ensure = (sectionPath: string): string[] => {
-		let bucket = groups.get(sectionPath);
-		if (!bucket) {
-			bucket = [];
-			groups.set(sectionPath, bucket);
-		}
-		return bucket;
-	};
-
-	// Per-call instance: the streaming preview re-runs each tick with the
-	// cumulative input, and we need the line counter to start at 1. A
-	// dedicated tokenizer keeps the shared HASHLINE_TOKENIZER above free
-	// for stateless predicate use elsewhere in this module.
-	const streamer = new HashlineTokenizer();
-	for (const token of streamer.tokenizeAll(input)) {
-		switch (token.kind) {
-			case "envelope-begin":
-			case "envelope-end":
-			case "abort":
-			case "op-delete":
-				continue;
-			case "blank":
-			case "raw":
-				continue;
-			case "header":
-				currentPath = token.path;
-				if (currentPath) ensure(currentPath);
-				continue;
-			case "op-insert":
-			case "op-replace":
-				// Inline body on the op line itself (`N↓payload`, `A-B:payload`) is
-				// payload content that just happens to share a line with the op
-				// header — render it the same as a standalone payload token so
-				// the very first character the model types after the sigil shows
-				// up in the streaming preview. Without this, the preview is
-				// empty until a newline arrives, and the renderer falls back to
-				// raw input ("A-B: bla bla bla") instead of "+ bla bla bla".
-				if (!currentPath || token.inlineBody === undefined) continue;
-				ensure(currentPath).push(`+${token.inlineBody}`);
-				continue;
-			case "payload":
-				if (!currentPath) continue;
-				ensure(currentPath).push(`+${token.text}`);
-				continue;
-		}
-	}
-
-	if (groups.size === 0) return null;
-	const previews: PerFileDiffPreview[] = [];
-	for (const [sectionPath, body] of groups) {
-		if (body.length === 0) continue;
-		previews.push({ path: sectionPath, diff: body.join("\n") });
-	}
-	return previews.length > 0 ? previews : null;
-}
-
 const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 	extractCompleteEdits(args) {
 		return args;
@@ -430,25 +315,21 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		if (typeof args.input !== "string" || args.input.length === 0) return null;
 		const input = trimTrailingPartialLine(args.input, ctx.isStreaming);
 		if (input.length === 0) return null;
-		if (ctx.isStreaming) {
-			// Skip the costly per-tick re-apply and avoid `Diff.structuredPatch`
-			// reordering by showing payload lines in input order.
-			return buildHashlineNaturalOrderPreviews(input, args.path);
-		}
 		ctx.signal.throwIfAborted();
 
 		let sections: readonly HashlineInputSection[];
 		try {
-			sections = HashlinePatch.parse(input, { cwd: ctx.cwd, path: args.path }).sections;
+			sections = HashlinePatch.parse(input, { cwd: ctx.cwd }).sections;
 		} catch {
-			// Single-section fallback keeps the original error rendering for the
-			// "haven't typed `¶ PATH` yet" case.
-			const result = await computeHashlineDiff({ input, path: args.path }, ctx.cwd, {
+			// While streaming, the trailing op may still be mid-typed and fail
+			// to parse; suppress until the next chunk arrives. Once args are
+			// complete, surface the error so the model sees what went wrong.
+			if (ctx.isStreaming) return null;
+			const result = await computeHashlineDiff({ input }, ctx.cwd, {
 				autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
 			});
 			ctx.signal.throwIfAborted();
-			if ("error" in result && !args.path) return [{ path: "", error: result.error }];
-			return [toPerFilePreview(args.path ?? "", result)];
+			return [toPerFilePreview("", result)];
 		}
 		if (sections.length === 0) return null;
 
@@ -467,6 +348,7 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 			const section = sectionsToProcess[i];
 			const result = await computeHashlineSectionDiff(section, ctx.cwd, {
 				autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
+				streaming: ctx.isStreaming,
 			});
 			ctx.signal.throwIfAborted();
 			// In a multi-section preview, ignore parse/apply errors from the
@@ -479,8 +361,13 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		}
 		return previews.length > 0 ? previews : null;
 	},
-	renderStreamingFallback(args, uiTheme) {
-		return typeof args.input === "string" ? renderHashlineInputFallback(args.input, uiTheme) : "";
+	renderStreamingFallback() {
+		// Never leak raw hashline syntax (`64:`, `|payload`, `¶path#hash`)
+		// to the user — the streaming preview already projects every
+		// parseable op onto the real file via applyPartialTo, and an
+		// unparseable trailing chunk renders as "no preview yet" rather
+		// than a sigil dump.
+		return "";
 	},
 };
 

package/src/extensibility/legacy-pi-ai-shim.ts

@@ -0,0 +1,24 @@
+/**
+ * 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/src/extensibility/plugins/legacy-pi-compat.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import * as url from "node:url";
+import { isCompiledBinary } from "@oh-my-pi/pi-utils";
 
 // Canonical scope for in-process pi packages. Plugins published against any of
 // the aliased scopes below (mariozechner's original publish, earendil-works'
@@ -56,7 +57,34 @@ const resolvedSpecifierFallbacks = new Map<string, string>();
 // relying on them must vendor `@sinclair/typebox` directly.
 const TYPEBOX_SPECIFIER = "@sinclair/typebox";
 const TYPEBOX_SPECIFIER_FILTER = /^@sinclair\/typebox$/;
-const TYPEBOX_SHIM_PATH = path.resolve(import.meta.dir, "../typebox.ts");
+
+// In-process compat shim paths. In dev `import.meta.dir` is the source folder of
+// this file, so the dev branches resolve to the real `.ts` source. In compiled
+// binaries `import.meta.dir` collapses to `/$bunfs/root`, so the runtime cannot
+// recover the source layout that way; instead, each shim file is registered as
+// a `--compile` entrypoint in `scripts/build-binary.ts`, which Bun emits into
+// bunfs at a deterministic `--root`-relative path with a `.js` extension. The
+// literals below must stay in sync with that listing — if either path drifts,
+// every legacy plugin loading the shim fails with a missing-module error in
+// release builds (without affecting `bun test`/dev).
+const TYPEBOX_SHIM_PATH = isCompiledBinary()
+	? "/$bunfs/root/packages/coding-agent/src/extensibility/typebox.js"
+	: path.resolve(import.meta.dir, "../typebox.ts");
+
+// Legacy extensions historically imported `Type` (and `Static`/`TSchema`) from
+// the package root of `@(scope)/pi-ai`. pi-ai 15.1.0 removed the runtime `Type`
+// export (see `packages/ai/CHANGELOG.md`), so the bare canonical specifier no
+// longer satisfies those imports. The override below redirects only the bare
+// pi-ai package root onto a sibling shim that re-exports the canonical surface
+// plus the borrowed `Type` runtime from the Zod-backed TypeBox shim. Subpath
+// imports such as `@oh-my-pi/pi-ai/utils/oauth` continue to resolve directly
+// against the bundled pi-ai package.
+const LEGACY_PI_AI_SHIM_PATH = isCompiledBinary()
+	? "/$bunfs/root/packages/coding-agent/src/extensibility/legacy-pi-ai-shim.js"
+	: path.resolve(import.meta.dir, "../legacy-pi-ai-shim.ts");
+const LEGACY_PI_PACKAGE_ROOT_OVERRIDES: Record<string, string> = {
+	[`${CANONICAL_PI_SCOPE}/pi-ai`]: LEGACY_PI_AI_SHIM_PATH,
+};
 
 let isLegacyPiSpecifierShimInstalled = false;
 
@@ -85,6 +113,22 @@ function getResolvedSpecifier(specifier: string): string {
 	return resolved;
 }
 
+/**
+ * Resolve a canonical `@oh-my-pi/*` specifier to a filesystem path, preferring
+ * a bundled compat shim when one is registered for the package root.
+ *
+ * Falls back to `getResolvedSpecifier` (which may throw under compiled binary
+ * mode); callers handle that the same way they would for non-overridden
+ * specifiers.
+ */
+function resolveCanonicalPiSpecifier(remappedSpecifier: string): string {
+	const override = LEGACY_PI_PACKAGE_ROOT_OVERRIDES[remappedSpecifier];
+	if (override) {
+		return override;
+	}
+	return getResolvedSpecifier(remappedSpecifier);
+}
+
 function toImportSpecifier(resolvedPath: string): string {
 	return url.pathToFileURL(resolvedPath).href;
 }
@@ -99,7 +143,7 @@ function rewriteLegacyPiImports(source: string): string {
 			}
 
 			try {
-				return `${prefix}${toImportSpecifier(getResolvedSpecifier(remappedSpecifier))}${suffix}`;
+				return `${prefix}${toImportSpecifier(resolveCanonicalPiSpecifier(remappedSpecifier))}${suffix}`;
 			} catch {
 				// Resolution failed — typically in compiled binary mode where
 				// Bun.resolveSync cannot walk up from /$bunfs/root to find the
@@ -250,7 +294,7 @@ function resolveLegacyPiSpecifier(args: { path: string; importer: string }): { p
 	// Primary: resolve the canonical @oh-my-pi/* specifier from the host binary
 	// location. Works in dev mode and in source-link installs.
 	try {
-		return { path: getResolvedSpecifier(remappedSpecifier) };
+		return { path: resolveCanonicalPiSpecifier(remappedSpecifier) };
 	} catch {
 		// Fallback for compiled binary mode: the bundled packages live inside
 		// /$bunfs/root and aren't reachable by filesystem resolution. Try the

package/src/main.ts

@@ -9,6 +9,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { createInterface } from "node:readline/promises";
+import { keepaliveWhile } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import {
 	$env,
@@ -315,7 +316,7 @@ async function runInteractiveMode(
 	}
 
 	while (true) {
-		const input = await mode.getUserInput();
+		const input = await keepaliveWhile(mode.getUserInput());
 		await submitInteractiveInput(mode, session, input);
 	}
 }

package/src/modes/rpc/rpc-client.ts

@@ -3,6 +3,8 @@
  *
  * Spawns the agent in RPC mode and provides a typed API for all operations.
  */
+
+import { isPromise } from "node:util/types";
 import type { AgentEvent, AgentMessage, AgentToolResult, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
@@ -790,7 +792,7 @@ export class RpcClient {
 		const stdin = this.#process.stdin as import("bun").FileSink;
 		stdin.write(`${JSON.stringify(frame)}\n`);
 		const flushResult = stdin.flush();
-		if (flushResult instanceof Promise) {
+		if (isPromise(flushResult)) {
 			flushResult.catch((err: Error) => {
 				onError?.(err);
 			});

package/src/prompts/tools/find.md

@@ -5,17 +5,18 @@ Finds files and directories using fast pattern matching that works with any code
 - Pass multiple targets as **separate array elements** (`paths: ["a", "b"]`), NEVER as a single comma-joined string (`paths: ["a,b"]` is rejected)
 - `gitignore` defaults to `true` and hides files matched by `.gitignore`. Set `gitignore: false` to find `.env*`, `*.log`, freshly-created build outputs, or anything else your repo ignores
 - `hidden` defaults to `true`; combine with `gitignore: false` to surface dotfiles that are also gitignored
+- `limit` is clamped to 1-200 (default 200). Narrow the pattern instead of raising the limit
 - `timeout` is in seconds (default 5, clamped to 0.5–60). On timeout, find returns whatever partial matches it has collected with `truncated: true` and a notice — increase `timeout` or narrow the pattern instead of retrying blindly
 - You SHOULD perform multiple searches in parallel when potentially useful
 </instruction>
 
 <output>
-Matching file and directory paths sorted by modification time (most recent first). Directories are suffixed with `/`. Truncated at 1000 entries or 50KB (configurable via `limit`).
+Matching file and directory paths sorted by modification time (most recent first), grouped by directory to reduce token usage. Each group starts with `# <dir>/` followed by basenames (one per line); directory entries get a trailing `/`. Root-level entries have no header. Truncated at 200 entries or 50KB.
 </output>
 
 <examples>
 # Find files
-`{"paths": ["src/**/*.ts"], "limit": 1000}`
+`{"paths": ["src/**/*.ts"]}`
 # Multiple targets — separate array elements
 `{"paths": ["src/**/*.ts", "test/**/*.ts"]}`
 # Find gitignored files like .env

package/src/session/agent-session.ts

@@ -17,6 +17,7 @@ import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { scheduler } from "node:timers/promises";
+import { isPromise } from "node:util/types";
 import {
 	type AfterToolCallContext,
 	type AfterToolCallResult,
@@ -1307,10 +1308,25 @@ export class AgentSession {
 
 	/** Emit an event to all listeners */
 	#emit(event: AgentSessionEvent): void {
-		// Copy array before iteration to avoid mutation during iteration
+		// Copy array before iteration to avoid mutation during iteration.
 		const listeners = [...this.#eventListeners];
 		for (const l of listeners) {
-			l(event);
+			try {
+				const result = l(event) as unknown;
+				// Listener may be an async function whose returned Promise we don't await;
+				// attach a catch so a rejection does not become an unhandled rejection.
+				if (isPromise(result)) {
+					result.catch(err => {
+						logger.warn("AgentSession listener rejected", {
+							error: err instanceof Error ? err.message : String(err),
+						});
+					});
+				}
+			} catch (err) {
+				logger.warn("AgentSession listener threw", {
+					error: err instanceof Error ? err.message : String(err),
+				});
+			}
 		}
 	}
 

package/src/tools/fetch.ts

@@ -6,6 +6,7 @@ import { htmlToMarkdown } from "@oh-my-pi/pi-natives";
 import { type Component, Text } from "@oh-my-pi/pi-tui";
 import { $which, ptree, truncate } from "@oh-my-pi/pi-utils";
 import { parseHTML } from "linkedom";
+import { LRUCache } from "lru-cache/raw";
 import type { Settings } from "../config/settings";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme, theme } from "../modes/theme/theme";
@@ -23,6 +24,7 @@ import { finalizeOutput, loadPage, looksLikeHtml, MAX_OUTPUT_CHARS } from "../we
 import { convertWithMarkit, fetchBinary } from "../web/scrapers/utils";
 import { applyListLimit } from "./list-limit";
 import { formatStyledArtifactReference, type OutputMeta } from "./output-meta";
+import { type LineRange, parseLineRanges } from "./path-utils";
 import { formatExpandHint, getDomain, replaceTabs } from "./render-utils";
 import { ToolAbortError, ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
@@ -138,16 +140,31 @@ export function isReadableUrlPath(value: string): boolean {
 	return /^https?:\/\//i.test(value) || /^www\./i.test(value);
 }
 
-// URL line selectors mirror the file form: `:50`, `:50-100`, `:50+150`, `:raw`.
-// If a URL would otherwise look like `host:port`, add a trailing slash before the selector
-// (e.g. `https://example.com/:80` to read line 80 of the document at `https://example.com/`).
-const URL_LINE_RANGE_RE = /^(\d+)(?:([-+])(\d+))?$/;
+// URL line selectors mirror the file form: `:50`, `:50-100`, `:50+150`, `:5-10,20-30`, `:raw`,
+// or `:raw:N-M` / `:N-M:raw` to combine raw mode with a range. If a URL would otherwise look
+// like `host:port`, add a trailing slash before the selector (e.g. `https://example.com/:80`
+// to read line 80 of the document at `https://example.com/`).
 
 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[];
+}
+
+/** Recognize a single selector token (`raw` or one/many line ranges). */
+function isUrlSelectorToken(token: string): boolean {
+	if (token === "raw") return true;
+	try {
+		return parseLineRanges(token) !== null;
+	} catch {
+		// `parseLineRanges` throws `ToolError` for malformed ranges (e.g. `5+0`). Only treat the
+		// token as a selector when it parses cleanly so URL ports like `:80` keep flowing
+		// through to the URL path.
+		return false;
+	}
 }
 
 export function parseReadUrlTarget(readPath: string): ParsedReadUrlTarget | null {
@@ -157,62 +174,71 @@ export function parseReadUrlTarget(readPath: string): ParsedReadUrlTarget | null
 		return null;
 	}
 
-	const selector = embedded?.sel;
-	const raw = selector === "raw";
-	const lineMatch = selector && selector !== "raw" ? URL_LINE_RANGE_RE.exec(selector) : null;
-	if (lineMatch) {
-		const startLine = Number.parseInt(lineMatch[1]!, 10);
-		if (startLine < 1) {
-			throw new ToolError("URL line selector 0 is invalid; lines are 1-indexed. Use :1.");
+	let raw = false;
+	let ranges: readonly LineRange[] | undefined;
+	for (const sel of embedded?.sels ?? []) {
+		if (sel === "raw") {
+			raw = true;
+			continue;
 		}
-		const sep = lineMatch[2];
-		const rhs = lineMatch[3] ? Number.parseInt(lineMatch[3], 10) : undefined;
-		let endLine: number | undefined;
-		if (sep === "+") {
-			if (rhs === undefined || rhs < 1) {
-				throw new ToolError(`Invalid range ${startLine}+${rhs ?? 0}: count must be >= 1.`);
-			}
-			endLine = startLine + rhs - 1;
-		} else if (sep === "-") {
-			if (rhs === undefined || rhs < startLine) {
-				throw new ToolError(`Invalid range ${startLine}-${rhs ?? 0}: end must be >= start.`);
-			}
-			endLine = rhs;
+		if (ranges !== undefined) {
+			// Two range groups on the same URL (`…:5-10:20-30`) — combine with commas instead.
+			throw new ToolError(
+				`URL selector has multiple range groups; combine them with commas (e.g. \`:5-10,20-30\`).`,
+			);
 		}
+		const parsed = parseLineRanges(sel);
+		if (parsed === null) {
+			// Shouldn't happen — isUrlSelectorToken vetted it. Belt-and-suspenders.
+			throw new ToolError(`Invalid URL line selector: ${sel}`);
+		}
+		ranges = parsed;
+	}
+
+	if (!ranges || ranges.length === 0) return { path: urlPath, raw };
+	if (ranges.length === 1) {
+		const r = ranges[0];
 		return {
 			path: urlPath,
-			raw: false,
-			offset: startLine,
-			limit: endLine !== undefined ? endLine - startLine + 1 : undefined,
+			raw,
+			offset: r.startLine,
+			limit: r.endLine !== undefined ? r.endLine - r.startLine + 1 : undefined,
 		};
 	}
-
-	return { path: urlPath, raw };
+	return { path: urlPath, raw, ranges };
 }
 
-function tryExtractEmbeddedUrlSelector(readPath: string): { path: string; sel?: string } | null {
-	const lastColonIndex = readPath.lastIndexOf(":");
-	if (lastColonIndex <= 0) {
-		return null;
-	}
-
-	const candidateSelector = readPath.slice(lastColonIndex + 1);
-	const basePath = readPath.slice(0, lastColonIndex);
-	if (!isReadableUrlPath(basePath)) {
-		return null;
-	}
+/**
+ * Peel one or more selector tokens off the right of a URL string. Walks back through
+ * trailing `:tok` segments while each token (a) looks like a selector and (b) leaves
+ * behind a string that still parses as a URL. Returns selectors left-to-right so callers
+ * can apply them in source order.
+ */
+function tryExtractEmbeddedUrlSelector(readPath: string): { path: string; sels: string[] } | null {
+	let basePath = readPath;
+	const sels: string[] = [];
+	while (true) {
+		const lastColonIndex = basePath.lastIndexOf(":");
+		if (lastColonIndex <= 0) break;
+
+		const candidate = basePath.slice(lastColonIndex + 1);
+		const remainder = basePath.slice(0, lastColonIndex);
+		if (!isReadableUrlPath(remainder)) break;
+		if (!isUrlSelectorToken(candidate)) break;
 
-	const isEmbeddedSelector = candidateSelector === "raw" || URL_LINE_RANGE_RE.test(candidateSelector);
-	if (!isEmbeddedSelector) {
-		return null;
-	}
+		try {
+			new URL(
+				remainder.startsWith("http://") || remainder.startsWith("https://") ? remainder : `https://${remainder}`,
+			);
+		} catch {
+			break;
+		}
 
-	try {
-		new URL(basePath.startsWith("http://") || basePath.startsWith("https://") ? basePath : `https://${basePath}`);
-		return { path: basePath, sel: candidateSelector };
-	} catch {
-		return null;
+		sels.unshift(candidate);
+		basePath = remainder;
 	}
+	if (sels.length === 0) return null;
+	return { path: basePath, sels };
 }
 
 /**
@@ -931,6 +957,22 @@ async function renderUrl(
 	const isText = mime.includes("text/plain") || mime.includes("text/markdown");
 	const isFeed = mime.includes("rss") || mime.includes("atom") || mime.includes("feed");
 
+	// Raw mode skips every text-shaping branch below (JSON pretty-print, feed-to-markdown,
+	// HTML extraction) and returns the response body verbatim. The image/markit branches
+	// above already ran because raw isn't useful for binary payloads.
+	if (raw) {
+		const output = finalizeOutput(rawContent);
+		return {
+			url,
+			finalUrl,
+			contentType: mime,
+			method: "raw",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes,
+		};
+	}
 	if (isJson) {
 		const output = finalizeOutput(formatJson(rawContent));
 		return {
@@ -1174,7 +1216,8 @@ interface ReadUrlCacheEntry {
 	output: string;
 }
 
-const readUrlCache = new Map<string, ReadUrlCacheEntry>();
+const READ_URL_CACHE_MAX_ENTRIES = 100;
+const readUrlCache = new LRUCache<string, ReadUrlCacheEntry>({ max: READ_URL_CACHE_MAX_ENTRIES });
 
 function getReadUrlCacheKey(session: ToolSession, requestedUrl: string, raw: boolean): string {
 	const scope = session.getSessionFile() ?? session.cwd;

package/src/tools/find.ts

@@ -39,14 +39,15 @@ const findSchema = z
 		paths: z.array(z.string().describe("glob including search path")).min(1).describe("globs including search paths"),
 		hidden: z.boolean().default(true).describe("include hidden files").optional(),
 		gitignore: z.boolean().default(true).describe("respect gitignore").optional(),
-		limit: z.number().default(1000).describe("max results").optional(),
+		limit: z.number().default(200).describe("max results (clamped to 1-200)").optional(),
 		timeout: z.number().min(0.5).max(60).default(5).describe("timeout in seconds (0.5–60)").optional(),
 	})
 	.strict();
 
 export type FindToolInput = z.infer<typeof findSchema>;
 
-const DEFAULT_LIMIT = 1000;
+const DEFAULT_LIMIT = 200;
+const MAX_LIMIT = 200;
 const DEFAULT_GLOB_TIMEOUT_MS = 5000;
 const MIN_GLOB_TIMEOUT_MS = 500;
 const MAX_GLOB_TIMEOUT_MS = 60_000;
@@ -78,6 +79,37 @@ export 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 function formatFindGroupedOutput(paths: readonly string[]): string {
+	if (paths.length === 0) return "";
+	const groups = new Map<string, string[]>();
+	for (const entry of paths) {
+		const hasTrailingSlash = entry.endsWith("/");
+		const trimmed = hasTrailingSlash ? entry.slice(0, -1) : entry;
+		const slash = trimmed.lastIndexOf("/");
+		const dir = slash === -1 ? "" : trimmed.slice(0, slash);
+		const base = slash === -1 ? trimmed : trimmed.slice(slash + 1);
+		const label = hasTrailingSlash ? `${base}/` : base;
+		const list = groups.get(dir);
+		if (list) list.push(label);
+		else groups.set(dir, [label]);
+	}
+	const sections: string[] = [];
+	for (const [dir, entries] of groups) {
+		if (dir === "") {
+			sections.push(entries.join("\n"));
+		} else {
+			sections.push(`# ${dir}/\n${entries.join("\n")}`);
+		}
+	}
+	return sections.join("\n\n");
+}
+
 export interface FindToolDetails {
 	truncation?: TruncationResult;
 	resultLimitReached?: number;
@@ -195,11 +227,11 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			if (searchPath === "/") {
 				throw new ToolError("Searching from root directory '/' is not allowed");
 			}
-			const rawLimit = limit ?? DEFAULT_LIMIT;
-			const effectiveLimit = Number.isFinite(rawLimit) ? Math.floor(rawLimit) : Number.NaN;
-			if (!Number.isFinite(effectiveLimit) || effectiveLimit <= 0) {
+			const requestedLimit = limit ?? DEFAULT_LIMIT;
+			if (!Number.isFinite(requestedLimit) || requestedLimit <= 0) {
 				throw new ToolError("Limit must be a positive number");
 			}
+			const effectiveLimit = Math.min(MAX_LIMIT, Math.max(1, Math.floor(requestedLimit)));
 			const includeHidden = hidden ?? true;
 			const useGitignore = gitignore ?? true;
 			const requestedTimeoutMs = timeout != null ? Math.round(timeout * 1000) : DEFAULT_GLOB_TIMEOUT_MS;
@@ -241,7 +273,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				const listLimit = applyListLimit(files, { limit: effectiveLimit });
 				const limited = listLimit.items;
 				const limitMeta = listLimit.meta;
-				const baseOutput = limited.join("\n");
+				const baseOutput = formatFindGroupedOutput(limited);
 				const trailingNotes: string[] = [];
 				if (notice) trailingNotes.push(notice);
 				if (missingPathsNote) trailingNotes.push(missingPathsNote);

package/src/tools/read.ts

@@ -1488,6 +1488,21 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			if (!this.session.settings.get("fetch.enabled")) {
 				throw new ToolError("URL reads are disabled by settings.");
 			}
+			if (parsedUrlTarget.ranges !== undefined) {
+				const cached = await loadReadUrlCacheEntry(
+					this.session,
+					{ path: parsedUrlTarget.path, raw: parsedUrlTarget.raw },
+					signal,
+					{ ensureArtifact: true, preferCached: true },
+				);
+				return this.#buildInMemoryMultiRangeResult(cached.output, parsedUrlTarget.ranges, {
+					details: { ...cached.details },
+					sourceUrl: cached.details.finalUrl,
+					entityLabel: "URL output",
+					raw: parsedUrlTarget.raw,
+					immutable: true,
+				});
+			}
 			if (parsedUrlTarget.offset !== undefined || parsedUrlTarget.limit !== undefined) {
 				const cached = await loadReadUrlCacheEntry(
 					this.session,
@@ -1502,6 +1517,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					details: { ...cached.details },
 					sourceUrl: cached.details.finalUrl,
 					entityLabel: "URL output",
+					raw: parsedUrlTarget.raw,
 					immutable: true,
 				});
 			}
@@ -1578,7 +1594,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			if (isMultiRange(parsed)) {
 				throw new ToolError("Multi-range line selectors are not supported for directory listings.");
 			}
-			const dirResult = await this.#readDirectory(absolutePath, selToOffsetLimit(parsed).limit, signal);
+			const { offset, limit } = selToOffsetLimit(parsed);
+			const dirResult = await this.#readDirectory(absolutePath, offset, limit, signal);
 			if (suffixResolution) {
 				dirResult.details ??= {};
 				dirResult.details.suffixResolution = suffixResolution;
@@ -2136,6 +2153,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	/** Read directory contents as a formatted listing */
 	async #readDirectory(
 		absolutePath: string,
+		offset: number | undefined,
 		limit: number | undefined,
 		signal?: AbortSignal,
 	): Promise<AgentToolResult<ReadToolDetails>> {
@@ -2149,7 +2167,9 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				maxDepth: READ_DIRECTORY_MAX_DEPTH,
 				perDirLimit: READ_DIRECTORY_CHILD_LIMIT,
 				rootLimit: null,
-				lineCap: limit ?? null,
+				// `lineCap` truncates the rendered tree itself, so apply it only when the caller
+				// did not request an offset — otherwise we'd cap the first N lines before slicing.
+				lineCap: offset === undefined && limit !== undefined ? limit : null,
 			});
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
@@ -2158,12 +2178,46 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		throwIfAborted(signal);
 
 		const output = tree.totalLines <= 1 ? "(empty directory)" : tree.rendered;
-		const truncation = truncateHead(output, { maxLines: Number.MAX_SAFE_INTEGER });
 		const details: ReadToolDetails = {
 			isDirectory: true,
 			resolvedPath: tree.rootPath,
 		};
 
+		// Slice the rendered listing when the caller passed an offset/limit. We do this
+		// instead of passing the selector down to `buildDirectoryTree` because the tree
+		// builder lays out entries hierarchically (per-dir caps, recent-then-elided
+		// summaries); line-based slicing operates on the formatted text and matches what
+		// users expect from `:N-M` on long listings.
+		const wantsSlice = offset !== undefined || limit !== undefined;
+		if (wantsSlice) {
+			const allLines = output.split("\n");
+			const start = offset ? Math.max(0, offset - 1) : 0;
+			if (start >= allLines.length) {
+				const suggestion =
+					allLines.length === 0
+						? "The listing is empty."
+						: `Use :1 to read from the start, or :${allLines.length} to read the last line.`;
+				return toolResult(details)
+					.text(`Line ${start + 1} is beyond end of listing (${allLines.length} lines total). ${suggestion}`)
+					.sourcePath(tree.rootPath)
+					.done();
+			}
+			const end = limit !== undefined ? Math.min(start + limit, allLines.length) : allLines.length;
+			const sliced = allLines.slice(start, end).join("\n");
+			const resultBuilder = toolResult(details).sourcePath(tree.rootPath);
+			let text = sliced;
+			if (end < allLines.length) {
+				const remaining = allLines.length - end;
+				text += `\n\n[${remaining} more lines in listing. Use :${end + 1} to continue]`;
+			}
+			resultBuilder.text(text);
+			if (tree.truncated) {
+				resultBuilder.limits({ resultLimit: 1 });
+			}
+			return resultBuilder.done();
+		}
+
+		const truncation = truncateHead(output, { maxLines: Number.MAX_SAFE_INTEGER });
 		const resultBuilder = toolResult(details).text(truncation.content).sourcePath(tree.rootPath);
 		if (tree.truncated) {
 			resultBuilder.limits({ resultLimit: 1 });