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

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [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/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.7",
 	"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.7",
+		"@oh-my-pi/pi-agent-core": "15.1.7",
+		"@oh-my-pi/pi-ai": "15.1.7",
+		"@oh-my-pi/pi-natives": "15.1.7",
+		"@oh-my-pi/pi-tui": "15.1.7",
+		"@oh-my-pi/pi-utils": "15.1.7",
 		"@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/eval/js/context-manager.ts

@@ -52,7 +52,7 @@ interface JsSession {
 }
 
 const sessions = new Map<string, JsSession>();
-const READY_TIMEOUT_MS = 5_000;
+const READY_TIMEOUT_MS_DEFAULT = 5_000;
 
 export async function executeInVmContext(options: {
 	sessionKey: string;
@@ -68,10 +68,11 @@ export async function executeInVmContext(options: {
 	if (options.reset) {
 		await resetVmContext(options.sessionKey);
 	}
-	const session = await acquireSession(options.sessionKey, {
-		cwd: options.cwd,
-		sessionId: options.sessionId,
-	});
+	const session = await acquireSession(
+		options.sessionKey,
+		{ cwd: options.cwd, sessionId: options.sessionId },
+		options.timeoutMs,
+	);
 	return await runQueued(session, () => runOnce(session, options));
 }
 
@@ -158,7 +159,7 @@ async function runOnce(
 	}
 }
 
-async function acquireSession(sessionKey: string, snapshot: SessionSnapshot): Promise<JsSession> {
+async function acquireSession(sessionKey: string, snapshot: SessionSnapshot, timeoutMs?: number): Promise<JsSession> {
 	const existing = sessions.get(sessionKey);
 	if (existing && existing.state === "alive") return existing;
 
@@ -186,7 +187,10 @@ async function acquireSession(sessionKey: string, snapshot: SessionSnapshot): Pr
 		handleSessionMessage(session, msg);
 	});
 	try {
-		await raceWithTimeout(readyPromise, READY_TIMEOUT_MS, "Timed out initializing JS eval worker");
+		// Cold-start can exceed 5s on slow hosts. Let the caller's per-cell timeout dominate so
+		// users can grant more headroom when they raise `timeout` on a cell.
+		const readyTimeoutMs = Math.max(READY_TIMEOUT_MS_DEFAULT, timeoutMs ?? 0);
+		await raceWithTimeout(readyPromise, readyTimeoutMs, "Timed out initializing JS eval worker");
 	} catch (error) {
 		unsubscribe();
 		await worker.terminate().catch(() => undefined);

package/src/eval/js/shared/rewrite-imports.ts

@@ -303,15 +303,27 @@ function returnFinalExpression(code: string): { source: string; returned: boolea
 	let lastIndex = body.length - 1;
 	while (lastIndex >= 0 && body[lastIndex]?.type === "EmptyStatement") lastIndex--;
 	const last = lastIndex >= 0 ? body[lastIndex] : undefined;
-	if (last?.type !== "ExpressionStatement") return { source: code, returned: false };
-
-	const expression = last as BabelExpressionStatement;
-	const prefix = code.slice(0, expression.start);
-	const statement = code.slice(expression.start, expression.end);
-	const suffix = code.slice(expression.end);
-	const semicolonMatch = statement.match(/;\s*$/);
-	const trimmedStatement = semicolonMatch ? statement.slice(0, semicolonMatch.index) : statement;
-	return { source: `${prefix}__omp_set_final_expr__((${trimmedStatement}));${suffix}`, returned: true };
+	if (last?.type === "ExpressionStatement") {
+		const expression = last as BabelExpressionStatement;
+		const prefix = code.slice(0, expression.start);
+		const statement = code.slice(expression.start, expression.end);
+		const suffix = code.slice(expression.end);
+		const semicolonMatch = statement.match(/;\s*$/);
+		const trimmedStatement = semicolonMatch ? statement.slice(0, semicolonMatch.index) : statement;
+		return { source: `${prefix}__omp_set_final_expr__((${trimmedStatement}));${suffix}`, returned: true };
+	}
+	if (last?.type === "ReturnStatement") {
+		// Top-level `return value;` is otherwise swallowed: it forces the cell into an async IIFE
+		// wrapper that discards the returned value. Rewrite into `__omp_set_final_expr__((expr))`
+		// so the runtime can surface the value to the caller just like a trailing expression.
+		const ret = last as unknown as { start: number; end: number; argument?: { start: number; end: number } | null };
+		if (!ret.argument) return { source: code, returned: false };
+		const prefix = code.slice(0, ret.start);
+		const suffix = code.slice(ret.end);
+		const expr = code.slice(ret.argument.start, ret.argument.end);
+		return { source: `${prefix}__omp_set_final_expr__((${expr}));${suffix}`, returned: true };
+	}
+	return { source: code, returned: false };
 }
 
 function isExecutionBoundary(type: string): boolean {

package/src/eval/js/shared/runtime.ts

@@ -165,7 +165,8 @@ export class JsRuntime {
 				const finalValue = this.#finalExpressionValue;
 				this.#finalExpressionSet = false;
 				this.#finalExpressionValue = undefined;
-				return await awaitMaybePromise(finalValue);
+				const resolved = await awaitMaybePromise(finalValue);
+				return resolved;
 			}
 			return awaited;
 		}

package/src/hashline/hash.ts

@@ -136,21 +136,24 @@ export const HL_BODY_SEP = "|";
 /** Regex-escaped form of {@link HL_BODY_SEP}, safe for embedding inside a regex. */
 export const HL_BODY_SEP_RE_RAW = regexEscape(HL_BODY_SEP);
 
-const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
-
 /**
  * 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.
  */
 export function computeLineHash(idx: number, line: string): string {
+	void idx;
 	line = line.replace(/\r/g, "").trimEnd();
-	const seed = RE_SIGNIFICANT.test(line) ? 0 : idx;
-	return HL_BIGRAMS[Bun.hash.xxHash32(line, seed) % HL_BIGRAMS_COUNT];
+	// Seed is fixed so the hash depends only on line content. Earlier we mixed
+	// in `idx` for blank/punctuation-only lines, but that meant any line shift
+	// (e.g. from a sibling edit in the same batch) invalidated anchors whose
+	// content had not changed. Identical blank lines are intentionally allowed
+	// to collide — the edit op's line number disambiguates them.
+	return HL_BIGRAMS[Bun.hash.xxHash32(line, 0) % HL_BIGRAMS_COUNT];
 }
 
 /**

package/src/hashline/parser.ts

@@ -74,19 +74,29 @@ export function cloneCursor(cursor: HashlineCursor): HashlineCursor {
 	if (cursor.kind === "after_anchor") return { kind: "after_anchor", anchor: { ...cursor.anchor } };
 	return cursor;
 }
+/** Returns true when every non-empty payload line starts with `${sep} ` (sep + one space). */
+function hasUniformSeparatorPadding(payload: string[]): boolean {
+	let any = false;
+	for (const text of payload) {
+		if (text.length === 0) continue;
+		if (!text.startsWith(" ")) return false;
+		any = true;
+	}
+	return any;
+}
 
 function collectPayload(
 	lines: string[],
 	startIndex: number,
 	opLineNum: number,
 	requirePayload: boolean,
-): { payload: string[]; nextIndex: number } {
+): { payload: string[]; nextIndex: number; paddingWarning?: string } {
 	const payload: string[] = [];
 	let index = startIndex;
 	while (index < lines.length) {
 		const line = lines[index];
 		if (line.startsWith(HL_EDIT_SEP)) {
-			payload.push(line.slice(1).trimEnd());
+			payload.push(line.slice(HL_EDIT_SEP.length).trimEnd());
 			index++;
 			continue;
 		}
@@ -115,7 +125,11 @@ function collectPayload(
 	if (payload.length === 0 && requirePayload) {
 		throw new Error(`line ${opLineNum}: + and < operations require at least one ${HL_EDIT_SEP}TEXT payload line.`);
 	}
-	return { payload, nextIndex: index };
+	const paddingWarning = hasUniformSeparatorPadding(payload)
+		? `line ${opLineNum}: all payload lines start with "${HL_EDIT_SEP} " (separator + space). ` +
+			`The space becomes file content. Remove it unless the target file requires leading spaces.`
+		: undefined;
+	return { payload, nextIndex: index, paddingWarning };
 }
 
 export function parseHashline(diff: string): HashlineEdit[] {
@@ -158,7 +172,8 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 		const insertBeforeMatch = INSERT_BEFORE_OP_RE.exec(line);
 		if (insertBeforeMatch) {
 			const cursor = parseInsertTarget(insertBeforeMatch[1], lineNum, "before");
-			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, true);
+			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, true);
+			if (paddingWarning) warnings.push(paddingWarning);
 			for (const text of payload) pushInsert(cursor, text, lineNum);
 			i = nextIndex;
 			continue;
@@ -167,7 +182,8 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 		const insertAfterMatch = INSERT_AFTER_OP_RE.exec(line);
 		if (insertAfterMatch) {
 			const cursor = parseInsertTarget(insertAfterMatch[1], lineNum, "after");
-			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, true);
+			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, true);
+			if (paddingWarning) warnings.push(paddingWarning);
 			for (const text of payload) pushInsert(cursor, text, lineNum);
 			i = nextIndex;
 			continue;
@@ -185,7 +201,8 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 		const replaceMatch = REPLACE_OP_RE.exec(line);
 		if (replaceMatch) {
 			const range = parseRange(replaceMatch[1], lineNum);
-			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, false);
+			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, false);
+			if (paddingWarning) warnings.push(paddingWarning);
 			// `= A..B` with no payload blanks the range to a single empty line.
 			const replacement = payload.length === 0 ? [""] : payload;
 			for (const text of replacement) {