@oh-my-pi/pi-coding-agent 13.5.2 → 13.5.3

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [Unreleased]
 
+## [13.5.3] - 2026-03-01
+
+### Added
+
+- Auto-include `ast_grep` and `ast_edit` tools when their text-based counterparts (`grep`, `edit`) are requested and the AST tools are enabled
+- Enforced tool decision in plan mode—agent now requires calling either `ask` or `exit_plan_mode` when a turn ends without a required tool call
+- Auto-correction of escaped tab indentation in edits (enabled by default, controllable via `PI_HASHLINE_AUTOCORRECT_ESCAPED_TABS` environment variable)
+- Warning when suspicious Unicode escape placeholder `\uDDDD` is detected in edit content
+
+### Changed
+
+- Updated bash tool description to conditionally show `ast_grep` and `ast_edit` guidance based on tool availability in the session
+- Replaced timeout-based cancellation with AbortSignal-based cancellation in the `ask` tool for more reliable user interaction handling
+- Updated `ask` tool to distinguish between user-initiated cancellation and timeout-driven auto-selection, with only user cancellation aborting the turn
+- Updated hashline documentation to clarify that `\t` in JSON represents a real tab character, not a literal backslash-t sequence
+
+### Fixed
+
+- Fixed race condition in dialog overlay handling where multiple concurrent resolutions could occur
+- Cancelling the `ask` tool now aborts the current turn instead of returning a normal cancelled selection, while timeout-driven auto-cancel still returns without aborting
+
 ## [13.5.2] - 2026-03-01
 
 ### Added

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "13.5.2",
+	"version": "13.5.3",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -41,12 +41,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "^0.6",
-		"@oh-my-pi/omp-stats": "13.5.2",
-		"@oh-my-pi/pi-agent-core": "13.5.2",
-		"@oh-my-pi/pi-ai": "13.5.2",
-		"@oh-my-pi/pi-natives": "13.5.2",
-		"@oh-my-pi/pi-tui": "13.5.2",
-		"@oh-my-pi/pi-utils": "13.5.2",
+		"@oh-my-pi/omp-stats": "13.5.3",
+		"@oh-my-pi/pi-agent-core": "13.5.3",
+		"@oh-my-pi/pi-ai": "13.5.3",
+		"@oh-my-pi/pi-natives": "13.5.3",
+		"@oh-my-pi/pi-tui": "13.5.3",
+		"@oh-my-pi/pi-utils": "13.5.3",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/src/config/prompt-templates.ts

