@howaboua/pi-codex-conversion 1.0.10 → 1.0.11

package/README.md

@@ -55,11 +55,13 @@ npm run check
 - `rg --files src | head -n 50` -> `Explored / List src`
 - `cat README.md` -> `Explored / Read README.md`
 - `exec_command({ cmd: "npm test", yield_time_ms: 1000 })` may return `session_id`, then continue with `write_stdin`
-- `write_stdin({ session_id, chars: "" })` renders like `Waited for background terminal`
+- for short or non-interactive commands, omitting `yield_time_ms` is preferred; tiny non-interactive waits are clamped upward to avoid unnecessary follow-up calls
+- `write_stdin({ session_id, chars: "" })` renders like `Waited for background terminal` and is meant for occasional polling, not tight repoll loops
 - `write_stdin({ session_id, chars: "y\\n" })` renders like `Interacted with background terminal`
 - `view_image({ path: "/absolute/path/to/screenshot.png" })` is available on image-capable models
 - `web_search` is surfaced only on `openai-codex`, and the adapter rewrites it into the native OpenAI Responses `type: "web_search"` payload instead of executing a local function tool
 - when native web search is available, the adapter shows a one-time session notice; individual searches are not surfaced because Pi does not expose native web-search execution events to extensions
+- `apply_patch` partial failures stay inline in the patch row so successful and failed file entries can be seen together
 
 Raw command output is still available by expanding the tool result.
 
@@ -136,7 +138,10 @@ That keeps the prompt much closer to `pi-mono` while still steering the model to
 - `view_image` resolves paths against the active session cwd and only exposes `detail: "original"` for Codex-family image-capable models.
 - `web_search` is exposed only for the `openai-codex` provider and is forwarded as the native OpenAI Codex Responses web search tool.
 - `apply_patch` paths stay restricted to the current working directory.
+- partial `apply_patch` failures stay in the original patch block and highlight the failed entry instead of adding a second warning row.
 - `exec_command` / `write_stdin` use a custom PTY-backed session manager via `node-pty` for interactive sessions.
