@oh-my-pi/pi-coding-agent 15.1.5 → 15.1.7

package/src/plan-mode/approved-plan.ts

@@ -49,6 +49,58 @@ export function normalizePlanTitle(title: string): { title: string; fileName: st
 	return { title: sanitized, fileName };
 }
 
+/** Best-effort derivation of a plan title from inputs the agent already produced.
+ *  Returns the first non-empty candidate that survives `normalizePlanTitle`:
+ *    1. an explicit `suppliedTitle` (e.g. `extra.title` from the resolve call),
+ *    2. the first level-1 markdown heading inside `planContent`,
+ *    3. the filename stem of `planFilePath` (e.g. `PLAN` from `local://PLAN.md`),
+ *    4. the literal `"plan"` so callers never have to handle `null`.
+ *  The fallback exists because some grammar-constrained models cannot emit a
+ *  string into the open `extra` schema and instead drop in `{}` (issue #1179);
+ *  plan-mode would otherwise loop forever on an unreachable validation. */
+export function resolvePlanTitle(input: { suppliedTitle?: unknown; planContent: string; planFilePath: string }): {
+	title: string;
+	fileName: string;
+	source: "supplied" | "heading" | "filename" | "default";
+} {
+	const candidates: Array<{ value: string; source: "supplied" | "heading" | "filename" | "default" }> = [];
+	if (typeof input.suppliedTitle === "string") {
+		const trimmed = input.suppliedTitle.trim();
+		if (trimmed) candidates.push({ value: trimmed, source: "supplied" });
+	}
+	const heading = firstLevelOneHeading(input.planContent);
+	if (heading) candidates.push({ value: heading, source: "heading" });
+	const stem = planFilenameStem(input.planFilePath);
+	if (stem) candidates.push({ value: stem, source: "filename" });
+	candidates.push({ value: "plan", source: "default" });
+
+	for (const candidate of candidates) {
+		try {
+			const normalized = normalizePlanTitle(candidate.value);
+			return { ...normalized, source: candidate.source };
+		} catch {
+			// Fall through to the next candidate.
+		}
+	}
+	// Last-ditch literal so the type-system contract holds even if `normalizePlanTitle("plan")` ever throws.
+	return { title: "plan", fileName: "plan.md", source: "default" };
+}
+
+/** First `# Heading` text on its own line, trimmed. Returns the empty string if
+ *  none is found so callers can chain it through truthiness checks. */
+function firstLevelOneHeading(planContent: string): string {
+	const match = planContent.match(/^[ \t]*#[ \t]+(.+?)[ \t]*$/m);
+	return match?.[1]?.trim() ?? "";
+}
+
+/** Stem of a `local://name.md` (or bare `name.md`) URL — the filename without
+ *  scheme or extension. Returns the empty string for inputs that have no stem. */
+function planFilenameStem(planFilePath: string): string {
+	const withoutScheme = planFilePath.replace(/^local:\/+/, "");
+	const lastSegment = withoutScheme.split(/[\\/]/).pop() ?? "";
+	return lastSegment.replace(/\.md$/i, "");
+}
+
 /** Humanize a normalized plan title for use as a session display name.
  *  Replaces `-`/`_` separators with spaces and capitalizes the first letter.
  *  Returns an empty string when the input collapses to whitespace. */

package/src/prompts/tools/bash.md

@@ -23,3 +23,17 @@ Executes bash command in shell session for terminal operations like git, bun, ca
 - Truncated output is retrievable from `artifact://<id>` (linked in metadata)
 - Exit codes shown on non-zero exit
 </output>
+
+{{#if asyncEnabled}}
+# Timeout and async
+
+- `timeout` (seconds) caps the **wall-clock duration** of the command. When it elapses the process is killed and the call returns with a timeout annotation. Range: `1`–`3600`s; default `300`s (see `clampTimeout("bash", …)` in `tool-timeouts.ts`).
+- `async: true` only defers **reporting** of the result — it does NOT disable, extend, or detach the timeout. A daemon started with `async: true` is still killed when `timeout` elapses, regardless of how long the agent waits before reading the result.
+- For long-running daemons (dev servers, watchers): either pass an explicit large `timeout` (up to `3600`), or fully detach the process from this shell using `nohup …  &` / `setsid … &` / `disown` so it survives independent of the bash call's lifecycle.
+{{/if}}
+
+# Output minimizer
+
+- Bash stdout/stderr may be rewritten before you see it: long output is head/tail truncated, and test/lint runners (e.g. `bun test`, `cargo test`, ESLint) are passed through heuristic filters that drop noise and keep failures.
+- When the minimizer changes the visible text, the tool appends a `[raw output: artifact://<id>]` footer pointing at the **full untouched capture**. If a run looks suspicious (e.g. only a version banner) or you need the exact bytes, read that artifact.
+- If no footer is present, what you see is what the command actually emitted.

package/src/prompts/tools/debug.md

@@ -4,6 +4,7 @@ Use for launching or attaching debuggers, setting breakpoints, stepping through
 <instruction>
 - Prefer over bash for program state, breakpoints, stepping, thread inspection, or interrupting a running process.
 - `action: "launch"` starts a session; `program` is required, `adapter` optional (auto-selected from target path and workspace).
+  For Python, set `adapter: "debugpy"` and `program` to the target `.py` file; put interpreter/script flags in `args`.
 - `action: "attach"` connects to an existing process: `pid` for local attach, `port` for remote attach (where the adapter supports it), `adapter` to force a specific debugger.
 - **Breakpoints**: `set_breakpoint`/`remove_breakpoint` with source (`file`+`line`) or function (`function`); optional `condition` for conditional breakpoints.
 - **Flow control**: `continue` (resumes; briefly waits to observe whether the program stops or keeps running), `step_over`/`step_in`/`step_out` (single-step), `pause` (interrupt a running program so you can inspect state).
@@ -15,6 +16,7 @@ Use for launching or attaching debuggers, setting breakpoints, stepping through
 - Only one active debug session is supported at a time.
 - Some adapters require a launched session to receive `configurationDone` before the target actually runs; if the tool says configuration is pending, set breakpoints and then call `continue`.
 - Adapter availability depends on local binaries. Common built-ins: `gdb`, `lldb-dap`, `python -m debugpy.adapter`, `dlv dap`.
+- `program` must be an executable file or debug target, not a directory or interpreter name that resolves to a workspace directory.
 </caution>
 
 <examples>
@@ -24,7 +26,8 @@ Use for launching or attaching debuggers, setting breakpoints, stepping through
 3. `debug(action: "continue")`
 4. If the program appears hung: `debug(action: "pause")`
 5. Inspect state with `threads`, `stack_trace`, `scopes`, and `variables`
-
+# Launch a Python script with debugpy
+`debug(action: "launch", adapter: "debugpy", program: "scripts/job.py", args: ["--flag"])`
 # Raw debugger command through repl
 `debug(action: "evaluate", expression: "info registers", context: "repl")`
 </examples>

package/src/prompts/tools/find.md

@@ -2,6 +2,10 @@ Finds files using fast pattern matching that works with any codebase size.
 
 <instruction>
 - `paths` is required and accepts an array of globs, files, or directories
+- Pass multiple targets as **separate array elements** (`paths: ["a", "b"]`), NEVER as a single comma-joined string (`paths: ["a,b"]` is rejected)
+- `gitignore` defaults to `true` and hides files matched by `.gitignore`. Set `gitignore: false` to find `.env*`, `*.log`, freshly-created build outputs, or anything else your repo ignores
+- `hidden` defaults to `true`; combine with `gitignore: false` to surface dotfiles that are also gitignored
+- `timeout` is in seconds (default 5, clamped to 0.5–60). On timeout, find returns whatever partial matches it has collected with `truncated: true` and a notice — increase `timeout` or narrow the pattern instead of retrying blindly
 - You SHOULD perform multiple searches in parallel when potentially useful
 </instruction>
 
@@ -12,6 +16,12 @@ Matching file paths sorted by modification time (most recent first). Truncated a
 <examples>
 # Find files
 `{"paths": ["src/**/*.ts"], "limit": 1000}`
+# Multiple targets — separate array elements
+`{"paths": ["src/**/*.ts", "test/**/*.ts"]}`
+# Find gitignored files like .env
+`{"paths": [".env*"], "gitignore": false}`
+# Long-running search on a slow volume
+`{"paths": ["/Volumes/Storage/**/*.py"], "timeout": 30}`
 </examples>
 
 <avoid>

package/src/prompts/tools/hashline.md

@@ -19,8 +19,9 @@ Each op line is ONE of:
 Op lines carry no content — payload goes on the next line.
 
 WRONG: + 5pg| some code
+WRONG: {{hsep}} some code
 RIGHT: + 5pg
-       {{hsep}} some code
+{{hsep}}some code
 
 A single `+`/`<`/`=` op accepts MANY `{{hsep}}` payload lines. To insert N consecutive lines, write ONE op followed by N payload lines — NEVER N ops with one payload each.
 
@@ -37,8 +38,9 @@ RIGHT (one op, many payload lines):
 </format-reminder>
 
 <rules>
-- Every payload line MUST start with `{{hsep}}`.
-- Payload is verbatim — NEVER escape unicode.
+- Every payload line MUST start with `{{hsep}}` immediately followed by payload text. Do NOT add a readability space after `{{hsep}}`.
+- Every character after `{{hsep}}` is file content. If the target line intentionally starts with one space, write exactly one space after `{{hsep}}`; otherwise write none.
+- Payload text is verbatim — NEVER escape unicode.
 - **Payload is only what's NEW relative to your range:**
   - `=` replaces inside; NEVER include lines outside.
   - `+`/`<` adds at the anchor; NEVER repeat line A or neighbors.

package/src/prompts/tools/resolve.md

@@ -3,7 +3,7 @@ Resolves a pending action by either applying or discarding it.
   - `"apply"` persists / submits the pending action.
   - `"discard"` rejects the pending action.
 - `reason` is required: one short complete sentence explaining why, starting with a capital letter and ending with a period.
-- `extra` (optional) is free-form metadata passed to the resolving tool. Schema depends on context:
+- `extra` (optional) is free-form metadata passed to the resolving tool. When the pending action is a plan-approval gate, supply `extra.title` (kebab/PascalCase slug for the approved plan filename). For preview-style pending actions (e.g. `ast_edit`), `extra` is unused.
 
 Valid whenever a pending action exists — either a preview-style staging (e.g. `ast_edit`) or a long-lived approval gate.
 Call fails with an error when no pending action exists.

package/src/prompts/tools/search.md

@@ -1,8 +1,9 @@
 Searches files using powerful regex matching.
 
 <instruction>
-- Supports full regex syntax (e.g., `log.*Error`, `function\\s+\\w+`); literal braces need escaping (`interface\\{\\}` for `interface{}` in Go)
+- Supports Rust regex syntax (RE2-style — no lookaround or backreferences). Use line anchors or post-filters instead of (?!…)/(?<!…)
 - `paths` is required and accepts an array of files, directories, globs, or internal URLs
+- `paths` is an array; do not embed commas or spaces inside a single entry. Pass `["src", "tests"]` not `["src,tests"]`.
 - Cross-line patterns are detected from literal `\n` or escaped `\\n` in `pattern`
 </instruction>
 

package/src/prompts/tools/task.md

@@ -70,8 +70,12 @@ Parallel when tasks touch disjoint files or are independent refactors/tests.
 </assignment-fmt>
 
 <agents>
+{{#if spawningDisabled}}
+Agent spawning is disabled for this context.
+{{else}}
 {{#list agents join="\n"}}
 # {{name}}
 {{description}}
 {{/list}}
+{{/if}}
 </agents>

package/src/prompts/tools/todo-write.md

@@ -1,3 +1,5 @@
+**Tasks are referenced by their verbatim content string, not by any auto-generated ID. There is no "task-1"/"task-N" identifier — the tool never emits one. Pass the task's content text in the `task` field.**
+
 Manages a phased task list. Pass `ops`: a flat array of operations.
 The next pending task is auto-promoted to `in_progress` after each completion.
 Allowed `op` values are only `init`, `start`, `done`, `drop`, `rm`, `append`, and `note`. `pending` is a task status, not an `op`; leave not-yet-started tasks implicit in `init`/`append` lists.

package/src/session/agent-session.ts

@@ -65,11 +65,13 @@ import type {
 } from "@oh-my-pi/pi-ai";
 import {
 	calculateRateLimitBackoffMs,
+	clearAnthropicFastModeFallback,
 	getSupportedEfforts,
 	isContextOverflow,
 	isUsageLimitError,
 	modelsAreEqual,
 	parseRateLimitReason,
+	resolveServiceTier,
 	streamSimple,
 } from "@oh-my-pi/pi-ai";
 import { MacOSPowerAssertion } from "@oh-my-pi/pi-natives";
@@ -443,6 +445,44 @@ function todoClearKey(phaseName: string, taskContent: string): string {
 	return `${phaseName}\u0000${taskContent}`;
 }
 
+const IRC_REPLY_MAX_BYTES = 4096;
+
+/**
+ * Collapse degenerate IRC ephemeral replies before they hit the relay.
+ * Models occasionally loop on a single line (~16 reports of N-times-repeated
+ * replies); compress runs longer than 3 down to one instance + `[…N×]`, then
+ * cap at 4 KiB so a runaway reply can't flood the channel.
+ */
+function dedupeIrcReply(text: string): string {
+	if (!text) return text;
+	const lines = text.split("\n");
+	const out: string[] = [];
+	let i = 0;
+	while (i < lines.length) {
+		let j = i + 1;
+		while (j < lines.length && lines[j] === lines[i]) j++;
+		const runLen = j - i;
+		if (runLen > 3) {
+			out.push(lines[i], `[…${runLen}×]`);
+		} else {
+			for (let k = 0; k < runLen; k++) out.push(lines[i]);
+		}
+		i = j;
+	}
+	let result = out.join("\n");
+	if (Buffer.byteLength(result, "utf8") > IRC_REPLY_MAX_BYTES) {
+		// Trim by characters until we're under the byte budget — handles multi-byte
+		// glyphs at the boundary without splitting them.
+		const suffix = "\n[…truncated]";
+		const budget = IRC_REPLY_MAX_BYTES - Buffer.byteLength(suffix, "utf8");
+		while (Buffer.byteLength(result, "utf8") > budget) {
+			result = result.slice(0, -1);
+		}
+		result += suffix;
+	}
+	return result;
+}
+
 /**
  * Build the per-request `metadata` payload for the Anthropic provider, shaped
  * like real Claude Code's `getAPIMetadata` output (`{ session_id, account_uuid,
@@ -1578,6 +1618,16 @@ export class AgentSession {
 			if (event.message.role === "assistant") {
 				this.#lastAssistantMessage = event.message;
 				const assistantMsg = event.message as AssistantMessage;
+				const currentGrantsAnthropicPriority =
+					this.serviceTier === "priority" || this.serviceTier === "claude-only";
+				if (assistantMsg.disabledFeatures?.includes("priority") && currentGrantsAnthropicPriority) {
+					this.setServiceTier(undefined);
+					this.emitNotice(
+						"warning",
+						"Priority/fast mode rejected for this model; retried without it. Fast mode is now off.",
+						"priority",
+					);
+				}
 				// 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.
@@ -1713,10 +1763,6 @@ export class AgentSession {
 			}
 			this.#resolveRetry();
 
-			if (msg.stopReason === "aborted" && this.#checkpointState) {
-				this.#checkpointState = undefined;
-				this.#pendingRewindReport = undefined;
-			}
 			const compactionTask = this.#checkCompaction(msg);
 			this.#trackPostPromptTask(compactionTask);
 			await compactionTask;
@@ -3101,6 +3147,13 @@ export class AgentSession {
 					if (!permissionIntent) {
 						return await target.execute(toolCallId, args as never, signal, onUpdate, ctx);
 					}
+					const command =
+						target.name === "bash" && args && typeof args === "object" && !Array.isArray(args)
+							? getStringProperty(args as Record<string, unknown>, "command")
+							: undefined;
+					const commandContent = command
+						? [{ type: "content" as const, content: { type: "text" as const, text: `$ ${command}` } }]
+						: undefined;
 					// Short-circuit on persisted decisions.
 					const persisted = this.#acpPermissionDecisions.get(permissionIntent.cacheKey);
 					if (persisted === "allow_always") {
@@ -3125,8 +3178,10 @@ export class AgentSession {
 								toolCallId,
 								toolName: target.name,
 								title: permissionIntent.title,
+								...(target.name === "bash" ? { kind: "execute" } : {}),
 								status: "pending",
 								rawInput: args,
+								...(commandContent ? { content: commandContent } : {}),
 								locations: extractPermissionLocations(
 									args,
 									this.sessionManager.getCwd(),
@@ -4599,7 +4654,12 @@ export class AgentSession {
 
 	/** Schedule auto-removal of completed/abandoned tasks after a delay. */
 	#scheduleTodoAutoClear(phases: TodoPhase[]): void {
-		const delaySec = this.settings.get("tasks.todoClearDelay") ?? 60;
+		// Default bumped from 60s to 30 min: the prior 60s splice mutated canonical
+		// state mid-turn, so the model observed phase totals shrinking ("6 → 5")
+		// between tool calls. Surviving the turn matches user expectations; a
+		// render-time filter in the UI consumer would be cleaner but lives in a
+		// different package and is out of scope for this fix.
+		const delaySec = this.settings.get("tasks.todoClearDelay") ?? 1800;
 		if (delaySec < 0) return; // "Never" — no auto-clear
 		const delayMs = delaySec * 1000;
 		const doneKeys = new Set<string>();
@@ -5110,17 +5170,50 @@ export class AgentSession {
 		return nextLevel;
 	}
 
+	/**
+	 * True when *any* fast-mode-granting service tier is configured, regardless
+	 * of whether the active model's provider actually realizes it. Used by the
+	 * toggle (`/fast on|off`) so re-toggling a scoped tier (`openai-only`,
+	 * `claude-only`) doesn't silently broaden it to unscoped `priority`.
+	 *
+	 * For "is fast mode actually applied to the next request?" use
+	 * {@link isFastModeActive} instead — that one respects the model's provider.
+	 */
 	isFastModeEnabled(): boolean {
-		return this.serviceTier === "priority";
+		return (
+			this.serviceTier === "priority" || this.serviceTier === "claude-only" || this.serviceTier === "openai-only"
+		);
+	}
+
+	/**
+	 * True when the configured `serviceTier` resolves to `"priority"` for the
+	 * *currently selected model's provider*. Returns false for scoped tiers
+	 * that don't match (e.g. `"openai-only"` on an anthropic model) and when
+	 * no model is selected.
+	 */
+	isFastModeActive(): boolean {
+		return resolveServiceTier(this.serviceTier, this.model?.provider) === "priority";
 	}
 
 	setServiceTier(serviceTier: ServiceTier | undefined): void {
 		if (this.serviceTier === serviceTier) return;
+		// Re-arming priority on Anthropic? Clear the per-session auto-fallback
+		// sticky disable so the next request actually carries `speed: "fast"`
+		// again. Without this, `/fast on` (or user switching to a tier that
+		// grants anthropic priority) after an auto-disable is a silent no-op
+		// and the warning notice fires every turn.
+		if (serviceTier === "priority" || serviceTier === "claude-only") {
+			clearAnthropicFastModeFallback(this.#providerSessionState);
+		}
 		this.agent.serviceTier = serviceTier;
 		this.sessionManager.appendServiceTierChange(serviceTier ?? null);
 	}
 
 	setFastMode(enabled: boolean): void {
+		if (enabled && this.isFastModeEnabled()) {
+			// Already on under any scope — keep the user's scoped value.
+			return;
+		}
 		this.setServiceTier(enabled ? "priority" : undefined);
 	}
 
@@ -7574,6 +7667,11 @@ export class AgentSession {
 		const context: Context = {
 			systemPrompt: this.systemPrompt,
 			messages: llmMessages,
+			// Empty tools array: with toolChoice="none" some encoders still serialize the
+			// recipient's tool catalog and the model leaks raw call markup
+			// (<function_calls>, DSML envelopes) into IRC replies. Stripping tools here
+			// removes the surface entirely.
+			tools: [],
 		};
 		const options = this.prepareSimpleStreamOptions(
 			{
@@ -7609,7 +7707,7 @@ export class AgentSession {
 		if (!assistantMessage) {
 			throw new Error("Ephemeral turn ended without a final message");
 		}
-		return { replyText: replyText.trim(), assistantMessage };
+		return { replyText: dedupeIrcReply(replyText.trim()), assistantMessage };
 	}
 
 	/**
@@ -7622,14 +7720,24 @@ export class AgentSession {
 		const messages = [...this.messages];
 		const streaming = this.agent.state.streamMessage;
 		if (streaming && streaming.role === "assistant") {
+			const preservedBlocks: AssistantMessage["content"] = [];
+			// Preserve thinking blocks: DeepSeek-class encoders replay them as
+			// `reasoning_content` and reject the request (HTTP 400) when the field
+			// goes missing on a turn that previously emitted thinking.
+			for (const c of streaming.content) {
+				if (c.type === "thinking") preservedBlocks.push(c);
+			}
 			const streamingText = streaming.content
 				.filter((c): c is TextContent => c.type === "text")
 				.map(c => c.text)
 				.join("");
 			if (streamingText) {
+				preservedBlocks.push({ type: "text", text: streamingText });
+			}
+			if (preservedBlocks.length > 0) {
 				const normalized: AssistantMessage = {
 					...streaming,
-					content: [{ type: "text", text: streamingText }],
+					content: preservedBlocks,
 				};
 				const lastMessage = messages.at(-1);
 				if (lastMessage?.role === "assistant") {

package/src/session/client-bridge.ts

@@ -27,6 +27,7 @@ export interface ClientBridgePermissionToolCall {
 	kind?: string;
 	status?: "pending" | "in_progress" | "completed" | "failed";
 	rawInput?: unknown;
+	content?: unknown[];
 	locations?: { path: string; line?: number }[];
 }
 

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

@@ -147,7 +147,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	},
 	{
 		name: "fast",
-		description: "Toggle fast mode (OpenAI service tier priority)",
+		description: "Toggle priority service tier (OpenAI service_tier=priority, Anthropic speed=fast)",
 		acpDescription: "Toggle fast mode",
 		acpInputHint: "[on|off|status]",
 		subcommands: [

package/src/task/index.ts

@@ -140,11 +140,25 @@ function renderDescription(
 	disabledAgents: string[],
 	simpleMode: TaskSimpleMode,
 	ircEnabled: boolean,
+	parentSpawns: string,
 ): string {
-	const filteredAgents = disabledAgents.length > 0 ? agents.filter(a => !disabledAgents.includes(a.name)) : agents;
+	const spawningDisabled = parentSpawns === "";
+	let filteredAgents = disabledAgents.length > 0 ? agents.filter(a => !disabledAgents.includes(a.name)) : agents;
+	if (spawningDisabled) {
+		filteredAgents = [];
+	} else if (parentSpawns !== "*") {
+		const allowed = new Set(
+			parentSpawns
+				.split(",")
+				.map(s => s.trim())
+				.filter(Boolean),
+		);
+		filteredAgents = filteredAgents.filter(a => allowed.has(a.name));
+	}
 	const { contextEnabled, customSchemaEnabled } = getTaskSimpleModeCapabilities(simpleMode);
 	return prompt.render(taskDescriptionTemplate, {
 		agents: filteredAgents,
+		spawningDisabled,
 		MAX_CONCURRENCY: maxConcurrency,
 		isolationEnabled,
 		asyncEnabled,
@@ -230,6 +244,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			disabledAgents,
 			this.#getTaskSimpleMode(),
 			this.session.settings.get("irc.enabled") === true,
+			this.session.getSessionSpawns() ?? "*",
 		);
 	}
 	private constructor(
@@ -493,10 +508,11 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			taskIdByItemId.set(taskItems[i].id, uniqueIds[i]);
 		}
 		const startedListing = startedJobs
-			.map(({ taskId }) => {
+			.map(({ taskId, jobId }) => {
 				const id = taskIdByItemId.get(taskId) ?? taskId;
 				const desc = progressByTaskId.get(taskId)?.description;
-				return desc ? `- \`${id}\` — ${desc}` : `- \`${id}\``;
+				const prefix = `- \`${id}\` (job \`${jobId}\`)`;
+				return desc ? `${prefix} — ${desc}` : prefix;
 			})
 			.join("\n");
 		const coordinationHint = ircEnabled
@@ -1075,6 +1091,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 
 			let mergeSummary = "";
 			let changesApplied: boolean | null = null;
+			let hadAnyChanges = false;
 			let mergedBranchesForNestedPatches: Set<string> | null = null;
 			if (isIsolated && repoRoot) {
 				try {
@@ -1086,13 +1103,18 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 
 						if (branchEntries.length === 0) {
 							changesApplied = true;
+							hadAnyChanges = false;
+							mergeSummary = "\n\nNo changes to apply.";
 						} else {
 							const mergeResult = await mergeTaskBranches(repoRoot, branchEntries);
 							mergedBranchesForNestedPatches = new Set(mergeResult.merged);
 							changesApplied = mergeResult.failed.length === 0;
+							hadAnyChanges = changesApplied && mergeResult.merged.length > 0;
 
 							if (changesApplied) {
-								mergeSummary = `\n\nMerged ${mergeResult.merged.length} branch${mergeResult.merged.length === 1 ? "" : "es"}: ${mergeResult.merged.join(", ")}`;
+								mergeSummary = hadAnyChanges
+									? `\n\nMerged ${mergeResult.merged.length} branch${mergeResult.merged.length === 1 ? "" : "es"}: ${mergeResult.merged.join(", ")}`
+									: "\n\nNo changes to apply.";
 							} else {
 								const mergedPart =
 									mergeResult.merged.length > 0 ? `Merged: ${mergeResult.merged.join(", ")}.\n` : "";
@@ -1113,6 +1135,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						const missingPatch = results.some(result => !result.patchPath);
 						if (missingPatch) {
 							changesApplied = false;
+							hadAnyChanges = false;
 						} else {
 							const patchStats = await Promise.all(
 								patchesInOrder.map(async patchPath => ({
@@ -1123,6 +1146,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 							const nonEmptyPatches = patchStats.filter(patch => patch.size > 0).map(patch => patch.patchPath);
 							if (nonEmptyPatches.length === 0) {
 								changesApplied = true;
+								hadAnyChanges = false;
 							} else {
 								const patchTexts = await Promise.all(
 									nonEmptyPatches.map(async patchPath => Bun.file(patchPath).text()),
@@ -1132,13 +1156,16 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 									.join("");
 								if (!combinedPatch.trim()) {
 									changesApplied = true;
+									hadAnyChanges = false;
 								} else {
 									changesApplied = await git.patch.canApplyText(repoRoot, combinedPatch);
 									if (changesApplied) {
 										try {
 											await git.patch.applyText(repoRoot, combinedPatch);
+											hadAnyChanges = true;
 										} catch {
 											changesApplied = false;
+											hadAnyChanges = false;
 										}
 									}
 								}
@@ -1146,7 +1173,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						}
 
 						if (changesApplied) {
-							mergeSummary = "\n\nApplied patches: yes";
+							mergeSummary = hadAnyChanges ? "\n\nApplied patches: yes" : "\n\nNo changes to apply.";
 						} else {
 							const notification =
 								"<system-notification>Patches were not applied and must be handled manually.</system-notification>";
@@ -1160,6 +1187,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 				} catch (mergeErr) {
 					const msg = mergeErr instanceof Error ? mergeErr.message : String(mergeErr);
 					changesApplied = false;
+					hadAnyChanges = false;
 					mergeSummary = `\n\n<system-notification>Merge phase failed: ${msg}\nTask outputs are preserved but changes were not applied.</system-notification>`;
 				}
 			}

package/src/task/render.ts

@@ -996,7 +996,10 @@ export function renderResult(
 			if (fallbackText.trim()) {
 				const summaryLines = fallbackText.split("\n");
 				const markerIndex = summaryLines.findIndex(
-					line => line.includes("<system-notification>") || line.startsWith("Applied patches:"),
+					line =>
+						line.includes("<system-notification>") ||
+						line.startsWith("Applied patches:") ||
+						line.startsWith("No changes to apply."),
 				);
 				if (markerIndex >= 0) {
 					const extra = summaryLines.slice(markerIndex);

package/src/tools/browser/tab-supervisor.ts

@@ -120,14 +120,34 @@ export async function acquireTab(
 	}
 
 	const initPayload = await buildInitPayload(browser, opts);
-	const worker = await spawnTabWorker();
+	let worker = await spawnTabWorker();
 	let info: ReadyInfo;
 	try {
 		info = await initializeTabWorker(worker, initPayload, opts.timeoutMs + GRACE_MS);
 	} catch (error) {
+		// `BuildMessage`-class failures arrive asynchronously via the worker's `error` event,
+		// after `spawnTabWorker`'s synchronous try/catch has already returned. Fall back to
+		// the inline worker here so module-resolution failures don't poison every tab open.
 		await worker.terminate().catch(() => undefined);
-		if (browser.refCount === 0) await releaseBrowser(browser, { kill: false });
-		throw error;
+		if (worker.mode === "inline") {
+			if (browser.refCount === 0) await releaseBrowser(browser, { kill: false });
+			throw error;
+		}
+		logger.warn("Tab worker init failed; retrying with inline tab worker (no sync-loop guard)", {
+			error: error instanceof Error ? error.message : String(error),
+		});
+		worker = await spawnInlineWorker();
+		try {
+			info = await initializeTabWorker(worker, initPayload, opts.timeoutMs + GRACE_MS);
+		} catch (inlineError) {
+			await worker.terminate().catch(() => undefined);
+			if (browser.refCount === 0) await releaseBrowser(browser, { kill: false });
+			const finalError = new ToolError(
+				`Failed to start browser tab worker (inline fallback also failed): ${inlineError instanceof Error ? inlineError.message : String(inlineError)}`,
+			);
+			(finalError as { cause?: unknown }).cause = error;
+			throw finalError;
+		}
 	}
 
 	holdBrowser(browser);

package/src/tools/browser/tab-worker.ts

@@ -459,7 +459,8 @@ export class WorkerCore {
 				if (payload.dialogs) this.#applyDialogPolicy(payload.dialogs);
 				if (payload.url) {
 					await this.#page.goto(payload.url, {
-						waitUntil: payload.waitUntil ?? "networkidle2",
+						// Default to "load" because dev servers with HMR/WS never reach networkidle.
+						waitUntil: payload.waitUntil ?? "load",
 						timeout: payload.timeoutMs,
 					});
 				}
@@ -667,7 +668,8 @@ export class WorkerCore {
 			goto: async (url, opts) => {
 				this.#clearElementCache();
 				await untilAborted(signal, () =>
-					page.goto(url, { waitUntil: opts?.waitUntil ?? "networkidle2", timeout: timeoutMs }),
+					// Default to "load" because dev servers with HMR/WS never reach networkidle.
+					page.goto(url, { waitUntil: opts?.waitUntil ?? "load", timeout: timeoutMs }),
 				);
 			},
 			observe: opts => this.#collectObservation({ ...opts, signal }),

package/src/tools/browser.ts

@@ -45,7 +45,7 @@ const browserSchema = z.object({
 		.describe("auto-handle dialogs")
 		.optional(),
 	code: z.string().describe("js body to run in tab").optional(),
-	timeout: z.number().default(30).describe("timeout in seconds").optional(),
+	timeout: z.number().default(30).describe("timeout in seconds (default 30, max 300)").optional(),
 	all: z.boolean().describe("close every tab").optional(),
 	kill: z.boolean().describe("also kill spawned-app browsers").optional(),
 });