@@ -255,7 +255,8 @@ handlebars.registerHelper("SECTION_SEPERATOR", (name: unknown): string => sectio
  */
 function formatHashlineRef(lineNum: unknown, content: unknown): { num: number; text: string; ref: string } {
 	const num = typeof lineNum === "number" ? lineNum : Number.parseInt(String(lineNum), 10);
-	const text = typeof content === "string" ? content : String(content ?? "");
+	const raw = typeof content === "string" ? content : String(content ?? "");
+	const text = raw.replace(/\\t/g, "\t").replace(/\\n/g, "\n").replace(/\\r/g, "\r");
 	const ref = `${num}#${computeLineHash(num, text)}`;
 	return { num, text, ref };
 }

package/src/exa/mcp-client.ts

@@ -16,6 +16,61 @@ export function findApiKey(): string | null {
 	return $env.EXA_API_KEY;
 }
 
+function asRecord(value: unknown): Record<string, unknown> | null {
+	if (typeof value !== "object" || value === null) return null;
+	return value as Record<string, unknown>;
+}
+
+function parseJsonContent(text: string): unknown | null {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Normalize tools/call payloads across MCP servers.
+ *
+ * Exa currently returns different shapes depending on deployment/environment:
+ * - direct payload in result
+ * - structured payload under result.structuredContent / result.data / result.result
+ * - JSON payload embedded as text in result.content[]
+ */
+function normalizeMcpToolPayload(payload: unknown): unknown {
+	const candidates: unknown[] = [];
+	const root = asRecord(payload);
+
+	if (root) {
+		if (root.structuredContent !== undefined) candidates.push(root.structuredContent);
+		if (root.data !== undefined) candidates.push(root.data);
+		if (root.result !== undefined) candidates.push(root.result);
+		candidates.push(root);
+
+		const content = root.content;
+		if (Array.isArray(content)) {
+			for (const item of content) {
+				const part = asRecord(item);
+				if (!part) continue;
+				const text = part.text;
+				if (typeof text !== "string" || text.trim().length === 0) continue;
+				const parsed = parseJsonContent(text);
+				if (parsed !== null) candidates.push(parsed);
+			}
+		}
+	} else {
+		candidates.push(payload);
+	}
+
+	for (const candidate of candidates) {
+		if (isSearchResponse(candidate)) {
+			return candidate;
+		}
+	}
+
+	return payload;
+}
+
 /** Fetch available tools from Exa MCP */
 export async function fetchExaTools(apiKey: string | null, toolNames: string[]): Promise<MCPTool[]> {
 	const params = new URLSearchParams();
@@ -65,7 +120,7 @@ export async function callExaTool(
 		throw new Error(`MCP error: ${response.error.message}`);
 	}
 
-	return response.result;
+	return normalizeMcpToolPayload(response.result);
 }
 
 /** Call a tool on Websets MCP */
@@ -85,7 +140,7 @@ export async function callWebsetsTool(
 		throw new Error(`MCP error: ${response.error.message}`);
 	}
 
-	return response.result;
+	return normalizeMcpToolPayload(response.result);
 }
 
 /** Format search results for LLM */

package/src/modes/controllers/extension-ui-controller.ts

@@ -41,7 +41,7 @@ export class ExtensionUiController {
 		const uiContext: ExtensionUIContext = {
 			select: (title, options, dialogOptions) => this.showHookSelector(title, options, dialogOptions),
 			confirm: (title, message, _dialogOptions) => this.showHookConfirm(title, message),
-			input: (title, placeholder, _dialogOptions) => this.showHookInput(title, placeholder),
+			input: (title, placeholder, dialogOptions) => this.showHookInput(title, placeholder, dialogOptions),
 			notify: (message, type) => this.showHookNotify(message, type),
 			onTerminalInput: handler => this.addExtensionTerminalInputListener(handler),
 			setStatus: (key, text) => this.setHookStatus(key, text),
@@ -561,6 +561,20 @@ export class ExtensionUiController {
 		dialogOptions?: ExtensionUIDialogOptions,
 	): Promise<string | undefined> {
 		const { promise, resolve } = Promise.withResolvers<string | undefined>();
+		let settled = false;
+		const onAbort = () => {
+			this.hideHookSelector();
+			if (!settled) {
+				settled = true;
+				resolve(undefined);
+			}
+		};
+		const finish = (value: string | undefined) => {
+			if (settled) return;
+			settled = true;
+			dialogOptions?.signal?.removeEventListener("abort", onAbort);
+			resolve(value);
+		};
 		this.#hookSelectorOverlay?.hide();
 		this.#hookSelectorOverlay = undefined;
 		const maxVisible = Math.max(4, Math.min(15, this.ctx.ui.terminal.rows - 12));
@@ -569,11 +583,11 @@ export class ExtensionUiController {
 			options,
 			option => {
 				this.hideHookSelector();
-				resolve(option);
+				finish(option);
 			},
 			() => {
 				this.hideHookSelector();
-				resolve(undefined);
+				finish(undefined);
 			},
 			{
 				initialIndex: dialogOptions?.initialIndex,
@@ -584,9 +598,15 @@ export class ExtensionUiController {
 			},
 		);
 		this.#hookSelectorOverlay = this.ctx.ui.showOverlay(this.ctx.hookSelector, this.#dialogOverlayOptions);
+		if (dialogOptions?.signal) {
+			if (dialogOptions.signal.aborted) {
+				onAbort();
+			} else {
+				dialogOptions.signal.addEventListener("abort", onAbort, { once: true });
+			}
+		}
 		return promise;
 	}
-
 	/**
 	 * Hide the hook selector.
 	 */
@@ -610,8 +630,26 @@ export class ExtensionUiController {
 	/**
 	 * Show a text input for hooks.
 	 */
-	showHookInput(title: string, placeholder?: string): Promise<string | undefined> {
+	showHookInput(
+		title: string,
+		placeholder?: string,
+		dialogOptions?: ExtensionUIDialogOptions,
+	): Promise<string | undefined> {
 		const { promise, resolve } = Promise.withResolvers<string | undefined>();
+		let settled = false;
+		const onAbort = () => {
+			this.hideHookInput();
+			if (!settled) {
+				settled = true;
+				resolve(undefined);
+			}
+		};
+		const finish = (value: string | undefined) => {
+			if (settled) return;
+			settled = true;
+			dialogOptions?.signal?.removeEventListener("abort", onAbort);
+			resolve(value);
+		};
 		this.#hookInputOverlay?.hide();
 		this.#hookInputOverlay = undefined;
 		this.ctx.hookInput = new HookInputComponent(
@@ -619,14 +657,21 @@ export class ExtensionUiController {
 			placeholder,
 			value => {
 				this.hideHookInput();
-				resolve(value);
+				finish(value);
 			},
 			() => {
 				this.hideHookInput();
-				resolve(undefined);
+				finish(undefined);
 			},
 		);
 		this.#hookInputOverlay = this.ctx.ui.showOverlay(this.ctx.hookInput, this.#dialogOverlayOptions);
+		if (dialogOptions?.signal) {
+			if (dialogOptions.signal.aborted) {
+				onAbort();
+			} else {
+				dialogOptions.signal.addEventListener("abort", onAbort, { once: true });
+			}
+		}
 		return promise;
 	}
 

package/src/patch/hashline.ts

@@ -411,6 +411,45 @@ export function validateLineRef(ref: { line: number; hash: string }, fileLines:
 	}
 }
 
+function isEscapedTabAutocorrectEnabled(): boolean {
+	const value = Bun.env.PI_HASHLINE_AUTOCORRECT_ESCAPED_TABS;
+	if (value === "0") return false;
+	if (value === "1") return true;
+	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.`,
+		);
+	}
+}
 // ═══════════════════════════════════════════════════════════════════════════
 // Edit Application
 // ═══════════════════════════════════════════════════════════════════════════
@@ -493,6 +532,8 @@ export function applyHashlineEdits(
 	if (mismatches.length > 0) {
 		throw new HashlineMismatchError(mismatches, fileLines);
 	}
+	maybeAutocorrectEscapedTabIndentation(edits, warnings);
+	maybeWarnSuspiciousUnicodeEscapePlaceholder(edits, warnings);
 	// Deduplicate identical edits targeting the same line(s)
 	const seenEditKeys = new Map<string, number>();
 	const dedupIndices = new Set<number>();

package/src/prompts/system/plan-mode-active.md

@@ -2,11 +2,12 @@
 Plan mode active. You **MUST** perform READ-ONLY operations only.
 
 You **MUST NOT**:
-- Creating/editing/deleting files (except plan file below)
-- Running state-changing commands (git commit, npm install, etc.)
-- Making any system changes
+- Create, edit, or delete files (except plan file below)
+- Run state-changing commands (git commit, npm install, etc.)
+- Make any system changes
 
-Supersedes all other instructions.
+To implement: call `{{exitToolName}}` → user approves → new session starts with full write access to execute the plan.
+You **MUST NOT** ask the user to exit plan mode for you; you **MUST** call `{{exitToolName}}` yourself.
 </critical>
 
 ## Plan File
@@ -32,7 +33,7 @@ Plan execution runs in fresh context (session cleared). You **MUST** make the pl
 3. Decide:
    - **Different task** → Overwrite plan
    - **Same task, continuing** → Update and clean outdated sections
-4. Call `exit_plan_mode` when complete
+4. Call `{{exitToolName}}` when complete
 </procedure>
 {{/if}}
 
@@ -43,7 +44,7 @@ Plan execution runs in fresh context (session cleared). You **MUST** make the pl
 ### 1. Explore
 You **MUST** use `find`, `grep`, `read`, `ls` to understand the codebase.
 ### 2. Interview
-You **MUST** use `ask` to clarify:
+You **MUST** use `{{askToolName}}` to clarify:
 - Ambiguous requirements
 - Technical decisions and tradeoffs
 - Preferences: UI/UX, performance, edge cases
@@ -78,7 +79,7 @@ You **MUST** focus on the request and associated code. You **SHOULD** launch par
 You **MUST** draft an approach based on exploration. You **MUST** consider trade-offs briefly, then choose.
 
 ### Phase 3: Review
-You **MUST** read critical files. You **MUST** verify plan matches original request. You **SHOULD** use `ask` to clarify remaining questions.
+You **MUST** read critical files. You **MUST** verify plan matches original request. You **SHOULD** use `{{askToolName}}` to clarify remaining questions.
 
 ### Phase 4: Update Plan
 You **MUST** update `{{planFilePath}}` (`{{editToolName}}` for changes, `{{writeToolName}}` only if creating from scratch):
@@ -93,14 +94,14 @@ You **MUST** ask questions throughout. You **MUST NOT** make large assumptions a
 {{/if}}
 
 <directives>
-- You **MUST** use `ask` only for clarifying requirements or choosing approaches
+- You **MUST** use `{{askToolName}}` only for clarifying requirements or choosing approaches
 </directives>
 
 <critical>
 Your turn ends ONLY by:
-1. Using `ask` gather information, OR
-2. Calling `exit_plan_mode` when ready
+1. Using `{{askToolName}}` to gather information, OR
+2. Calling `{{exitToolName}}` when ready — this triggers user approval, then a new implementation session with full tool access
 
-You **MUST NOT** ask plan approval via text or `ask`; you **MUST** use `exit_plan_mode`.
+You **MUST NOT** ask plan approval via text or `{{askToolName}}`; you **MUST** use `{{exitToolName}}`.
 You **MUST** keep going until complete.
 </critical>

package/src/prompts/system/plan-mode-subagent.md

@@ -2,11 +2,9 @@
 Plan mode active. You **MUST** perform READ-ONLY operations only.
 
 You **MUST NOT**:
-- Creating, editing, deleting, moving, or copying files
-- Running state-changing commands
-- Making any changes to system
-
-Supersedes all other instructions.
+- Create, edit, delete, move, or copy files
+- Run state-changing commands
+- Make any changes to the system
 </critical>
 
 <role>

package/src/prompts/system/plan-mode-tool-decision-reminder.md

@@ -0,0 +1,9 @@
+<system-reminder>
+Plan mode turn ended without a required tool call.
+
+You **MUST** choose exactly one next action now:
+1. Call `{{askToolName}}` to gather required clarification, OR
+2. Call `{{exitToolName}}` to finish planning and request approval
+
+You **MUST NOT** output plain text in this turn.
+</system-reminder>

package/src/prompts/tools/bash.md

@@ -33,10 +33,12 @@ You **MUST** use specialized tools instead of bash for ALL file operations:
 |`rg 'pattern' dir/`|`grep(pattern="pattern", path="dir/")`|
 |`find dir -name '*.ts'`|`find(pattern="dir/**/*.ts")`|
 |`ls dir/`|`read(path="dir/")`|
-|`cat <<'EOF' > file`|`write(path="file", content="...")`|
-|`sed -i 's/old/new/' file`|`edit(path="file", edits=[...])`|
-- If `ast_grep` / `ast_edit` tools are available in the session, you **MUST** use them for structural code search/rewrites instead of bash `grep`/`sed`/`awk`/`perl` pipelines
-- Bash is for command execution, not syntax-aware code transformation; prefer `ast_grep` for discovery and `ast_edit` for codemods
+|`cat <<'EOF' > file`|`write(path="file", content="…")`|
+|`sed -i 's/old/new/' file`|`edit(path="file", edits=[…])`|
+
+{{#if hasAstEdit}}|`sed -i 's/oldFn(/newFn(/' src/*.ts`|`ast_edit({ops:[{pat:"oldFn($$$A)", out:"newFn($$$A)"}], path:"src/"})`|{{/if}}
+{{#if hasAstGrep}}- You **MUST** use `ast_grep` for structural code search instead of bash `grep`/`awk`/`perl` pipelines{{/if}}
+{{#if hasAstEdit}}- You **MUST** use `ast_edit` for structural rewrites instead of bash `sed`/`awk`/`perl` pipelines{{/if}}
 - You **MUST NOT** use Bash for these operations like read, grep, find, edit, write, where specialized tools exist.
 - You **MUST NOT** use `2>&1` | `2>/dev/null` pattern, stdout and stderr are already merged.
 - You **MUST NOT** use `| head -n 50` or `| tail -n 100` pattern, use `head` and `tail` parameters instead.

package/src/prompts/tools/hashline.md

@@ -49,6 +49,7 @@ Every edit has `op`, `pos`, and `lines`. Range replaces also have `end`. Both `p
    - You **MUST NOT** set `end` to an interior line and then re-add the boundary token in `lines`; that duplicates the next surviving line.
    - To remove a line while keeping its neighbors, **delete** it (`lines: null`). You **MUST NOT** replace it with the content of an adjacent line — that line still exists and will be duplicated.
 4. **Match surrounding indentation:** Leading whitespace in `lines` **MUST** be copied verbatim from adjacent lines in the `read` output. Do not infer or reconstruct indentation from memory — count the actual leading spaces on the lines immediately above and below the insertion or replacement point.
+5. **Preserve idiomatic sibling spacing:** When inserting declarations between top-level siblings, you **MUST** preserve existing blank-line separators. If siblings are separated by one blank line, include a trailing `""` in `lines` so inserted code keeps the same spacing.
 </rules>
 
 <recovery>
@@ -121,18 +122,17 @@ Range — add `end`:
 {{hlinefull 62 "      return null;"}}
 {{hlinefull 63 "    }"}}
 ```
+Target only the inner lines that change — leave unchanged boundaries out of the range.
 ```
 {
   path: "…",
   edits: [{
     op: "replace",
-    pos: {{hlinejsonref 60 "    } catch (err) {"}},
-    end: {{hlinejsonref 63 "    }"}},
+    pos: {{hlinejsonref 61 "      console.error(err);"}},
+    end: {{hlinejsonref 62 "      return null;"}},
     lines: [
-      "    } catch (err) {",
       "      if (isEnoent(err)) return null;",
-      "      throw err;",
-      "    }"
+      "      throw err;"
     ]
   }]
 }
@@ -141,39 +141,24 @@ Range — add `end`:
 
 <example name="inclusive end avoids duplicate boundary">
 ```ts
-{{hlinefull 70 "if (ok) {"}}
-{{hlinefull 71 "  run();"}}
-{{hlinefull 72 "}"}}
-{{hlinefull 73 "after();"}}
+{{hlinefull 70 "\tif (user.isAdmin) {"}}
+{{hlinefull 71 "\t\tdeleteRecord(id);"}}
+{{hlinefull 72 "\t}"}}
+{{hlinefull 73 "\tafter();"}}
 ```
-Bad — `end` stops before `}` while `lines` already includes `}`:
+The block grows by one line and the condition changes — two single-line ops would be needed otherwise. Since `}` appears in `lines`, `end` must include `72`:
 ```
 {
   path: "…",
   edits: [{
     op: "replace",
-    pos: {{hlinejsonref 70 "if (ok) {"}},
-    end: {{hlinejsonref 71 "  run();"}},
+    pos: {{hlinejsonref 70 "\tif (user.isAdmin) {"}},
+    end: {{hlinejsonref 72 "\t}"}},
     lines: [
-      "if (ok) {",
-      "  runSafe();",
-      "}"
-    ]
-  }]
-}
-```
-Good — include original `}` in the replaced range when replacement keeps `}`:
-```
-{
-  path: "…",
-  edits: [{
-    op: "replace",
-    pos: {{hlinejsonref 70 "if (ok) {"}},
-    end: {{hlinejsonref 72 "}"}},
-    lines: [
-      "if (ok) {",
-      "  runSafe();",
-      "}"
+      "\tif (user.isAdmin && confirmed) {",
+      "\t\tauditLog(id);",
+      "\t\tdeleteRecord(id);",
+      "\t}"
     ]
   }]
 }
@@ -191,6 +176,7 @@ Also apply the same rule to `);`, `],`, and `},` closers: if replacement include
 {{hlinefull 49 "  runY();"}}
 {{hlinefull 50 "}"}}
 ```
+Use a trailing `""` to preserve the blank line between top-level sibling declarations.
 ```
 {
   path: "…",
@@ -206,20 +192,6 @@ Also apply the same rule to `);`, `],`, and `},` closers: if replacement include
   }]
 }
 ```
-Result:
-```ts
-{{hlinefull 44 "function x() {"}}
-{{hlinefull 45 "  runX();"}}
-{{hlinefull 46 "}"}}
-{{hlinefull 47 ""}}
-{{hlinefull 48 "function z() {"}}
-{{hlinefull 49 "  runZ();"}}
-{{hlinefull 50 "}"}}
-{{hlinefull 51 ""}}
-{{hlinefull 52 "function y() {"}}
-{{hlinefull 53 "  runY();"}}
-{{hlinefull 54 "}"}}
-```
 </example>
 
 <example name="anchor to structure, not whitespace">
@@ -249,30 +221,15 @@ Good — anchors to structural line:
 </example>
 
 <example name="indentation must match context">
-Leading whitespace in `lines` **MUST** be copied from the `read` output, not reconstructed from memory. Check the actual indent of neighboring lines.
+Leading whitespace in `lines` **MUST** be copied from the `read` output, not reconstructed from memory. If the file uses tabs, use `\t` in JSON — you **MUST NOT** use `\\t`, which produces a literal backslash-t in the file.
 ```ts
 {{hlinefull 10 "class Foo {"}}
-{{hlinefull 11 "  bar() {"}}
-{{hlinefull 12 "    return 1;"}}
-{{hlinefull 13 "  }"}}
+{{hlinefull 11 "\tbar() {"}}
+{{hlinefull 12 "\t\treturn 1;"}}
+{{hlinefull 13 "\t}"}}
 {{hlinefull 14 "}"}}
 ```
-Bad — indent guessed as 4 spaces instead of 2 (as seen on lines 11–13):
-```
-{
-  path: "…",
-  edits: [{
-    op: "prepend",
-    pos: {{hlinejsonref 14 "}"}},
-    lines: [
-      "    baz() {",
-      "        return 2;",
-      "    }"
-    ]
-  }]
-}
-```
-Good — indent matches the 2-space style visible on adjacent lines:
+Good — `\t` in JSON is a real tab, matching the file's indentation:
 ```
 {
   path: "…",
@@ -280,9 +237,9 @@ Good — indent matches the 2-space style visible on adjacent lines:
     op: "prepend",
     pos: {{hlinejsonref 14 "}"}},
     lines: [
-      "  baz() {",
-      "    return 2;",
-      "  }"
+      "\tbaz() {",
+      "\t\treturn 2;",
+      "\t}"
     ]
   }]
 }
@@ -294,5 +251,5 @@ Good — indent matches the 2-space style visible on adjacent lines:
 - Every tag **MUST** be copied exactly from fresh tool result as `N#ID`.
 - You **MUST** re-read after each edit call before issuing another on same file.
 - Formatting is a batch operation. You **MUST NOT** use this tool to reformat, reindent, or adjust whitespace — run the project's formatter instead. If the only change is whitespace, it is formatting; do not touch it.
-- `lines` entries **MUST** be literal file content with real space indentation. (`\\t` in JSON inserts a literal backslash-t into the file, not a tab.)
+- `lines` entries **MUST** be literal file content with indentation copied exactly from the `read` output. If the file uses tabs, use `\t` in JSON (a real tab character) — you **MUST NOT** use `\\t` (two characters: backslash + t), which produces the literal string `\t` in the file.
 </critical>

package/src/session/agent-session.ts

@@ -82,6 +82,9 @@ import { normalizeDiff, normalizeToLF, ParseError, previewPatch, stripBom } from
 import type { PlanModeState } from "../plan-mode/state";
 import planModeActivePrompt from "../prompts/system/plan-mode-active.md" with { type: "text" };
 import planModeReferencePrompt from "../prompts/system/plan-mode-reference.md" with { type: "text" };
+import planModeToolDecisionReminderPrompt from "../prompts/system/plan-mode-tool-decision-reminder.md" with {
+	type: "text",
+};
 import ttsrInterruptTemplate from "../prompts/system/ttsr-interrupt.md" with { type: "text" };
 import type { SecretObfuscator } from "../secrets/obfuscator";
 import type { CheckpointState } from "../tools/checkpoint";
@@ -733,9 +736,13 @@ export class AgentSession {
 		}
 
 		// Check auto-retry and auto-compaction after agent completes
-		if (event.type === "agent_end" && this.#lastAssistantMessage) {
-			const msg = this.#lastAssistantMessage;
+		if (event.type === "agent_end") {
+			const fallbackAssistant = [...event.messages]
+				.reverse()
+				.find((message): message is AssistantMessage => message.role === "assistant");
+			const msg = this.#lastAssistantMessage ?? fallbackAssistant;
 			this.#lastAssistantMessage = undefined;
+			if (!msg) return;
 
 			if (this.#skipPostTurnMaintenanceAssistantTimestamp === msg.timestamp) {
 				this.#skipPostTurnMaintenanceAssistantTimestamp = undefined;
@@ -1901,6 +1908,9 @@ export class AgentSession {
 			: { role: "user" as const, content: userContent, timestamp: Date.now() };
 
 		await this.#promptWithMessage(message, expandedText, options);
+		if (!options?.synthetic) {
+			await this.#enforcePlanModeToolDecision();
+		}
 	}
 
 	async promptCustomMessage<T = unknown>(
@@ -3329,6 +3339,52 @@ Be thorough - include exact file paths, function names, error messages, and tech
 		this.#checkpointState = undefined;
 		this.#pendingRewindReport = undefined;
 	}
+	async #enforcePlanModeToolDecision(): Promise<void> {
+		if (!this.#planModeState?.enabled) {
+			return;
+		}
+		const assistantMessage = this.#findLastAssistantMessage();
+		if (!assistantMessage) {
+			return;
+		}
+		if (assistantMessage.stopReason === "error" || assistantMessage.stopReason === "aborted") {
+			return;
+		}
+
+		const calledRequiredTool = assistantMessage.content.some(
+			content => content.type === "toolCall" && (content.name === "ask" || content.name === "exit_plan_mode"),
+		);
+		if (calledRequiredTool) {
+			return;
+		}
+
+		const askTool = this.#toolRegistry.get("ask");
+		const exitPlanModeTool = this.#toolRegistry.get("exit_plan_mode");
+		if (!askTool || !exitPlanModeTool) {
+			logger.warn("Plan mode enforcement skipped because ask/exit tools are unavailable", {
+				activeToolNames: this.agent.state.tools.map(tool => tool.name),
+			});
+			return;
+		}
+		const forcedTools = [askTool, exitPlanModeTool];
+
+		const reminder = renderPromptTemplate(planModeToolDecisionReminderPrompt, {
+			askToolName: "ask",
+			exitToolName: "exit_plan_mode",
+		});
+
+		const previousTools = this.agent.state.tools;
+		this.agent.setTools(forcedTools);
+		try {
+			await this.prompt(reminder, {
+				synthetic: true,
+				expandPromptTemplates: false,
+				toolChoice: "required",
+			});
+		} finally {
+			this.agent.setTools(previousTools);
+		}
+	}
 	/**
 	 * Check if agent stopped with incomplete todos and prompt to continue.
 	 */

package/src/tools/ask.ts

@@ -14,9 +14,11 @@
  *   - Use recommended: <index> to mark the default option; "(Recommended)" suffix is added automatically
  *   - Questions may time out and auto-select the recommended option (configurable, disabled in plan mode)
  */
+
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { TERMINAL, Text } from "@oh-my-pi/pi-tui";
+import { ptree, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
@@ -25,6 +27,7 @@ import askDescription from "../prompts/tools/ask.md" with { type: "text" };
 import { renderStatusLine } from "../tui";
 import type { ToolSession } from ".";
 import { formatErrorMessage, formatMeta, formatTitle } from "./render-utils";
+import { ToolAbortError } from "./tool-errors";
 
 // =============================================================================
 // Types
@@ -110,14 +113,9 @@ interface UIContext {
 	select(
 		prompt: string,
 		options: string[],
-		options_?: { initialIndex?: number; timeout?: number; outline?: boolean },
+		options_?: { initialIndex?: number; signal?: AbortSignal; outline?: boolean },
 	): Promise<string | undefined>;
-	input(prompt: string): Promise<string | undefined>;
-}
-
-interface AskQuestionOptions {
-	/** Timeout in milliseconds, null/undefined to disable */
-	timeout?: number | null;
+	input(prompt: string, options_?: { signal?: AbortSignal }): Promise<string | undefined>;
 }
 
 async function askSingleQuestion(
@@ -126,9 +124,8 @@ async function askSingleQuestion(
 	optionLabels: string[],
 	multi: boolean,
 	recommended?: number,
-	options?: AskQuestionOptions,
+	signal?: AbortSignal,
 ): Promise<SelectionResult> {
-	const timeout = options?.timeout ?? undefined;
 	const doneLabel = getDoneOptionLabel();
 	let selectedOptions: string[] = [];
 	let customInput: string | undefined;
@@ -152,22 +149,27 @@ async function askSingleQuestion(
 			opts.push(OTHER_OPTION);
 
 			const prefix = selected.size > 0 ? `(${selected.size} selected) ` : "";
-			const selectionStart = Date.now();
-			const choice = await ui.select(`${prefix}${question}`, opts, {
-				initialIndex: cursorIndex,
-				timeout: timeout ?? undefined,
-				outline: true,
-			});
-			const elapsed = Date.now() - selectionStart;
-			const timedOut = timeout != null && elapsed >= timeout;
+			const choice = signal
+				? await untilAborted(signal, () =>
+						ui.select(`${prefix}${question}`, opts, {
+							initialIndex: cursorIndex,
+							signal,
+							outline: true,
+						}),
+					)
+				: await ui.select(`${prefix}${question}`, opts, {
+						initialIndex: cursorIndex,
+						signal,
+						outline: true,
+					});
 
 			if (choice === undefined || choice === doneLabel) break;
 
 			if (choice === OTHER_OPTION) {
-				if (!timedOut) {
-					const input = await ui.input("Enter your response:");
-					if (input) customInput = input;
-				}
+				const input = signal
+					? await untilAborted(signal, () => ui.input("Enter your response:", { signal }))
+					: await ui.input("Enter your response:", { signal });
+				if (input) customInput = input;
 				break;
 			}
 
@@ -192,21 +194,28 @@ async function askSingleQuestion(
 					selected.add(opt);
 				}
 			}
-
-			if (timedOut) {
-				break;
-			}
 		}
 		selectedOptions = Array.from(selected);
 	} else {
 		const displayLabels = addRecommendedSuffix(optionLabels, recommended);
-		const choice = await ui.select(question, [...displayLabels, OTHER_OPTION], {
-			timeout: timeout ?? undefined,
-			initialIndex: recommended,
-			outline: true,
-		});
+		const choice = signal
+			? await untilAborted(signal, () =>
+					ui.select(question, [...displayLabels, OTHER_OPTION], {
+						initialIndex: recommended,
+						signal,
+						outline: true,
+					}),
+				)
+			: await ui.select(question, [...displayLabels, OTHER_OPTION], {
+					initialIndex: recommended,
+					signal,
+					outline: true,
+				});
+
 		if (choice === OTHER_OPTION) {
-			const input = await ui.input("Enter your response:");
+			const input = signal
+				? await untilAborted(signal, () => ui.input("Enter your response:", { signal }))
+				: await ui.input("Enter your response:", { signal });
 			if (input) customInput = input;
 		} else if (choice) {
 			selectedOptions = [stripRecommendedSuffix(choice)];
@@ -265,7 +274,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 	async execute(
 		_toolCallId: string,
 		params: AskParams,
-		_signal?: AbortSignal,
+		signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<AskToolDetails>,
 		context?: AgentToolContext,
 	): Promise<AgentToolResult<AskToolDetails>> {
@@ -277,7 +286,11 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 			};
 		}
 
-		const { ui } = context;
+		const extensionUi = context.ui;
+		const ui: UIContext = {
+			select: (prompt, options, dialogOptions) => extensionUi.select(prompt, options, dialogOptions),
+			input: (prompt, dialogOptions) => extensionUi.input(prompt, undefined, dialogOptions),
+		};
 
 		// Determine timeout based on settings and plan mode
 		const planModeEnabled = this.session.getPlanModeState?.()?.enabled ?? false;
@@ -296,18 +309,41 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 			};
 		}
 
+		const askQuestion = async (q: AskParams["questions"][number]) => {
+			const optionLabels = q.options.map(o => o.label);
+			const timeoutSignal = timeout == null ? undefined : AbortSignal.timeout(timeout);
+			const questionSignal = ptree.combineSignals(signal, timeoutSignal);
+			try {
+				const { selectedOptions, customInput } = await askSingleQuestion(
+					ui,
+					q.question,
+					optionLabels,
+					q.multi ?? false,
+					q.recommended,
+					questionSignal,
+				);
+				return { optionLabels, selectedOptions, customInput, timedOut: false };
+			} catch (error) {
+				if (error instanceof Error && error.name === "AbortError") {
+					if (signal?.aborted) {
+						throw new ToolAbortError("Ask input was cancelled");
+					}
+					if (timeoutSignal?.aborted) {
+						return { optionLabels, selectedOptions: [], customInput: undefined, timedOut: true };
+					}
+				}
+				throw error;
+			}
+		};
+
 		if (params.questions.length === 1) {
 			const [q] = params.questions;
-			const optionLabels = q.options.map(o => o.label);
-			const { selectedOptions, customInput } = await askSingleQuestion(
-				ui,
-				q.question,
-				optionLabels,
-				q.multi ?? false,
-				q.recommended,
-				{ timeout },
-			);
+			const { optionLabels, selectedOptions, customInput, timedOut } = await askQuestion(q);
 
+			if (!timedOut && selectedOptions.length === 0 && !customInput) {
+				context.abort();
+				throw new ToolAbortError("Ask tool was cancelled by the user");
+			}
 			const details: AskToolDetails = {
 				question: q.question,
 				options: optionLabels,
@@ -333,16 +369,12 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 		const results: QuestionResult[] = [];
 
 		for (const q of params.questions) {
-			const optionLabels = q.options.map(o => o.label);
-			const { selectedOptions, customInput } = await askSingleQuestion(
-				ui,
-				q.question,
-				optionLabels,
-				q.multi ?? false,
-				q.recommended,
-				{ timeout },
-			);
+			const { optionLabels, selectedOptions, customInput, timedOut } = await askQuestion(q);
 
+			if (!timedOut && selectedOptions.length === 0 && !customInput) {
+				context.abort();
+				throw new ToolAbortError("Ask tool was cancelled by the user");
+			}
 			results.push({
 				id: q.id,
 				question: q.question,

package/src/tools/bash.ts

@@ -98,7 +98,11 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 	constructor(private readonly session: ToolSession) {
 		this.#asyncEnabled = this.session.settings.get("async.enabled");
 		this.parameters = this.#asyncEnabled ? bashSchemaWithAsync : bashSchemaBase;
-		this.description = renderPromptTemplate(bashDescription, { asyncEnabled: this.#asyncEnabled });
+		this.description = renderPromptTemplate(bashDescription, {
+			asyncEnabled: this.#asyncEnabled,
+			hasAstGrep: this.session.settings.get("astGrep.enabled"),
+			hasAstEdit: this.session.settings.get("astEdit.enabled"),
+		});
 	}
 
 	#formatResultOutput(result: BashResult | BashInteractiveResult, headLines?: number, tailLines?: number): string {

package/src/tools/index.ts

@@ -282,6 +282,24 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 	) {
 		requestedTools.push("bash");
 	}
+
+	// Auto-include AST counterparts when their text-based sibling is present
+	if (requestedTools) {
+		if (
+			requestedTools.includes("grep") &&
+			!requestedTools.includes("ast_grep") &&
+			session.settings.get("astGrep.enabled")
+		) {
+			requestedTools.push("ast_grep");
+		}
+		if (
+			requestedTools.includes("edit") &&
+			!requestedTools.includes("ast_edit") &&
+			session.settings.get("astEdit.enabled")
+		) {
+			requestedTools.push("ast_edit");
+		}
+	}
 	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS, ...HIDDEN_TOOLS };
 	const isToolAllowed = (name: string) => {
 		if (name === "lsp") return enableLsp;

package/src/utils/prompt-format.ts

@@ -86,9 +86,8 @@ export function formatPromptContent(content: string, options: PromptFormatOption
 
 	for (let i = 0; i < lines.length; i++) {
 		let line = lines[i].trimEnd();
-		const trimmed = line.trimStart();
-
-		if (CODE_FENCE.test(trimmed)) {
+		let trimmedStart = line.trimStart();
+		if (CODE_FENCE.test(trimmedStart)) {
 			inCodeBlock = !inCodeBlock;
 			result.push(line);
 			continue;
@@ -102,30 +101,29 @@ export function formatPromptContent(content: string, options: PromptFormatOption
 		if (replaceAsciiSymbols) {
 			line = replaceCommonAsciiSymbols(line);
 		}
+		trimmedStart = line.trimStart();
+		const trimmed = line.trim();
 
-		const isOpeningXml = OPENING_XML.test(trimmed) && !trimmed.endsWith("/>");
-		if (isOpeningXml && line.length === trimmed.length) {
-			const match = OPENING_XML.exec(trimmed);
+		const isOpeningXml = OPENING_XML.test(trimmedStart) && !trimmedStart.endsWith("/>");
+		if (isOpeningXml && line.length === trimmedStart.length) {
+			const match = OPENING_XML.exec(trimmedStart);
 			if (match) topLevelTags.push(match[1]);
 		}
 
-		const closingMatch = CLOSING_XML.exec(trimmed);
+		const closingMatch = CLOSING_XML.exec(trimmedStart);
 		if (closingMatch) {
 			const tagName = closingMatch[1];
 			if (topLevelTags.length > 0 && topLevelTags[topLevelTags.length - 1] === tagName) {
-				line = trimmed;
 				topLevelTags.pop();
-			} else {
-				line = line.trimEnd();
 			}
-		} else if (isPreRender && trimmed.startsWith("{{")) {
-			line = trimmed;
-		} else if (TABLE_SEP.test(trimmed)) {
-			line = compactTableSep(trimmed);
-		} else if (TABLE_ROW.test(trimmed)) {
-			line = compactTableRow(trimmed);
-		} else {
-			line = line.trimEnd();
+		} else if (isPreRender && trimmedStart.startsWith("{{")) {
+			/* keep indentation as-is in pre-render for Handlebars markers */
+		} else if (TABLE_SEP.test(trimmedStart)) {
+			const leadingWhitespace = line.slice(0, line.length - trimmedStart.length);
+			line = `${leadingWhitespace}${compactTableSep(trimmedStart)}`;
+		} else if (TABLE_ROW.test(trimmedStart)) {
+			const leadingWhitespace = line.slice(0, line.length - trimmedStart.length);
+			line = `${leadingWhitespace}${compactTableRow(trimmedStart)}`;
 		}
 
 		if (shouldBoldRfc2119) {