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

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(),
 });

package/src/tools/debug.ts

@@ -1,3 +1,4 @@
+import * as fs from "node:fs/promises";
 import type {
 	AgentTool,
 	AgentToolContext,
@@ -6,7 +7,7 @@ import type {
 	RenderResultOptions,
 } from "@oh-my-pi/pi-agent-core";
 import { type Component, Text } from "@oh-my-pi/pi-tui";
-import { prompt } from "@oh-my-pi/pi-utils";
+import { isEnoent, prompt } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
 import {
 	type DapBreakpointRecord,
@@ -37,7 +38,7 @@ import { renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
 import type { ToolSession } from ".";
 import type { OutputMeta } from "./output-meta";
-import { resolveToCwd } from "./path-utils";
+import { formatPathRelativeToCwd, resolveToCwd } from "./path-utils";
 import {
 	formatExpandHint,
 	formatStatusIcon,
@@ -469,6 +470,21 @@ function getConfiguredAdapters(cwd: string): string {
 	const adapters = getAvailableAdapters(cwd).map(adapter => adapter.name);
 	return adapters.length > 0 ? adapters.join(", ") : "none";
 }
+async function validateLaunchProgram(program: string, cwd: string): Promise<void> {
+	let isDirectory: boolean;
+	try {
+		isDirectory = (await fs.stat(program)).isDirectory();
+	} catch (error) {
+		if (isEnoent(error)) return;
+		throw error;
+	}
+	if (!isDirectory) return;
+
+	const displayPath = formatPathRelativeToCwd(program, cwd, { trailingSlash: true });
+	throw new ToolError(
+		`launch program resolves to a directory: ${displayPath}. Pass an executable file path, or for Python use adapter "debugpy" with program set to the .py file.`,
+	);
+}
 
 interface DebugRenderArgs extends Partial<DebugParams> {}
 
@@ -628,6 +644,7 @@ export class DebugTool implements AgentTool<typeof debugSchema, DebugToolDetails
 				}
 				const commandCwd = params.cwd ? resolveToCwd(params.cwd, this.session.cwd) : this.session.cwd;
 				const program = resolveToCwd(params.program, commandCwd);
+				await validateLaunchProgram(program, commandCwd);
 				const adapter = selectLaunchAdapter(program, commandCwd, params.adapter);
 				if (!adapter) {
 					throw new ToolError(