@oh-my-pi/pi-coding-agent 15.8.0 → 15.8.2

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 ## [Unreleased]
 
+## [15.8.2] - 2026-06-03
+
+### Added
+
+- Added a bundled TypeScript rule that warns against leaving `@deprecated` compatibility shims behind instead of finishing a refactor.
+
+### Fixed
+
+- Fixed `/review`'s uncommitted-change mode in Jujutsu repositories to read `jj diff --git` from the current workspace, so non-default JJ workspaces include their working-copy changes instead of falling back to the colocated Git checkout.
+- Fixed empty assistant stop retry continuations preserving auto-retry state until a non-empty assistant turn completes or recovery reaches its retry cap.
+- Fixed TTSR rule conditions never matching streamed `edit`/`write` tool calls whose wire format obscures the real content (hashline `+` body rows, apply_patch envelopes, JSON-escaped `write` content). The edit and write tools now expose a `matcherDigest` normalization and TTSR matches against the introduced source text, so rule regexes stay universal regardless of the active edit mode.
+
+### Changed
+
+- Changed the JJ utility API to mirror Git's scoped helpers: repository operations now live under `jj.repo` (`root`, `resolve`, `is`, `clearRootCache`), and diff file listing is available as `jj.diff.changedFiles`.
+
+- Changed the `search_tool_bm25` tool description to name the hidden discoverable built-in tools (e.g. `write`, `find`, `search`, `lsp`, `task`) when `tools.discoveryMode: "all"` is active, so a model can form a targeted discovery query by name instead of guessing or falling back to shell. `mcp-only` mode is unchanged (no built-ins are advertised) and the `Total discoverable tools available: N` count still includes them.
+
+## [15.8.1] - 2026-06-02
+
+### Fixed
+
+- Fixed an unhandled `EPIPE` rejection when an MCP stdio server exits between returning the `initialize` response and the client's `notifications/initialized` send. `StdioTransport.notify()` and `#sendResponse()` now route stdin writes through a shared helper that catches synchronous sink failures: `notify()` tears the transport down (firing `onClose`) and surfaces a `Transport closed while sending notification` rejection so `connectToServer()` treats the handshake as a failed connection instead of returning a "connected" handle wrapping a dead transport; `#sendResponse()` stays silent because a dead subprocess has no use for the response. `StdioTransport.close()` is now the authoritative resource teardown — it no longer early-returns when `#handleClose()` has already flipped `#connected`, so the subprocess and read loop are always cleaned up (including in the `connectToServer()` failure path) ([#1710](https://github.com/can1357/oh-my-pi/issues/1710)).
+- Fixed startup model resolution ignoring cached discovery rows for special built-in providers (`google-antigravity`, `google-gemini-cli`, `openai-codex`) until the background refresh completed ([#1721](https://github.com/can1357/oh-my-pi/issues/1721)).
+- Fixed Windows clipboard-image paste keeping `Ctrl+V` unregistered by default. The TUI now registers `Ctrl+V` plus the Windows Terminal-safe `Alt+V` fallback, and the keybinding docs call out when to use the fallback ([#1708](https://github.com/can1357/oh-my-pi/issues/1708)).
+
 ## [15.8.0] - 2026-06-02
 
 ### Added

package/dist/types/config/keybindings.d.ts

@@ -43,6 +43,10 @@ declare module "@oh-my-pi/pi-tui" {
     interface Keybindings extends AppKeybindings {
     }
 }
+/**
+ * Resolve default image-paste shortcuts for the current terminal platform.
+ */
+export declare function getDefaultPasteImageKeys(platform?: NodeJS.Platform): KeyId[];
 /**
  * All keybindings definitions: TUI + app-specific.
  */
@@ -228,7 +232,7 @@ export declare const KEYBINDINGS: {
         readonly description: "Dequeue message";
     };
     readonly "app.clipboard.pasteImage": {
-        readonly defaultKeys: "alt+v" | "ctrl+v";
+        readonly defaultKeys: KeyId[];
         readonly description: "Paste image from clipboard";
     };
     readonly "app.clipboard.pasteTextRaw": {

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

@@ -52,5 +52,11 @@ export declare class EditTool implements AgentTool<TInput> {
      * internal `name` and `customWireName`, so returned calls route correctly.
      */
     get customWireName(): string | undefined;
+    /**
+     * Normalize streamed args into the source text this edit introduces, so
+     * stream matchers (TTSR rules) run against real file content instead of the
+     * mode-specific patch grammar.
+     */
+    matcherDigest(args: unknown): string | undefined;
     execute(_toolCallId: string, params: EditParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<EditToolDetails, TInput>, context?: AgentToolContext): Promise<AgentToolResult<EditToolDetails, TInput>>;
 }

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

@@ -52,6 +52,14 @@ export interface EditStreamingStrategy<Args = unknown> {
      * compute returned `null` because args are still too partial).
      */
     renderStreamingFallback(args: Args, uiTheme: Theme): string;
+    /**
+     * Project the (potentially partial) args onto the plain text the edit
+     * introduces into files — added lines without patch grammar — so stream
+     * matchers (TTSR rules) can run source-level patterns against real content
+     * instead of the mode-specific wire format. Returns `undefined` when the
+     * args don't yet carry any content.
+     */
+    matcherDigest(args: Args): string | undefined;
 }
 /**
  * Given an edits array parsed from partial JSON, drop the last entry when the

package/dist/types/export/ttsr.d.ts

@@ -23,6 +23,15 @@ export declare class TtsrManager {
      * assistant prose, thinking text, and unrelated tool argument streams.
      */
     checkDelta(delta: string, context: TtsrMatchContext): Rule[];
+    /**
+     * Replace the scoped buffer with a tool-provided normalized snapshot and
+     * return matching rules.
+     *
+     * Used for tools exposing `matcherDigest`: the digest is recomputed from the
+     * full (partial) arguments on every delta, so it replaces the buffer instead
+     * of being appended to it.
+     */
+    checkSnapshot(snapshot: string, context: TtsrMatchContext): Rule[];
     /** Mark rules as injected (won't trigger again until conditions allow). */
     markInjected(rulesToMark: Rule[]): void;
     /** Mark rule names as injected (won't trigger again until conditions allow). */

package/dist/types/mcp/transports/stdio.d.ts

@@ -5,6 +5,24 @@
  * Messages are newline-delimited JSON.
  */
 import type { MCPRequestOptions, MCPStdioServerConfig, MCPTransport } from "../../mcp/types";
+/** Minimal write surface of `Subprocess.stdin` we need for framed sends. */
+interface FrameSink {
+    write(chunk: string): unknown;
+    flush(): unknown;
+}
+/**
+ * Write a newline-delimited JSON-RPC frame to the subprocess's stdin sink,
+ * swallowing synchronous errors so the caller can decide how to react.
+ *
+ * Bun's `FileSink` may throw synchronously (most reliably on Windows) when
+ * the read end of the pipe has been closed by a subprocess that exited
+ * between read-loop ticks. Letting that throw escape an `async` method
+ * surfaces as an unhandled promise rejection at the call site.
+ *
+ * Returns `true` when the frame was accepted by the sink, `false` when the
+ * sink threw — callers signal transport closure on `false`.
+ */
+export declare function writeFrame(stdin: FrameSink, frame: string): boolean;
 /**
  * Stdio transport for MCP servers.
  * Spawns a subprocess and communicates via stdin/stdout.
@@ -30,3 +48,4 @@ export declare class StdioTransport implements MCPTransport {
  * Create and connect a stdio transport.
  */
 export declare function createStdioTransport(config: MCPStdioServerConfig): Promise<StdioTransport>;
+export {};

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

@@ -41,6 +41,8 @@ export declare class WriteTool implements AgentTool<typeof writeSchema, WriteToo
     readonly concurrency = "exclusive";
     readonly loadMode = "discoverable";
     readonly summary = "Write content to a file (creates or overwrites)";
+    /** Stream matchers should see the real file content, not its JSON-escaped argument encoding. */
+    matcherDigest(args: unknown): string | undefined;
     constructor(session: ToolSession);
     execute(_toolCallId: string, { path, content }: WriteParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<WriteToolDetails>, context?: AgentToolContext): Promise<AgentToolResult<WriteToolDetails>>;
 }

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

@@ -0,0 +1,49 @@
+/** Result from a completed `jj` subprocess invocation. */
+export interface JjCommandResult {
+    /** Process exit code reported by `jj`. */
+    exitCode: number;
+    /** Captured standard output as UTF-8 text. */
+    stdout: string;
+    /** Captured standard error as UTF-8 text. */
+    stderr: string;
+}
+/** Resolved Jujutsu workspace metadata. */
+export interface JjRepository {
+    /** Root directory containing the `.jj` workspace metadata. */
+    repoRoot: string;
+    /** Path to the workspace store directory used to verify a real JJ checkout. */
+    storeDir: string;
+}
+/** Options for `jj diff` invocations. */
+export interface DiffOptions {
+    /** Optional file paths to restrict the diff with `-- <files>`. */
+    readonly files?: readonly string[];
+    /** Return only changed file names instead of Git-format diff text. */
+    readonly nameOnly?: boolean;
+    /** Optional abort signal passed to the spawned `jj` process. */
+    readonly signal?: AbortSignal;
+}
+/** Error thrown when a checked `jj` command exits non-zero. */
+export declare class JjCommandError extends Error {
+    /** Arguments passed after the common `jj --no-pager --color=never` prefix. */
+    readonly args: readonly string[];
+    /** Captured command result that caused the failure. */
+    readonly result: JjCommandResult;
+    /** Create an error for a failed checked `jj` command. */
+    constructor(args: readonly string[], result: JjCommandResult);
+}
+/** Run `jj diff --git` for the current workspace commit and return the raw Git-format diff text. */
+export declare const diff: ((cwd: string, options?: DiffOptions) => Promise<string>) & {
+    /** List changed file paths. */
+    changedFiles(cwd: string, options?: Pick<DiffOptions, "files" | "signal">): Promise<string[]>;
+};
+export declare const repo: {
+    /** Clear cached workspace roots. Intended for tests that mutate JJ metadata under an existing path. */
+    clearRootCache(): void;
+    /** Resolve the current Jujutsu workspace root, or `null` when `cwd` is not in a JJ repository. */
+    root(cwd: string): Promise<string | null>;
+    /** Full Jujutsu workspace metadata. */
+    resolve(cwd: string): Promise<JjRepository | null>;
+    /** Check whether `cwd` is inside a Jujutsu repository. */
+    is(cwd: string): Promise<boolean>;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.8.0",
+	"version": "15.8.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,14 +47,14 @@
 		"@agentclientprotocol/sdk": "0.22.1",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "15.8.0",
-		"@oh-my-pi/omp-stats": "15.8.0",
-		"@oh-my-pi/pi-agent-core": "15.8.0",
-		"@oh-my-pi/pi-ai": "15.8.0",
-		"@oh-my-pi/pi-mnemopi": "15.8.0",
-		"@oh-my-pi/pi-natives": "15.8.0",
-		"@oh-my-pi/pi-tui": "15.8.0",
-		"@oh-my-pi/pi-utils": "15.8.0",
+		"@oh-my-pi/hashline": "15.8.2",
+		"@oh-my-pi/omp-stats": "15.8.2",
+		"@oh-my-pi/pi-agent-core": "15.8.2",
+		"@oh-my-pi/pi-ai": "15.8.2",
+		"@oh-my-pi/pi-mnemopi": "15.8.2",
+		"@oh-my-pi/pi-natives": "15.8.2",
+		"@oh-my-pi/pi-tui": "15.8.2",
+		"@oh-my-pi/pi-utils": "15.8.2",
 		"@puppeteer/browsers": "^3.0.4",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/config/keybindings.ts

@@ -58,6 +58,13 @@ declare module "@oh-my-pi/pi-tui" {
 	interface Keybindings extends AppKeybindings {}
 }
 
+/**
+ * Resolve default image-paste shortcuts for the current terminal platform.
+ */
+export function getDefaultPasteImageKeys(platform: NodeJS.Platform = process.platform): KeyId[] {
+	return platform === "win32" ? ["ctrl+v", "alt+v"] : ["ctrl+v"];
+}
+
 /**
  * All keybindings definitions: TUI + app-specific.
  */
@@ -120,7 +127,7 @@ export const KEYBINDINGS = {
 		description: "Dequeue message",
 	},
 	"app.clipboard.pasteImage": {
-		defaultKeys: process.platform === "win32" ? "alt+v" : "ctrl+v",
+		defaultKeys: getDefaultPasteImageKeys(),
 		description: "Paste image from clipboard",
 	},
 	"app.clipboard.pasteTextRaw": {

package/src/config/model-registry.ts

@@ -53,6 +53,17 @@ function discoveryDefaultMaxTokens(api: Api | undefined): number {
 	return api === "anthropic-messages" ? DISCOVERY_DEFAULT_MAX_TOKENS_ANTHROPIC : DISCOVERY_DEFAULT_MAX_TOKENS;
 }
 
+const SPECIAL_MODEL_MANAGER_PROVIDER_IDS: readonly string[] = [
+	"google-antigravity",
+	"google-gemini-cli",
+	"openai-codex",
+];
+
+const STARTUP_MODEL_CACHE_PROVIDER_IDS: readonly string[] = [
+	...PROVIDER_DESCRIPTORS.map(descriptor => descriptor.providerId),
+	...SPECIAL_MODEL_MANAGER_PROVIDER_IDS,
+];
+
 import { registerOAuthProvider, unregisterOAuthProviders } from "@oh-my-pi/pi-ai/utils/oauth";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/utils/oauth/types";
 import { isRecord, logger } from "@oh-my-pi/pi-utils";
@@ -1133,28 +1144,28 @@ export class ModelRegistry {
 		const configuredDiscoveryProviders = new Set(this.#discoverableProviders.map(provider => provider.provider));
 		const cachedModels: Model<Api>[] = [];
 		const authoritativeFreshProviders = new Set<string>();
-		for (const descriptor of PROVIDER_DESCRIPTORS) {
-			if (configuredDiscoveryProviders.has(descriptor.providerId)) {
+		for (const providerId of STARTUP_MODEL_CACHE_PROVIDER_IDS) {
+			if (configuredDiscoveryProviders.has(providerId)) {
 				continue;
 			}
-			const cache = readModelCache<Api>(descriptor.providerId, 24 * 60 * 60 * 1000, Date.now, this.#cacheDbPath);
+			const cache = readModelCache<Api>(providerId, 24 * 60 * 60 * 1000, Date.now, this.#cacheDbPath);
 			if (!cache) {
 				continue;
 			}
 			if (cache.fresh && cache.authoritative) {
-				authoritativeFreshProviders.add(descriptor.providerId);
+				authoritativeFreshProviders.add(providerId);
 			}
 			const models = cache.models.map(model =>
-				model.provider === descriptor.providerId ? model : { ...model, provider: descriptor.providerId },
+				model.provider === providerId ? model : { ...model, provider: providerId },
 			);
-			const providerOverride = this.#providerOverrides.get(descriptor.providerId);
+			const providerOverride = this.#providerOverrides.get(providerId);
 			const withTransport = providerOverride
 				? models.map(model => this.#applyProviderTransportOverride(model, providerOverride))
 				: models;
 			const withCompat = providerOverride?.compat
 				? withTransport.map(model => ({ ...model, compat: mergeCompat(model.compat, providerOverride.compat) }))
 				: withTransport;
-			cachedModels.push(...this.#applyProviderModelOverrides(descriptor.providerId, withCompat));
+			cachedModels.push(...this.#applyProviderModelOverrides(providerId, withCompat));
 		}
 		return { models: cachedModels, authoritativeFreshProviders };
 	}

package/src/discovery/builtin-rules/index.ts

@@ -17,6 +17,7 @@ import rsResultType from "./rs-result-type.md" with { type: "text" };
 import tsBareCatch from "./ts-bare-catch.md" with { type: "text" };
 import tsImportType from "./ts-import-type.md" with { type: "text" };
 import tsNoAny from "./ts-no-any.md" with { type: "text" };
+import tsNoDeprecatedLeftovers from "./ts-no-deprecated-leftovers.md" with { type: "text" };
 import tsNoDynamicImport from "./ts-no-dynamic-import.md" with { type: "text" };
 import tsNoReturnType from "./ts-no-return-type.md" with { type: "text" };
 import tsNoTinyFunctions from "./ts-no-tiny-functions.md" with { type: "text" };
@@ -40,6 +41,7 @@ export const BUILTIN_RULE_SOURCES: readonly BuiltinRuleSource[] = [
 	{ name: "ts-bare-catch", content: tsBareCatch },
 	{ name: "ts-import-type", content: tsImportType },
 	{ name: "ts-no-any", content: tsNoAny },
+	{ name: "ts-no-deprecated-leftovers", content: tsNoDeprecatedLeftovers },
 	{ name: "ts-no-dynamic-import", content: tsNoDynamicImport },
 	{ name: "ts-no-return-type", content: tsNoReturnType },
 	{ name: "ts-no-tiny-functions", content: tsNoTinyFunctions },

package/src/discovery/builtin-rules/ts-no-deprecated-leftovers.md

@@ -0,0 +1,44 @@
+---
+description: "Do not leave `@deprecated` shims behind after refactors — update call sites and remove the old API"
+condition: "@deprecated"
+scope: "tool:edit(*.ts), tool:edit(*.tsx), tool:write(*.ts), tool:write(*.tsx)"
+---
+
+Do not use `@deprecated` as a substitute for finishing a refactor. If an API is obsolete inside the code you control, update every call site and remove the old name in the same change.
+
+## Why
+
+- Deprecated aliases keep two contracts alive.
+- Future maintainers must preserve behavior nobody should call.
+- Tests can pass while production code keeps using the old path.
+- The next refactor has to unwind both the real API and the compatibility layer.
+
+## Avoid
+
+```typescript
+// Bad — leaves a stale compatibility name instead of finishing the cutover.
+/** @deprecated Use loadSettings instead. */
+export const loadConfig = loadSettings;
+
+// Bad — preserves an obsolete wrapper after callers can be updated.
+/** @deprecated Use createClient instead. */
+export function makeClient(options: ClientOptions): Client {
+	return createClient(options);
+}
+```
+
+## Use
+
+```typescript
+// Update all imports and call sites to the durable name.
+export function loadSettings(path: string): Settings { ... }
+export function createClient(options: ClientOptions): Client { ... }
+```
+
+## Exceptions
+
+- Public package APIs with a documented migration window.
+- Third-party declarations where the deprecated marker reflects an external contract.
+- Tests that intentionally verify deprecated API behavior during a supported transition.
+
+If an exception applies, state the external compatibility requirement. Otherwise, finish the refactor and delete the deprecated symbol.

package/src/edit/index.ts

@@ -24,6 +24,7 @@ import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
 import { executePatchSingle, type PatchEditEntry, type PatchParams, patchEditSchema } from "./modes/patch";
 import { executeReplaceSingle, type ReplaceEditEntry, type ReplaceParams, replaceEditSchema } from "./modes/replace";
 import { type EditToolDetails, type EditToolPerFileResult, getLspBatchRequest, type LspBatchRequest } from "./renderer";
+import { EDIT_MODE_STRATEGIES } from "./streaming";
 
 export * from "@oh-my-pi/hashline";
 export { DEFAULT_EDIT_MODE, type EditMode, normalizeEditMode } from "../utils/edit-mode";
@@ -360,6 +361,15 @@ export class EditTool implements AgentTool<TInput> {
 		return "apply_patch";
 	}
 
+	/**
+	 * Normalize streamed args into the source text this edit introduces, so
+	 * stream matchers (TTSR rules) run against real file content instead of the
+	 * mode-specific patch grammar.
+	 */
+	matcherDigest(args: unknown): string | undefined {
+		return EDIT_MODE_STRATEGIES[this.mode].matcherDigest(args);
+	}
+
 	async execute(
 		_toolCallId: string,
 		params: EditParams,

package/src/edit/streaming.ts

@@ -69,6 +69,14 @@ export interface EditStreamingStrategy<Args = unknown> {
 	 * compute returned `null` because args are still too partial).
 	 */
 	renderStreamingFallback(args: Args, uiTheme: Theme): string;
+	/**
+	 * Project the (potentially partial) args onto the plain text the edit
+	 * introduces into files — added lines without patch grammar — so stream
+	 * matchers (TTSR rules) can run source-level patterns against real content
+	 * instead of the mode-specific wire format. Returns `undefined` when the
+	 * args don't yet carry any content.
+	 */
+	matcherDigest(args: Args): string | undefined;
 }
 
 // -----------------------------------------------------------------------------
@@ -161,6 +169,28 @@ function groupApplyPatchEntriesByPath(entries: readonly ApplyPatchEntry[]): Map<
 	return groups;
 }
 
+/**
+ * Extract the lines a patch-style payload adds (`+` prefix, excluding `+++ `
+ * file headers), stripped of the prefix. When the text carries no added lines,
+ * returns the whole text if `fallbackToWhole` (full-content payloads such as a
+ * `create` op), otherwise an empty string (grammar-only payloads).
+ */
+function extractAddedLines(text: string, fallbackToWhole: boolean): string {
+	let added: string | undefined;
+	let lineStart = 0;
+	while (lineStart <= text.length) {
+		let lineEnd = text.indexOf("\n", lineStart);
+		if (lineEnd === -1) lineEnd = text.length;
+		if (text.charCodeAt(lineStart) === 43 /* + */ && !text.startsWith("+++ ", lineStart)) {
+			const line = text.slice(lineStart + 1, lineEnd);
+			added = added === undefined ? line : `${added}\n${line}`;
+		}
+		lineStart = lineEnd + 1;
+	}
+	if (added === undefined) return fallbackToWhole ? text : "";
+	return added;
+}
+
 // -----------------------------------------------------------------------------
 // Strategies
 // -----------------------------------------------------------------------------
@@ -196,6 +226,16 @@ const replaceStrategy: EditStreamingStrategy<ReplaceArgs> = {
 	renderStreamingFallback() {
 		return "";
 	},
+	matcherDigest(args) {
+		const edits = args?.edits;
+		if (!Array.isArray(edits)) return undefined;
+		let digest: string | undefined;
+		for (const edit of edits) {
+			if (typeof edit?.new_text !== "string") continue;
+			digest = digest === undefined ? edit.new_text : `${digest}\n${edit.new_text}`;
+		}
+		return digest;
+	},
 };
 
 interface PatchArgs {
@@ -225,6 +265,19 @@ const patchStrategy: EditStreamingStrategy<PatchArgs> = {
 	renderStreamingFallback() {
 		return "";
 	},
+	matcherDigest(args) {
+		const edits = args?.edits;
+		if (!Array.isArray(edits)) return undefined;
+		let digest: string | undefined;
+		for (const edit of edits) {
+			if (typeof edit?.diff !== "string") continue;
+			// `create` ops carry full file content in `diff` with no +/- markers;
+			// pass that content through whole.
+			const added = extractAddedLines(edit.diff, true);
+			digest = digest === undefined ? added : `${digest}\n${added}`;
+		}
+		return digest;
+	},
 };
 
 interface HashlineArgs {
@@ -378,6 +431,12 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		// than a sigil dump.
 		return "";
 	},
+	matcherDigest(args) {
+		const input = args?.input;
+		if (typeof input !== "string") return undefined;
+		// Body rows are `+TEXT`; headers and op lines are grammar, never content.
+		return extractAddedLines(input, false);
+	},
 };
 
 interface ApplyPatchArgs {
@@ -430,6 +489,12 @@ const applyPatchStrategy: EditStreamingStrategy<ApplyPatchArgs> = {
 	renderStreamingFallback() {
 		return "";
 	},
+	matcherDigest(args) {
+		const input = args?.input;
+		if (typeof input !== "string") return undefined;
+		// Envelope markers and `@@` hunk headers are grammar, never content.
+		return extractAddedLines(input, false);
+	},
 };
 export const EDIT_MODE_STRATEGIES: Record<EditMode, EditStreamingStrategy<unknown>> = {
 	replace: replaceStrategy as EditStreamingStrategy<unknown>,

package/src/export/ttsr.ts

@@ -339,7 +339,24 @@ export class TtsrManager {
 		const bufferKey = this.#bufferKey(context);
 		const nextBuffer = `${this.#buffers.get(bufferKey) ?? ""}${delta}`;
 		this.#buffers.set(bufferKey, nextBuffer);
+		return this.#matchBuffer(nextBuffer, context);
+	}
+
+	/**
+	 * Replace the scoped buffer with a tool-provided normalized snapshot and
+	 * return matching rules.
+	 *
+	 * Used for tools exposing `matcherDigest`: the digest is recomputed from the
+	 * full (partial) arguments on every delta, so it replaces the buffer instead
+	 * of being appended to it.
+	 */
+	checkSnapshot(snapshot: string, context: TtsrMatchContext): Rule[] {
+		const bufferKey = this.#bufferKey(context);
+		this.#buffers.set(bufferKey, snapshot);
+		return this.#matchBuffer(snapshot, context);
+	}
 
+	#matchBuffer(buffer: string, context: TtsrMatchContext): Rule[] {
 		const matches: Rule[] = [];
 		for (const [name, entry] of this.#rules) {
 			if (!this.#canTrigger(name)) {
@@ -351,7 +368,7 @@ export class TtsrManager {
 			if (!this.#matchesGlobalPaths(entry, context)) {
 				continue;
 			}
-			if (!this.#matchesCondition(entry, nextBuffer)) {
+			if (!this.#matchesCondition(entry, buffer)) {
 				continue;
 			}