@oh-my-pi/pi-coding-agent 13.3.7 → 13.3.8

package/src/prompts/tools/lsp.md

@@ -1,16 +1,33 @@
 Interacts with Language Server Protocol servers for code intelligence.
 
 <operations>
-- `definition`: Go to symbol definition → file path + position
-- `references`: Find all references → list of locations (file + position)
+- `diagnostics`: Get errors/warnings for file, glob, or entire workspace (no file)
+- `definition`: Go to symbol definition → file path + position + 3-line source context
+- `type_definition`: Go to symbol type definition → file path + position + 3-line source context
+- `implementation`: Find concrete implementations → file path + position + 3-line source context
+- `references`: Find references → locations with 3-line source context (first 50), remaining location-only
 - `hover`: Get type info and documentation → type signature + docs
-- `symbols`: List symbols in file, or search workspace (with query, no file) → names, kinds, locations
-- `rename`: Rename symbol across codebase → confirmation of changes
-- `diagnostics`: Get errors/warnings for file, or check entire project (no file) → list with severity + message
+- `symbols`: List symbols in file, or search workspace (with query, no file)
+- `rename`: Rename symbol across codebase → preview or apply edits
+- `code_actions`: List available quick-fixes/refactors/import actions; apply one when `apply: true` and `query` matches title or index
+- `status`: Show active language servers
 - `reload`: Restart the language server
 </operations>
 
+<parameters>
+- `file`: File path; for diagnostics it may be a glob pattern (e.g., `src/**/*.ts`)
+- `line`: 1-indexed line number for position-based actions
+- `symbol`: Substring on the target line used to resolve column automatically
+- `occurrence`: 1-indexed match index when `symbol` appears multiple times on the same line
+- `query`: Symbol search query, code-action kind filter (list mode), or code-action selector (apply mode)
+- `new_name`: Required for rename
+- `apply`: Apply edits for rename/code_actions (default true for rename, list mode for code_actions unless explicitly true)
+- `timeout`: Request timeout in seconds (clamped to 5-60, default 20)
+</parameters>
+
 <caution>
 - Requires running LSP server for target language
 - Some operations require file to be saved to disk
+- Diagnostics glob mode samples up to 20 files per request to avoid long-running stalls on broad patterns
+- When `symbol` is provided for position-based actions, missing symbols or out-of-bounds `occurrence` values return an explicit error instead of silently falling back
 </caution>

package/src/sdk.ts

@@ -1295,7 +1295,17 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			return key;
 		},
 		cursorExecHandlers,
-		transformToolCallArguments: obfuscator?.hasSecrets() ? args => obfuscator!.deobfuscateObject(args) : undefined,
+		transformToolCallArguments: (args, _toolName) => {
+			let result = args;
+			const maxTimeout = settings.get("tools.maxTimeout");
+			if (maxTimeout > 0 && typeof result.timeout === "number") {
+				result = { ...result, timeout: Math.min(result.timeout, maxTimeout) };
+			}
+			if (obfuscator?.hasSecrets()) {
+				result = obfuscator.deobfuscateObject(result);
+			}
+			return result;
+		},
 		intentTracing: !!intentField,
 	});
 	cursorEventEmitter = event => agent.emitExternalEvent(event);

package/src/session/agent-session.ts

