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

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [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
@@ -762,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.1",
+	"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.1",
-		"@oh-my-pi/pi-agent-core": "14.5.1",
-		"@oh-my-pi/pi-ai": "14.5.1",
-		"@oh-my-pi/pi-natives": "14.5.1",
-		"@oh-my-pi/pi-tui": "14.5.1",
-		"@oh-my-pi/pi-utils": "14.5.1",
+		"@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);
@@ -586,7 +564,19 @@ export function applyAtomEdits(
 	if (mismatches.length > 0) {
 		throw new HashlineMismatchError(mismatches, fileLines);
 	}
-	validateNoConflictingAnchorOps(edits);
+	// 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) {
@@ -603,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 });
@@ -659,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/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

@@ -269,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";
 	}