@oh-my-pi/pi-coding-agent 14.5.0 → 14.5.2

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## [Unreleased]
 
+## [14.5.2] - 2026-04-26
+### Breaking Changes
+
+- Removed support for sed-style string expressions and required `sed` to be specified as an object with `pat` and `rep` (and optional `g`, `F`, `i` flags)
+
+### Changed
+
+- Changed atom `sed` replacements to be global by default and require `g:false` for first-match-only replacements
+- Changed anchor validation so multiple `sed` operations can target the same line and run sequentially
+- Changed cross-entry conflict resolution so `del` edits on an anchor are ignored when that line is also replaced by `sed` or `splice` in another edit entry
+
+### Fixed
+
+- Fixed zero-length regex `sed` patterns (for example `()`, `^`, `$`) to fall back to literal substring matching instead of producing insertion-like replacements
+- Fixed `sed` chaining so each edit on the same anchor applies to the latest line state from prior replacements
+
+## [14.5.1] - 2026-04-26
+
+### Removed
+
+- Removed `\t` escaped-tab indentation autocorrect from hashline and atom edit modes (and the `PI_HASHLINE_AUTOCORRECT_ESCAPED_TABS` environment toggle); literal `\t` in edit content is now preserved verbatim
+- Removed the suspicious-`\uDDDD` warning preflight from hashline edits
+- Removed the hand-rolled JSON unescape fallback in the streaming edit-arg renderer; partial fragments that fail `JSON.parse` are now surfaced raw rather than partially decoded with a non-spec-compliant unescaper that mishandled lone surrogates
+
 ## [14.4.3] - 2026-04-26
 ### Added
 
@@ -754,6 +778,7 @@
 - Fixed PR checkout tool to resolve symlinks in worktree paths, ensuring consistent path references in results and metadata
 - Fixed `read` output for file-backed internal URLs like `local://...` to include hashline prefixes in hashline edit mode, preserving usable line refs for follow-up edits
 - Fixed the plan review selector to support the external editor shortcut for opening and updating the current plan from the approval screen
+- Fixed status line dropping git branch name when path is long by shrinking the path segment before dropping other segments
 
 ## [13.18.0] - 2026-04-02
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "14.5.0",
+	"version": "14.5.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -46,12 +46,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.20.0",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "14.5.0",
-		"@oh-my-pi/pi-agent-core": "14.5.0",
-		"@oh-my-pi/pi-ai": "14.5.0",
-		"@oh-my-pi/pi-natives": "14.5.0",
-		"@oh-my-pi/pi-tui": "14.5.0",
-		"@oh-my-pi/pi-utils": "14.5.0",
+		"@oh-my-pi/omp-stats": "14.5.2",
+		"@oh-my-pi/pi-agent-core": "14.5.2",
+		"@oh-my-pi/pi-ai": "14.5.2",
+		"@oh-my-pi/pi-natives": "14.5.2",
+		"@oh-my-pi/pi-tui": "14.5.2",
+		"@oh-my-pi/pi-utils": "14.5.2",
 		"@puppeteer/browsers": "^2.13.0",
 		"@sinclair/typebox": "^0.34.49",
 		"@xterm/headless": "^6.0.0",
