@oh-my-pi/pi-coding-agent 14.0.5 → 14.1.1

package/src/modes/print-mode.ts

@@ -6,6 +6,7 @@
  * - `omp --mode json "prompt"` - JSON event stream
  */
 import type { AssistantMessage, ImageContent } from "@oh-my-pi/pi-ai";
+import { sanitizeText } from "@oh-my-pi/pi-natives";
 import type { AgentSession } from "../session/agent-session";
 
 /**
@@ -72,11 +73,14 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 				},
 				getThinkingLevel: () => session.thinkingLevel,
 				setThinkingLevel: level => session.setThinkingLevel(level),
+				getSessionName: () => session.sessionManager.getSessionName(),
+				setSessionName: async name => {
+					await session.sessionManager.setSessionName(name, "user");
+				},
 			},
 			// ExtensionContextActions
 			{
 				getModel: () => session.model,
-				getSearchDb: () => session.searchDb,
 				isIdle: () => !session.isStreaming,
 				abort: () => session.abort(),
 				hasPendingMessages: () => session.queuedMessageCount > 0,
@@ -166,14 +170,19 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 
 			// Check for error/aborted
 			if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
-				process.stderr.write(`${assistantMsg.errorMessage || `Request ${assistantMsg.stopReason}`}\n`);
-				process.exit(1);
+				const errorLine = sanitizeText(assistantMsg.errorMessage || `Request ${assistantMsg.stopReason}`);
+				const flushed = process.stderr.write(`${errorLine}\n`);
+				if (flushed) {
+					process.exit(1);
+				} else {
+					process.stderr.once("drain", () => process.exit(1));
+				}
 			}
 
 			// Output text content
 			for (const content of assistantMsg.content) {
 				if (content.type === "text") {
-					process.stdout.write(`${content.text}\n`);
+					process.stdout.write(`${sanitizeText(content.text)}\n`);
 				}
 			}
 		}

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

@@ -1,4 +1,3 @@
-import type { SearchDb } from "@oh-my-pi/pi-natives";
 import {
 	type AutocompleteItem,
 	type AutocompleteProvider,
@@ -24,7 +23,6 @@ interface PromptActionAutocompleteItem extends AutocompleteItem {
 interface PromptActionAutocompleteOptions {
 	commands: SlashCommand[];
 	basePath: string;
-	searchDb?: SearchDb;
 	keybindings: KeybindingsManager;
 	copyCurrentLine: () => void;
 	copyPrompt: () => void;
@@ -92,8 +90,8 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 	#baseProvider: CombinedAutocompleteProvider;
 	#actions: PromptActionDefinition[];
 
-	constructor(commands: SlashCommand[], basePath: string, actions: PromptActionDefinition[], searchDb?: SearchDb) {
-		this.#baseProvider = new CombinedAutocompleteProvider(commands, basePath, searchDb);
+	constructor(commands: SlashCommand[], basePath: string, actions: PromptActionDefinition[]) {
+		this.#baseProvider = new CombinedAutocompleteProvider(commands, basePath);
 		this.#actions = actions;
 	}
 
@@ -229,5 +227,5 @@ export function createPromptActionAutocompleteProvider(
 		},
 	];
 
-	return new PromptActionAutocompleteProvider(options.commands, options.basePath, actions, options.searchDb);
+	return new PromptActionAutocompleteProvider(options.commands, options.basePath, actions);
 }

package/src/modes/rpc/rpc-mode.ts

@@ -440,11 +440,14 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 				},
 				getThinkingLevel: () => session.thinkingLevel,
 				setThinkingLevel: level => session.setThinkingLevel(level),
+				getSessionName: () => session.sessionManager.getSessionName(),
+				setSessionName: async name => {
+					await session.sessionManager.setSessionName(name, "user");
+				},
 			},
 			// ExtensionContextActions
 			{
 				getModel: () => session.agent.state.model,
-				getSearchDb: () => session.searchDb,
 				isIdle: () => !session.isStreaming,
 				abort: () => session.abort(),
 				hasPendingMessages: () => session.queuedMessageCount > 0,
@@ -751,7 +754,10 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 				if (!name) {
 					return error(id, "set_session_name", "Session name cannot be empty");
 				}
-				session.setSessionName(name);
+				const applied = await session.setSessionName(name, "user");
+				if (!applied) {
+					return error(id, "set_session_name", "Session name cannot be empty");
+				}
 				return success(id, "set_session_name");
 			}
 

package/src/modes/shared.ts

@@ -5,10 +5,10 @@ import { theme } from "./theme/theme";
 // Text Sanitization
 // ═══════════════════════════════════════════════════════════════════════════
 
-/** Sanitize text for display in a single-line status. Replaces newlines/tabs with space, collapses runs, trims. */
+/** Sanitize text for display in a single-line status. Strips C0/C1 control characters (including ANSI ESC), collapses whitespace, trims. */
 export function sanitizeStatusText(text: string): string {
 	return text
-		.replace(/[\r\n\t]/g, " ")
+		.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
 		.replace(/ +/g, " ")
 		.trim();
 }

package/src/modes/types.ts

@@ -187,6 +187,7 @@ export interface InteractiveModeContext {
 	handleCompactCommand(customInstructions?: string): Promise<void>;
 	handleHandoffCommand(customInstructions?: string): Promise<void>;
 	handleMoveCommand(targetPath: string): Promise<void>;
+	handleRenameCommand(title: string): Promise<void>;
 	handleMemoryCommand(text: string): Promise<void>;
 	handleSTTToggle(): Promise<void>;
 	executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean): Promise<void>;

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