+- tiny `exec_command` waits are clamped for non-interactive commands so short runs do not burn an avoidable follow-up tool call.
+- empty `write_stdin` polls are clamped to a meaningful minimum wait so long-running processes are not repolled too aggressively.
 - PTY output handling applies basic terminal rewrite semantics (`\r`, `\b`, erase-in-line, and common escape cleanup) so interactive redraws replay sensibly.
 - Skills inventory is reintroduced in a Codex-style section when Pi's composed prompt already exposed the underlying Pi skills inventory.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/pi-codex-conversion",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "Codex-oriented tool and prompt adapter for pi coding agent",
   "type": "module",
   "repository": {

package/src/patch/core.ts

@@ -1,8 +1,36 @@
-import { mkdirSync, unlinkSync, writeFileSync } from "node:fs";
+import * as fs from "node:fs";
 import { dirname } from "node:path";
 import { parsePatchActions, parseUpdateFile } from "./parser.ts";
 import { openFileAtPath, pathExists, removeFileAtPath, resolvePatchPath, writeFileAtPath } from "./paths.ts";
-import { DiffError, type ExecutePatchResult, type ParsedPatchAction, type ParserState, type PatchAction } from "./types.ts";
+import { DiffError, ExecutePatchError, type ExecutePatchResult, type ParsedPatchAction, type ParserState, type PatchAction } from "./types.ts";
+
+export const patchFsOps = {
+	mkdirSync: fs.mkdirSync,
+	writeFileSync: fs.writeFileSync,
+	unlinkSync: fs.unlinkSync,
+};
+
+function buildExecutePatchResult({
+	changedFiles,
+	createdFiles,
+	deletedFiles,
+	movedFiles,
+	fuzz,
+}: {
+	changedFiles: Set<string>;
+	createdFiles: Set<string>;
+	deletedFiles: Set<string>;
+	movedFiles: Set<string>;
+	fuzz: number;
+}): ExecutePatchResult {
+	return {
+		changedFiles: [...changedFiles],
+		createdFiles: [...createdFiles],
+		deletedFiles: [...deletedFiles],
+		movedFiles: [...movedFiles],
+		fuzz,
+	};
+}
 
 function splitFileLines(text: string): string[] {
 	const lines = text.split("\n");
@@ -103,21 +131,23 @@ function applyMove({
 	const toAbsolutePath = resolvePatchPath({ cwd, patchPath: movePath });
 	const destinationExisted = pathExists({ cwd, path: movePath });
 
-	mkdirSync(dirname(toAbsolutePath), { recursive: true });
-	writeFileSync(toAbsolutePath, content, "utf8");
-	if (fromAbsolutePath !== toAbsolutePath) {
-		unlinkSync(fromAbsolutePath);
-	}
-
-	changedFiles.add(path);
+	patchFsOps.mkdirSync(dirname(toAbsolutePath), { recursive: true });
+	patchFsOps.writeFileSync(toAbsolutePath, content, "utf8");
 	changedFiles.add(movePath);
-	movedFiles.add(`${path} -> ${movePath}`);
 	if (!destinationExisted) {
 		createdFiles.add(movePath);
 	}
+
 	if (fromAbsolutePath !== toAbsolutePath) {
+		patchFsOps.unlinkSync(fromAbsolutePath);
+		changedFiles.add(path);
+		movedFiles.add(`${path} -> ${movePath}`);
 		deletedFiles.add(path);
+		return;
 	}
+
+	changedFiles.add(path);
+	movedFiles.add(`${path} -> ${movePath}`);
 }
 
 function applyAction({
@@ -200,21 +230,36 @@ export function executePatch({ cwd, patchText }: { cwd: string; patchText: strin
 	let fuzz = 0;
 
 	for (const action of actions) {
-		fuzz += applyAction({
-			cwd,
-			action,
-			changedFiles,
-			createdFiles,
-			deletedFiles,
-			movedFiles,
-		});
+		try {
+			fuzz += applyAction({
+				cwd,
+				action,
+				changedFiles,
+				createdFiles,
+				deletedFiles,
+				movedFiles,
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new ExecutePatchError(
+				message,
+				buildExecutePatchResult({
+					changedFiles,
+					createdFiles,
+					deletedFiles,
+					movedFiles,
+					fuzz,
+				}),
+				action,
+			);
+		}
 	}
 
-	return {
-		changedFiles: [...changedFiles],
-		createdFiles: [...createdFiles],
-		deletedFiles: [...deletedFiles],
-		movedFiles: [...movedFiles],
+	return buildExecutePatchResult({
+		changedFiles,
+		createdFiles,
+		deletedFiles,
+		movedFiles,
 		fuzz,
-	};
+	});
 }

package/src/patch/types.ts

@@ -42,3 +42,25 @@ export class DiffError extends Error {
 		this.name = "DiffError";
 	}
 }
+
+export class ExecutePatchError extends DiffError {
+	result: ExecutePatchResult;
+	failedAction?: ParsedPatchAction;
+
+	constructor(message: string, result: ExecutePatchResult, failedAction?: ParsedPatchAction) {
+		super(message);
+		this.name = "ExecutePatchError";
+		this.result = result;
+		this.failedAction = failedAction;
+	}
+
+	hasPartialSuccess(): boolean {
+		return (
+			this.result.changedFiles.length > 0 ||
+			this.result.createdFiles.length > 0 ||
+			this.result.deletedFiles.length > 0 ||
+			this.result.movedFiles.length > 0 ||
+			this.result.fuzz > 0
+		);
+	}
+}

package/src/prompt/build-system-prompt.ts

@@ -6,9 +6,12 @@ export interface PromptSkill {
 
 const CODEX_GUIDELINES = [
 	"Prefer a single `apply_patch` call that updates all related files together when one coherent patch will do.",
+	"When making coordinated edits across multiple files, include them in one `apply_patch` call instead of splitting them into separate patches.",
 	"When multiple tool calls are independent, emit them together so they can execute in parallel instead of serializing them.",
 	"Use `parallel` only when tool calls are independent and can safely run at the same time.",
 	"Use `write_stdin` when an exec session returns `session_id`, and continue until `exit_code` is present.",
+	"For short or non-interactive commands, prefer the default `exec_command` wait instead of a tiny `yield_time_ms` that forces an extra follow-up call.",
+	"When polling a running exec session with empty `chars`, wait meaningfully between polls and do not repeatedly poll by reflex.",
 	"Do not request `tty` unless interactive terminal behavior is required.",
 ];
 

package/src/tools/apply-patch-rendering.ts

@@ -38,14 +38,14 @@ export function formatApplyPatchSummary(patchText: string, cwd = process.cwd()):
 
 	if (files.length === 1) {
 		const [file] = files;
-		lines.push(`${bulletHeader(file.verb, renderPath(file.path, file.movePath, cwd))} ${renderCounts(file.added, file.removed)}`);
+		lines.push(`${bulletHeader(file.verb, formatPatchTarget(file.path, file.movePath, cwd))} ${renderCounts(file.added, file.removed)}`);
 		return lines.join("\n");
 	}
 
 	lines.push(`${bulletHeader("Edited", `${files.length} files`)} ${renderCounts(totalAdded, totalRemoved)}`);
 	for (const [index, file] of files.entries()) {
 		const prefix = index === 0 ? "  └ " : "    ";
-		lines.push(`${prefix}${renderPath(file.path, file.movePath, cwd)} ${renderCounts(file.added, file.removed)}`);
+		lines.push(`${prefix}${formatPatchTarget(file.path, file.movePath, cwd)} ${renderCounts(file.added, file.removed)}`);
 	}
 
 	return lines.join("\n");
@@ -70,7 +70,7 @@ export function formatApplyPatchCall(patchText: string, cwd = process.cwd()): st
 
 	if (files.length === 1) {
 		const [file] = files;
-		lines.push(`${bulletHeader(file.verb, renderPath(file.path, file.movePath, cwd))} ${renderCounts(file.added, file.removed)}`);
+		lines.push(`${bulletHeader(file.verb, formatPatchTarget(file.path, file.movePath, cwd))} ${renderCounts(file.added, file.removed)}`);
 		lines.push(...file.lines.map((line) => formatPreviewLine(line, file.lines)));
 		return lines.join("\n");
 	}
@@ -80,7 +80,7 @@ export function formatApplyPatchCall(patchText: string, cwd = process.cwd()): st
 		if (index > 0) {
 			lines.push("");
 		}
-		lines.push(`  └ ${renderPath(file.path, file.movePath, cwd)} ${renderCounts(file.added, file.removed)}`);
+		lines.push(`  └ ${formatPatchTarget(file.path, file.movePath, cwd)} ${renderCounts(file.added, file.removed)}`);
 		lines.push(...file.lines.map((line) => formatPreviewLine(line, file.lines)));
 	}
 
@@ -106,7 +106,7 @@ export function renderApplyPatchCall(patchText: string, cwd = process.cwd()): st
 
 	if (files.length === 1) {
 		const [file] = files;
-		lines.push(`${bulletHeader(file.verb, renderPath(file.path, file.movePath, cwd))} ${renderCounts(file.added, file.removed)}`);
+		lines.push(`${bulletHeader(file.verb, formatPatchTarget(file.path, file.movePath, cwd))} ${renderCounts(file.added, file.removed)}`);
 		lines.push(...renderPreviewLines(file.lines));
 		return lines.join("\n");
 	}
@@ -116,7 +116,7 @@ export function renderApplyPatchCall(patchText: string, cwd = process.cwd()): st
 		if (index > 0) {
 			lines.push("");
 		}
-		lines.push(`  └ ${renderPath(file.path, file.movePath, cwd)} ${renderCounts(file.added, file.removed)}`);
+		lines.push(`  └ ${formatPatchTarget(file.path, file.movePath, cwd)} ${renderCounts(file.added, file.removed)}`);
 		lines.push(...renderPreviewLines(file.lines));
 	}
 
@@ -303,7 +303,7 @@ function findSequence(lines: string[], context: string[], start: number, normali
 	return -1;
 }
 
-function renderPath(path: string, movePath: string | undefined, cwd: string): string {
+export function formatPatchTarget(path: string, movePath: string | undefined, cwd: string): string {
 	const from = displayPath(path, cwd);
 	if (!movePath) {
 		return from;

package/src/tools/apply-patch-tool.ts

@@ -2,8 +2,8 @@ import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Container, Text } from "@mariozechner/pi-tui";
 import { executePatch } from "../patch/core.ts";
-import type { ExecutePatchResult } from "../patch/types.ts";
-import { formatApplyPatchSummary, renderApplyPatchCall } from "./apply-patch-rendering.ts";
+import { ExecutePatchError, type ExecutePatchResult } from "../patch/types.ts";
+import { formatApplyPatchSummary, formatPatchTarget, renderApplyPatchCall } from "./apply-patch-rendering.ts";
 
 const APPLY_PATCH_PARAMETERS = Type.Object({
 	input: Type.String({
@@ -13,10 +13,27 @@ const APPLY_PATCH_PARAMETERS = Type.Object({
 
 interface ApplyPatchRenderState {
 	cwd: string;
+	patchText: string;
 	collapsed: string;
 	expanded: string;
+	status: "pending" | "partial_failure";
+	failedTarget?: string;
 }
 
+interface ApplyPatchSuccessDetails {
+	status: "success";
+	result: ExecutePatchResult;
+}
+
+interface ApplyPatchPartialFailureDetails {
+	status: "partial_failure";
+	result: ExecutePatchResult;
+	error: string;
+	failedTarget?: string;
+}
+
+type ApplyPatchToolDetails = ApplyPatchSuccessDetails | ApplyPatchPartialFailureDetails;
+
 const applyPatchRenderStates = new Map<string, ApplyPatchRenderState>();
 
 interface ApplyPatchRenderContextLike {
@@ -33,8 +50,104 @@ function parseApplyPatchParams(params: unknown): { patchText: string } {
 	return { patchText: params.input };
 }
 
-function isExecutePatchResult(details: unknown): details is ExecutePatchResult {
-	return typeof details === "object" && details !== null;
+function isApplyPatchToolDetails(details: unknown): details is ApplyPatchToolDetails {
+	return typeof details === "object" && details !== null && "status" in details && "result" in details;
+}
+
+function setApplyPatchRenderState(
+	toolCallId: string,
+	patchText: string,
+	cwd: string,
+	status: "pending" | "partial_failure" = "pending",
+	failedTarget?: string,
+): void {
+	const collapsed = formatApplyPatchSummary(patchText, cwd);
+	const expanded = renderApplyPatchCall(patchText, cwd);
+	applyPatchRenderStates.set(toolCallId, {
+		cwd,
+		patchText,
+		collapsed,
+		expanded,
+		status,
+		failedTarget,
+	});
+}
+
+function markApplyPatchPartialFailure(toolCallId: string, failedTarget?: string): void {
+	const existing = applyPatchRenderStates.get(toolCallId);
+	if (!existing) {
+		return;
+	}
+	applyPatchRenderStates.set(toolCallId, {
+		...existing,
+		status: "partial_failure",
+		failedTarget,
+	});
+}
+
+function renderPartialFailureCall(
+	text: string,
+	theme: { fg(role: string, text: string): string },
+	failedTarget?: string,
+): string {
+	const lines = text.split("\n");
+	if (lines.length === 0) {
+		return theme.fg("warning", "• Edit partially failed");
+	}
+	lines[0] = lines[0].replace(/^• (Added|Edited|Deleted)\b/, "• Edit partially failed");
+	const failedLineIndexes = new Set<number>();
+	if (failedTarget) {
+		for (let i = 0; i < lines.length; i += 1) {
+			const failedLine = markFailedTargetLine(lines[i], failedTarget);
+			if (failedLine) {
+				lines[i] = failedLine;
+				failedLineIndexes.add(i);
+			}
+		}
+	}
+	return lines
+		.map((line, index) => {
+			if (failedLineIndexes.has(index)) {
+				return theme.fg("error", line);
+			}
+			if (index === 0) {
+				return theme.fg("warning", line);
+			}
+			return line;
+		})
+		.join("\n");
+}
+
+function markFailedTargetLine(line: string, failedTarget: string): string | undefined {
+	const suffixMatch = line.match(/ \(\+\d+ -\d+\)$/);
+	if (!suffixMatch) {
+		return undefined;
+	}
+	const suffix = suffixMatch[0];
+	const prefixAndTarget = line.slice(0, -suffix.length);
+	const candidatePrefixes = ["• Edit partially failed ", "• Added ", "• Edited ", "• Deleted ", "  └ ", "    "];
+	for (const prefix of candidatePrefixes) {
+		if (prefixAndTarget === `${prefix}${failedTarget}`) {
+			return `${prefix}${failedTarget} failed${suffix}`;
+		}
+	}
+	return undefined;
+}
+
+function summarizePatchCounts(result: ExecutePatchResult): string {
+	return [
+		`changed ${result.changedFiles.length} file${result.changedFiles.length === 1 ? "" : "s"}`,
+		`created ${result.createdFiles.length}`,
+		`deleted ${result.deletedFiles.length}`,
+		`moved ${result.movedFiles.length}`,
+	].join(", ");
+}
+
+function describeFailedAction(error: ExecutePatchError, cwd: string): string | undefined {
+	if (!error.failedAction) {
+		return undefined;
+	}
+	return formatPatchTarget(error.failedAction.path, error.failedAction.type === "update" ? error.failedAction.movePath : undefined, cwd);
 }
 
 export type { ExecutePatchResult } from "../patch/types.ts";
@@ -57,7 +170,11 @@ const renderApplyPatchCallWithOptionalContext: any = (
 	}
 	const cached = context?.toolCallId ? applyPatchRenderStates.get(context.toolCallId) : undefined;
 	const cwd = context?.cwd ?? cached?.cwd;
-	const text = context?.expanded ? cached?.expanded ?? renderApplyPatchCall(patchText, cwd) : cached?.collapsed ?? formatApplyPatchSummary(patchText, cwd);
+	const effectivePatchText = cached?.patchText ?? patchText;
+	const baseText = context?.expanded
+		? cached?.expanded ?? renderApplyPatchCall(effectivePatchText, cwd)
+		: cached?.collapsed ?? formatApplyPatchSummary(effectivePatchText, cwd);
+	const text = cached?.status === "partial_failure" ? renderPartialFailureCall(baseText, theme, cached.failedTarget) : baseText;
 	return new Text(text, 0, 0);
 };
 
@@ -67,7 +184,10 @@ export function registerApplyPatchTool(pi: ExtensionAPI): void {
 		label: "apply_patch",
 		description: "Use `apply_patch` to edit files. Send the full patch in `input`.",
 		promptSnippet: "Edit files with a patch.",
-		promptGuidelines: ["Prefer apply_patch for focused textual edits instead of rewriting whole files."],
+		promptGuidelines: [
+			"Prefer apply_patch for focused textual edits instead of rewriting whole files.",
+			"When one task needs coordinated edits across multiple files, send them in a single apply_patch call when one coherent patch will do.",
+		],
 		parameters: APPLY_PATCH_PARAMETERS,
 		async execute(toolCallId, params, signal, _onUpdate, ctx) {
 			if (signal?.aborted) {
@@ -75,12 +195,34 @@ export function registerApplyPatchTool(pi: ExtensionAPI): void {
 			}
 
 			const typedParams = parseApplyPatchParams(params);
-			applyPatchRenderStates.set(toolCallId, {
-				cwd: ctx.cwd,
-				collapsed: formatApplyPatchSummary(typedParams.patchText, ctx.cwd),
-				expanded: renderApplyPatchCall(typedParams.patchText, ctx.cwd),
-			});
-			const result = executePatch({ cwd: ctx.cwd, patchText: typedParams.patchText });
+			setApplyPatchRenderState(toolCallId, typedParams.patchText, ctx.cwd);
+			let result: ExecutePatchResult;
+			try {
+				result = executePatch({ cwd: ctx.cwd, patchText: typedParams.patchText });
+			} catch (error) {
+				if (error instanceof ExecutePatchError) {
+					const partial = error.hasPartialSuccess();
+					const failedTarget = describeFailedAction(error, ctx.cwd);
+					const prefix = partial
+						? `apply_patch partially failed after ${summarizePatchCounts(error.result)}`
+						: "apply_patch failed";
+					const message = failedTarget ? `${prefix} while patching ${failedTarget}: ${error.message}` : `${prefix}: ${error.message}`;
+					if (partial) {
+						markApplyPatchPartialFailure(toolCallId, failedTarget);
+						return {
+							content: [{ type: "text", text: message }],
+							details: {
+								status: "partial_failure",
+								result: error.result,
+								error: message,
+								failedTarget,
+							} satisfies ApplyPatchPartialFailureDetails,
+						};
+					}
+					throw new Error(message);
+				}
+				throw error;
+			}
 			const summary = [
 				"Applied patch successfully.",
 				`Changed files: ${result.changedFiles.length}`,
@@ -92,16 +234,23 @@ export function registerApplyPatchTool(pi: ExtensionAPI): void {
 
 			return {
 				content: [{ type: "text", text: summary }],
-				details: result,
+				details: {
+					status: "success",
+					result,
+				} satisfies ApplyPatchSuccessDetails,
 			};
 		},
 		renderCall: renderApplyPatchCallWithOptionalContext,
-		renderResult(result, { isPartial }, theme) {
+		renderResult(result, { isPartial, expanded }, theme) {
 			if (isPartial) {
 				return new Text(`${theme.fg("dim", "•")} ${theme.bold("Patching")}`, 0, 0);
 			}
 
-			if (!isExecutePatchResult(result.details)) {
+			if (!isApplyPatchToolDetails(result.details)) {
+				return new Container();
+			}
+
+			if (result.details.status === "partial_failure") {
 				return new Container();
 			}
 

package/src/tools/exec-command-tool.ts

@@ -121,6 +121,7 @@ export function registerExecCommandTool(pi: ExtensionAPI, tracker: ExecCommandTr
 		promptGuidelines: [
 			"Use exec_command for search, listing files, and local text-file reads.",
 			"Prefer rg or rg --files when possible.",
+			"For short or non-interactive commands, omit `yield_time_ms` so the default wait can avoid unnecessary follow-up calls.",
 			"Keep tty disabled unless the command truly needs interactive terminal behavior.",
 		],
 		parameters: EXEC_COMMAND_PARAMETERS,

package/src/tools/exec-session-manager.ts

@@ -65,10 +65,19 @@ export interface ExecSessionManager {
 	shutdown(): void;
 }
 
+export interface ExecSessionManagerOptions {
+	defaultExecYieldTimeMs?: number;
+	defaultWriteYieldTimeMs?: number;
+	minNonInteractiveExecYieldTimeMs?: number;
+	minEmptyWriteYieldTimeMs?: number;
+}
+
 const DEFAULT_EXEC_YIELD_TIME_MS = 10_000;
-const DEFAULT_WRITE_YIELD_TIME_MS = 10_000;
+const DEFAULT_WRITE_YIELD_TIME_MS = 250;
 const DEFAULT_MAX_OUTPUT_TOKENS = 10_000;
 const MIN_YIELD_TIME_MS = 250;
+const MIN_NON_INTERACTIVE_EXEC_YIELD_TIME_MS = 5_000;
+const MIN_EMPTY_WRITE_YIELD_TIME_MS = 5_000;
 const MAX_YIELD_TIME_MS = 30_000;
 const MAX_COMMAND_HISTORY = 256;
 
@@ -139,6 +148,32 @@ function clampYieldTime(yieldTimeMs: number | undefined, fallback: number): numb
 	return Math.min(MAX_YIELD_TIME_MS, Math.max(MIN_YIELD_TIME_MS, value));
 }
 
+function clampExecYieldTime(
+	yieldTimeMs: number | undefined,
+	fallback: number,
+	isInteractive: boolean,
+	minNonInteractiveExecYieldTimeMs: number,
+): number {
+	const value = clampYieldTime(yieldTimeMs, fallback);
+	if (isInteractive) {
+		return value;
+	}
+	return Math.min(MAX_YIELD_TIME_MS, Math.max(minNonInteractiveExecYieldTimeMs, value));
+}
+
+function clampWriteYieldTime(
+	yieldTimeMs: number | undefined,
+	fallback: number,
+	isEmptyPoll: boolean,
+	minEmptyWriteYieldTimeMs: number,
+): number {
+	const value = clampYieldTime(yieldTimeMs, fallback);
+	if (!isEmptyPoll) {
+		return value;
+	}
+	return Math.min(MAX_YIELD_TIME_MS, Math.max(minEmptyWriteYieldTimeMs, value));
+}
+
 function maxCharsForTokens(maxOutputTokens = DEFAULT_MAX_OUTPUT_TOKENS): number {
 	return Math.max(256, maxOutputTokens * 4);
 }
@@ -309,11 +344,21 @@ function registerAbortHandler(signal: AbortSignal | undefined, onAbort: () => vo
 	return () => signal.removeEventListener("abort", abortListener);
 }
 
-export function createExecSessionManager(): ExecSessionManager {
+export function createExecSessionManager(options: ExecSessionManagerOptions = {}): ExecSessionManager {
 	let nextSessionId = 1;
 	const sessions = new Map<number, ExecSession>();
 	const commandHistory = new Map<number, string>();
 	const exitListeners = new Set<(sessionId: number, command: string) => void>();
+	const defaultExecYieldTimeMs = options.defaultExecYieldTimeMs ?? DEFAULT_EXEC_YIELD_TIME_MS;
+	const defaultWriteYieldTimeMs = options.defaultWriteYieldTimeMs ?? DEFAULT_WRITE_YIELD_TIME_MS;
+	const minNonInteractiveExecYieldTimeMs = Math.min(
+		MAX_YIELD_TIME_MS,
+		Math.max(MIN_YIELD_TIME_MS, options.minNonInteractiveExecYieldTimeMs ?? MIN_NON_INTERACTIVE_EXEC_YIELD_TIME_MS),
+	);
+	const minEmptyWriteYieldTimeMs = Math.min(
+		MAX_YIELD_TIME_MS,
+		Math.max(MIN_YIELD_TIME_MS, options.minEmptyWriteYieldTimeMs ?? MIN_EMPTY_WRITE_YIELD_TIME_MS),
+	);
 
 	function rememberCommand(sessionId: number, command: string): void {
 		commandHistory.set(sessionId, command);
@@ -494,7 +539,10 @@ export function createExecSessionManager(): ExecSessionManager {
 			sessions.set(session.id, session);
 			rememberCommand(session.id, session.command);
 
-			const waitedMs = await waitForExitOrTimeout(session, clampYieldTime(input.yield_time_ms, DEFAULT_EXEC_YIELD_TIME_MS));
+			const waitedMs = await waitForExitOrTimeout(
+				session,
+				clampExecYieldTime(input.yield_time_ms, defaultExecYieldTimeMs, session.interactive, minNonInteractiveExecYieldTimeMs),
+			);
 			return makeResult(session, waitedMs, input.max_output_tokens);
 		},
 		write: async (input) => {
@@ -512,7 +560,15 @@ export function createExecSessionManager(): ExecSessionManager {
 			}
 			const waitedMs =
 				session.exitCode === undefined
-					? await waitForExitOrTimeout(session, clampYieldTime(input.yield_time_ms, DEFAULT_WRITE_YIELD_TIME_MS))
+					? await waitForExitOrTimeout(
+							session,
+							clampWriteYieldTime(
+								input.yield_time_ms,
+								defaultWriteYieldTimeMs,
+								!input.chars || input.chars.length === 0,
+								minEmptyWriteYieldTimeMs,
+							),
+						)
 					: 0;
 			return makeResult(session, waitedMs, input.max_output_tokens);
 		},

package/src/tools/write-stdin-tool.ts

@@ -110,6 +110,10 @@ export function registerWriteStdinTool(pi: ExtensionAPI, sessions: ExecSessionMa
 		label: "write_stdin",
 		description: "Writes characters to an existing unified exec session and returns recent output.",
 		promptSnippet: "Write to an exec session.",
+		promptGuidelines: [
+			"Use empty `chars` only to poll a running exec session.",
+			"When polling with empty `chars`, wait meaningfully between polls and do not repeatedly poll by reflex.",
+		],
 		parameters: WRITE_STDIN_PARAMETERS,
 		async execute(_toolCallId, params) {
 			const typed = parseWriteStdinParams(params);