@oh-my-pi/pi-coding-agent 16.2.1 → 16.2.3

package/src/debug/raw-sse.ts

@@ -1,13 +1,6 @@
-import {
-	type Component,
-	matchesKey,
-	padding,
-	replaceTabs,
-	ScrollView,
-	truncateToWidth,
-	visibleWidth,
-} from "@oh-my-pi/pi-tui";
+import { type Component, matchesKey, parseSgrMouse, replaceTabs, ScrollView, truncateToWidth } from "@oh-my-pi/pi-tui";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
+import { bottomBorder, divider, row, topBorder } from "../modes/components/overlay-box";
 import { theme } from "../modes/theme/theme";
 import { copyToClipboard } from "../utils/clipboard";
 import {
@@ -17,8 +10,8 @@ import {
 	rawSseRecordLines,
 } from "./raw-sse-buffer";
 
-const MIN_VIEWER_WIDTH = 20;
-const VIEWER_FRAME_LINES = 5;
+const MIN_VIEWER_WIDTH = 40;
+const VIEWER_CHROME_LINES = 6;
 // `data:` lines below this width render fine on a single row; anything wider gets pretty-printed
 // across multiple `data:` lines so streamed JSON blobs stop getting clipped by `truncateToWidth`.
 const PRETTY_PRINT_DATA_THRESHOLD = 100;
@@ -79,6 +72,8 @@ export class RawSseViewerComponent implements Component {
 	#followTail = true;
 	#lastRenderWidth = MIN_VIEWER_WIDTH;
 	#statusMessage: string | undefined;
+	#bodyRowStart = 0;
+	#bodyRowCount = 0;
 	// Pretty-printed wire lines keyed by `record.sequence`. Pretty-printing is
 	// the JSON.parse + JSON.stringify per `data:` line, so we cache the result —
 	// the render path runs on every keypress and from `#maxScrollOffset()`.
@@ -98,9 +93,17 @@ export class RawSseViewerComponent implements Component {
 		});
 	}
 
+	dispose(): void {
+		this.#unsubscribe();
+	}
+
 	handleInput(keyData: string): void {
+		if (keyData.startsWith("\x1b[<") && this.#handleMouse(keyData)) {
+			return;
+		}
+
 		if (matchesKey(keyData, "escape") || matchesKey(keyData, "esc")) {
-			this.#unsubscribe();
+			this.dispose();
 			this.#onExit();
 			return;
 		}
@@ -145,15 +148,44 @@ export class RawSseViewerComponent implements Component {
 		}
 	}
 