@@ -355,6 +355,13 @@ export class AgentSession {
 	#pendingTtsrInjections: Rule[] = [];
 	#ttsrAbortPending = false;
 	#ttsrRetryToken = 0;
+	#ttsrResumePromise: Promise<void> | undefined = undefined;
+	#ttsrResumeResolve: (() => void) | undefined = undefined;
+	#postPromptTaskCounter = 0;
+	#postPromptTaskIds = new Set<number>();
+	#postPromptTasksPromise: Promise<void> | undefined = undefined;
+	#postPromptTasksResolve: (() => void) | undefined = undefined;
+	#postPromptTasksAbortController = new AbortController();
 
 	#streamingEditAbortTriggered = false;
 	#streamingEditCheckedLineCounts = new Map<string, number>();
@@ -509,6 +516,7 @@ export class AgentSession {
 					if (this.#shouldInterruptForTtsrMatch(matchContext)) {
 						// Abort the stream immediately — do not gate on extension callbacks
 						this.#ttsrAbortPending = true;
+						this.#ensureTtsrResumePromise();
 						this.agent.abort();
 						// Notify extensions (fire-and-forget, does not block abort)
 						this.#emitSessionEvent({ type: "ttsr_triggered", rules: matches }).catch(() => {});
@@ -517,49 +525,58 @@ export class AgentSession {
 						const generation = this.#promptGeneration;
 						const targetMessageTimestamp =
 							event.message.role === "assistant" ? event.message.timestamp : undefined;
-						setTimeout(async () => {
-							if (this.#ttsrRetryToken !== retryToken) {
-								return;
-							}
+						this.#schedulePostPromptTask(
+							async () => {
+								if (this.#ttsrRetryToken !== retryToken) {
+									this.#resolveTtsrResume();
+									return;
+								}
 
-							const targetAssistantIndex = this.#findTtsrAssistantIndex(targetMessageTimestamp);
-							if (
-								!this.#ttsrAbortPending ||
-								this.#promptGeneration !== generation ||
-								targetAssistantIndex === -1
-							) {
+								const targetAssistantIndex = this.#findTtsrAssistantIndex(targetMessageTimestamp);
+								if (
+									!this.#ttsrAbortPending ||
+									this.#promptGeneration !== generation ||
+									targetAssistantIndex === -1
+								) {
+									this.#ttsrAbortPending = false;
+									this.#pendingTtsrInjections = [];
+									this.#resolveTtsrResume();
+									return;
+								}
 								this.#ttsrAbortPending = false;
-								this.#pendingTtsrInjections = [];
-								return;
-							}
-							this.#ttsrAbortPending = false;
-							const ttsrSettings = this.#ttsrManager?.getSettings();
-							if (ttsrSettings?.contextMode === "discard") {
-								// Remove the partial/aborted assistant turn from agent state
-								this.agent.replaceMessages(this.agent.state.messages.slice(0, targetAssistantIndex));
-							}
-							// Inject TTSR rules as system reminder before retry
-							const injection = this.#getTtsrInjectionContent();
-							if (injection) {
-								const details = { rules: injection.rules.map(rule => rule.name) };
-								this.agent.appendMessage({
-									role: "custom",
-									customType: "ttsr-injection",
-									content: injection.content,
-									display: false,
-									details,
-									timestamp: Date.now(),
-								});
-								this.sessionManager.appendCustomMessageEntry(
-									"ttsr-injection",
-									injection.content,
-									false,
-									details,
-								);
-								this.#markTtsrInjected(details.rules);
-							}
-							this.agent.continue().catch(() => {});
-						}, 50);
+								const ttsrSettings = this.#ttsrManager?.getSettings();
+								if (ttsrSettings?.contextMode === "discard") {
+									// Remove the partial/aborted assistant turn from agent state
+									this.agent.replaceMessages(this.agent.state.messages.slice(0, targetAssistantIndex));
+								}
+								// Inject TTSR rules as system reminder before retry
+								const injection = this.#getTtsrInjectionContent();
+								if (injection) {
+									const details = { rules: injection.rules.map(rule => rule.name) };
+									this.agent.appendMessage({
+										role: "custom",
+										customType: "ttsr-injection",
+										content: injection.content,
+										display: false,
+										details,
+										timestamp: Date.now(),
+									});
+									this.sessionManager.appendCustomMessageEntry(
+										"ttsr-injection",
+										injection.content,
+										false,
+										details,
+									);
+									this.#markTtsrInjected(details.rules);
+								}
+								try {
+									await this.agent.continue();
+								} catch {
+									this.#resolveTtsrResume();
+								}
+							},
+							{ delayMs: 50 },
+						);
 						return;
 					}
 				}
@@ -607,6 +624,13 @@ export class AgentSession {
 			if (event.message.role === "assistant") {
 				this.#lastAssistantMessage = event.message;
 				const assistantMsg = event.message as AssistantMessage;
+				// Resolve TTSR resume gate before checking for new deferred injections.
+				// Gate on #ttsrAbortPending, not stopReason: a non-TTSR abort (e.g. streaming
+				// edit) also produces stopReason === "aborted" but has no continuation coming.
+				// Only skip when #ttsrAbortPending is true (TTSR continuation is imminent).
+				if (!this.#ttsrAbortPending) {
+					this.#resolveTtsrResume();
+				}
 				this.#queueDeferredTtsrInjectionIfNeeded(assistantMsg);
 				if (this.#handoffAbortController) {
 					this.#skipPostTurnMaintenanceAssistantTimestamp = assistantMsg.timestamp;
@@ -683,8 +707,9 @@ export class AgentSession {
 				if (didRetry) return; // Retry was initiated, don't proceed to compaction
 			}
 
-			await this.#checkCompaction(msg);
-
+			const compactionTask = this.#checkCompaction(msg);
+			this.#trackPostPromptTask(compactionTask);
+			await compactionTask;
 			// Check for incomplete todos (unless there was an error or abort)
 			if (msg.stopReason !== "error" && msg.stopReason !== "aborted") {
 				await this.#checkTodoCompletion();
@@ -701,6 +726,141 @@ export class AgentSession {
 		}
 	}
 
+	/** Create the TTSR resume gate promise if one doesn't already exist. */
+	#ensureTtsrResumePromise(): void {
+		if (this.#ttsrResumePromise) return;
+		const { promise, resolve } = Promise.withResolvers<void>();
+		this.#ttsrResumePromise = promise;
+		this.#ttsrResumeResolve = resolve;
+	}
+
+	/** Resolve and clear the TTSR resume gate. */
+	#resolveTtsrResume(): void {
+		if (!this.#ttsrResumeResolve) return;
+		this.#ttsrResumeResolve();
+		this.#ttsrResumeResolve = undefined;
+		this.#ttsrResumePromise = undefined;
+	}
+
+	#ensurePostPromptTasksPromise(): void {
+		if (this.#postPromptTasksPromise) return;
+		const { promise, resolve } = Promise.withResolvers<void>();
+		this.#postPromptTasksPromise = promise;
+		this.#postPromptTasksResolve = resolve;
+	}
+
+	#resolvePostPromptTasks(): void {
+		if (!this.#postPromptTasksResolve) return;
+		this.#postPromptTasksResolve();
+		this.#postPromptTasksResolve = undefined;
+		this.#postPromptTasksPromise = undefined;
+	}
+
+	#trackPostPromptTask(task: Promise<void>): void {
+		const taskId = ++this.#postPromptTaskCounter;
+		this.#postPromptTaskIds.add(taskId);
+		this.#ensurePostPromptTasksPromise();
+		void task
+			.catch(() => {})
+			.finally(() => {
+				this.#postPromptTaskIds.delete(taskId);
+				if (this.#postPromptTaskIds.size === 0) {
+					this.#resolvePostPromptTasks();
+				}
+			});
+	}
+
+	#schedulePostPromptTask(
+		task: (signal: AbortSignal) => Promise<void>,
+		options?: { delayMs?: number; generation?: number; onSkip?: () => void },
+	): void {
+		const delayMs = options?.delayMs ?? 0;
+		const signal = this.#postPromptTasksAbortController.signal;
+		const scheduled = (async () => {
+			if (delayMs > 0) {
+				try {
+					await abortableSleep(delayMs, signal);
+				} catch {
+					return;
+				}
+			}
+			if (signal.aborted) {
+				options?.onSkip?.();
+				return;
+			}
+			if (options?.generation !== undefined && this.#promptGeneration !== options.generation) {
+				options.onSkip?.();
+				return;
+			}
+			await task(signal);
+		})();
+		this.#trackPostPromptTask(scheduled);
+	}
+
+	#scheduleAgentContinue(options?: {
+		delayMs?: number;
+		generation?: number;
+		shouldContinue?: () => boolean;
+		onSkip?: () => void;
+		onError?: () => void;
+	}): void {
+		this.#schedulePostPromptTask(
+			async () => {
+				if (options?.shouldContinue && !options.shouldContinue()) {
+					options.onSkip?.();
+					return;
+				}
+				try {
+					await this.agent.continue();
+				} catch {
+					options?.onError?.();
+				}
+			},
+			{
+				delayMs: options?.delayMs,
+				generation: options?.generation,
+				onSkip: options?.onSkip,
+			},
+		);
+	}
+
+	#cancelPostPromptTasks(): void {
+		this.#postPromptTasksAbortController.abort();
+		this.#postPromptTasksAbortController = new AbortController();
+		this.#postPromptTaskIds.clear();
+		this.#resolvePostPromptTasks();
+	}
+	/**
+	 * Wait for retry, TTSR resume, and any background continuation to settle.
+	 * Loops because a TTSR continuation can trigger a retry (or vice-versa),
+	 * and fire-and-forget `agent.continue()` may still be streaming after
+	 * the TTSR resume gate resolves.
+	 */
+	async #waitForPostPromptRecovery(): Promise<void> {
+		while (true) {
+			if (this.#retryPromise) {
+				await this.#retryPromise;
+				continue;
+			}
+			if (this.#ttsrResumePromise) {
+				await this.#ttsrResumePromise;
+				continue;
+			}
+			if (this.#postPromptTasksPromise) {
+				await this.#postPromptTasksPromise;
+				continue;
+			}
+			// Tracked post-prompt tasks cover deferred continuations scheduled from
+			// event handlers. Keep the streaming fallback for direct agent activity
+			// outside the scheduler.
+			if (this.agent.state.isStreaming) {
+				await this.agent.waitForIdle();
+				continue;
+			}
+			break;
+		}
+	}
+
 	/** Get TTSR injection payload and clear pending injections. */
 	#getTtsrInjectionContent(): { content: string; rules: Rule[] } | undefined {
 		if (this.#pendingTtsrInjections.length === 0) return undefined;
@@ -792,14 +952,26 @@ export class AgentSession {
 			details: { rules: injection.rules.map(rule => rule.name) },
 			timestamp: Date.now(),
 		});