@@ -69,7 +69,7 @@
 		"zod": "4.3.6"
 	},
 	"devDependencies": {
-		"@types/bun": "^1.3.13",
+		"@types/bun": "^1.3",
 		"@types/turndown": "5.0.6"
 	},
 	"engines": {

package/src/edit/modes/atom.ts

@@ -12,7 +12,7 @@
  *   { path, loc: "5th",      pre: [...], splice: [...], post: [...] }
  *   { path, loc: "$",        pre:  [...] }                            // prepend to file
  *   { path, loc: "$",        post: [...] }                            // append to file
- *   { path, loc: "$",        sed:  "s/foo/bar/" }                    // sed on every line
+ *   { path, loc: "$",        sed:  { pat, rep, g?, F? } }                 // sed on every line
  *
  * `splice: []` on a single-anchor locator deletes that line. `splice:[""]` preserves
  * a blank line. Line ranges are not supported.
@@ -66,10 +66,17 @@ export const atomEditSchema = Type.Object(
 		pre: Type.Optional(textSchema),
 		post: Type.Optional(textSchema),
 		sed: Type.Optional(
-			Type.String({
-				description: "sed-style substitution applied to the anchored line",
-				examples: ["s/foo/bar/", "s|api|API|g", "s/<pat>/<rep>/F"],
-			}),
+			Type.Object(
+				{
+					pat: Type.String({ description: "pattern to find" }),
+					rep: Type.String({ description: "replacement text" }),
+					g: Type.Optional(Type.Boolean({ description: "global replace", default: false })),
+					F: Type.Optional(Type.Boolean({ description: "literal replace", default: false })),
+				},
+				{
+					additionalProperties: false,
+				},
+			),
 		),
 	},
 	{ additionalProperties: false },
@@ -104,7 +111,6 @@ export interface SedSpec {
 	pattern: string;
 	replacement: string;
 	global: boolean;
-	ignoreCase: boolean;
 	literal: boolean;
 }
 
@@ -258,70 +264,46 @@ function extractAnchorContentHint(raw: string): string | undefined {
 	return hint;
 }
 
-function parseSedExpression(raw: string, editIndex: number): SedSpec {
-	if (typeof raw !== "string" || raw.length < 3) {
-		throw new Error(
-			`Edit ${editIndex}: sed expression must start with "s" followed by a delimiter, e.g. "s/foo/bar/".`,
-		);
+function parseSedSpec(input: unknown, editIndex: number): SedSpec {
+	if (input === null || typeof input !== "object" || Array.isArray(input)) {
+		throw new Error(`Edit ${editIndex}: sed must be an object with shape {pat, rep, g?, F?}.`);
 	}
-	// Tolerate a missing leading `s`: models occasionally emit `/foo/bar/` directly.
-	// As long as the first character is a valid delimiter, treat the expression as
-	// if `s` was prepended.
-	let bodyStart = 0;
-	if (raw[0] === "s") {
-		bodyStart = 1;
+	const obj = input as Record<string, unknown>;
+	const pat = obj.pat;
+	const rep = obj.rep;
+	if (typeof pat !== "string" || pat.length === 0) {
+		throw new Error(`Edit ${editIndex}: sed.pat must be a non-empty string.`);
 	}
-	const delim = raw[bodyStart]!;
-	if (/[\sA-Za-z0-9\\]/.test(delim)) {
+	if (pat.includes("\n")) {
 		throw new Error(
-			`Edit ${editIndex}: sed delimiter must be a non-alphanumeric, non-whitespace, non-backslash character (got ${JSON.stringify(delim)}).`,
+			`Edit ${editIndex}: sed.pat must be a single line; contains a newline. Use \`splice\` to replace multiple lines, anchoring the first changed line and listing replacement lines in the array.`,
 		);
 	}
-	const parts: [string, string] = ["", ""];
-	let bucket: 0 | 1 = 0;
-	let i = bodyStart + 1;
-	while (i < raw.length) {
-		const c = raw[i]!;
-		if (c === "\\" && raw[i + 1] === delim) {
-			parts[bucket] += delim;
-			i += 2;
-			continue;
-		}
-		if (c === delim) {
-			if (bucket === 0) {
-				bucket = 1;
-				i += 1;
-				continue;
-			}
-			i += 1;
-			break;
-		}
-		parts[bucket] += c;
-		i += 1;
-	}
-	if (bucket !== 1) {
-		throw new Error(
-			`Edit ${editIndex}: malformed sed expression ${JSON.stringify(raw)}. Expected three ${JSON.stringify(delim)} separators.`,
-		);
+	if (typeof rep !== "string") {
+		throw new Error(`Edit ${editIndex}: sed.rep must be a string.`);
 	}
-	const flagsStr = raw.slice(i);
-	let global = false;
-	let ignoreCase = false;
-	let literal = false;
-	for (const f of flagsStr) {
-		if (f === "g") global = true;
-		else if (f === "i") ignoreCase = true;
-		else if (f === "F") literal = true;
-		else {
-			throw new Error(
-				`Edit ${editIndex}: unknown sed flag ${JSON.stringify(f)}. Supported flags: g (all), i (case-insensitive), F (literal).`,
-			);
+	const readBool = (key: "g" | "F", defaultValue: boolean): boolean => {
+		const v = obj[key];
+		if (v === undefined) return defaultValue;
+		if (typeof v !== "boolean") {
+			throw new Error(`Edit ${editIndex}: sed.${key} must be a boolean when provided.`);
 		}
-	}
-	if (parts[0] === "") {
-		throw new Error(`Edit ${editIndex}: sed expression has empty pattern.`);
-	}
-	return { pattern: parts[0], replacement: parts[1], global, ignoreCase, literal };
+		return v;
+	};
+	const global = readBool("g", false);
+	const literal = readBool("F", false);
+	return { pattern: pat, replacement: rep, global, literal };
+}
+
+function formatSedExpression(spec: SedSpec): string {
+	const obj: { pat: string; rep: string; g?: boolean; F?: boolean } = {
+		pat: spec.pattern,
+		rep: spec.replacement,
+	};
+	// Only emit non-default flags so error messages stay compact (g defaults false).
+	if (spec.global) obj.g = true;
+	if (spec.literal) obj.F = true;
+	return JSON.stringify(obj);
 }
 
 function applyLiteralSed(currentLine: string, spec: SedSpec): { result: string; matched: boolean } {
@@ -345,7 +327,6 @@ function applySedToLine(
 	}
 	let flags = "";
 	if (spec.global) flags += "g";
-	if (spec.ignoreCase) flags += "i";
 	let re: RegExp | undefined;
 	let compileError: string | undefined;
 	try {
@@ -357,18 +338,13 @@ function applySedToLine(
 		re.lastIndex = 0;
 		const probe = re.exec(currentLine);
 		re.lastIndex = 0;
-		if (probe && probe[0].length === 0) {
-			// Zero-length matches (e.g. `()`, `(?=…)`, `^`, `$`) cause `String.replace`
-			// to insert the replacement at the match position rather than substitute,
-			// which is almost never what models intend. Reject with a pointer to the
-			// dedicated insertion verbs.
-			return {
-				result: currentLine,
-				matched: false,
-				error: `pattern ${JSON.stringify(spec.pattern)} matches an empty string; use \`pre\`/\`post\`/\`splice\` to insert or replace whole lines, or use a non-empty pattern`,
-			};
+		// Zero-length matches (e.g. `()`, `(?=…)`, `^`, `$`) cause `String.replace` to
+		// insert the replacement at the match position rather than substitute. When that
+		// happens, fall through to the literal-substring fallback below — the model almost
+		// always meant the pattern literally (`()` is the parens, `^` is a caret, etc.).
+		if (!probe || probe[0].length > 0) {
+			return { result: currentLine.replace(re, spec.replacement), matched: true };
 		}
-		return { result: currentLine.replace(re, spec.replacement), matched: true };
 	}
 	// Fall back to literal substring match. Models frequently send sed patterns
 	// containing unescaped regex metacharacters (parentheses, `?`, `.`) that they
@@ -417,8 +393,8 @@ function resolveAtomToolEdit(edit: AtomToolEdit, editIndex = 0): AtomEdit[] {
 			resolved.push({ op: "append_file", lines: hashlineParseText(entry.post) });
 		}
 		if (entry.sed !== undefined) {
-			const spec = parseSedExpression(entry.sed, editIndex);
-			resolved.push({ op: "sed_file", spec, expression: entry.sed });
+			const spec = parseSedSpec(entry.sed, editIndex);
+			resolved.push({ op: "sed_file", spec, expression: formatSedExpression(spec) });
 		}
 		return resolved;
 	}
@@ -448,8 +424,8 @@ function resolveAtomToolEdit(edit: AtomToolEdit, editIndex = 0): AtomEdit[] {
 		// matching `sed`. The explicit replacement wins; the redundant `sed` would
 		// otherwise trigger a confusing `Conflicting ops` rejection.
 		if (!spliceIsExplicitReplacement) {
-			const spec = parseSedExpression(entry.sed, editIndex);
-			resolved.push({ op: "sed", pos: loc.pos, spec, expression: entry.sed });
+			const spec = parseSedSpec(entry.sed, editIndex);
+			resolved.push({ op: "sed", pos: loc.pos, spec, expression: formatSedExpression(spec) });
 		}
 	}
 	return resolved;
@@ -537,16 +513,18 @@ function validateAtomAnchors(edits: AtomEdit[], fileLines: string[], warnings: s
 }
 
 function validateNoConflictingAnchorOps(edits: AtomEdit[]): void {
-	// For each anchor line, at most one mutating op (splice/del).
-	// `pre`/`post` (insert ops) may coexist with them — they don't mutate the anchor line.
+	// For each anchor line, at most one mutating op (splice/del). Multiple `sed`
+	// ops on the same line are allowed and applied sequentially. `pre`/`post`
+	// (insert ops) may coexist with them — they don't mutate the anchor line.
 	const mutatingPerLine = new Map<number, string>();
 	for (const edit of edits) {
 		if (edit.op !== "splice" && edit.op !== "del" && edit.op !== "sed") continue;
 		const existing = mutatingPerLine.get(edit.pos.line);
 		if (existing) {
+			if (existing === "sed" && edit.op === "sed") continue;
 			throw new Error(
 				`Conflicting ops on anchor line ${edit.pos.line}: \`${existing}\` and \`${edit.op}\`. ` +
-					`At most one of splice/del/sed is allowed per anchor.`,
+					`At most one of splice/del is allowed per anchor.`,
 			);
 		}
 		mutatingPerLine.set(edit.pos.line, edit.op);
@@ -557,31 +535,6 @@ function validateNoConflictingAnchorOps(edits: AtomEdit[]): void {
 // Apply
 // ═══════════════════════════════════════════════════════════════════════════
 
-function maybeAutocorrectEscapedTabIndentation(edits: AtomEdit[], warnings: string[]): void {
-	const enabled = Bun.env.PI_HASHLINE_AUTOCORRECT_ESCAPED_TABS !== "0";
-	if (!enabled) return;
-	for (const edit of edits) {
-		if (edit.op !== "splice" && edit.op !== "pre" && edit.op !== "post") continue;
-		if (edit.lines.length === 0) continue;
-		const hasEscapedTabs = edit.lines.some(line => line.includes("\\t"));
-		if (!hasEscapedTabs) continue;
-		const hasRealTabs = edit.lines.some(line => line.includes("\t"));
-		if (hasRealTabs) continue;
-		let correctedCount = 0;
-		const corrected = edit.lines.map(line =>
-			line.replace(/^((?:\\t)+)/, escaped => {
-				correctedCount += escaped.length / 2;
-				return "\t".repeat(escaped.length / 2);
-			}),
-		);
-		if (correctedCount === 0) continue;
-		edit.lines = corrected;
-		warnings.push(
-			`Auto-corrected escaped tab indentation in edit: converted leading \\t sequence(s) to real tab characters`,
-		);
-	}
-}
-
 export interface AtomNoopEdit {
 	editIndex: number;
 	loc: string;
@@ -611,8 +564,19 @@ export function applyAtomEdits(
 	if (mismatches.length > 0) {
 		throw new HashlineMismatchError(mismatches, fileLines);
 	}
-	validateNoConflictingAnchorOps(edits);
-	maybeAutocorrectEscapedTabIndentation(edits, warnings);
+	// When a `del` and a `sed`/`splice` target the same anchor (across separate edit
+	// entries), the `del` is almost always a hallucinated cleanup the model added on top
+	// of the real replacement. Drop the `del` silently so the replacement wins, matching
+	// the in-entry handling for `splice: []` paired with `sed`.
+	const replacedLines = new Set<number>();
+	for (const e of edits) {
+		if (e.op === "splice" || e.op === "sed") replacedLines.add(e.pos.line);
+	}
+	let effective = edits;
+	if (replacedLines.size > 0) {
+		effective = edits.filter(e => !(e.op === "del" && replacedLines.has(e.pos.line)));
+	}
+	validateNoConflictingAnchorOps(effective);
 
 	const trackFirstChanged = (line: number) => {
 		if (firstChangedLine === undefined || line < firstChangedLine) {
@@ -629,7 +593,7 @@ export function applyAtomEdits(
 	const appendEdits: Indexed<Extract<AtomEdit, { op: "append_file" }>>[] = [];
 	const sedFileEdits: Indexed<Extract<AtomEdit, { op: "sed_file" }>>[] = [];
 	const prependEdits: Indexed<Extract<AtomEdit, { op: "prepend_file" }>>[] = [];
-	edits.forEach((edit, idx) => {
+	effective.forEach((edit, idx) => {
 		if (edit.op === "append_file") appendEdits.push({ edit, idx });
 		else if (edit.op === "prepend_file") prependEdits.push({ edit, idx });
 		else if (edit.op === "sed_file") sedFileEdits.push({ edit, idx });
@@ -685,13 +649,14 @@ export function applyAtomEdits(
 					anchorMutated = true;
 					break;
 				case "sed": {
-					const { result, matched, error, literalFallback } = applySedToLine(currentLine, edit.spec);
+					const input = replacementSet ? (replacement[0] ?? "") : currentLine;
+					const { result, matched, error, literalFallback } = applySedToLine(input, edit.spec);
 					if (error) {
 						throw new Error(`Edit sed expression ${JSON.stringify(edit.expression)} rejected: ${error}`);
 					}
 					if (!matched) {
 						throw new Error(
-							`Edit sed expression ${JSON.stringify(edit.expression)} did not match line ${edit.pos.line}: ${JSON.stringify(currentLine)}`,
+							`Edit sed expression ${JSON.stringify(edit.expression)} did not match line ${edit.pos.line}: ${JSON.stringify(input)}`,
 						);
 					}
 					if (literalFallback) {

package/src/edit/modes/hashline.ts

@@ -681,55 +681,6 @@ export function tryRebaseAnchor(
 	return found;
 }
 
-function isEscapedTabAutocorrectEnabled(): boolean {
-	switch (Bun.env.PI_HASHLINE_AUTOCORRECT_ESCAPED_TABS) {
-		case "0":
-			return false;
-		case "1":
-			return true;
-		default:
-			return true;
-	}
-}
-
-function maybeAutocorrectEscapedTabIndentation(edits: HashlineEdit[], warnings: string[]): void {
-	if (!isEscapedTabAutocorrectEnabled()) return;
-	for (const edit of edits) {
-		if (edit.lines.length === 0) continue;
-		const hasEscapedTabs = edit.lines.some(line => line.includes("\\t"));
-		if (!hasEscapedTabs) continue;
-		const hasRealTabs = edit.lines.some(line => line.includes("\t"));
-		if (hasRealTabs) continue;
-		let correctedCount = 0;
-		const corrected = edit.lines.map(line =>
-			line.replace(/^((?:\\t)+)/, escaped => {
-				correctedCount += escaped.length / 2;
-				return "\t".repeat(escaped.length / 2);
-			}),
-		);
-		if (correctedCount === 0) continue;
-		edit.lines = corrected;
-		warnings.push(
-			`Auto-corrected escaped tab indentation in edit: converted leading \\t sequence(s) to real tab characters`,
-		);
-	}
-}
-
-function maybeWarnSuspiciousUnicodeEscapePlaceholder(edits: HashlineEdit[], warnings: string[]): void {
-	for (const edit of edits) {
-		if (edit.lines.length === 0) continue;
-		if (!edit.lines.some(line => /\\uDDDD/i.test(line))) continue;
-		warnings.push(
-			`Detected literal \\uDDDD in edit content; no autocorrection applied. Verify whether this should be a real Unicode escape or plain text.`,
-		);
-	}
-}
-
-function runHashlinePreflightSanitizers(edits: HashlineEdit[], warnings: string[]): void {
-	maybeAutocorrectEscapedTabIndentation(edits, warnings);
-	maybeWarnSuspiciousUnicodeEscapePlaceholder(edits, warnings);
-}
-
 function ensureHashlineEditHasContent(edit: HashlineEdit): void {
 	if (edit.lines.length === 0) {
 		edit.lines = [""];
@@ -1026,7 +977,6 @@ export function applyHashlineEdits(
 	if (mismatches.length > 0) {
 		throw new HashlineMismatchError(mismatches, fileLines);
 	}
-	runHashlinePreflightSanitizers(edits, warnings);
 	for (const edit of edits) {
 		collectBoundaryDuplicationWarning(edit, originalFileLines, warnings);
 	}

package/src/edit/renderer.ts

@@ -1,6 +1,7 @@
 /**
  * Edit tool renderer and LSP batching helpers.
  */
+import { sanitizeText } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text, visibleWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
@@ -157,32 +158,16 @@ function filePathFromEditEntry(p: string | undefined): string | undefined {
 }
 
 function decodePartialJsonStringFragment(fragment: string): string {
-	let text = fragment;
+	// Trim a trailing partial escape so JSON.parse sees a well-formed string.
+	let text = fragment.replace(/\\u[0-9a-fA-F]{0,3}$/, "");
 	const trailingBackslashes = text.match(/\\+$/)?.[0].length ?? 0;
-	if (trailingBackslashes % 2 === 1) {
-		text = text.slice(0, -1);
-	}
+	if (trailingBackslashes % 2 === 1) text = text.slice(0, -1);
 	try {
 		return JSON.parse(`"${text}"`) as string;
 	} catch {
-		return text
-			.replace(/\\u([0-9a-fA-F]{4})/g, (_, hex: string) => String.fromCharCode(Number.parseInt(hex, 16)))
-			.replace(/\\(["\\/bfnrt])/g, (_, ch: string) => {
-				switch (ch) {
-					case "b":
-						return "\b";
-					case "f":
-						return "\f";
-					case "n":
-						return "\n";
-					case "r":
-						return "\r";
-					case "t":
-						return "\t";
-					default:
-						return ch;
-				}
-			});
+		// Streaming fragment isn't a valid JSON string yet; surface it raw rather
+		// than ad-hoc unescaping that mishandles surrogates and partial escapes.
+		return text;
 	}
 }
 
@@ -243,11 +228,11 @@ function formatEditDescription(
 	};
 }
 
-function renderPlainTextPreview(text: string, uiTheme: Theme): string {
-	const previewLines = text.split("\n");
+function renderPlainTextPreview(text: string, uiTheme: Theme, filePath?: string): string {
+	const previewLines = sanitizeText(text).split("\n");
 	let preview = "\n\n";
 	for (const line of previewLines.slice(0, CALL_TEXT_PREVIEW_LINES)) {
-		preview += `${uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line), CALL_TEXT_PREVIEW_WIDTH))}\n`;
+		preview += `${uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line, filePath), CALL_TEXT_PREVIEW_WIDTH))}\n`;
 	}
 	if (previewLines.length > CALL_TEXT_PREVIEW_LINES) {
 		preview += uiTheme.fg("dim", `… ${previewLines.length - CALL_TEXT_PREVIEW_LINES} more lines`);
@@ -284,7 +269,7 @@ function formatMultiFileStreamingDiff(previews: PerFileDiffPreview[], uiTheme: T
 		if (!preview.diff && !preview.error) continue;
 		const header = uiTheme.fg("dim", `\n\n\u2500\u2500 ${shortenPath(preview.path)} \u2500\u2500`);
 		if (preview.error) {
-			parts.push(`${header}\n${uiTheme.fg("error", replaceTabs(preview.error))}`);
+			parts.push(`${header}\n${uiTheme.fg("error", replaceTabs(preview.error, preview.path))}`);
 			continue;
 		}
 		if (preview.diff) {
@@ -311,10 +296,10 @@ function getCallPreview(
 		return formatStreamingDiff(args.diff, rawPath, uiTheme);
 	}
 	if (args.diff) {
-		return renderPlainTextPreview(args.diff, uiTheme);
+		return renderPlainTextPreview(args.diff, uiTheme, rawPath);
 	}
 	if (args.newText || args.patch) {
-		return renderPlainTextPreview(args.newText ?? args.patch ?? "", uiTheme);
+		return renderPlainTextPreview(args.newText ?? args.patch ?? "", uiTheme, rawPath);
 	}
 	return "";
 }
@@ -438,7 +423,7 @@ export const editToolRenderer = {
 		}
 		text += getCallPreview(editArgs, rawPath, uiTheme, renderContext);
 		if (applyPatchSummary?.error) {
-			text += `\n\n${uiTheme.fg("error", truncateToWidth(replaceTabs(applyPatchSummary.error), CALL_TEXT_PREVIEW_WIDTH))}`;
+			text += `\n\n${uiTheme.fg("error", truncateToWidth(replaceTabs(applyPatchSummary.error, rawPath), CALL_TEXT_PREVIEW_WIDTH))}`;
 		}
 
 		return new Text(text, 0, 0);
@@ -529,13 +514,13 @@ function renderSingleFileResult(
 
 			if (isError) {
 				if (errorText) {
-					text += `\n\n${uiTheme.fg("error", replaceTabs(errorText))}`;
+					text += `\n\n${uiTheme.fg("error", replaceTabs(errorText, rawPath))}`;
 				}
 			} else if (details?.diff) {
 				text += renderDiffSection(details.diff, rawPath, expanded, uiTheme, renderDiffFn);
 			} else if (editDiffPreview) {
 				if ("error" in editDiffPreview) {
-					text += `\n\n${uiTheme.fg("error", replaceTabs(editDiffPreview.error))}`;
+					text += `\n\n${uiTheme.fg("error", replaceTabs(editDiffPreview.error, rawPath))}`;
 				} else if (editDiffPreview.diff) {
 					text += renderDiffSection(editDiffPreview.diff, rawPath, expanded, uiTheme, renderDiffFn);
 				}

package/src/modes/components/diff.ts

@@ -1,3 +1,4 @@
+import { sanitizeText } from "@oh-my-pi/pi-natives";
 import { getIndentation } from "@oh-my-pi/pi-utils";
 import * as Diff from "diff";
 import { theme } from "../../modes/theme/theme";
@@ -15,7 +16,7 @@ const DIM_OFF = "\x1b[22m";
  */
 function visualizeIndent(text: string, filePath?: string): string {
 	const match = text.match(/^([ \t]+)/);
-	if (!match) return replaceTabs(text);
+	if (!match) return replaceTabs(text, filePath);
 	const indent = match[1];
 	const rest = text.slice(indent.length);
 	const tabWidth = getIndentation(filePath);
@@ -30,7 +31,7 @@ function visualizeIndent(text: string, filePath?: string): string {
 			visible += `${DIM}·${DIM_OFF}`;
 		}
 	}
-	return `${visible}${replaceTabs(rest)}`;
+	return `${visible}${replaceTabs(rest, filePath)}`;
 }
 
 /**
@@ -106,7 +107,7 @@ export interface RenderDiffOptions {
  * - Added lines: green, with inverse on changed tokens
  */
 export function renderDiff(diffText: string, options: RenderDiffOptions = {}): string {
-	const lines = diffText.split("\n");
+	const lines = sanitizeText(diffText).split("\n");
 	const result: string[] = [];
 	const parsedLines = lines.map(parseDiffLine);
 	const lineNumberWidth = parsedLines.reduce((width, parsed) => {
@@ -138,7 +139,7 @@ export function renderDiff(diffText: string, options: RenderDiffOptions = {}): s
 
 		if (!parsed) {
 			prevLineNum = "";
-			result.push(theme.fg("toolDiffContext", line));
+			result.push(theme.fg("toolDiffContext", replaceTabs(line, options.filePath)));
 			i++;
 			continue;
 		}

package/src/modes/components/status-line.ts

@@ -388,10 +388,12 @@ export class StatusLineComponent implements Component {
 
 		// Collect visible segment contents
 		const leftParts: string[] = [];
+		const leftSegIds: StatusLineSegmentId[] = [];
 		for (const segId of effectiveSettings.leftSegments) {
 			const rendered = renderSegment(segId, ctx);
 			if (rendered.visible && rendered.content) {
 				leftParts.push(rendered.content);
+				leftSegIds.push(segId);
 			}
 		}
 
@@ -434,8 +436,42 @@ export class StatusLineComponent implements Component {
 				right.pop();
 				rightWidth = groupWidth(right, rightCapWidth, rightSepWidth);
 			}
+			// Shrink path before dropping left segments — path is the only elastic segment
+			const pathIdx = leftSegIds.indexOf("path");
+			if (pathIdx >= 0 && totalWidth() > topFillWidth) {
+				const overflow = totalWidth() - topFillWidth;
+				const currentPathVW = visibleWidth(left[pathIdx]);
+				const minPathVW = 8; // icon + ellipsis + a few chars
+				const shrinkable = currentPathVW - minPathVW;
+				if (shrinkable > 0) {
+					const shrinkBy = Math.min(shrinkable, overflow);
+					const currentMaxLen = ctx.options.path?.maxLength ?? 40;
+					let newMaxLen = Math.max(4, Math.min(currentMaxLen, currentPathVW) - shrinkBy);
+					const pathCtx = (maxLen: number): SegmentContext => ({
+						...ctx,
+						options: { ...ctx.options, path: { ...ctx.options.path, maxLength: maxLen } },
+					});
+					let reRendered = renderSegment("path", pathCtx(newMaxLen));
+					if (reRendered.visible && reRendered.content) {
+						// maxLength governs path text, not icon prefix; iterate to compensate
+						for (let i = 0; i < 8; i++) {
+							const saved = currentPathVW - visibleWidth(reRendered.content);
+							if (saved >= shrinkBy) break;
+							const nextMaxLen = Math.max(4, newMaxLen - (shrinkBy - saved));
+							if (nextMaxLen >= newMaxLen) break; // no progress or hit floor
+							newMaxLen = nextMaxLen;
+							const adjusted = renderSegment("path", pathCtx(newMaxLen));
+							if (!adjusted.visible || !adjusted.content) break;
+							reRendered = adjusted;
+						}
+						left[pathIdx] = reRendered.content;
+						leftWidth = groupWidth(left, leftCapWidth, leftSepWidth);
+					}
+				}
+			}
 			while (totalWidth() > topFillWidth && left.length > 0) {
 				left.pop();
+				leftSegIds.pop();
 				leftWidth = groupWidth(left, leftCapWidth, leftSepWidth);
 			}
 		}

package/src/modes/controllers/event-controller.ts

@@ -172,12 +172,18 @@ export class EventController {
 			const signature = `${textContent}\u0000${imageCount}`;
 
 			this.#resetReadGroup();
-			if (this.ctx.optimisticUserMessageSignature !== signature) {
+			const wasOptimistic = this.ctx.optimisticUserMessageSignature === signature;
+			if (!wasOptimistic) {
 				this.ctx.addMessageToChat(event.message);
 			}
 			this.ctx.optimisticUserMessageSignature = undefined;
 
-			if (!event.message.synthetic) {
+			// Clear the editor only when the submission did not originate from this
+			// session's optimistic flow (which already cleared the editor at submit
+			// time). Clearing here on the optimistic path would race with the user
+			// typing the next prompt while the previous large redraw lands and erase
+			// their in-progress draft (#783).
+			if (!event.message.synthetic && !wasOptimistic) {
 				this.ctx.editor.setText("");
 				this.ctx.updatePendingMessagesDisplay();
 			}
@@ -263,8 +269,21 @@ export class EventController {
 			for (const content of this.ctx.streamingMessage.content) {
 				if (content.type !== "toolCall") continue;
 				const args = content.arguments;
-				if (!args || typeof args !== "object" || !(INTENT_FIELD in args)) continue;
-				this.#updateWorkingMessageFromIntent(args[INTENT_FIELD] as string | undefined);
+				if (!args || typeof args !== "object") continue;
+				if (INTENT_FIELD in args) {
+					this.#updateWorkingMessageFromIntent(args[INTENT_FIELD] as string | undefined);
+					continue;
+				}
+				const tool = this.ctx.session.getToolByName(content.name);
+				if (typeof tool?.intent !== "function") continue;
+				try {
+					const derived = tool.intent(args as never)?.trim();
+					if (derived) {
+						this.#updateWorkingMessageFromIntent(derived);
+					}
+				} catch {
+					// intent function must never break the UI
+				}
 			}
 
 			this.ctx.ui.requestRender();

package/src/prompts/system/system-prompt.md

@@ -168,7 +168,7 @@ Tools:
 
 {{#if intentTracing}}
 <intent-field>
-Every tool has a `{{intentField}}` parameter. Fill it with a concise intent in present participle form, 2-6 words, no period.
+Most tools have a `{{intentField}}` parameter. Fill it with a concise intent in present participle form, 2-6 words, no period.
 </intent-field>
 {{/if}}
 

package/src/prompts/tools/atom.md

@@ -14,10 +14,12 @@ Verbs:
 - `splice: […]`: lines are spliced in at the anchor.
 - `pre: […]`: prepend before the anchor (or at BOF if `loc=$`)
 - `post: […]`: append after the anchor (or at EOF if `loc=$`)
-- `sed: "s/foo/bar/"` — sed-style substitution applied to the anchor line. **Prefer this over `splice` for token-level changes**
-Flags: `g` (all occurrences), `i` (case-insensitive), `F` (literal).
-Delimiter is whatever character follows `s`.
-You **MUST** keep the pattern as short as possible.
+- `sed: { pat, rep, g?, F? }` — structured find/replace on the anchor line. **Prefer this over `splice` for token-level changes**
+  - `pat`: pattern to find (regex by default)
+  - `rep`: replacement (regex back-refs like `$1`, `$&` available)
+  - `g`: global — replace every occurrence (default `false`; pass `true` to replace all)
+  - `F`: literal — treat `pat` as a literal substring (no regex). Use this whenever `pat` contains `||`, `.`, `(`, `?`, `\`, etc. you mean literally.
+You **MUST** keep `pat` as short as possible.
 
 Combination rules:
 - On a single-anchor `loc`, you may combine `pre`, `splice`, and `post` in the same entry.
@@ -55,12 +57,15 @@ All examples below reference the same file:
 `{path:"a.ts",edits:[{loc:{{href 3 "function beta(x) {"}},pre:["function gamma() {","\tvalidate();","}",""]}]}`
 
 # Substitute one token with `sed` (regex) — preferred for token-level edits
-Use the smallest pattern that uniquely identifies the change.
-`{path:"a.ts",edits:[{loc:{{href 5 "\t\treturn parse(data) || fallback;"}},sed:"s/\\|\\|/??/"}]}`
+Use the smallest `pat` that uniquely identifies the change.
+`{path:"a.ts",edits:[{loc:{{href 5 "\t\treturn parse(data) || fallback;"}},sed:{pat:"\\|\\|",rep:"??"}}]}`
 
-# Substitute every occurrence with `sed` (literal/fixed-string)
-Use the `F` flag to disable regex; the delimiter can be any non-alphanumeric char.
-`{path:"a.ts",edits:[{loc:{{href 5 "\t\treturn parse(data) || fallback;"}},sed:"s|data|input|gF"}]}`
+# Substitute literal text — set `F:true` so `pat` is not parsed as regex
+`{path:"a.ts",edits:[{loc:{{href 5 "\t\treturn parse(data) || fallback;"}},sed:{pat:"data",rep:"input",F:true}}]}`
+
+# Comment out a line by capturing the whole content with a regex
+Use `$&` (the entire match) inside `rep` to keep the original text and prepend `// `.
+`{path:"a.ts",edits:[{loc:{{href 7 "\treturn null;"}},sed:{pat:".+",rep:"// $&"}}]}`
 
 # Prepend / append at file edges
 `{path:"a.ts",edits:[{loc:"$",pre:["// Copyright (c) 2026",""]}]}`
@@ -74,7 +79,7 @@ Use the `F` flag to disable regex; the delimiter can be any non-alphanumeric cha
 The 2nd array element matches existing line 5, which is **not** overwritten, it shifts, so return statement ends up duplicated.
 
 # RIGHT: split into separate edits
-- `{path:"a.ts",edits:[{loc:{{href 4 "\tif (x) {"}},sed:"s/x/x \\&\\& ready/"},{loc:{{href 5 "\t\treturn parse(data) ?? fallback;"}},post:["\t\t//unreachable"]}]}`
+- `{path:"a.ts",edits:[{loc:{{href 4 "\tif (x) {"}},sed:{pat:"x",rep:"x && ready",g:false}},{loc:{{href 5 "\t\treturn parse(data) ?? fallback;"}},post:["\t\t//unreachable"]}]}`
 OR
 - `{path:"a.ts",edits:[{loc:{{href 4 "\tif (x) {"}},splice:["\tif (x && ready) {"]},{loc:{{href 5 "\t\treturn parse(data) ?? fallback;"}},splice:["\t\treturn parse(data) ?? fallback;","\t\t//unreachable"]}]}`
 </examples>
@@ -88,7 +93,7 @@ OR
 - `splice: []` deletes the anchored line. `splice:[""]` preserves a blank line.
 - Within a single request you may submit edits in any order — the runtime applies them bottom-up so they don't shift each other. After any request that mutates a file, anchors below the mutation are stale on disk; re-read before issuing more edits to that file.
 - `splice` operations target the current file content only. Do not try to reference old line text after the file has changed.
-- For **small** in-line edits (renaming a token, flipping an operator, tweaking a literal), prefer `sed` over `splice`. The `loc` anchor already pins the line — repeating the entire line in a `splice` array invites hallucinated content. Use the smallest `sed` pattern that uniquely identifies the change on that line; do not pad it with surrounding text just to feel safe. For multi-line restructuring (wrapping logic, adding new branches, inserting blocks), use `splice`/`pre`/`post` — do **not** stretch `sed` into a rewrite tool.
+- For **small** in-line edits (renaming a token, flipping an operator, tweaking a literal), prefer `sed` over `splice`. The `loc` anchor already pins the line — repeating the entire line in a `splice` array invites hallucinated content. Use the smallest `pat` that uniquely identifies the change on that line; do not pad it with surrounding text just to feel safe. When `pat` contains regex metacharacters you mean literally (e.g. `||`, `.`, `(`, `?`, `\`), set `F:true` to disable regex. `g` is `false` by default — pass `g:true` to replace every occurrence. For multi-line restructuring (wrapping logic, adding new branches, inserting blocks), use `splice`/`pre`/`post` — do **not** stretch `sed` into a rewrite tool.
 - When you do use `splice`, re-read the anchored line first and copy it verbatim, changing only the required token(s). Anchor identity does not verify line content, so a hallucinated replacement will silently corrupt the file.
 - Anchors are pin points, not region markers. One anchor pins exactly one line. If your change touches N distinct source lines, that is N edits with N anchors — not one big `splice` array intended to cover the whole region. `splice` cannot "replace lines 4 through 7"; it can only splice content in at one anchor.
 - You **MUST NOT** include lines in `splice`/`pre`/`post` that already exist immediately adjacent to the anchor in the current file. `splice` does not overwrite the lines below — they shift down — so any neighbor you re-type in your array becomes a duplicate. If your intended replacement contains content that is already on neighboring source lines, split into multiple edits at each real change site instead of one fat `splice`.

package/src/session/agent-session.ts

@@ -2970,6 +2970,30 @@ export class AgentSession {
 			attribution: "user",
 			timestamp: Date.now(),
 		});
+		// When fully idle AND the session is in a resumable assistant-ended state,
+		// schedule an immediate continue so the queued follow-up is delivered
+		// without waiting for the next user turn. We gate on isStreaming (model
+		// actively producing), isRetrying (auto-retry backoff is sleeping between
+		// attempts, #retryPromise set), and the last message being assistant —
+		// agent.continue() only dequeues follow-ups from an assistant-ended state;
+		// resuming from user/toolResult state runs an extra model call on the
+		// stale prompt before draining the queue.
+		if (this.#canAutoContinueForFollowUp()) {
+			this.#scheduleAgentContinue({
+				shouldContinue: () => this.#canAutoContinueForFollowUp() && this.agent.hasQueuedMessages(),
+			});
+		}
+	}
+
+	/**
+	 * Gate for idle-path follow-up auto-continue. See `#queueFollowUp` for rationale.
+	 */
+	#canAutoContinueForFollowUp(): boolean {
+		if (this.isStreaming) return false;
+		if (this.isRetrying) return false;
+		const messages = this.agent.state.messages;
+		const last = messages[messages.length - 1];
+		return last?.role === "assistant";
 	}
 
 	queueDeferredMessage(message: CustomMessage): void {

package/src/tools/checkpoint.ts

@@ -52,6 +52,7 @@ export class CheckpointTool implements AgentTool<typeof checkpointSchema, Checkp
 	readonly description: string;
 	readonly parameters = checkpointSchema;
 	readonly strict = true;
+	readonly intent = (args: Partial<CheckpointParams>) => args.goal;
 
 	constructor(private readonly session: ToolSession) {
 		this.description = prompt.render(checkpointDescription);
@@ -94,6 +95,7 @@ export class RewindTool implements AgentTool<typeof rewindSchema, RewindToolDeta
 	readonly description: string;
 	readonly parameters = rewindSchema;
 	readonly strict = true;
+	readonly intent = (): string => "Rewinding to checkpoint";
 
 	constructor(private readonly session: ToolSession) {
 		this.description = prompt.render(rewindDescription);

package/src/tools/exit-plan-mode.ts

@@ -46,6 +46,7 @@ export class ExitPlanModeTool implements AgentTool<typeof exitPlanModeSchema, Ex
 	readonly parameters = exitPlanModeSchema;
 	readonly strict = true;
 	readonly concurrency = "exclusive";
+	readonly intent = (): string => "Exiting plan mode";
 
 	constructor(private readonly session: ToolSession) {
 		this.description = prompt.render(exitPlanModeDescription);

package/src/tools/read.ts

@@ -456,6 +456,12 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	readonly parameters = readSchema;
 	readonly nonAbortable = true;
 	readonly strict = true;
+	readonly intent = (args: Partial<ReadParams>): string => {
+		const p = typeof args.path === "string" ? args.path.trim() : "";
+		if (!p) return "Reading";
+		const isUrl = /^(https?|ftp):\/\//i.test(p);
+		return isUrl ? `Fetching ${p}` : `Reading ${p}`;
+	};
 
 	readonly #autoResizeImages: boolean;
 	readonly #defaultLimit: number;

package/src/tools/report-tool-issue.ts

@@ -60,6 +60,7 @@ export function createReportToolIssueTool(session: ToolSession): AgentTool {
 		strict: false,
 		description: "Report unexpected tool behavior for automated QA tracking.",
 		parameters: ReportToolIssueParams,
+		intent: "omit",
 		async execute(_toolCallId, rawParams) {
 			try {
 				const params = rawParams as { tool: string; report: string };

package/src/tools/resolve.ts

@@ -110,6 +110,8 @@ export class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolD
 	readonly description: string;
 	readonly parameters = resolveSchema;
 	readonly strict = true;
+	readonly intent = (args: Partial<ResolveParams>) =>
+		args.action === "discard" ? "Discarding pending action" : "Applying pending action";
 
 	constructor(private readonly session: ToolSession) {
 		this.description = prompt.render(resolveDescription);

package/src/tools/review.ts

@@ -135,6 +135,7 @@ export const reportFindingTool: AgentTool<typeof ReportFindingParams, ReportFind
 	label: "Report Finding",
 	description: "Report a code review finding. Use this for each issue found. Call yield when done.",
 	parameters: ReportFindingParams,
+	intent: "omit",
 	async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
 		const { title, body, priority, confidence, file_path, line_start, line_end } = params;
 		const location = `${file_path}:${line_start}${line_end !== line_start ? `-${line_end}` : ""}`;

package/src/tools/todo-write.ts

@@ -583,6 +583,7 @@ export class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWrit
 	readonly parameters = todoWriteSchema;
 	readonly concurrency = "exclusive";
 	readonly strict = true;
+	readonly intent = "omit" as const;
 
 	constructor(private readonly session: ToolSession) {
 		this.description = prompt.render(todoWriteDescription);

package/src/tools/yield.ts

@@ -49,6 +49,7 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 		"The `data`/`error` wrapper is required — do not put your output directly in `result`.";
 	readonly parameters: TSchema;
 	strict = true;
+	readonly intent = "omit" as const;
 	lenientArgValidation = true;
 
 	readonly #validate?: ValidateFunction;

package/src/utils/tool-choice.ts

@@ -20,7 +20,12 @@ export function buildNamedToolChoice(toolName: string, model?: Model<Api>): Tool
 		return { type: "function", name: toolName };
 	}
 
-	if (model.api === "google-generative-ai" || model.api === "google-gemini-cli" || model.api === "google-vertex") {
+	if (
+		model.api === "google-generative-ai" ||
+		model.api === "google-gemini-cli" ||
+		model.api === "google-vertex" ||
+		model.api === "ollama-chat"
+	) {
 		return "required";
 	}
 

package/src/web/search/providers/zai.ts

@@ -14,7 +14,7 @@ import { SearchProvider } from "./base";
 import { findCredential, isApiKeyAvailable } from "./utils";
 
 const ZAI_MCP_URL = "https://api.z.ai/api/mcp/web_search_prime/mcp";
-const ZAI_TOOL_NAME = "webSearchPrime";
+const ZAI_TOOL_NAME = "web_search_prime";
 const DEFAULT_NUM_RESULTS = 10;
 
 export interface ZaiSearchParams {