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

package/src/session/agent-session.ts

@@ -49,13 +49,22 @@ import {
 	modelsAreEqual,
 	parseRateLimitReason,
 } from "@oh-my-pi/pi-ai";
-import { killTree, MacOSPowerAssertion, type SearchDb } from "@oh-my-pi/pi-natives";
-import { abortableSleep, getAgentDbPath, isEnoent, logger, prompt, setNativeKillTree } from "@oh-my-pi/pi-utils";
+import { killTree, MacOSPowerAssertion } from "@oh-my-pi/pi-natives";
+import {
+	abortableSleep,
+	getAgentDbPath,
+	isEnoent,
+	logger,
+	prompt,
+	Snowflake,
+	setNativeKillTree,
+} from "@oh-my-pi/pi-utils";
 import type { AsyncJob, AsyncJobManager } from "../async";
 import type { Rule } from "../capability/rule";
 import { MODEL_ROLE_IDS, type ModelRegistry } from "../config/model-registry";
 import {
 	extractExplicitThinkingSelector,
+	formatModelSelectorValue,
 	formatModelString,
 	parseModelString,
 	type ResolvedModelRoleValue,
@@ -94,7 +103,11 @@ import type { HookCommandContext } from "../extensibility/hooks/types";
 import type { Skill, SkillWarning } from "../extensibility/skills";
 import { expandSlashCommand, type FileSlashCommand } from "../extensibility/slash-commands";
 import { resolveLocalUrlToPath } from "../internal-urls";
-import { executePython as executePythonCommand, type PythonResult } from "../ipy/executor";
+import {
+	disposeKernelSessionsByOwner,
+	executePython as executePythonCommand,
+	type PythonResult,
+} from "../ipy/executor";
 import {
 	buildDiscoverableMCPSearchIndex,
 	collectDiscoverableMCPTools,
@@ -125,6 +138,7 @@ import { getLatestTodoPhasesFromEntries, type TodoItem, type TodoPhase } from ".
 import { ToolError } from "../tools/tool-errors";
 import { clampTimeout } from "../tools/tool-timeouts";
 import { parseCommandArgs } from "../utils/command-args";
+import { type EditMode, resolveEditMode } from "../utils/edit-mode";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import { extractFileMentions, generateFileMentionMessages } from "../utils/file-mentions";
 import { buildNamedToolChoice } from "../utils/tool-choice";
@@ -243,8 +257,8 @@ export interface AgentSessionConfig {
 	ttsrManager?: TtsrManager;
 	/** Secret obfuscator for deobfuscating streaming edit content */
 	obfuscator?: SecretObfuscator;
-	/** Shared native search DB for grep/glob/fuzzyFind-backed workflows. */
-	searchDb?: SearchDb;
+	/** Logical owner for retained Python kernels created by this session. */
+	pythonKernelOwnerId?: string;
 }
 
 /** Options for AgentSession.prompt() */
@@ -396,7 +410,6 @@ export class AgentSession {
 	readonly agent: Agent;
 	readonly sessionManager: SessionManager;
 	readonly settings: Settings;
-	readonly searchDb: SearchDb | undefined;
 
 	#powerAssertion: MacOSPowerAssertion | undefined;
 
@@ -451,9 +464,11 @@ export class AgentSession {
 	#pendingBashMessages: BashExecutionMessage[] = [];
 
 	// Python execution state
-	#pythonAbortController: AbortController | undefined = undefined;
+	#pythonAbortControllers = new Set<AbortController>();
+	#pythonKernelOwnerId: string;
 	#pendingPythonMessages: PythonExecutionMessage[] = [];
-
+	#activePythonExecutions = new Set<Promise<unknown>>();
+	#pythonExecutionDisposing = false;
 	// Extension system
 	#extensionRunner: ExtensionRunner | undefined = undefined;
 	#turnIndex = 0;
@@ -543,9 +558,9 @@ export class AgentSession {
 		this.agent = config.agent;
 		this.sessionManager = config.sessionManager;
 		this.settings = config.settings;
-		this.searchDb = config.searchDb;
 		this.#startPowerAssertion();
 		this.#asyncJobManager = config.asyncJobManager;
+		this.#pythonKernelOwnerId = config.pythonKernelOwnerId ?? `agent-session:${Snowflake.next()}`;
 		this.#scopedModels = config.scopedModels ?? [];
 		this.#thinkingLevel = config.thinkingLevel;
 		this.#promptTemplates = config.promptTemplates ?? [];
@@ -691,7 +706,23 @@ export class AgentSession {
 		}
 	}
 
+	#queuedExtensionEvents: Promise<void> = Promise.resolve();
+
+	#queueExtensionEvent(event: AgentSessionEvent): Promise<void> {
+		const emit = async () => {
+			await this.#emitExtensionEvent(event);
+		};
+		const queued = this.#queuedExtensionEvents.then(emit, emit);
+		this.#queuedExtensionEvents = queued.catch(() => {});
+		return queued;
+	}
+
 	async #emitSessionEvent(event: AgentSessionEvent): Promise<void> {
+		if (event.type === "message_update") {
+			this.#emit(event);
+			void this.#queueExtensionEvent(event);
+			return;
+		}
 		await this.#emitExtensionEvent(event);
 		this.#emit(event);
 	}
@@ -1797,6 +1828,7 @@ export class AgentSession {
 	 * Call this when completely done with the session.
 	 */
 	async dispose(): Promise<void> {
+		this.#pythonExecutionDisposing = true;
 		try {
 			if (this.#extensionRunner?.hasHandlers("session_shutdown")) {
 				await this.#extensionRunner.emit({ type: "session_shutdown" });
@@ -1811,6 +1843,13 @@ export class AgentSession {
 		if (drained === false && deliveryState) {
 			logger.warn("Async job completion deliveries still pending during dispose", { ...deliveryState });
 		}
+		const pythonExecutionsSettled = await this.#preparePythonExecutionsForDispose();
+		if (!pythonExecutionsSettled) {
+			logger.warn(
+				"Detaching retained Python kernel ownership during dispose while Python execution is still active",
+			);
+		}
+		await disposeKernelSessionsByOwner(this.#pythonKernelOwnerId);
 		this.#stopPowerAssertion();
 		await this.sessionManager.close();
 		this.#closeAllProviderSessions("dispose");
@@ -1969,6 +2008,24 @@ export class AgentSession {
 		return Array.from(this.#toolRegistry.keys());
 	}
 
+	#getEditModeSession() {
+		return {
+			settings: this.settings,
+			getActiveModelString: () => (this.model ? formatModelString(this.model) : undefined),
+		} as const;
+	}
+
+	#resolveActiveEditMode(): EditMode {
+		return resolveEditMode(this.#getEditModeSession());
+	}
+
+	async #syncEditToolModeAfterModelChange(previousEditMode: EditMode): Promise<void> {
+		const currentEditMode = this.#resolveActiveEditMode();
+		if (previousEditMode !== currentEditMode && this.getActiveToolNames().includes("edit")) {
+			await this.refreshBaseSystemPrompt();
+		}
+	}
+
 	isMCPDiscoveryEnabled(): boolean {
 		return this.#mcpDiscoveryEnabled;
 	}
@@ -2016,6 +2073,7 @@ export class AgentSession {
 		toolNames: string[],
 		options?: { persistMCPSelection?: boolean; previousSelectedMCPToolNames?: string[] },
 	): Promise<void> {
+		toolNames = [...new Set(toolNames.map(name => name.toLowerCase()))];
 		const previousSelectedMCPToolNames = options?.previousSelectedMCPToolNames ?? this.getSelectedMCPToolNames();
 		const tools: AgentTool[] = [];
 		const validToolNames: string[] = [];
@@ -2107,7 +2165,6 @@ export class AgentSession {
 			sessionManager: this.sessionManager,
 			modelRegistry: this.#modelRegistry,
 			model: this.model,
-			searchDb: this.searchDb,
 			isIdle: () => !this.isStreaming,
 			hasQueuedMessages: () => this.queuedMessageCount > 0,
 			abort: () => {
@@ -3313,8 +3370,8 @@ export class AgentSession {
 	/**
 	 * Set a display name for the current session.
 	 */
-	setSessionName(name: string): void {
-		this.sessionManager.setSessionName(name);
+	setSessionName(name: string, source: "auto" | "user" = "auto"): Promise<boolean> {
+		return this.sessionManager.setSessionName(name, source);
 	}
 
 	/**
@@ -3390,7 +3447,12 @@ export class AgentSession {
 	 * Validates API key, saves to session and settings.
 	 * @throws Error if no API key available for the model
 	 */
-	async setModel(model: Model, role: string = "default"): Promise<void> {
+	async setModel(
+		model: Model,
+		role: string = "default",
+		options?: { selector?: string; thinkingLevel?: ThinkingLevel },
+	): Promise<void> {
+		const previousEditMode = this.#resolveActiveEditMode();
 		const apiKey = await this.#modelRegistry.getApiKey(model, this.sessionId);
 		if (!apiKey) {
 			throw new Error(`No API key for ${model.provider}/${model.id}`);
@@ -3399,11 +3461,15 @@ export class AgentSession {
 		this.#clearActiveRetryFallback();
 		this.#setModelWithProviderSessionReset(model);
 		this.sessionManager.appendModelChange(`${model.provider}/${model.id}`, role);
-		this.settings.setModelRole(role, this.#formatRoleModelValue(role, model));
+		this.settings.setModelRole(
+			role,
+			this.#formatRoleModelValue(role, model, options?.selector, options?.thinkingLevel),
+		);
 		this.settings.getStorage()?.recordModelUsage(`${model.provider}/${model.id}`);
 
 		// Re-apply the current thinking level for the newly selected model
 		this.setThinkingLevel(this.thinkingLevel);
+		await this.#syncEditToolModeAfterModelChange(previousEditMode);
 	}
 
 	/**
@@ -3412,6 +3478,7 @@ export class AgentSession {
 	 * @throws Error if no API key available for the model
 	 */
 	async setModelTemporary(model: Model, thinkingLevel?: ThinkingLevel): Promise<void> {
+		const previousEditMode = this.#resolveActiveEditMode();
 		const apiKey = await this.#modelRegistry.getApiKey(model, this.sessionId);
 		if (!apiKey) {
 			throw new Error(`No API key for ${model.provider}/${model.id}`);
@@ -3424,6 +3491,7 @@ export class AgentSession {
 
 		// Apply explicit thinking level, or re-clamp current level to new model's capabilities
 		this.setThinkingLevel(thinkingLevel ?? this.thinkingLevel);
+		await this.#syncEditToolModeAfterModelChange(previousEditMode);
 	}
 
 	/**
@@ -3472,6 +3540,7 @@ export class AgentSession {
 			const resolved = resolveModelRoleValue(roleModelStr, availableModels, {
 				settings: this.settings,
 				matchPreferences,
+				modelRegistry: this.#modelRegistry,
 			});
 			if (!resolved.model) continue;
 
@@ -3530,6 +3599,7 @@ export class AgentSession {
 	}
 
 	async #cycleScopedModel(direction: "forward" | "backward"): Promise<ModelCycleResult | undefined> {
+		const previousEditMode = this.#resolveActiveEditMode();
 		const scopedModels = await this.#getScopedModelsWithApiKey();
 		if (scopedModels.length <= 1) return undefined;
 
@@ -3550,11 +3620,13 @@ export class AgentSession {
 
 		// Apply the scoped model's configured thinking level
 		this.setThinkingLevel(next.thinkingLevel);
+		await this.#syncEditToolModeAfterModelChange(previousEditMode);
 
 		return { model: next.model, thinkingLevel: this.thinkingLevel, isScoped: true };
 	}
 
 	async #cycleAvailableModel(direction: "forward" | "backward"): Promise<ModelCycleResult | undefined> {
+		const previousEditMode = this.#resolveActiveEditMode();
 		const availableModels = this.#modelRegistry.getAvailable();
 		if (availableModels.length <= 1) return undefined;
 
@@ -3578,6 +3650,7 @@ export class AgentSession {
 		this.settings.getStorage()?.recordModelUsage(`${nextModel.provider}/${nextModel.id}`);
 		// Re-apply the current thinking level for the newly selected model
 		this.setThinkingLevel(this.thinkingLevel);
+		await this.#syncEditToolModeAfterModelChange(previousEditMode);
 
 		return { model: nextModel, thinkingLevel: this.thinkingLevel, isScoped: false };
 	}
@@ -4236,6 +4309,14 @@ export class AgentSession {
 			return undefined;
 		}
 
+		// Only inject on the first user message of the conversation. Subsequent user
+		// turns must not receive the eager todo reminder — they often correct, clarify,
+		// or redirect the prior task, and forcing a brand-new todo list there is wrong.
+		const hasPriorUserMessage = this.agent.state.messages.some(m => m.role === "user");
+		if (hasPriorUserMessage) {
+			return undefined;
+		}
+
 		const trimmedPromptText = promptText.trimEnd();
 		if (trimmedPromptText.endsWith("?") || trimmedPromptText.endsWith("!")) {
 			return undefined;
@@ -4588,14 +4669,21 @@ export class AgentSession {
 		return `${model.provider}/${model.id}`;
 	}
 
-	#formatRoleModelValue(role: string, model: Model): string {
-		const modelKey = `${model.provider}/${model.id}`;
+	#formatRoleModelValue(
+		role: string,
+		model: Model,
+		selectorOverride?: string,
+		thinkingLevelOverride?: ThinkingLevel,
+	): string {
+		const modelKey = selectorOverride ?? `${model.provider}/${model.id}`;
+		if (thinkingLevelOverride !== undefined) {
+			return formatModelSelectorValue(modelKey, thinkingLevelOverride);
+		}
 		const existingRoleValue = this.settings.getModelRole(role);
 		if (!existingRoleValue) return modelKey;
 
 		const thinkingLevel = extractExplicitThinkingSelector(existingRoleValue, this.settings);
-		if (thinkingLevel === undefined) return modelKey;
-		return `${modelKey}:${thinkingLevel}`;
+		return formatModelSelectorValue(modelKey, thinkingLevel);
 	}
 	#resolveContextPromotionConfiguredTarget(currentModel: Model, availableModels: Model[]): Model | undefined {
 		const configuredTarget = currentModel.contextPromotionTarget?.trim();
@@ -4628,6 +4716,7 @@ export class AgentSession {
 		return resolveModelRoleValue(roleModelStr, availableModels, {
 			settings: this.settings,
 			matchPreferences: { usageOrder: this.settings.getStorage()?.getModelUsageOrder() },
+			modelRegistry: this.#modelRegistry,
 		});
 	}
 
@@ -5644,43 +5733,67 @@ export class AgentSession {
 	): Promise<PythonResult> {
 		const excludeFromContext = options?.excludeFromContext === true;
 		const cwd = this.sessionManager.getCwd();
-
-		if (this.#extensionRunner?.hasHandlers("user_python")) {
-			const hookResult = await this.#extensionRunner.emitUserPython({
-				type: "user_python",
-				code,
-				excludeFromContext,
-				cwd,
-			});
-			if (hookResult?.result) {
-				this.recordPythonResult(code, hookResult.result, options);
-				return hookResult.result;
+		this.assertPythonExecutionAllowed();
+
+		const abortController = new AbortController();
+		const execution = (async (): Promise<PythonResult> => {
+			if (this.#extensionRunner?.hasHandlers("user_python")) {
+				const hookResult = await this.#extensionRunner.emitUserPython({
+					type: "user_python",
+					code,
+					excludeFromContext,
+					cwd,
+				});
+				this.assertPythonExecutionAllowed();
+				if (hookResult?.result) {
+					this.recordPythonResult(code, hookResult.result, options);
+					return hookResult.result;
+				}
 			}
-		}
 
-		this.#pythonAbortController = new AbortController();
-
-		try {
 			// Use the same session ID as the Python tool for kernel sharing
 			const sessionFile = this.sessionManager.getSessionFile();
 			const sessionId = sessionFile ? `session:${sessionFile}:cwd:${cwd}` : `cwd:${cwd}`;
-
 			const result = await executePythonCommand(code, {
 				cwd,
 				sessionId,
+				kernelOwnerId: this.#pythonKernelOwnerId,
 				kernelMode: this.settings.get("python.kernelMode"),
 				useSharedGateway: this.settings.get("python.sharedGateway"),
 				onChunk,
-				signal: this.#pythonAbortController.signal,
+				signal: abortController.signal,
 			});
-
 			this.recordPythonResult(code, result, options);
 			return result;
-		} finally {
-			this.#pythonAbortController = undefined;
+		})();
+		return await this.trackPythonExecution(execution, abortController);
+	}
+
+	assertPythonExecutionAllowed(): void {
+		if (this.#pythonExecutionDisposing) {
+			throw new Error("Python execution is unavailable while session disposal is in progress");
 		}
 	}
 
+	/**
+	 * Track Python work started outside AgentSession.executePython so dispose can await and abort it too.
+	 */
+	trackPythonExecution<T>(execution: Promise<T>, abortController: AbortController): Promise<T> {
+		this.#pythonAbortControllers.add(abortController);
+		this.#activePythonExecutions.add(execution);
+		void execution.then(
+			() => {
+				this.#pythonAbortControllers.delete(abortController);
+				this.#activePythonExecutions.delete(execution);
+			},
+			() => {
+				this.#pythonAbortControllers.delete(abortController);
+				this.#activePythonExecutions.delete(execution);
+			},
+		);
+		return execution;
+	}
+
 	/**
 	 * Record a Python execution result in session history.
 	 */
@@ -5711,12 +5824,46 @@ export class AgentSession {
 	 * Cancel running Python execution.
 	 */
 	abortPython(): void {
-		this.#pythonAbortController?.abort();
+		for (const abortController of this.#pythonAbortControllers) {
+			abortController.abort();
+		}
+	}
+
+	async #waitForPythonExecutionsToSettle(timeoutMs: number): Promise<boolean> {
+		const deadline = Date.now() + timeoutMs;
+		while (this.#activePythonExecutions.size > 0) {
+			const remainingMs = deadline - Date.now();
+			if (remainingMs <= 0) {
+				return false;
+			}
+			const settled = await Promise.race([
+				Promise.allSettled(Array.from(this.#activePythonExecutions)).then(() => true),
+				Bun.sleep(remainingMs).then(() => false),
+			]);
+			if (!settled && this.#activePythonExecutions.size > 0) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	async #preparePythonExecutionsForDispose(): Promise<boolean> {
+		if (!(await this.#waitForPythonExecutionsToSettle(3_000))) {
+			logger.warn("Aborting active Python execution during dispose before retained kernel cleanup");
+			this.abortPython();
+			if (!(await this.#waitForPythonExecutionsToSettle(1_000))) {
+				logger.warn(
+					"Python execution is still active after dispose aborted all active runs; retained kernel ownership will still be detached",
+				);
+				return false;
+			}
+		}
+		return true;
 	}
 
 	/** Whether a Python execution is currently running */
 	get isPythonRunning(): boolean {
-		return this.#pythonAbortController !== undefined;
+		return this.#pythonAbortControllers.size > 0;
 	}
 
 	/** Whether there are pending Python messages waiting to be flushed */

package/src/session/session-manager.ts

@@ -58,6 +58,7 @@ export interface SessionHeader {
 	version?: number; // v1 sessions don't have this
 	id: string;
 	title?: string; // Auto-generated title from first message
+	titleSource?: "auto" | "user";
 	timestamp: string;
 	cwd: string;
 	parentSession?: string;
@@ -268,6 +269,7 @@ export type ReadonlySessionManager = Pick<
 	| "getSessionDir"
 	| "getSessionId"
 	| "getSessionFile"
+	| "getSessionName"
 	| "getArtifactsDir"
 	| "allocateArtifactPath"
 	| "saveArtifact"
@@ -1270,7 +1272,14 @@ async function collectSessionsFromFiles(files: string[], storage: SessionStorage
 				if (entries.length === 0) return;
 
 				// Check first entry for valid session header
-				type SessionHeaderShape = { type: string; id: string; cwd?: string; title?: string; timestamp: string };
+				type SessionHeaderShape = {
+					type: string;
+					id: string;
+					cwd?: string;
+					title?: string;
+					titleSource?: "auto" | "user";
+					timestamp: string;
+				};
 				const header = entries[0] as SessionHeaderShape;
 				if (header.type !== "session" || !header.id) return;
 
@@ -1378,6 +1387,7 @@ export async function resolveResumableSession(
 interface SessionManagerStateSnapshot {
 	sessionId: string;
 	sessionName: string | undefined;
+	titleSource: "auto" | "user" | undefined;
 	sessionFile: string | undefined;
 	flushed: boolean;
 	needsFullRewriteOnNextPersist: boolean;
@@ -1387,6 +1397,7 @@ interface SessionManagerStateSnapshot {
 export class SessionManager {
 	#sessionId: string = "";
 	#sessionName: string | undefined;
+	#titleSource: "auto" | "user" | undefined;
 	#sessionFile: string | undefined;
 	#flushed: boolean = false;
 	#needsFullRewriteOnNextPersist: boolean = false;
@@ -1438,6 +1449,7 @@ export class SessionManager {
 		return {
 			sessionId: this.#sessionId,
 			sessionName: this.#sessionName,
+			titleSource: this.#titleSource,
 			sessionFile: this.#sessionFile,
 			flushed: this.#flushed,
 			needsFullRewriteOnNextPersist: this.#needsFullRewriteOnNextPersist,
@@ -1450,6 +1462,7 @@ export class SessionManager {
 	restoreState(snapshot: SessionManagerStateSnapshot): void {
 		this.#sessionId = snapshot.sessionId;
 		this.#sessionName = snapshot.sessionName;
+		this.#titleSource = snapshot.titleSource;
 		this.#sessionFile = snapshot.sessionFile;
 		this.#flushed = snapshot.flushed;
 		this.#needsFullRewriteOnNextPersist = snapshot.needsFullRewriteOnNextPersist;
@@ -1489,6 +1502,7 @@ export class SessionManager {
 			const header = this.#fileEntries.find(e => e.type === "session") as SessionHeader | undefined;
 			this.#sessionId = header?.id ?? Snowflake.next();
 			this.#sessionName = header?.title;
+			this.#titleSource = header?.titleSource;
 
 			this.#needsFullRewriteOnNextPersist = migrateToCurrentVersion(this.#fileEntries);
 
@@ -1547,11 +1561,13 @@ export class SessionManager {
 			version: CURRENT_SESSION_VERSION,
 			id: this.#sessionId,
 			title: oldHeader?.title ?? this.#sessionName,
+			titleSource: oldHeader?.titleSource ?? this.#titleSource,
 			timestamp,
 			cwd: this.cwd,
 			parentSession: oldSessionId,
 		};
 		this.#sessionName = newHeader.title;
+		this.#titleSource = newHeader.titleSource;
 
 		// Replace the header in fileEntries
 		const entries = this.#fileEntries.filter((e): e is SessionEntry => e.type !== "session");
@@ -1666,6 +1682,7 @@ export class SessionManager {
 		this.#persistErrorReported = false;
 		this.#sessionId = Snowflake.next();
 		this.#sessionName = undefined;
+		this.#titleSource = undefined;
 		const timestamp = new Date().toISOString();
 		const header: SessionHeader = {
 			type: "session",
@@ -1953,17 +1970,43 @@ export class SessionManager {
 		return manager.getPath(id);
 	}
 
+	/** The source that set the session name: "user" (manual /rename or RPC) or "auto" (generated title). */
+	get titleSource(): "auto" | "user" | undefined {
+		return this.#titleSource;
+	}
+
 	getSessionName(): string | undefined {
 		return this.#sessionName;
 	}
 
-	async setSessionName(name: string): Promise<void> {
-		this.#sessionName = name;
+	/** Strip C0/C1 control characters (includes ESC, so removes ANSI sequences) and collapse whitespace. */
+	static #sanitizeName(name: string): string {
+		return name
+			.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
+			.replace(/ +/g, " ")
+			.trim();
+	}
+
+	/**
+	 * Set the session display name.
+	 * @param source - "user" for explicit renames (/rename command, RPC); "auto" for generated titles.
+	 *   Auto-generated titles are silently ignored when the user has already set a name.
+	 */
+	async setSessionName(name: string, source: "auto" | "user" = "auto"): Promise<boolean> {
+		// User-set names take permanent precedence over auto-generated ones.
+		if (this.#titleSource === "user" && source === "auto") return false;
+
+		const sanitized = SessionManager.#sanitizeName(name);
+		if (!sanitized) return false;
+
+		this.#sessionName = sanitized;
+		this.#titleSource = source;
 
 		// Update the in-memory header (so first flush includes title)
 		const header = this.#fileEntries.find(e => e.type === "session") as SessionHeader | undefined;
 		if (header) {
-			header.title = name;
+			header.title = sanitized;
+			header.titleSource = source;
 		}
 
 		// Update the session file header with the title (if already flushed)
@@ -1971,6 +2014,7 @@ export class SessionManager {
 		if (this.persist && sessionFile && this.storage.existsSync(sessionFile)) {
 			await this.#rewriteFile();
 		}
+		return true;
 	}
 
 	_persist(entry: SessionEntry): void {
@@ -2630,8 +2674,10 @@ export class SessionManager {
 		manager.#newSessionSync({ parentSession: sourceHeader?.id });
 		const newHeader = manager.#fileEntries[0] as SessionHeader;
 		newHeader.title = sourceHeader?.title;
+		newHeader.titleSource = sourceHeader?.titleSource;
 		manager.#fileEntries = [newHeader, ...historyEntries];
 		manager.#sessionName = newHeader.title;
+		manager.#titleSource = newHeader.titleSource;
 		manager.sanitizeLoadedOpenAIResponsesReplayMetadata();
 		manager.#buildIndex();
 		await manager.#rewriteFile();

package/src/slash-commands/builtin-registry.ts

@@ -561,6 +561,23 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			await runtime.ctx.handleMemoryCommand(command.text);
 		},
 	},
+	{
+		name: "rename",
+		description: "Rename the current session",
+		inlineHint: "<title>",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const title = command.args.trim();
+			if (!title) {
+				runtime.ctx.showError("Usage: /rename <title>");
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleRenameCommand(title);
+		},
+	},
+
 	{
 		name: "move",
 		description: "Move session to a different working directory",

package/src/task/executor.ts

@@ -5,7 +5,6 @@
  */
 import path from "node:path";
 import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { SearchDb } from "@oh-my-pi/pi-natives";
 import { logger, prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
 import Ajv, { type ValidateFunction } from "ajv";
@@ -149,7 +148,6 @@ export interface ExecutorOptions {
 	mcpManager?: MCPManager;
 	authStorage?: AuthStorage;
 	modelRegistry?: ModelRegistry;
-	searchDb?: SearchDb;
 	settings?: Settings;
 }
 
@@ -435,7 +433,11 @@ function createSubagentSettings(baseSettings: Settings): Settings {
 	for (const key of Object.keys(SETTINGS_SCHEMA) as SettingPath[]) {
 		snapshot[key] = baseSettings.get(key);
 	}
-	return Settings.isolated({ ...snapshot, "async.enabled": false });
+	return Settings.isolated({
+		...snapshot,
+		"async.enabled": false,
+		"bash.autoBackground.enabled": false,
+	});
 }
 
 /**
@@ -954,7 +956,6 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				cwd: worktree ?? cwd,
 				authStorage,
 				modelRegistry,
-				searchDb: options.searchDb,
 				settings: subagentSettings,
 				model,
 				thinkingLevel: effectiveThinkingLevel,
@@ -1057,10 +1058,13 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						},
 						getThinkingLevel: () => session.thinkingLevel,
 						setThinkingLevel: level => session.setThinkingLevel(level),
+						getSessionName: () => session.sessionManager.getSessionName(),
+						setSessionName: async name => {
+							await session.sessionManager.setSessionName(name, "user");
+						},
 					},
 					{
 						getModel: () => session.model,
-						getSearchDb: () => session.searchDb,
 						isIdle: () => !session.isStreaming,
 						abort: () => session.abort(),
 						hasPendingMessages: () => session.queuedMessageCount > 0,