@oh-my-pi/pi-coding-agent 15.1.6 → 15.1.8

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## [Unreleased]
 
+## [15.1.8] - 2026-05-20
+
+### Fixed
+
+- Fixed streaming edit previews for `apply_patch` and `hashline` jittering as the model typed `+added` lines. Two root causes addressed: (1) the trailing partial line of the streaming text input is now trimmed at each tick so a half-typed `+added` line no longer flickers; (2) the preview is rendered in the model's input order during streaming instead of re-deriving a unified diff via `Diff.structuredPatch`, whose coalescing previously reshuffled existing `+added` lines downward each time a new `-removed` line arrived. Existing additions now stay put and the preview only grows at the bottom while streaming. A residual trailing `-removed`/hunk-header block whose matching `+added` companion has not yet arrived is also suppressed until the additions land.
+- Fixed Perplexity web search appearing "logged out" roughly an hour after `omp auth login perplexity`. The search provider's `findOAuthToken` was honoring the bogus `expires = login_time + 1h` written by older logins (Perplexity JWTs typically omit `exp` because sessions are server-side) and silently dropping the credential. The loader now decodes the JWT's `exp` claim directly and only skips when the JWT itself is expired; tokens without an `exp` claim are treated as non-expiring.
+
+## [15.1.7] - 2026-05-19
+
+### Fixed
+
+- Fixed `debug` launch/attach failures so `configurationDone` no longer masks the underlying DAP launch error, early stop-outcome watchers cannot emit unhandled rejections, and directory-valued launch programs are rejected before adapter selection. ([#1187](https://github.com/can1357/oh-my-pi/issues/1187))
+- Fixed hashline edit payloads that use a readability space after `~` by warning on separator-padding-shaped payload blocks and tightening the model prompt. ([#1166](https://github.com/can1357/oh-my-pi/issues/1166))
+- Fixed ACP bash permission requests to include execute tool metadata and command content so clients can render command approval prompts consistently. ([#1189](https://github.com/can1357/oh-my-pi/issues/1189))
+- Fixed the status-line fast-mode indicator (`⚡`) rendering for scoped service tiers (`openai-only`, `claude-only`) even when the active model's provider didn't realize them — e.g. `serviceTier: "openai-only"` would still show the indicator next to a Claude model the wire request couldn't apply fast mode to. The indicator now consults a new `AgentSession.isFastModeActive()` predicate that runs the configured tier through `resolveServiceTier(tier, model.provider)` and only lights up when the result is `"priority"` for the current model. `isFastModeEnabled()` keeps its scope-aware semantics so `/fast on|off|toggle` and `/fast status` continue to reflect the user's configured intent.
+
+### Added
+
+- Added scoped service tier values to the `serviceTier` setting: `priority (OpenAI only)` and `priority (Claude only)`. They let you opt into premium processing on one provider family without paying premium costs on the other when switching models mid-session. `/fast on` continues to set the unscoped `"priority"` (active everywhere supported); `/fast status` and `isFastModeEnabled()` now report `on` for any scoped value too.
+
+### Changed
+
+- Changed `/fast` to be a single provider-agnostic toggle: enabling the command sets `serviceTier: "priority"` for every provider, and the anthropic-messages provider translates `priority` into `speed: "fast"` plus the `fast-mode-2026-02-01` beta. Anthropic fast mode is currently supported on Claude Opus 4.6 and 4.7; the server rejects other models, which triggers the provider's auto-fallback (request retried without the priority signal, `providerSessionState.fastModeDisabled` persisted for the rest of the session). The session listens for the `"priority"` marker in `AssistantMessage.disabledFeatures`, syncs `/fast` off, and emits a warning notice. Re-running `/fast on` clears the per-session disable so the next request actually re-tries priority.
+
 ## [15.1.6] - 2026-05-19
 
 ### Fixed

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

@@ -884,12 +884,12 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly serviceTier: {
         readonly type: "enum";
-        readonly values: readonly ["none", "auto", "default", "flex", "scale", "priority"];
+        readonly values: readonly ["none", "auto", "default", "flex", "scale", "priority", "openai-only", "claude-only"];
         readonly default: "none";
         readonly ui: {
             readonly tab: "model";
             readonly label: "Service Tier";
-            readonly description: "OpenAI processing priority (none = omit parameter)";
+            readonly description: 'Processing priority hint (none = omit). OpenAI accepts the tier values directly; Anthropic realizes `priority` as `speed: "fast"` on supported Opus models. Scoped values target one family.';
             readonly options: readonly [{
                 readonly value: "none";
                 readonly label: "None";
@@ -897,23 +897,31 @@ export declare const SETTINGS_SCHEMA: {
             }, {
                 readonly value: "auto";
                 readonly label: "Auto";
-                readonly description: "Use provider default tier selection";
+                readonly description: "Use provider default tier selection (OpenAI)";
             }, {
                 readonly value: "default";
                 readonly label: "Default";
-                readonly description: "Standard priority processing";
+                readonly description: "Standard priority processing (OpenAI)";
             }, {
                 readonly value: "flex";
                 readonly label: "Flex";
-                readonly description: "Use flexible capacity tier when available";
+                readonly description: "Flexible capacity tier when available (OpenAI)";
             }, {
                 readonly value: "scale";
                 readonly label: "Scale";
-                readonly description: "Use Scale Tier credits when available";
+                readonly description: "Scale Tier credits when available (OpenAI)";
             }, {
                 readonly value: "priority";
                 readonly label: "Priority";
-                readonly description: "Use Priority processing";
+                readonly description: "Priority on every supported provider (OpenAI `service_tier`, Anthropic fast mode)";
+            }, {
+                readonly value: "openai-only";
+                readonly label: "Priority (OpenAI only)";
+                readonly description: "Priority on OpenAI/OpenAI-Codex requests; ignored elsewhere";
+            }, {
+                readonly value: "claude-only";
+                readonly label: "Priority (Claude only)";
+                readonly description: "Anthropic fast mode on direct Claude requests; ignored elsewhere (incl. Bedrock/Vertex)";
             }];
         };
     };

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

@@ -26,6 +26,13 @@ export interface StreamingDiffContext {
     fuzzyThreshold?: number;
     allowFuzzy?: boolean;
     hashlineAutoDropPureInsertDuplicates?: boolean;
+    /**
+     * True while the tool's arguments are still streaming in. Strategies that
+     * accept free-form text input (apply_patch, hashline) trim the trailing
+     * partial line so per-character growth of an in-flight `+added` line does
+     * not flicker in the preview.
+     */
+    isStreaming?: boolean;
 }
 export interface EditStreamingStrategy<Args = unknown> {
     /**

package/dist/types/hashline/hash.d.ts

@@ -111,10 +111,10 @@ export declare const HL_BODY_SEP = "|";
 export declare const HL_BODY_SEP_RE_RAW: string;
 /**
  * Compute a 2-character hash of a single line via xxHash32 mod 647 over
- * {@link HL_BIGRAMS}. Lines with no letter or digit mix the line number
- * into the seed so adjacent identical punctuation-only lines (e.g. brace-only
- * lines) get distinct hashes; lines with significant content stay
- * line-number-independent so a line is identifiable across small shifts.
+ * {@link HL_BIGRAMS}. The hash depends only on the line's content (after
+ * stripping CR and trailing whitespace); the `idx` parameter is accepted
+ * for call-site symmetry with line numbers but is intentionally unused so
+ * that anchors remain stable across line shifts caused by sibling edits.
  *
  * The line input should not include a trailing newline.
  */

package/dist/types/hashline/recovery.d.ts

@@ -18,5 +18,10 @@ export interface HashlineRecoveryResult {
  * onto the current on-disk content. Returns `null` when no recovery is
  * possible — callers should propagate the original mismatch error in that
  * case.
+ *
+ * Recovery is gated on a strict precondition: every line the model anchored
+ * MUST be present in the cached snapshot AND its content MUST hash to the
+ * model-supplied hash. This prevents 3-way merges from silently sliding onto
+ * the wrong site when only tangential parts of the file went stale.
  */
 export declare function tryRecoverHashlineWithCache(args: HashlineRecoveryArgs): HashlineRecoveryResult | null;

package/dist/types/lsp/edits.d.ts

@@ -1,9 +1,16 @@
-import type { TextEdit, WorkspaceEdit } from "./types";
+import type { Range, TextEdit, WorkspaceEdit } from "./types";
 /**
  * Apply text edits to a string in-memory.
  * Edits are applied in reverse order (bottom-to-top) to preserve line/character indices.
  */
 export declare function applyTextEditsToString(content: string, edits: TextEdit[]): string;
+/** True when two ranges overlap (share any position other than a touching boundary). */
+export declare function rangesOverlap(a: Range, b: Range): boolean;
+/**
+ * Flatten a WorkspaceEdit's text edits into a Map<uri, TextEdit[]>.
+ * Resource operations (create/rename/delete) are ignored — callers handle them separately.
+ */
+export declare function flattenWorkspaceTextEdits(edit: WorkspaceEdit): Map<string, TextEdit[]>;
 /**
  * Apply text edits to a file.
  * Edits are applied in reverse order (bottom-to-top) to preserve line/character indices.

package/dist/types/session/agent-session.d.ts

@@ -618,7 +618,23 @@ export declare class AgentSession {
      * @returns New level, or undefined if model doesn't support thinking
      */
     cycleThinkingLevel(): ThinkingLevel | undefined;
+    /**
+     * True when *any* fast-mode-granting service tier is configured, regardless
+     * of whether the active model's provider actually realizes it. Used by the
+     * toggle (`/fast on|off`) so re-toggling a scoped tier (`openai-only`,
+     * `claude-only`) doesn't silently broaden it to unscoped `priority`.
+     *
+     * For "is fast mode actually applied to the next request?" use
+     * {@link isFastModeActive} instead — that one respects the model's provider.
+     */
     isFastModeEnabled(): boolean;
+    /**
+     * True when the configured `serviceTier` resolves to `"priority"` for the
+     * *currently selected model's provider*. Returns false for scoped tiers
+     * that don't match (e.g. `"openai-only"` on an anthropic model) and when
+     * no model is selected.
+     */
+    isFastModeActive(): boolean;
     setServiceTier(serviceTier: ServiceTier | undefined): void;
     setFastMode(enabled: boolean): void;
     toggleFastMode(): boolean;

package/dist/types/session/client-bridge.d.ts

@@ -25,6 +25,7 @@ export interface ClientBridgePermissionToolCall {
     kind?: string;
     status?: "pending" | "in_progress" | "completed" | "failed";
     rawInput?: unknown;
+    content?: unknown[];
     locations?: {
         path: string;
         line?: number;

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

@@ -9,7 +9,9 @@ import { type OutputMeta } from "./output-meta";
 declare const findSchema: z.ZodObject<{
     paths: z.ZodArray<z.ZodString>;
     hidden: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    gitignore: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
 }, z.core.$strict>;
 export type FindToolInput = z.infer<typeof findSchema>;
 export interface FindToolDetails {
@@ -62,7 +64,9 @@ export declare class FindTool implements AgentTool<typeof findSchema, FindToolDe
     readonly parameters: z.ZodObject<{
         paths: z.ZodArray<z.ZodString>;
         hidden: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        gitignore: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     }, z.core.$strict>;
     readonly strict = true;
     constructor(session: ToolSession, options?: FindToolOptions);

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

@@ -49,6 +49,11 @@ export declare function runResolveInvocation(params: ResolveParams, options: {
     label: string;
     apply(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown>>;
     reject?(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown> | undefined>;
+    /** Invoked synchronously when `apply()` throws, before the error is rethrown.
+     *  The queued caller uses this to re-push the resolve directive so the
+     *  pending preview survives a failed apply (e.g. overlapping ast_edit
+     *  replacements) and the model can `discard` or fix-and-retry. */
+    onApplyError?(error: unknown): void;
 }): Promise<AgentToolResult<ResolveToolDetails>>;
 export declare class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolDetails> {
     private readonly session;

package/dist/types/tools/tool-timeouts.d.ts

@@ -20,7 +20,7 @@ export declare const TOOL_TIMEOUTS: {
     readonly browser: {
         readonly default: 30;
         readonly min: 1;
-        readonly max: 30;
+        readonly max: 300;
     };
     readonly ssh: {
         readonly default: 60;

package/package.json

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

package/src/config/settings-schema.ts

@@ -755,19 +755,34 @@ export const SETTINGS_SCHEMA = {
 
 	serviceTier: {
 		type: "enum",
-		values: ["none", "auto", "default", "flex", "scale", "priority"] as const,
+		values: ["none", "auto", "default", "flex", "scale", "priority", "openai-only", "claude-only"] as const,
 		default: "none",
 		ui: {
 			tab: "model",
 			label: "Service Tier",
-			description: "OpenAI processing priority (none = omit parameter)",
+			description:
+				'Processing priority hint (none = omit). OpenAI accepts the tier values directly; Anthropic realizes `priority` as `speed: "fast"` on supported Opus models. Scoped values target one family.',
 			options: [
 				{ value: "none", label: "None", description: "Omit service_tier parameter" },
-				{ value: "auto", label: "Auto", description: "Use provider default tier selection" },
-				{ value: "default", label: "Default", description: "Standard priority processing" },
-				{ value: "flex", label: "Flex", description: "Use flexible capacity tier when available" },
-				{ value: "scale", label: "Scale", description: "Use Scale Tier credits when available" },
-				{ value: "priority", label: "Priority", description: "Use Priority processing" },
+				{ value: "auto", label: "Auto", description: "Use provider default tier selection (OpenAI)" },
+				{ value: "default", label: "Default", description: "Standard priority processing (OpenAI)" },
+				{ value: "flex", label: "Flex", description: "Flexible capacity tier when available (OpenAI)" },
+				{ value: "scale", label: "Scale", description: "Scale Tier credits when available (OpenAI)" },
+				{
+					value: "priority",
+					label: "Priority",
+					description: "Priority on every supported provider (OpenAI `service_tier`, Anthropic fast mode)",
+				},
+				{
+					value: "openai-only",
+					label: "Priority (OpenAI only)",
+					description: "Priority on OpenAI/OpenAI-Codex requests; ignored elsewhere",
+				},
+				{
+					value: "claude-only",
+					label: "Priority (Claude only)",
+					description: "Anthropic fast mode on direct Claude requests; ignored elsewhere (incl. Bedrock/Vertex)",
+				},
 			],
 		},
 	},

package/src/dap/session.ts

@@ -105,6 +105,41 @@ function toErrorMessage(value: unknown): string {
 	return String(value);
 }
 
+interface DapStartRequestFailure {
+	rejected: boolean;
+	error?: unknown;
+}
+
+function trackDapStartRequest<T>(promise: Promise<T>, failure: DapStartRequestFailure): Promise<T> {
+	return promise.catch(error => {
+		failure.rejected = true;
+		failure.error = error;
+		throw error;
+	});
+}
+
+function combineDapStartErrors(command: "launch" | "attach", startError: unknown, configurationError: unknown): Error {
+	const startMessage = toErrorMessage(startError);
+	const configurationMessage = toErrorMessage(configurationError);
+	if (startMessage === configurationMessage) {
+		return startError instanceof Error ? startError : new Error(startMessage);
+	}
+	return new Error(
+		`DAP ${command} failed: ${startMessage}\nDAP configurationDone also failed: ${configurationMessage}`,
+	);
+}
+
+async function throwPreferredDapStartError(
+	command: "launch" | "attach",
+	startFailure: DapStartRequestFailure,
+	configurationError: unknown,
+): Promise<never> {
+	await Promise.resolve();
+	if (startFailure.rejected) {
+		throw combineDapStartErrors(command, startFailure.error, configurationError);
+	}
+	throw configurationError;
+}
 function normalizePath(filePath: string): string {
 	return path.resolve(filePath);
 }
@@ -209,12 +244,20 @@ export class DapSessionManager {
 			// DAP spec: many adapters do not respond to launch until after
 			// configurationDone. Fire launch, complete the config handshake,
 			// then await the launch response.
-			const launchPromise = client.sendRequest("launch", launchArguments, signal, timeoutMs);
+			const launchFailure: DapStartRequestFailure = { rejected: false };
+			const launchPromise = trackDapStartRequest(
+				client.sendRequest("launch", launchArguments, signal, timeoutMs),
+				launchFailure,
+			);
 			// Mark handled so a fast error response doesn't become an unhandled
 			// rejection while we await the config handshake. The actual error
 			// still propagates when we await launchPromise below.
 			launchPromise.catch(() => {});
-			await this.#completeConfigurationHandshake(session, signal, timeoutMs);
+			try {
+				await this.#completeConfigurationHandshake(session, signal, timeoutMs);
+			} catch (error) {
+				await throwPreferredDapStartError("launch", launchFailure, error);
+			}
 			await launchPromise;
 			// Try to capture initial stopped state (e.g. stopOnEntry).
 			// Timeout is acceptable — the program may simply be running.
@@ -262,9 +305,17 @@ export class DapSessionManager {
 				signal,
 				Math.min(timeoutMs, STOP_CAPTURE_TIMEOUT_MS),
 			);
-			const attachPromise = client.sendRequest("attach", attachArguments, signal, timeoutMs);
+			const attachFailure: DapStartRequestFailure = { rejected: false };
+			const attachPromise = trackDapStartRequest(
+				client.sendRequest("attach", attachArguments, signal, timeoutMs),
+				attachFailure,
+			);
 			attachPromise.catch(() => {});
-			await this.#completeConfigurationHandshake(session, signal, timeoutMs);
+			try {
+				await this.#completeConfigurationHandshake(session, signal, timeoutMs);
+			} catch (error) {
+				await throwPreferredDapStartError("attach", attachFailure, error);
+			}
 			await attachPromise;
 			try {
 				await untilAborted(signal, initialStopPromise);
@@ -1085,7 +1136,9 @@ export class DapSessionManager {
 		for (const p of promises) {
 			p.catch(() => {});
 		}
-		return Promise.race(promises);
+		const outcome = Promise.race(promises);
+		outcome.catch(() => {});
+		return outcome;
 	}
 
 	/**

package/src/edit/modes/patch.ts

@@ -26,6 +26,7 @@ import {
 import { outputMeta } from "../../tools/output-meta";
 import { resolveToCwd } from "../../tools/path-utils";
 import { enforcePlanModeWrite, resolvePlanPath } from "../../tools/plan-mode-guard";
+import { ToolError } from "../../tools/tool-errors";
 import {
 	ApplyPatchError,
 	type DiffHunk,
@@ -1714,6 +1715,24 @@ export async function executePatchSingle(
 
 	await assertEditableFile(resolvedPath, path);
 
+	// Capture pre-edit content so we can verify the write actually hit disk.
+	// `LspFileSystem.writeFile` delegates to a writethrough callback that, in
+	// some host integrations, has been observed to report success without
+	// persisting bytes — leaving the tool to claim "Updated <path>" while the
+	// file on disk is byte-identical to before. After the write we re-read
+	// the file and assert the bytes match the expected newContent; relying
+	// on stat (mtime/size) is unreliable because filesystems with coarse
+	// timestamp resolution can record an unchanged mtime even when the
+	// content was rewritten, and same-length rewrites leave size unchanged.
+	let preEditContent: Uint8Array | undefined;
+	if (op === "update") {
+		try {
+			preEditContent = await fs.promises.readFile(resolvedPath);
+		} catch (err) {
+			if (!isEnoent(err)) throw err;
+		}
+	}
+
 	const input: PatchInput = { path: resolvedPath, op, rename: resolvedRename, diff };
 	const patchFileSystem = new LspFileSystem(writethrough, signal, batchRequest, beginDeferredDiagnosticsForPath);
 	const result = await applyPatch(input, {
@@ -1723,6 +1742,33 @@ export async function executePatchSingle(
 		allowFuzzy,
 	});
 
+	// Post-write verification: only meaningful for in-place updates where the
+	// patch actually changes content and the file is not being renamed away.
+	if (
+		result.change.type === "update" &&
+		!result.change.newPath &&
+		preEditContent !== undefined &&
+		result.change.oldContent !== undefined &&
+		result.change.newContent !== undefined &&
+		result.change.oldContent !== result.change.newContent
+	) {
+		let postEditContent: Uint8Array | undefined;
+		try {
+			postEditContent = await fs.promises.readFile(resolvedPath);
+		} catch (err) {
+			if (!isEnoent(err)) throw err;
+		}
+		const unchanged =
+			postEditContent !== undefined &&
+			postEditContent.length === preEditContent.length &&
+			postEditContent.every((b, i) => b === preEditContent[i]);
+		if (unchanged) {
+			throw new ToolError(`edit appeared successful but file content did not change on disk: ${resolvedPath}`, {
+				path: resolvedPath,
+			});
+		}
+	}
+
 	if (resolvedRename) {
 		invalidateFsScanAfterRename(resolvedPath, resolvedRename);
 	} else if (result.change.type === "delete") {

package/src/edit/streaming.ts

@@ -45,6 +45,13 @@ export interface StreamingDiffContext {
 	fuzzyThreshold?: number;
 	allowFuzzy?: boolean;
 	hashlineAutoDropPureInsertDuplicates?: boolean;
+	/**
+	 * True while the tool's arguments are still streaming in. Strategies that
+	 * accept free-form text input (apply_patch, hashline) trim the trailing
+	 * partial line so per-character growth of an in-flight `+added` line does
+	 * not flicker in the preview.
+	 */
+	isStreaming?: boolean;
 }
 
 export interface EditStreamingStrategy<Args = unknown> {
@@ -274,21 +281,146 @@ interface HashlineArgs {
 	__partialJson?: string;
 }
 
+/**
+ * While streaming a free-form text payload (apply_patch envelope, hashline
+ * input), trim the trailing partial line so per-character growth of an
+ * in-flight `+added` line does not cause the diff preview to flicker. The
+ * full line will show on the next streaming tick once its `\n` arrives.
+ * Returns `text` unchanged when not streaming or when no newline is present.
+ */
+function trimTrailingPartialLine(text: string, isStreaming: boolean | undefined): string {
+	if (!isStreaming) return text;
+	const idx = text.lastIndexOf("\n");
+	if (idx === -1) return "";
+	return text.slice(0, idx + 1);
+}
+
+/**
+ * Build a per-file diff preview directly from a partial `apply_patch`
+ * envelope by emitting its body lines in *input order*. This bypasses the
+ * file-state re-diff (`computePatchDiff` → `Diff.structuredPatch`) whose
+ * coalescing reorders the model's `-old +new -old +new` stream into
+ * `-old -old +new +new` and visibly shifts existing `+added` lines
+ * downward each time a new `-` arrives. The preview therefore grows
+ * monotonically at the bottom while streaming and only becomes a real
+ * unified diff once the args are complete.
+ */
+function buildApplyPatchNaturalOrderPreviews(input: string): PerFileDiffPreview[] | null {
+	const lines = input.split("\n");
+	const groups = new Map<string, string[]>();
+	let currentPath: string | undefined;
+	const ensure = (path: string): string[] => {
+		let bucket = groups.get(path);
+		if (!bucket) {
+			bucket = [];
+			groups.set(path, bucket);
+		}
+		return bucket;
+	};
+	for (const raw of lines) {
+		const trimmedEnd = raw.trimEnd();
+		if (trimmedEnd === BEGIN_PATCH_MARKER || trimmedEnd === END_PATCH_MARKER || trimmedEnd === ABORT_MARKER) {
+			continue;
+		}
+		if (trimmedEnd.startsWith("*** Add File: ")) {
+			currentPath = trimmedEnd.slice("*** Add File: ".length);
+			ensure(currentPath);
+			continue;
+		}
+		if (trimmedEnd.startsWith("*** Delete File: ")) {
+			currentPath = trimmedEnd.slice("*** Delete File: ".length);
+			ensure(currentPath);
+			continue;
+		}
+		if (trimmedEnd.startsWith("*** Update File: ")) {
+			currentPath = trimmedEnd.slice("*** Update File: ".length);
+			ensure(currentPath);
+			continue;
+		}
+		if (trimmedEnd.startsWith("*** Move to:") || trimmedEnd.startsWith("*** End of File")) {
+			continue;
+		}
+		if (!currentPath) continue;
+		// Diff body: keep `-/+/space`-prefixed lines and `@@` hunk headers in
+		// input order. parseDiffLine accepts the no-line-number legacy form so
+		// the renderer styles them as additions/removals/context naturally.
+		if (raw.startsWith("+") || raw.startsWith("-") || raw.startsWith(" ") || raw.startsWith("@@")) {
+			ensure(currentPath).push(raw);
+		}
+	}
+	if (groups.size === 0) return null;
+	const previews: PerFileDiffPreview[] = [];
+	for (const [path, body] of groups) {
+		if (body.length === 0) continue;
+		previews.push({ path, diff: body.join("\n") });
+	}
+	return previews.length > 0 ? previews : null;
+}
+
+/**
+ * Hashline equivalent: emit each section's `~payload` lines as `+added`
+ * lines in the order the model typed them. 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 lines = input.split("\n");
+	const groups = new Map<string, string[]>();
+	let currentPath = defaultPath ?? "";
+	const ensure = (path: string): string[] => {
+		let bucket = groups.get(path);
+		if (!bucket) {
+			bucket = [];
+			groups.set(path, bucket);
+		}
+		return bucket;
+	};
+	for (const raw of lines) {
+		if (isHashlineEnvelopeMarkerLine(raw)) continue;
+		if (isHashlineHeaderLine(raw)) {
+			currentPath = raw.trimEnd().slice(1).trim();
+			if (currentPath) ensure(currentPath);
+			continue;
+		}
+		if (raw.startsWith("~")) {
+			ensure(currentPath).push(`+${raw.slice(1)}`);
+		}
+	}
+	if (groups.size === 0) return null;
+	const previews: PerFileDiffPreview[] = [];
+	for (const [path, body] of groups) {
+		if (body.length === 0) continue;
+		previews.push({ path, diff: body.join("\n") });
+	}
+	return previews.length > 0 ? previews : null;
+}
+
 const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 	extractCompleteEdits(args) {
 		return args;
 	},
 	async computeDiffPreview(args, ctx) {
 		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 the model's `~payload` lines in input order.
+			return buildHashlineNaturalOrderPreviews(input, args.path);
+		}
 		ctx.signal.throwIfAborted();
 
 		let sections: HashlineInputSection[];
 		try {
-			sections = splitHashlineInputs(args.input, { cwd: ctx.cwd, path: args.path });
+			sections = splitHashlineInputs(input, { cwd: ctx.cwd, path: args.path });
 		} catch {
 			// Single-section fallback keeps the original error rendering for the
 			// "haven't typed `@@ PATH` yet" case.
-			const result = await computeHashlineDiff({ input: args.input, path: args.path }, ctx.cwd, {
+			const result = await computeHashlineDiff({ input, path: args.path }, ctx.cwd, {
 				autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
 			});
 			ctx.signal.throwIfAborted();
@@ -340,12 +472,21 @@ const applyPatchStrategy: EditStreamingStrategy<ApplyPatchArgs> = {
 	},
 	async computeDiffPreview(args, ctx) {
 		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) {
+			// Render the envelope's diff body in input order so newly streamed
+			// `+added` lines append at the bottom instead of being shuffled
+			// upward as later `-removed` lines arrive and reorder the unified
+			// diff that `Diff.structuredPatch` would otherwise produce.
+			return buildApplyPatchNaturalOrderPreviews(input);
+		}
 		let entries: ApplyPatchEntry[];
 		try {
-			entries = expandApplyPatchToEntries({ input: args.input });
+			entries = expandApplyPatchToEntries({ input });
 		} catch {
 			try {
-				entries = expandApplyPatchToPreviewEntries({ input: args.input });
+				entries = expandApplyPatchToPreviewEntries({ input });
 			} catch (err) {
 				return [{ path: "", error: err instanceof Error ? err.message : String(err) }];
 			}