+	#handleMouse(keyData: string): boolean {
+		const event = parseSgrMouse(keyData);
+		if (!event) return false;
+
+		const overBody = event.row >= this.#bodyRowStart && event.row < this.#bodyRowStart + this.#bodyRowCount;
+		if (event.wheel !== null && overBody) {
+			this.#followTail = false;
+			this.#scrollOffset = Math.max(0, Math.min(this.#maxScrollOffset(), this.#scrollOffset + event.wheel * 3));
+			this.#onUpdate?.();
+			return true;
+		}
+
+		if (!event.leftClick) return false;
+		if (event.row === 1) {
+			this.#followTail = !this.#followTail;
+			this.#followIfNeeded();
+			this.#onUpdate?.();
+			return true;
+		}
+		if (overBody) {
+			this.#followTail = false;
+			const clickedOffset = this.#scrollOffset + event.row - this.#bodyRowStart;
+			this.#scrollOffset = Math.max(0, Math.min(this.#maxScrollOffset(), clickedOffset));
+			this.#onUpdate?.();
+			return true;
+		}
+		return false;
+	}
+
 	invalidate(): void {}
 
 	render(width: number): readonly string[] {
 		this.#lastRenderWidth = Math.max(MIN_VIEWER_WIDTH, width);
 		this.#followIfNeeded();
 
-		const innerWidth = Math.max(1, this.#lastRenderWidth - 2);
+		const contentWidth = Math.max(1, this.#lastRenderWidth - 4);
 		const bodyHeight = this.#bodyHeight();
-		const rawLines = this.#renderRawLines(innerWidth);
+		const rawLines = this.#renderRawLines(contentWidth);
 		const sv = new ScrollView(rawLines.slice(this.#scrollOffset, this.#scrollOffset + bodyHeight), {
 			height: bodyHeight,
 			scrollbar: "auto",
@@ -161,15 +193,18 @@ export class RawSseViewerComponent implements Component {
 			theme: { track: t => theme.fg("muted", t), thumb: t => theme.fg("accent", t) },
 		});
 		sv.setScrollOffset(this.#scrollOffset);
-		const bodyRows = sv.render(innerWidth);
+		const bodyRows = sv.render(contentWidth);
+		this.#bodyRowStart = 3;
+		this.#bodyRowCount = bodyHeight;
 
 		return [
-			this.#frameTop(innerWidth),
-			this.#frameLine(this.#summaryText(), innerWidth),
-			this.#frameSeparator(innerWidth),
-			...bodyRows.map(line => this.#frameLine(line, innerWidth)),
-			this.#frameLine(this.#statusText(), innerWidth),
-			this.#frameBottom(innerWidth),
+			topBorder(this.#lastRenderWidth, "Raw Provider Stream"),
+			row(this.#summaryText(), this.#lastRenderWidth),
+			divider(this.#lastRenderWidth),
+			...bodyRows.map(line => row(line, this.#lastRenderWidth)),
+			divider(this.#lastRenderWidth),
+			row(this.#statusText(), this.#lastRenderWidth),
+			bottomBorder(this.#lastRenderWidth),
 		];
 	}
 
@@ -221,22 +256,25 @@ export class RawSseViewerComponent implements Component {
 			if (key < firstSequence) this.#prettyLinesCache.delete(key);
 		}
 	}
-
 	#summaryText(): string {
 		const snapshot = this.#buffer.snapshot();
-		const last = snapshot.lastUpdatedAt ? ` last=${formatRawSseIsoTime(snapshot.lastUpdatedAt)}` : "";
-		const follow = this.#followTail ? "follow:on" : "follow:off";
-		return ` # raw provider stream (SSE + WS) | events=${snapshot.totalEvents} records=${snapshot.records.length}${last} | ${follow} | Esc back Ctrl+C copy End follow`;
+		const last = snapshot.lastUpdatedAt
+			? `${theme.fg("muted", "last")} ${theme.fg("accent", formatRawSseIsoTime(snapshot.lastUpdatedAt))}`
+			: theme.fg("muted", "waiting for first frame");
+		const follow = this.#followTail ? theme.fg("success", "follow on") : theme.fg("warning", "follow off");
+		return `${theme.fg("muted", "events")} ${theme.fg("accent", String(snapshot.totalEvents))}  ${theme.fg("muted", "records")} ${theme.fg("accent", String(snapshot.records.length))}  ${last}  ${follow}`;
 	}
 
 	#statusText(): string {
-		return this.#statusMessage ?? " Up/Down scroll  PgUp/PgDn page";
+		const help = "Esc close · Ctrl+C copy raw · End follow tail · wheel scroll · click summary toggles follow";
+		return this.#statusMessage
+			? `${theme.fg("success", this.#statusMessage)}  ${theme.fg("dim", help)}`
+			: theme.fg("dim", help);
 	}
 
 	#bodyHeight(): number {
-		return Math.max(3, this.#terminalRows - VIEWER_FRAME_LINES);
+		return Math.max(3, (process.stdout.rows || this.#terminalRows || 24) - VIEWER_CHROME_LINES);
 	}
-
 	#followIfNeeded(): void {
 		if (this.#followTail) this.#scrollToTail();
 	}
@@ -246,8 +284,8 @@ export class RawSseViewerComponent implements Component {
 	}
 
 	#maxScrollOffset(): number {
-		const innerWidth = Math.max(1, this.#lastRenderWidth - 2);
-		return Math.max(0, this.#renderRawLines(innerWidth).length - this.#bodyHeight());
+		const contentWidth = Math.max(1, this.#lastRenderWidth - 4);
+		return Math.max(0, this.#renderRawLines(contentWidth).length - this.#bodyHeight());
 	}
 
 	#copyAll(): void {
@@ -271,22 +309,4 @@ export class RawSseViewerComponent implements Component {
 		}
 		this.#onUpdate?.();
 	}
-
-	#frameTop(innerWidth: number): string {
-		return `${theme.boxRound.topLeft}${theme.boxRound.horizontal.repeat(innerWidth)}${theme.boxRound.topRight}`;
-	}
-
-	#frameSeparator(innerWidth: number): string {
-		return `${theme.boxRound.teeRight}${theme.boxRound.horizontal.repeat(innerWidth)}${theme.boxRound.teeLeft}`;
-	}
-
-	#frameBottom(innerWidth: number): string {
-		return `${theme.boxRound.bottomLeft}${theme.boxRound.horizontal.repeat(innerWidth)}${theme.boxRound.bottomRight}`;
-	}
-
-	#frameLine(content: string, innerWidth: number): string {
-		const truncated = truncateToWidth(content, innerWidth);
-		const remaining = Math.max(0, innerWidth - visibleWidth(truncated));
-		return `${theme.boxRound.vertical}${truncated}${padding(remaining)}${theme.boxRound.vertical}`;
-	}
 }

package/src/discovery/codex.ts

@@ -342,12 +342,20 @@ async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
 	const codexDir = getProjectCodexDir(ctx);
 	const projectHooksDir = path.join(codexDir, "hooks");
 
+	// OMP hooks must be named `pre-<tool>.<ts|js>` or `post-<tool>.<ts|js>`.
+	// Files without that prefix are not OMP hooks (e.g. the standalone Codex
+	// hook scripts users keep alongside) — silently dropping the prefix and
+	// defaulting to `pre:<basename>` caused those scripts to be imported as
+	// extension factories and any top-level `process.exit()` killed startup
+	// (#3680).
 	const transformHook =
-		(level: "user" | "project") => (name: string, _content: string, path: string, source: SourceMeta) => {
+		(level: "user" | "project") =>
+		(name: string, _content: string, path: string, source: SourceMeta): Hook | null => {
 			const baseName = name.replace(/\.(ts|js)$/, "");
 			const match = baseName.match(/^(pre|post)-(.+)$/);
-			const hookType = (match?.[1] as "pre" | "post") || "pre";
-			const toolName = match?.[2] || baseName;
+			if (!match) return null;
+			const hookType = match[1] as "pre" | "post";
+			const toolName = match[2];
 			return {
 				name,
 				path,
@@ -359,11 +367,11 @@ async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
 		};
 
 	const results = await Promise.all([
-		loadFilesFromDir(ctx, userHooksDir, PROVIDER_ID, "user", {
+		loadFilesFromDir<Hook>(ctx, userHooksDir, PROVIDER_ID, "user", {
 			extensions: ["ts", "js"],
 			transform: transformHook("user"),
 		}),
-		loadFilesFromDir(ctx, projectHooksDir, PROVIDER_ID, "project", {
+		loadFilesFromDir<Hook>(ctx, projectHooksDir, PROVIDER_ID, "project", {
 			extensions: ["ts", "js"],
 			transform: transformHook("project"),
 		}),

package/src/discovery/omp-extension-roots.ts

@@ -22,6 +22,7 @@ import { readDirEntries, readFile } from "../capability/fs";
 import type { LoadContext } from "../capability/types";
 import { getEnabledPlugins } from "../extensibility/plugins/loader";
 import { expandTilde } from "../tools/path-utils";
+import { listClaudePluginRoots } from "./helpers";
 
 /** A resolved extension package directory wired into the discovery surfaces. */
 export interface OmpExtensionRoot {
@@ -123,9 +124,9 @@ async function isDirectory(p: string): Promise<boolean> {
  * 1. CLI roots injected via {@link injectOmpExtensionCliRoots}
  * 2. Project `<cwd>/.omp/settings.json#extensions`
  * 3. User `~/.omp/agent/settings.json#extensions`
- * 4. Enabled plugins installed under `<plugins>/node_modules/` (e.g. via
- *    `omp install <pkg>` / `omp plugin install` / `omp plugin link`)
- *
+ * 4. Enabled npm/link plugins installed under `<plugins>/node_modules/` (for
+ *    `omp install <pkg>` / `omp plugin install` / `omp plugin link`). Marketplace
+ *    installs are loaded by the `claude-plugins` provider and are excluded here.
  * Only entries that resolve to a directory on disk are returned; file
  * entrypoints contribute zero sub-discovery surface and are filtered out.
  * Installed-plugin enumeration failures (missing lockfile, unreadable
@@ -167,20 +168,44 @@ export async function listOmpExtensionRoots(ctx: LoadContext): Promise<OmpExtens
 }
 
 /**
- * Enumerate every enabled installed plugin's package directory so its
- * conventional `skills/`, `hooks/`, `tools/`, `commands/`, `rules/`,
- * `prompts/`, and `.mcp.json` are wired into discovery — mirrors how
- * `getAllPluginExtensionPaths` already feeds the extension factory loader.
+ * Enumerate every enabled npm/link plugin's package directory so its conventional
+ * `skills/`, `hooks/`, `tools/`, `commands/`, `rules/`, `prompts/`, and
+ * `.mcp.json` are wired into discovery — mirrors how `getAllPluginExtensionPaths`
+ * already feeds the extension factory loader.
  *
- * Marketplace and `omp plugin link` installs write to the plugin manager's
- * `node_modules` (or symlink into it) rather than to `extensions:` in
- * settings; without this branch the sub-discovery provider would still miss
- * everything those install paths produce.
+ * Marketplace installs also create runtime symlinks for enable-state persistence,
+ * but their resources are discovered through the `claude-plugins` provider.
+ * Filtering them here prevents `/status` from showing the same plugin under both
+ * "Claude Code Marketplace" and "OMP Extension Packages".
  */
+async function realpathOrResolved(p: string): Promise<string> {
+	try {
+		return await fs.realpath(p);
+	} catch (err) {
+		if (isEnoent(err)) return path.resolve(p);
+		throw err;
+	}
+}
+
 async function listInstalledPluginRoots(ctx: LoadContext): Promise<InjectedRoot[]> {
 	try {
-		const plugins = await getEnabledPlugins(ctx.cwd, { home: ctx.home });
-		return plugins.map(({ path: p, scope }) => ({ path: p, level: scope }));
+		const [plugins, marketplaceRoots] = await Promise.all([
+			getEnabledPlugins(ctx.cwd, { home: ctx.home }),
+			listClaudePluginRoots(ctx.home, ctx.cwd),
+		]);
+		const marketplaceRealpaths = new Set(
+			await Promise.all(marketplaceRoots.roots.map(root => realpathOrResolved(root.path))),
+		);
+		const installedRoots = await Promise.all(
+			plugins.map(async plugin => ({
+				path: plugin.path,
+				scope: plugin.scope,
+				realpath: await realpathOrResolved(plugin.path),
+			})),
+		);
+		return installedRoots
+			.filter(root => !marketplaceRealpaths.has(root.realpath))
+			.map(({ path: p, scope }) => ({ path: p, level: scope }));
 	} catch (err) {
 		logger.debug("listInstalledPluginRoots: enumeration failed", { error: String(err) });
 		return [];

package/src/edit/hashline/diff.ts

@@ -9,6 +9,7 @@
  * match is accepted even when the tag was minted by a source that did not keep
  * history, and stale tags recover through the session snapshot store when possible.
  */
+import * as path from "node:path";
 import {
 	type ApplyResult,
 	applyEdits,
@@ -30,6 +31,7 @@ import {
 } from "@oh-my-pi/hashline";
 import { resolveToCwd } from "../../tools/path-utils";
 import { generateDiffString } from "../diff";
+import { canonicalSnapshotKey } from "../file-snapshot-store";
 import { readEditFileText } from "../read-file";
 import { nativeBlockResolver } from "./block-resolver";
 
@@ -90,6 +92,54 @@ async function readSectionTextCached(absolutePath: string, sectionPath: string):
 	return rawContent;
 }
 
+/**
+ * Resolve a missing authored path to a file read this session by matching its
+ * basename and snapshot tag, mirroring {@link Patcher}'s apply-time recovery so
+ * a bare/wrong-directory `[basename#tag]` header previews against the same file
+ * the edit will land on. Returns `undefined` when no unique basename+tag match
+ * exists, leaving the caller to surface the original read error.
+ */
+function recoverSectionPathFromTag(
+	section: PatchSection,
+	authoredAbsolutePath: string,
+	snapshots: SnapshotStore,
+): string | undefined {
+	if (section.fileHash === undefined) return undefined;
+	const authoredName = path.basename(section.path);
+	const authoredKey = canonicalSnapshotKey(authoredAbsolutePath);
+	const candidates = [
+		...new Set(
+			snapshots
+				.findByHash(section.fileHash)
+				.filter(snapshot => path.basename(snapshot.path) === authoredName)
+				.map(snapshot => snapshot.path),
+		),
+	].filter(candidate => candidate !== authoredKey);
+	return candidates.length === 1 ? candidates[0] : undefined;
+}
+
+/**
+ * Read the section's target file for a preview, recovering a bare/mis-typed
+ * `[basename#tag]` path onto the file its tag uniquely names. Recovery fires
+ * only when the authored path is absent — matching {@link Patcher}'s apply-time
+ * order — so a permission/parse error on an existing file surfaces against the
+ * authored path instead of silently previewing a different tagged file. Returns
+ * the path actually read so callers key snapshot lookups off the same file.
+ */
+async function readSectionForPreview(
+	section: PatchSection,
+	authoredAbsolutePath: string,
+	snapshots: SnapshotStore,
+	streaming: boolean | undefined,
+): Promise<{ absolutePath: string; rawContent: string }> {
+	const read = streaming ? readSectionTextCached : readSectionText;
+	const recovered = (await Bun.file(authoredAbsolutePath).exists())
+		? undefined
+		: recoverSectionPathFromTag(section, authoredAbsolutePath, snapshots);
+	const target = recovered ?? authoredAbsolutePath;
+	return { absolutePath: target, rawContent: await read(target, section.path) };
+}
+
 function hasAnchorScopedEdit(edits: readonly Edit[]): boolean {
 	return edits.some(edit => {
 		if (edit.kind === "delete") return true;
@@ -258,10 +308,13 @@ export async function computeHashlineSectionDiff(
 	options: HashlineDiffOptions = {},
 ): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
 	try {
-		const absolutePath = resolveToCwd(section.path, cwd);
-		const rawContent = options.streaming
-			? await readSectionTextCached(absolutePath, section.path)
-			: await readSectionText(absolutePath, section.path);
+		const authoredPath = resolveToCwd(section.path, cwd);
+		const { absolutePath, rawContent } = await readSectionForPreview(
+			section,
+			authoredPath,
+			snapshots,
+			options.streaming,
+		);
 		const { text: content } = stripBom(rawContent);
 		const normalized = normalizeToLF(content);
 		// Streaming favors a stable, monotonic preview over an exact unified

package/src/edit/index.ts

@@ -397,6 +397,27 @@ export class EditTool implements AgentTool<TInput> {
 		return EDIT_MODE_STRATEGIES[this.mode].matcherDigest(args);
 	}
 
+	/**
+	 * Project the streamed args onto their target file paths so path-scoped
+	 * stream matchers (e.g. TTSR `tool:edit(*.ts)` globs) match hashline and
+	 * apply_patch edits even though the path lives in the wire payload (a
+	 * section header / envelope marker) rather than a top-level argument.
+	 */
+	matcherPaths(args: unknown): readonly string[] | undefined {
+		return EDIT_MODE_STRATEGIES[this.mode].matcherPaths(args);
+	}
+
+	/**
+	 * Per-file projection of the streamed args, splitting multi-section
+	 * hashline / multi-hunk apply_patch payloads into one (path, digest) entry
+	 * per touched file. Path-scoped stream matchers (TTSR) then evaluate each
+	 * file in isolation, so a `tool:edit(*.ts)` rule never fires on text that
+	 * actually belongs to a sibling Markdown hunk.
+	 */
+	matcherEntries(args: unknown): readonly { path: string; digest: string }[] | undefined {
+		return EDIT_MODE_STRATEGIES[this.mode].matcherEntries(args);
+	}
+
 	async execute(
 		_toolCallId: string,
 		params: EditParams,

package/src/edit/streaming.ts

@@ -52,6 +52,17 @@ export interface StreamingDiffContext {
 	isStreaming?: boolean;
 }
 
+/**
+ * Per-file projection of a streamed edit payload. Pairs one target file path
+ * with the digest of only the lines added to that file, so path-scoped stream
+ * matchers (TTSR) evaluate each file in isolation — a `tool:edit(*.ts)` rule
+ * never fires on text that actually belongs to a sibling `README.md` hunk.
+ */
+export interface EditMatcherEntry {
+	readonly path: string;
+	readonly digest: string;
+}
+
 export interface EditStreamingStrategy<Args = unknown> {
 	/**
 	 * Return the args restricted to edits that are "complete enough" to
@@ -77,6 +88,26 @@ export interface EditStreamingStrategy<Args = unknown> {
 	 * args don't yet carry any content.
 	 */
 	matcherDigest(args: Args): string | undefined;
+	/**
+	 * Surface the target file paths a (potentially partial) call would touch,
+	 * so path-scoped stream matchers (e.g. TTSR `tool:edit(*.ts)` globs) match
+	 * even when the path is not a top-level argument but lives inside the wire
+	 * payload — `hashline` section headers, `apply_patch` envelope markers.
+	 * Returns `undefined` (or an empty list) when no paths are recoverable.
+	 */
+	matcherPaths(args: Args): readonly string[] | undefined;
+	/**
+	 * Per-file projection of the (potentially partial) args: one entry per
+	 * touched file pairing the path with the digest of only the lines added to
+	 * that file. Multi-file payloads (multi-section hashline / multi-hunk
+	 * apply_patch) MUST split here so callers can evaluate each file under its
+	 * own path scope instead of leaking added lines from one file into the
+	 * other's match context. Same-path sections / hunks are merged into one
+	 * entry. Returns `undefined` (or empty) when no per-file split is
+	 * recoverable yet — the caller falls back to {@link matcherDigest} +
+	 * {@link matcherPaths}.
+	 */
+	matcherEntries(args: Args): readonly EditMatcherEntry[] | undefined;
 }
 
 // -----------------------------------------------------------------------------
@@ -191,6 +222,103 @@ function extractAddedLines(text: string, fallbackToWhole: boolean): string {
 	return added;
 }
 
+/**
+ * Extract hashline `[path#TAG]` (and untagged `[path]`) section-header paths
+ * from a (possibly partial) hashline buffer. Tolerant of streaming chunks
+ * where `Patch.parse` would still throw on the trailing op — only fully
+ * closed header lines are recognised.
+ */
+function extractHashlineHeaderPaths(input: string): string[] {
+	const paths: string[] = [];
+	const re = /^\s*\[([^\]\r\n]+?)(?:#[0-9a-fA-F]{4})?\]\s*$/gm;
+	for (const match of input.matchAll(re)) {
+		const candidate = stripApplyPatchPathNoise(match[1]).trim();
+		if (candidate.length > 0) paths.push(candidate);
+	}
+	return paths;
+}
+
+/**
+ * Strip the `*** Add/Update/Delete File:` / `*** Move to:` noise that the
+ * model sometimes pastes into a hashline header (the hashline tokenizer does
+ * the same in its recovery path).
+ */
+function stripApplyPatchPathNoise(value: string): string {
+	return value
+		.replace(/^\s*\*{3}\s*(?:Add|Update|Delete)\s+File\s*:\s*/i, "")
+		.replace(/^\s*\*{3}\s*Move\s+to\s*:\s*/i, "");
+}
+
+/** Extract `*** Add/Update/Delete File:` paths from a (possibly partial) apply_patch envelope. */
+function extractApplyPatchEnvelopePaths(input: string): string[] {
+	const paths: string[] = [];
+	const re = /^\s*\*{3}\s+(?:Add|Update|Delete)\s+File\s*:\s*(\S.*?)\s*$/gm;
+	for (const match of input.matchAll(re)) {
+		const candidate = match[1].trim();
+		if (candidate.length > 0) paths.push(candidate);
+	}
+	return paths;
+}
+
+/**
+ * Split a (possibly partial) hashline buffer into one matcher entry per
+ * touched file: pair the section header path with the added lines from that
+ * section's body, merging sections that target the same file into one entry.
+ * Header-line regex (not `Patch.parse`) so a mid-typed trailing op still
+ * yields entries for completed sections.
+ */
+function splitHashlinePerFile(input: string): EditMatcherEntry[] {
+	const headerRe = /^\s*\[([^\]\r\n]+?)(?:#[0-9a-fA-F]{4})?\]\s*$/gm;
+	const sections: { path: string; headerStart: number; bodyStart: number }[] = [];
+	let match: RegExpExecArray | null = headerRe.exec(input);
+	while (match !== null) {
+		const candidate = stripApplyPatchPathNoise(match[1]).trim();
+		if (candidate.length > 0) {
+			sections.push({ path: candidate, headerStart: match.index, bodyStart: headerRe.lastIndex });
+		}
+		match = headerRe.exec(input);
+	}
+	if (sections.length === 0) return [];
+
+	const byPath = new Map<string, string>();
+	for (let i = 0; i < sections.length; i++) {
+		const { path: sectionPath, bodyStart } = sections[i];
+		const bodyEnd = i + 1 < sections.length ? sections[i + 1].headerStart : input.length;
+		const added = extractAddedLines(input.slice(bodyStart, bodyEnd), false);
+		if (added.length === 0) continue;
+		const existing = byPath.get(sectionPath);
+		byPath.set(sectionPath, existing === undefined ? added : `${existing}\n${added}`);
+	}
+	return Array.from(byPath, ([path, digest]) => ({ path, digest }));
+}
+
+/**
+ * Split a (possibly partial) apply_patch envelope into one matcher entry per
+ * touched file. Same-path hunks are merged into one entry. Falls back to the
+ * streaming-tolerant parser when the envelope hasn't reached `*** End Patch`.
+ */
+function splitApplyPatchPerFile(input: string): EditMatcherEntry[] {
+	let entries: ApplyPatchEntry[];
+	try {
+		entries = expandApplyPatchToEntries({ input });
+	} catch {
+		try {
+			entries = expandApplyPatchToPreviewEntries({ input });
+		} catch {
+			return [];
+		}
+	}
+	const byPath = new Map<string, string>();
+	for (const entry of entries) {
+		if (typeof entry.diff !== "string") continue;
+		const added = extractAddedLines(entry.diff, false);
+		if (added.length === 0) continue;
+		const existing = byPath.get(entry.path);
+		byPath.set(entry.path, existing === undefined ? added : `${existing}\n${added}`);
+	}
+	return Array.from(byPath, ([path, digest]) => ({ path, digest }));
+}
+
 // -----------------------------------------------------------------------------
 // Strategies
 // -----------------------------------------------------------------------------
@@ -236,6 +364,15 @@ const replaceStrategy: EditStreamingStrategy<ReplaceArgs> = {
 		}
 		return digest;
 	},
+	matcherPaths(args) {
+		return typeof args?.path === "string" && args.path.length > 0 ? [args.path] : undefined;
+	},
+	matcherEntries(args) {
+		const path = args?.path;
+		if (typeof path !== "string" || path.length === 0) return undefined;
+		const digest = replaceStrategy.matcherDigest(args);
+		return digest === undefined ? undefined : [{ path, digest }];
+	},
 };
 
 interface PatchArgs {
@@ -278,6 +415,15 @@ const patchStrategy: EditStreamingStrategy<PatchArgs> = {
 		}
 		return digest;
 	},
+	matcherPaths(args) {
+		return typeof args?.path === "string" && args.path.length > 0 ? [args.path] : undefined;
+	},
+	matcherEntries(args) {
+		const path = args?.path;
+		if (typeof path !== "string" || path.length === 0) return undefined;
+		const digest = patchStrategy.matcherDigest(args);
+		return digest === undefined ? undefined : [{ path, digest }];
+	},
 };
 
 interface HashlineArgs {
@@ -437,6 +583,18 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		// Body rows are `+TEXT`; headers and op lines are grammar, never content.
 		return extractAddedLines(input, false);
 	},
+	matcherPaths(args) {
+		const input = args?.input;
+		if (typeof input !== "string" || input.length === 0) return undefined;
+		const paths = extractHashlineHeaderPaths(input);
+		return paths.length > 0 ? paths : undefined;
+	},
+	matcherEntries(args) {
+		const input = args?.input;
+		if (typeof input !== "string" || input.length === 0) return undefined;
+		const entries = splitHashlinePerFile(input);
+		return entries.length > 0 ? entries : undefined;
+	},
 };
 
 interface ApplyPatchArgs {
@@ -495,6 +653,18 @@ const applyPatchStrategy: EditStreamingStrategy<ApplyPatchArgs> = {
 		// Envelope markers and `@@` hunk headers are grammar, never content.
 		return extractAddedLines(input, false);
 	},
+	matcherPaths(args) {
+		const input = args?.input;
+		if (typeof input !== "string" || input.length === 0) return undefined;
+		const paths = extractApplyPatchEnvelopePaths(input);
+		return paths.length > 0 ? paths : undefined;
+	},
+	matcherEntries(args) {
+		const input = args?.input;
+		if (typeof input !== "string" || input.length === 0) return undefined;
+		const entries = splitApplyPatchPerFile(input);
+		return entries.length > 0 ? entries : undefined;
+	},
 };
 export const EDIT_MODE_STRATEGIES: Record<EditMode, EditStreamingStrategy<unknown>> = {
 	replace: replaceStrategy as EditStreamingStrategy<unknown>,