+		this.#ensureTtsrResumePromise();
 		// Mark as injected after this custom message is delivered and persisted (handled in message_end).
 		// followUp() only enqueues; resume on the next tick once streaming settles.
-		setTimeout(() => {
-			if (this.agent.state.isStreaming || !this.agent.hasQueuedMessages()) {
-				return;
-			}
-			this.agent.continue().catch(() => {});
-		}, 0);
+		this.#scheduleAgentContinue({
+			delayMs: 1,
+			generation: this.#promptGeneration,
+			onSkip: () => {
+				this.#resolveTtsrResume();
+			},
+			shouldContinue: () => {
+				if (this.agent.state.isStreaming || !this.agent.hasQueuedMessages()) {
+					this.#resolveTtsrResume();
+					return false;
+				}
+				return true;
+			},
+			onError: () => {
+				this.#resolveTtsrResume();
+			},
+		});
 	}
 
 	/** Build TTSR match context for tool call argument deltas. */
@@ -1271,6 +1443,7 @@ export class AgentSession {
 		} catch (error) {
 			logger.warn("Failed to emit session_shutdown event", { error: String(error) });
 		}
+		this.#cancelPostPromptTasks();
 		const drained = await this.#asyncJobManager?.dispose({ timeoutMs: 3_000 });
 		const deliveryState = this.#asyncJobManager?.getDeliveryState();
 		if (drained === false && deliveryState) {
@@ -1322,6 +1495,16 @@ export class AgentSession {
 		return this.agent.state.isStreaming || this.#promptInFlight;
 	}
 
+	/** Wait until streaming and deferred recovery work are fully settled. */
+	async waitForIdle(): Promise<void> {
+		await this.agent.waitForIdle();
+		await this.#waitForPostPromptRecovery();
+	}
+
+	/** Most recent assistant message in agent state. */
+	getLastAssistantMessage(): AssistantMessage | undefined {
+		return this.#findLastAssistantMessage();
+	}
 	/** Current effective system prompt (includes any per-turn extension modifications) */
 	get systemPrompt(): string {
 		return this.agent.state.systemPrompt;
@@ -1721,7 +1904,7 @@ export class AgentSession {
 	async #promptWithMessage(
 		message: AgentMessage,
 		expandedText: string,
-		options?: Pick<PromptOptions, "toolChoice" | "images">,
+		options?: Pick<PromptOptions, "toolChoice" | "images"> & { skipPostPromptRecoveryWait?: boolean },
 	): Promise<void> {
 		this.#promptInFlight = true;
 		const generation = this.#promptGeneration;
@@ -1826,7 +2009,9 @@ export class AgentSession {
 
 			const agentPromptOptions = options?.toolChoice ? { toolChoice: options.toolChoice } : undefined;
 			await this.#promptAgentWithIdleRetry(messages, agentPromptOptions);
-			await this.#waitForRetry();
+			if (!options?.skipPostPromptRecoveryWait) {
+				await this.#waitForPostPromptRecovery();
+			}
 		} finally {
 			this.#promptInFlight = false;
 		}
@@ -1886,7 +2071,7 @@ export class AgentSession {
 			},
 			hasQueuedMessages: () => this.queuedMessageCount > 0,
 			getContextUsage: () => this.getContextUsage(),
-			waitForIdle: () => this.agent.waitForIdle(),
+			waitForIdle: () => this.waitForIdle(),
 			newSession: async options => {
 				const success = await this.newSession({ parentSession: options?.parentSession });
 				if (!success) {
@@ -2217,6 +2402,8 @@ export class AgentSession {
 	async abort(): Promise<void> {
 		this.abortRetry();
 		this.#promptGeneration++;
+		this.#resolveTtsrResume();
+		this.#cancelPostPromptTasks();
 		this.agent.abort();
 		await this.agent.waitForIdle();
 		// Clear promptInFlight: waitForIdle resolves when the agent loop's finally
@@ -3004,6 +3191,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 		// Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
 		if (skipAbortedCheck && assistantMessage.stopReason === "aborted") return;
 		const contextWindow = this.model?.contextWindow ?? 0;
+		const generation = this.#promptGeneration;
 		// Skip overflow check if the message came from a different model.
 		// This handles the case where user switched from a smaller-context model (e.g. opus)
 		// to a larger-context model (e.g. codex) - the overflow error from the old model
@@ -3029,9 +3217,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 			const promoted = await this.#tryContextPromotion(assistantMessage);
 			if (promoted) {
 				// Retry on the promoted (larger) model without compacting
-				setTimeout(() => {
-					this.agent.continue().catch(() => {});
-				}, 100);
+				this.#scheduleAgentContinue({ delayMs: 100, generation });
 				return;
 			}
 
@@ -3132,7 +3318,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 			content: [{ type: "text", text: reminder }],
 			timestamp: Date.now(),
 		});
-		this.agent.continue().catch(() => {});
+		this.#scheduleAgentContinue({ generation: this.#promptGeneration });
 	}
 
 	/**
@@ -3302,6 +3488,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 	async #runAutoCompaction(reason: "overflow" | "threshold", willRetry: boolean): Promise<void> {
 		const compactionSettings = this.settings.getGroup("compaction");
 
+		const generation = this.#promptGeneration;
 		await this.#emitSessionEvent({ type: "auto_compaction_start", reason });
 		// Properly abort and null existing controller before replacing
 		if (this.#autoCompactionAbortController) {
@@ -3541,10 +3728,15 @@ Be thorough - include exact file paths, function names, error messages, and tech
 			await this.#emitSessionEvent({ type: "auto_compaction_end", result, aborted: false, willRetry });
 
 			if (!willRetry && compactionSettings.autoContinue !== false) {
-				await this.prompt("Continue if you have next steps.", {
-					expandPromptTemplates: false,
-					synthetic: true,
-				});
+				await this.#promptWithMessage(
+					{
+						role: "developer",
+						content: [{ type: "text", text: "Continue if you have next steps." }],
+						timestamp: Date.now(),
+					},
+					"Continue if you have next steps.",
+					{ skipPostPromptRecoveryWait: true },
+				);
 			}
 
 			if (willRetry) {
@@ -3554,15 +3746,15 @@ Be thorough - include exact file paths, function names, error messages, and tech
 					this.agent.replaceMessages(messages.slice(0, -1));
 				}
 
-				setTimeout(() => {
-					this.agent.continue().catch(() => {});
-				}, 100);
+				this.#scheduleAgentContinue({ delayMs: 100, generation });
 			} else if (this.agent.hasQueuedMessages()) {
 				// Auto-compaction can complete while follow-up/steering/custom messages are waiting.
 				// Kick the loop so queued messages are actually delivered.
-				setTimeout(() => {
-					this.agent.continue().catch(() => {});
-				}, 100);
+				this.#scheduleAgentContinue({
+					delayMs: 100,
+					generation,
+					shouldContinue: () => this.agent.hasQueuedMessages(),
+				});
 			}
 		} catch (error) {
 			if (this.#autoCompactionAbortController?.signal.aborted) {
@@ -3685,6 +3877,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 		const retrySettings = this.settings.getGroup("retry");
 		if (!retrySettings.enabled) return false;
 
+		const generation = this.#promptGeneration;
 		this.#retryAttempt++;
 
 		// Create retry promise on first attempt so waitForRetry() can await it
@@ -3764,12 +3957,8 @@ Be thorough - include exact file paths, function names, error messages, and tech
 		}
 		this.#retryAbortController = undefined;
 
-		// Retry via continue() - use setTimeout to break out of event handler chain
-		setTimeout(() => {
-			this.agent.continue().catch(() => {
-				// Retry failed - will be caught by next agent_end
-			});
-		}, 0);
+		// Retry via continue() outside the agent_end event callback chain.
+		this.#scheduleAgentContinue({ delayMs: 1, generation });
 
 		return true;
 	}
@@ -3783,16 +3972,6 @@ Be thorough - include exact file paths, function names, error messages, and tech
 		this.#resolveRetry();
 	}
 
-	/**
-	 * Wait for any in-progress retry to complete.
-	 * Returns immediately if no retry is in progress.
-	 */
-	async #waitForRetry(): Promise<void> {
-		if (this.#retryPromise) {
-			await this.#retryPromise;
-		}
-	}
-
 	async #promptAgentWithIdleRetry(messages: AgentMessage[], options?: { toolChoice?: ToolChoice }): Promise<void> {
 		const deadline = Date.now() + 30_000;
 		for (;;) {

package/src/task/executor.ts

@@ -1070,6 +1070,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			});
 
 			await session.prompt(task);
+			await session.waitForIdle();
 
 			const reminderToolChoice = buildSubmitResultToolChoice(session.model);
 
@@ -1083,6 +1084,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					});
 
 					await session.prompt(reminder, reminderToolChoice ? { toolChoice: reminderToolChoice } : undefined);
+					await session.waitForIdle();
 				} catch (err) {
 					logger.error("Subagent prompt failed", {
 						error: err instanceof Error ? err.message : String(err),
@@ -1090,20 +1092,21 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				}
 			}
 
+			await session.waitForIdle();
 			if (!submitResultCalled && !abortSignal.aborted) {
 				aborted = true;
 				exitCode = 1;
 				error ??= SUBAGENT_WARNING_MISSING_SUBMIT_RESULT;
 			}
 
-			const lastMessage = session.state.messages[session.state.messages.length - 1];
-			if (lastMessage?.role === "assistant") {
-				if (lastMessage.stopReason === "aborted") {
+			const lastAssistant = session.getLastAssistantMessage();
+			if (lastAssistant) {
+				if (lastAssistant.stopReason === "aborted") {
 					aborted = abortReason === "signal" || abortReason === undefined;
 					exitCode = 1;
-				} else if (lastMessage.stopReason === "error") {
+				} else if (lastAssistant.stopReason === "error") {
 					exitCode = 1;
-					error ??= lastMessage.errorMessage || "Subagent failed";
+					error ??= lastAssistant.errorMessage || "Subagent failed";
 				}
 			}
 		} catch (err) {