@@ -297,6 +297,7 @@ export class UiHelpers {
 						tool,
 						this.ctx.ui,
 						this.ctx.sessionManager.getCwd(),
+						content.id,
 					);
 					component.setExpanded(this.ctx.toolOutputExpanded);
 					this.ctx.chatContainer.addChild(component);

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

@@ -54,6 +54,7 @@ Push back when warranted: state the downside, propose an alternative, but **MUST
 - (1) Correctness first, (2) Brevity second, (3) Politeness third.
 - Prefer concise, information-dense writing.
 - Avoid repeating the user's request or narrating routine tool calls.
+- Do not give time estimates or predictions for how long tasks will take. Focus on what needs to be done, not how long it might take.
 </communication>
 
 <instruction-priority>
@@ -101,6 +102,8 @@ You generate code inside-out: starting at the function body, working outward. Th
 - **DRY at 2.** When you write the same pattern a second time, stop and extract a shared helper. Two copies is a maintenance fork. Three copies is a bug.
 - Write maintainable code. Add brief comments when they clarify non-obvious intent, invariants, edge cases, or tradeoffs. Prefer explaining why over restating what the code already does.
 - **Earn every line.** A 12-line switch for a 3-way mapping is a lookup table. A one-liner wrapper that exists only for test access is a design smell.
+- **No speculative complexity.** Do not create helpers, utilities, or abstractions for one-time operations. Do not design for hypothetical future requirements. Three similar lines of code is better than a premature abstraction. The right amount of complexity is what the task actually requires.
+- **Trust internal code.** Do not add error handling, fallbacks, or validation for scenarios that cannot happen. Only validate at system boundaries — user input, external APIs, network responses. Do not use feature flags or backwards-compatibility shims when you can just change the code.
 </code-integrity>
 
 <stakes>
@@ -338,7 +341,8 @@ You are not making code that works. You are making code that communicates — to
 **One job, one level of abstraction.** If you need "and" to describe what something does, it should be two things. Code that mixes levels — orchestrating a flow while also handling parsing, formatting, or low-level manipulation — has no coherent owner and no coherent test. Each piece operates at one level and delegates everything else.
 **Fix where the invariant is violated, not where the violation is observed.** If a function returns the wrong thing, fix the function — not the caller's workaround. If a type is wrong, fix the type — not the cast. The right fix location is always where the contract is broken.
 **New code makes old code obsolete. Remove it.** When you introduce an abstraction, find what it replaces: old helpers, compatibility branches, stale tests, documentation describing removed behavior. Remove them in the same change.
-**No forwarding addresses.** Deleted or moved code leaves no trace — no `// moved to X` comments, no re-exports from the old location, no aliases kept "for now."
+**No forwarding addresses.** Deleted or moved code leaves no trace — no `// moved to X` comments, no re-exports from the old location, no aliases kept "for now," no renaming unused parameters to `_var`, no `// removed` tombstones. If something is unused, delete it completely.
+**Prefer editing over creating.** Do not create new files unless they are necessary to achieve the goal. Editing an existing file prevents file bloat and builds on existing work. A new file must earn its existence.
 **After writing, inhabit the call site.** Read your own code as someone who has never seen the implementation. Does the interface honestly reflect what happened? Is any accepted input silently discarded? Does any pattern exist in more than one place? Fix it.
 When a tool call fails, read the full error before doing anything else. When a file changed since you last read it, re-read before editing.
 {{#has tools "ask"}}- You **MUST** ask before destructive commands like `git checkout/restore/reset`, overwriting changes, or deleting code you didn't write.{{else}}- You **MUST NOT** run destructive git commands, overwrite changes, or delete code you didn't write.{{/has}}

package/src/prompts/tools/bash.md

@@ -12,8 +12,23 @@ Executes bash command in shell session for terminal operations like git, bun, ca
 - Internal URLs are also auto-resolved to filesystem paths before execution.
 {{#if asyncEnabled}}
 - Use `async: true` for long-running commands when you don't need immediate output; the call returns a background job ID and the result is delivered automatically as a follow-up.
+{{/if}}
+{{#if autoBackgroundEnabled}}
+- Long-running non-PTY bash commands may auto-background after about {{autoBackgroundThresholdSeconds}}s and continue as background jobs automatically.
+{{/if}}
+{{#if asyncEnabled}}
+{{else}}
+{{#if autoBackgroundEnabled}}
+- Auto-backgrounded jobs use the same background-job pipeline as explicit async execution.
+{{/if}}
+{{/if}}
+{{#if asyncEnabled}}
 - Use `read jobs://` to inspect all background jobs and `read jobs://<job-id>` for detailed status/output when needed.
-- When you need to wait for async results before continuing, call `await` — it blocks until jobs complete. Do NOT poll `read jobs://` in a loop or yield and hope for delivery.
+- When you need to wait for async results before continuing, call `poll` — it blocks until jobs complete. Do NOT poll `read jobs://` in a loop or yield and hope for delivery.
+{{else}}
+{{#if autoBackgroundEnabled}}
+- If a command auto-backgrounds, use `read jobs://` to inspect jobs and `poll` when you need to wait for completion instead of polling in a loop.
+{{/if}}
 {{/if}}
 </instruction>
 

package/src/prompts/tools/cancel-job.md

@@ -1,4 +1,4 @@
-Cancels a running background job started via async tool execution.
+Cancels a running background job started via async tool execution or bash auto-backgrounding.
 
 You **SHOULD** use this when a background `bash` or `task` job is no longer needed or is stuck.