@oh-my-pi/pi-coding-agent 13.9.6 → 13.9.12

package/src/modes/components/tool-execution.ts

@@ -478,7 +478,7 @@ export class ToolExecutionComponent extends Container {
 						},
 						this.#renderState,
 						theme,
-						this.#args, // Pass args for tools that need them
+						this.#getCallArgsForRender(),
 					);
 					if (resultComponent) {
 						this.#contentBox.addChild(ensureInvalidate(resultComponent));
@@ -560,10 +560,14 @@ export class ToolExecutionComponent extends Container {
 			return Math.max(1, Math.min(maxSeconds, value));
 		};
 
-		if (this.#toolName === "bash" && this.#result) {
-			// Pass raw output and expanded state - renderer handles width-aware truncation
-			const output = this.#getTextOutput().trimEnd();
-			context.output = output;
+		if (this.#toolName === "bash") {
+			// Bash needs render context even before a result exists. The renderer uses the pending-call args
+			// plus this context to keep the inline command preview visible while tool-call JSON is still streaming.
+			if (this.#result) {
+				// Pass raw output and expanded state - renderer handles width-aware truncation
+				const output = this.#getTextOutput().trimEnd();
+				context.output = output;
+			}
 			context.expanded = this.#expanded;
 			context.previewLines = BASH_DEFAULT_PREVIEW_LINES;
 			context.timeout = normalizeTimeoutSeconds(this.#args?.timeout, 3600);

package/src/modes/components/tree-selector.ts

@@ -2,6 +2,7 @@ import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import {
 	type Component,
 	Container,
+	extractPrintableText,
 	Input,
 	matchesKey,
 	Spacer,
@@ -745,12 +746,9 @@ class TreeList implements Component {
 				this.onLabelEdit(selected.node.entry.id, selected.node.label);
 			}
 		} else {
-			const hasControlChars = [...keyData].some(ch => {
-				const code = ch.charCodeAt(0);
-				return code < 32 || code === 0x7f || (code >= 0x80 && code <= 0x9f);
-			});
-			if (!hasControlChars && keyData.length > 0) {
-				this.#searchQuery += keyData;
+			const printableText = extractPrintableText(keyData);
+			if (printableText) {
+				this.#searchQuery += printableText;
 				this.#applyFilter();
 			}
 		}

package/src/modes/components/welcome.ts

@@ -122,6 +122,7 @@ export class WelcomeComponent implements Component {
 		const rightLines = [
 			` ${theme.bold(theme.fg("accent", "Tips"))}`,
 			` ${theme.fg("dim", "?")}${theme.fg("muted", " for keyboard shortcuts")}`,
+			` ${theme.fg("dim", "#")}${theme.fg("muted", " for prompt actions")}`,
 			` ${theme.fg("dim", "/")}${theme.fg("muted", " for commands")}`,
 			` ${theme.fg("dim", "!")}${theme.fg("muted", " to run bash")}`,
 			` ${theme.fg("dim", "$")}${theme.fg("muted", " to run python")}`,

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

@@ -435,49 +435,54 @@ export class CommandController {
 		const expandToolsKey = this.ctx.keybindings.getDisplayString("expandTools") || "Ctrl+O";
 		const planModeKey = this.ctx.keybindings.getDisplayString("togglePlanMode") || "Alt+Shift+P";
 		const sttKey = this.ctx.keybindings.getDisplayString("toggleSTT") || "Alt+H";
+		const copyLineKey = this.ctx.keybindings.getDisplayString("copyLine") || "Alt+Shift+L";
+		const copyPromptKey = this.ctx.keybindings.getDisplayString("copyPrompt") || "Alt+Shift+C";
 		const hotkeys = `
-**Navigation**
-| Key | Action |
-|-----|--------|
-| \`Arrow keys\` | Move cursor / browse history (Up when empty) |
-| \`Option+Left/Right\` | Move by word |
-| \`Ctrl+A\` / \`Home\` / \`Cmd+Left\` | Start of line |
-| \`Ctrl+E\` / \`End\` / \`Cmd+Right\` | End of line |
-
-**Editing**
-| Key | Action |
-|-----|--------|
-| \`Enter\` | Send message |
-| \`Shift+Enter\` / \`Alt+Enter\` | New line |
-| \`Ctrl+W\` / \`Option+Backspace\` | Delete word backwards |
-| \`Ctrl+U\` | Delete to start of line |
-| \`Ctrl+K\` | Delete to end of line |
-
-**Other**
-| Key | Action |
-|-----|--------|
-| \`Tab\` | Path completion / accept autocomplete |
-| \`Escape\` | Cancel autocomplete / abort streaming |
-| \`Ctrl+C\` | Clear editor (first) / exit (second) |
-| \`Ctrl+D\` | Exit (when editor is empty) |
-| \`Ctrl+Z\` | Suspend to background |
-| \`Shift+Tab\` | Cycle thinking level |
-| \`Ctrl+P\` | Cycle role models (slow/default/smol) |
-| \`Shift+Ctrl+P\` | Cycle role models (temporary) |
-| \`Alt+P\` | Select model (temporary) |
-| \`Ctrl+L\` | Select model (set roles) |
-| \`${planModeKey}\` | Toggle plan mode |
-| \`Ctrl+R\` | Search prompt history |
-| \`${expandToolsKey}\` | Toggle tool output expansion |
-| \`Ctrl+T\` | Toggle todo list expansion |
-| \`Ctrl+G\` | Edit message in external editor |
-| \`${sttKey}\` | Toggle speech-to-text recording |
-| \`/\` | Slash commands |
-| \`!\` | Run bash command |
-| \`!!\` | Run bash command (excluded from context) |
-| \`$\` | Run Python in shared kernel |
-| \`$$\` | Run Python (excluded from context) |
-`;
+		**Navigation**
+		| Key | Action |
+		|-----|--------|
+		| \`Arrow keys\` | Move cursor / browse history (Up when empty) |
+		| \`Option+Left/Right\` | Move by word |
+		| \`Ctrl+A\` / \`Home\` / \`Cmd+Left\` | Start of line |
+		| \`Ctrl+E\` / \`End\` / \`Cmd+Right\` | End of line |
+		
+		**Editing**
+		| Key | Action |
+		|-----|--------|
+		| \`Enter\` | Send message |
+		| \`Shift+Enter\` / \`Alt+Enter\` | New line |
+		| \`Ctrl+W\` / \`Option+Backspace\` | Delete word backwards |
+		| \`Ctrl+U\` | Delete to start of line |
+		| \`Ctrl+K\` | Delete to end of line |
+		| \`${copyLineKey}\` | Copy current line |
+		| \`${copyPromptKey}\` | Copy whole prompt |
+		
+		**Other**
+		| Key | Action |
+		|-----|--------|
+		| \`Tab\` | Path completion / accept autocomplete |
+		| \`Escape\` | Cancel autocomplete / abort streaming |
+		| \`Ctrl+C\` | Clear editor (first) / exit (second) |
+		| \`Ctrl+D\` | Exit (when editor is empty) |
+		| \`Ctrl+Z\` | Suspend to background |
+		| \`Shift+Tab\` | Cycle thinking level |
+		| \`Ctrl+P\` | Cycle role models (slow/default/smol) |
+		| \`Shift+Ctrl+P\` | Cycle role models (temporary) |
+		| \`Alt+P\` | Select model (temporary) |
+		| \`Ctrl+L\` | Select model (set roles) |
+		| \`${planModeKey}\` | Toggle plan mode |
+		| \`Ctrl+R\` | Search prompt history |
+		| \`${expandToolsKey}\` | Toggle tool output expansion |
+		| \`Ctrl+T\` | Toggle todo list expansion |
+		| \`Ctrl+G\` | Edit message in external editor |
+		| \`${sttKey}\` | Toggle speech-to-text recording |
+		| \`#\` | Open prompt actions |
+		| \`/\` | Slash commands |
+		| \`!\` | Run bash command |
+		| \`!!\` | Run bash command (excluded from context) |
+		| \`$\` | Run Python in shared kernel |
+		| \`$$\` | Run Python (excluded from context) |
+		`;
 		this.ctx.chatContainer.addChild(new Spacer(1));
 		this.ctx.chatContainer.addChild(new DynamicBorder());
 		this.ctx.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", "Keyboard Shortcuts")), 1, 0));

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

@@ -184,13 +184,19 @@ export class EventController {
 							continue;
 						}
 
+						// Preserve the raw partial JSON for renderers that need to surface fields before the JSON object closes.
+						// Bash uses this to show inline env assignments during streaming instead of popping them in at completion.
+						const renderArgs =
+							"partialJson" in content
+								? { ...content.arguments, __partialJson: content.partialJson }
+								: content.arguments;
 						if (!this.ctx.pendingTools.has(content.id)) {
 							this.#resetReadGroup();
 							this.ctx.chatContainer.addChild(new Text("", 0, 0));
 							const tool = this.ctx.session.getToolByName(content.name);
 							const component = new ToolExecutionComponent(
 								content.name,
-								content.arguments,
+								renderArgs,
 								{
 									showImages: settings.get("terminal.showImages"),
 									editFuzzyThreshold: settings.get("edit.fuzzyThreshold"),
@@ -206,7 +212,7 @@ export class EventController {
 						} else {
 							const component = this.ctx.pendingTools.get(content.id);
 							if (component) {
-								component.updateArgs(content.arguments, content.id);
+								component.updateArgs(renderArgs, content.id);
 							}
 						}
 					}

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

@@ -1,8 +1,10 @@
 import * as fs from "node:fs/promises";
 import { type AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { copyToClipboard, readImageFromClipboard, sanitizeText } from "@oh-my-pi/pi-natives";
+import type { AutocompleteProvider, SlashCommand } from "@oh-my-pi/pi-tui";
 import { $env } from "@oh-my-pi/pi-utils";
 import { settings } from "../../config/settings";
+import { createPromptActionAutocompleteProvider } from "../../modes/prompt-action-autocomplete";
 import { theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext } from "../../modes/types";
 import type { AgentSessionEvent } from "../../session/agent-session";
@@ -87,7 +89,8 @@ export class InputController {
 		this.ctx.editor.onCtrlG = () => void this.openExternalEditor();
 		this.ctx.editor.onQuestionMark = () => this.ctx.handleHotkeysCommand();
 		this.ctx.editor.onCtrlV = () => this.handleImagePaste();
-		this.ctx.editor.onCopyPrompt = () => this.handleCopyPrompt();
+		const copyPromptKeys = this.ctx.keybindings.getKeys("copyPrompt");
+		this.ctx.editor.onCopyPrompt = copyPromptKeys.includes("alt+shift+c") ? () => this.handleCopyPrompt() : undefined;
 
 		// Wire up extension shortcuts
 		this.registerExtensionShortcuts();
@@ -129,6 +132,13 @@ export class InputController {
 		for (const key of this.ctx.keybindings.getKeys("toggleSTT")) {
 			this.ctx.editor.setCustomKeyHandler(key, () => void this.ctx.handleSTTToggle());
 		}
+		for (const key of this.ctx.keybindings.getKeys("copyLine")) {
+			this.ctx.editor.setCustomKeyHandler(key, () => this.handleCopyCurrentLine());
+		}
+		for (const key of copyPromptKeys) {
+			if (key === "alt+shift+c") continue;
+			this.ctx.editor.setCustomKeyHandler(key, () => this.handleCopyPrompt());
+		}
 
 		this.ctx.editor.onChange = (text: string) => {
 			const wasBashMode = this.ctx.isBashMode;
@@ -503,6 +513,36 @@ export class InputController {
 		}
 	}
 
+	createAutocompleteProvider(commands: SlashCommand[], basePath: string): AutocompleteProvider {
+		return createPromptActionAutocompleteProvider({
+			commands,
+			basePath,
+			keybindings: this.ctx.keybindings,
+			copyCurrentLine: () => this.handleCopyCurrentLine(),
+			copyPrompt: () => this.handleCopyPrompt(),
+			moveCursorToLineStart: () => this.ctx.editor.moveToLineStart(),
+			moveCursorToLineEnd: () => this.ctx.editor.moveToLineEnd(),
+		});
+	}
+
+	/** Copy the current editor line to the system clipboard. */
+	handleCopyCurrentLine(): void {
+		const { line } = this.ctx.editor.getCursor();
+		const text = this.ctx.editor.getLines()[line] || "";
+		if (!text) {
+			this.ctx.showStatus("Nothing to copy");
+			return;
+		}
+		try {
+			copyToClipboard(text);
+			const sanitized = sanitizeText(text);
+			const preview = sanitized.length > 30 ? `${sanitized.slice(0, 30)}...` : sanitized;
+			this.ctx.showStatus(`Copied line: ${preview}`);
+		} catch {
+			this.ctx.showWarning("Failed to copy to clipboard");
+		}
+	}
+
 	/** Copy current prompt text to system clipboard. */
 	handleCopyPrompt(): void {
 		const text = this.ctx.editor.getText();

package/src/modes/interactive-mode.ts

@@ -6,15 +6,7 @@ import * as path from "node:path";
 import { type Agent, type AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { AssistantMessage, ImageContent, Message, Model, UsageReport } from "@oh-my-pi/pi-ai";
 import type { Component, Loader, SlashCommand } from "@oh-my-pi/pi-tui";
-import {
-	CombinedAutocompleteProvider,
-	Container,
-	Markdown,
-	ProcessTerminal,
-	Spacer,
-	Text,
-	TUI,
-} from "@oh-my-pi/pi-tui";
+import { Container, Markdown, ProcessTerminal, Spacer, Text, TUI } from "@oh-my-pi/pi-tui";
 import { APP_NAME, getProjectDir, hsvToRgb, isEnoent, logger, postmortem } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import { KeybindingsManager } from "../config/keybindings";
@@ -389,7 +381,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			name: cmd.name,
 			description: cmd.description,
 		}));
-		const autocompleteProvider = new CombinedAutocompleteProvider(
+		const autocompleteProvider = this.#inputController.createAutocompleteProvider(
 			[...this.#pendingSlashCommands, ...fileSlashCommands],
 			basePath,
 		);

package/src/modes/prompt-action-autocomplete.ts

@@ -0,0 +1,201 @@
+import {
+	type AutocompleteItem,
+	type AutocompleteProvider,
+	CombinedAutocompleteProvider,
+	getEditorKeybindings,
+	type SlashCommand,
+} from "@oh-my-pi/pi-tui";
+import { formatKeyHints, type KeybindingsManager } from "../config/keybindings";
+
+interface PromptActionDefinition {
+	id: string;
+	label: string;
+	description: string;
+	keywords: string[];
+	execute: () => void;
+}
+
+interface PromptActionAutocompleteItem extends AutocompleteItem {
+	actionId: string;
+	execute: () => void;
+}
+
+interface PromptActionAutocompleteOptions {
+	commands: SlashCommand[];
+	basePath: string;
+	keybindings: KeybindingsManager;
+	copyCurrentLine: () => void;
+	copyPrompt: () => void;
+	moveCursorToLineStart: () => void;
+	moveCursorToLineEnd: () => void;
+}
+
+function fuzzyMatch(query: string, target: string): boolean {
+	if (query.length === 0) return true;
+	if (query.length > target.length) return false;
+
+	let queryIndex = 0;
+	for (let targetIndex = 0; targetIndex < target.length && queryIndex < query.length; targetIndex += 1) {
+		if (query[queryIndex] === target[targetIndex]) {
+			queryIndex += 1;
+		}
+	}
+
+	return queryIndex === query.length;
+}
+
+function fuzzyScore(query: string, target: string): number {
+	if (query.length === 0) return 1;
+	if (target === query) return 100;
+	if (target.startsWith(query)) return 80;
+	if (target.includes(query)) return 60;
+
+	let queryIndex = 0;
+	let gaps = 0;
+	let lastMatchIndex = -1;
+	for (let targetIndex = 0; targetIndex < target.length && queryIndex < query.length; targetIndex += 1) {
+		if (query[queryIndex] === target[targetIndex]) {
+			if (lastMatchIndex >= 0 && targetIndex - lastMatchIndex > 1) {
+				gaps += 1;
+			}
+			lastMatchIndex = targetIndex;
+			queryIndex += 1;
+		}
+	}
+
+	if (queryIndex !== query.length) return 0;
+	return Math.max(1, 40 - gaps * 5);
+}
+
+function isPromptActionItem(item: AutocompleteItem): item is PromptActionAutocompleteItem {
+	return (
+		"actionId" in item && "execute" in item && typeof (item as PromptActionAutocompleteItem).execute === "function"
+	);
+}
+
+function getPromptActionPrefix(textBeforeCursor: string): string | null {
+	const hashIndex = textBeforeCursor.lastIndexOf("#");
+	if (hashIndex === -1) return null;
+
+	const query = textBeforeCursor.slice(hashIndex + 1);
+	if (/[\s]/.test(query)) {
+		return null;
+	}
+
+	return textBeforeCursor.slice(hashIndex);
+}
+
+export class PromptActionAutocompleteProvider implements AutocompleteProvider {
+	#baseProvider: CombinedAutocompleteProvider;
+	#actions: PromptActionDefinition[];
+
+	constructor(commands: SlashCommand[], basePath: string, actions: PromptActionDefinition[]) {
+		this.#baseProvider = new CombinedAutocompleteProvider(commands, basePath);
+		this.#actions = actions;
+	}
+
+	async getSuggestions(
+		lines: string[],
+		cursorLine: number,
+		cursorCol: number,
+	): Promise<{ items: AutocompleteItem[]; prefix: string } | null> {
+		const currentLine = lines[cursorLine] || "";
+		const textBeforeCursor = currentLine.slice(0, cursorCol);
+		const promptActionPrefix = getPromptActionPrefix(textBeforeCursor);
+		if (promptActionPrefix) {
+			const query = promptActionPrefix.slice(1).toLowerCase();
+			const items = this.#actions
+				.map(action => {
+					const searchable = [action.label, action.description, ...action.keywords].join(" ").toLowerCase();
+					if (!fuzzyMatch(query, searchable)) return null;
+					return {
+						value: action.label,
+						label: action.label,
+						description: action.description,
+						actionId: action.id,
+						execute: action.execute,
+						score: fuzzyScore(query, searchable),
+					} satisfies PromptActionAutocompleteItem & { score: number };
+				})
+				.filter(item => item !== null)
+				.sort((a, b) => b.score - a.score)
+				.map(({ score: _score, ...item }) => item);
+			if (items.length > 0) {
+				return { items, prefix: promptActionPrefix };
+			}
+		}
+
+		return this.#baseProvider.getSuggestions(lines, cursorLine, cursorCol);
+	}
+
+	applyCompletion(
+		lines: string[],
+		cursorLine: number,
+		cursorCol: number,
+		item: AutocompleteItem,
+		prefix: string,
+	): {
+		lines: string[];
+		cursorLine: number;
+		cursorCol: number;
+		onApplied?: () => void;
+	} {
+		if (prefix.startsWith("#") && isPromptActionItem(item)) {
+			const currentLine = lines[cursorLine] || "";
+			const beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
+			const afterCursor = currentLine.slice(cursorCol);
+			const newLines = [...lines];
+			newLines[cursorLine] = beforePrefix + afterCursor;
+			return {
+				lines: newLines,
+				cursorLine,
+				cursorCol: beforePrefix.length,
+				onApplied: item.execute,
+			};
+		}
+
+		return this.#baseProvider.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+	}
+
+	getInlineHint(lines: string[], cursorLine: number, cursorCol: number): string | null {
+		return this.#baseProvider.getInlineHint?.(lines, cursorLine, cursorCol) ?? null;
+	}
+}
+
+export function createPromptActionAutocompleteProvider(
+	options: PromptActionAutocompleteOptions,
+): PromptActionAutocompleteProvider {
+	const editorKeybindings = getEditorKeybindings();
+	const actions: PromptActionDefinition[] = [
+		{
+			id: "copy-line",
+			label: "Copy current line",
+			description: formatKeyHints(options.keybindings.getKeys("copyLine")),
+			keywords: ["copy", "line", "clipboard", "current"],
+			execute: options.copyCurrentLine,
+		},
+		{
+			id: "copy-prompt",
+			label: "Copy whole prompt",
+			description: formatKeyHints(options.keybindings.getKeys("copyPrompt")),
+			keywords: ["copy", "prompt", "clipboard", "message"],
+			execute: options.copyPrompt,
+		},
+		{
+			id: "cursor-line-start",
+			label: "Move cursor to beginning of line",
+			description: formatKeyHints(editorKeybindings.getKeys("cursorLineStart")),
+			keywords: ["move", "cursor", "line", "start", "beginning", "home"],
+			execute: options.moveCursorToLineStart,
+		},
+		{
+			id: "cursor-line-end",
+			label: "Move cursor to end of line",
+			description: formatKeyHints(editorKeybindings.getKeys("cursorLineEnd")),
+			keywords: ["move", "cursor", "line", "end"],
+			execute: options.moveCursorToLineEnd,
+		},
+	];
+
+	return new PromptActionAutocompleteProvider(options.commands, options.basePath, actions);
+}

package/src/modes/utils/ui-helpers.ts

@@ -272,9 +272,13 @@ export class UiHelpers {
 
 					readGroup = null;
 					const tool = this.ctx.session.getToolByName(content.name);
+					const renderArgs =
+						"partialJson" in content
+							? { ...content.arguments, __partialJson: content.partialJson }
+							: content.arguments;
 					const component = new ToolExecutionComponent(
 						content.name,
-						content.arguments,
+						renderArgs,
 						{
 							showImages: settings.get("terminal.showImages"),
 							editFuzzyThreshold: settings.get("edit.fuzzyThreshold"),

package/src/patch/index.ts

@@ -96,7 +96,7 @@ export type ReplaceParams = Static<typeof replaceEditSchema>;
 export type PatchParams = Static<typeof patchEditSchema>;
 
 /** Pattern matching hashline display format prefixes: `LINE#ID:CONTENT` and `#ID:CONTENT` */
-const HASHLINE_PREFIX_RE = /^\s*(?:>>>|>>)?\s*(?:\d+\s*#\s*|#)\s*[0-9a-zA-Z]{1,16}:/;
+const HASHLINE_PREFIX_RE = /^\s*(?:>>>|>>)?\s*(?:\d+\s*#\s*|#\s*)[ZPMQVRWSNKTXJBYH]{2}:/;
 
 /** Pattern matching a unified-diff added-line `+` prefix (but not `++`). Does NOT match `-` to avoid corrupting Markdown list items. */
 const DIFF_PLUS_RE = /^[+](?![+])/;

package/src/prompts/agents/explore.md

@@ -99,6 +99,7 @@ Given a task, you rapidly investigate the codebase and return structured finding
 <directives>
 - You **MUST** use tools for broad pattern matching / code search as much as possible.
 - You **SHOULD** invoke tools in parallel when possible—this is a short investigation, and you are supposed to finish in a few seconds.
+- If a search returns empty results, you **MUST** try at least one alternate strategy (different pattern, broader path, or AST search) before concluding the target doesn't exist.
 </directives>
 
 <thoroughness>

package/src/prompts/agents/librarian.md

@@ -111,6 +111,8 @@ Before acting, determine what kind of question this is:
 - If you discover undocumented behavior or gotchas, you **MUST** populate `caveats`.
 - When local `node_modules` has the package, you **SHOULD** prefer it over cloning — it reflects the version the project actually uses.
 - You **SHOULD** use `web_search` to find the canonical repo URL and to check for known issues, but the definitive answer **MUST** come from reading source code.
+- If a search or lookup returns empty or unexpectedly few results, you **MUST** try at least 2 fallback strategies (broader query, alternate path, different source) before concluding nothing exists.
+- If the package is absent from local `node_modules` and cloning fails, you **MUST** fall back to `web_search` for official API documentation before reporting failure.
 </directives>
 
 <critical>

package/src/prompts/system/handoff-document.md

@@ -0,0 +1,46 @@
+<critical>
+Write a comprehensive handoff document for another instance of yourself.
+The handoff **MUST** be sufficient for seamless continuation without access to this conversation.
+Output ONLY the handoff document. No preamble, no commentary, no wrapper text.
+</critical>
+
+<instruction>
+Capture exact technical state, not abstractions.
+Include concrete file paths, symbol names, commands run, test results, observed failures, decisions made, and any partial work that materially affects the next step.
+</instruction>
+
+<output>
+Use exactly this structure:
+
+## Goal
+[What the user is trying to accomplish]
+
+## Constraints & Preferences
+- [Any constraints, preferences, or requirements mentioned]
+
+## Progress
+### Done
+- [x] [Completed tasks with specifics]
+
+### In Progress
+- [ ] [Current work if any]
+
+### Pending
+- [ ] [Tasks mentioned but not started]
+
+## Key Decisions
+- **[Decision]**: [Rationale]
+
+## Critical Context
+- [Code snippets, file paths, function/type names, error messages, or data essential to continue]
+- [Repository state if relevant]
+
+## Next Steps
+1. [What should happen next]
+</output>
+
+{{#if additionalFocus}}
+<instruction>
+Additional focus: {{additionalFocus}}
+</instruction>
+{{/if}}

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

@@ -29,13 +29,7 @@ Your result **MUST** match this TypeScript interface:
 {{/if}}
 
 {{SECTION_SEPERATOR "Giving Up"}}
-If you cannot complete the assignment, you **MUST** call `submit_result` exactly once with `result.error` describing what you tried and the exact blocker.
+Giving up is a last resort. If truly blocked, you **MUST** call `submit_result` exactly once with `result.error` describing what you tried and the exact blocker.
+You **MUST NOT** give up due to uncertainty, missing information obtainable via tools or repo context, or needing a design decision you can derive yourself.
 
-Giving up is a last resort.
-You **MUST NOT** give up due to uncertainty or missing information obtainable via tools or repo context.
-You **MUST NOT** give up due to requiring a design, you can derive that yourself, more than capable of that.
-
-Proceed with the best approach using the most reasonable option.
-
-You **MUST** keep going until this ticket is closed.
-This matters.
+You **MUST** keep going until this ticket is closed. This matters.

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

@@ -313,8 +313,9 @@ Today is '{{date}}', and your work begins now. Get it right.
 - You **MUST** use the most specialized tool, **NEVER** `cat` if there's tool.bash, `rg/grep`:tool.grep, `find`:tool.find, `sed`:tool.edit…
 - Every turn **MUST** materially advance the deliverable.
 - You **MUST** default to action. You **MUST NOT** ask for confirmation to continue work. If you hit an error, you **MUST** fix it. If you know the next step, you **MUST** take it. The user will intervene if needed.
-- You **MUST NOT** make speculative edits before understanding the surrounding design.
 - You **MUST** default to informed action. You **MUST NOT** ask for confirmation to continue work. If you hit an error, you **MUST** fix it. If you know the next step, you **MUST** take it. The user will intervene if needed.
+- You **MUST NOT** make speculative edits before understanding the surrounding design.
+- You **MUST NOT** stop calling tools to save round-trips when the task is incomplete. Completeness beats efficiency.
 - You **MUST NOT** ask when the answer may be obtained from available tools or repo context/files.
 - You **MUST** verify the effect. When a task involves a behavioral change, you **MUST** confirm the change is observable before yielding: run the specific test, command, or scenario that covers your change.
 </critical>

package/src/prompts/tools/bash.md

@@ -2,6 +2,8 @@ Executes bash command in shell session for terminal operations like git, bun, ca
 
 <instruction>
 - You **MUST** use `cwd` parameter to set working directory instead of `cd dir && …`
+- Prefer `env: { NAME: "…" }` for multiline, quote-heavy, or untrusted values instead of inlining them into shell syntax; reference them from the command as `$NAME`
+- Quote variable expansions like `"$NAME"` to preserve exact content and avoid shell parsing bugs
 - PTY mode is opt-in: set `pty: true` only when command expects a real terminal (for example `sudo`, `ssh` where you need input from the user); default is `false`
 - You **MUST** use `;` only when later commands should run regardless of earlier failures
 - `skill://` URIs are auto-resolved to filesystem paths before execution