@oh-my-pi/pi-coding-agent 15.10.10 → 15.10.11

package/src/task/index.ts

@@ -43,7 +43,7 @@ import type { LocalProtocolOptions } from "../internal-urls";
 import { loadOverallPlanReference } from "../plan-mode/plan-handoff";
 import { generateCommitMessage } from "../utils/commit-message-generator";
 import * as git from "../utils/git";
-import { discoverAgents, getAgent } from "./discovery";
+import { type DiscoveryResult, discoverAgents, getAgent } from "./discovery";
 import { runSubprocess } from "./executor";
 import { AgentOutputManager } from "./output-manager";
 import { mapWithConcurrencyLimit, Semaphore } from "./parallel";
@@ -242,6 +242,88 @@ function validateTaskModeParams(simpleMode: TaskSimpleMode, params: TaskParams):
 	return "task.simple is set to independent, so the task tool does not accept `context` or `schema`. Put all required background and output expectations inside each task assignment or the selected agent definition.";
 }
 
+/** Sentinel for async jobs whose subagent finished with a failing result; batch counters are already updated. */
+class TaskJobError extends Error {}
+
+/**
+ * Validate task ids: every task needs a non-empty id and ids must be unique
+ * (case-insensitive). Returns a problem description, or undefined when valid.
+ */
+function validateTaskIds(tasks: TaskParams["tasks"]): string | undefined {
+	const missingTaskIndexes: number[] = [];
+	const idIndexes = new Map<string, number[]>();
+
+	for (let i = 0; i < tasks.length; i++) {
+		const id = tasks[i]?.id;
+		if (typeof id !== "string" || id.trim() === "") {
+			missingTaskIndexes.push(i);
+			continue;
+		}
+		const normalizedId = id.toLowerCase();
+		const indexes = idIndexes.get(normalizedId);
+		if (indexes) {
+			indexes.push(i);
+		} else {
+			idIndexes.set(normalizedId, [i]);
+		}
+	}
+
+	const duplicateIds: Array<{ id: string; indexes: number[] }> = [];
+	for (const [normalizedId, indexes] of idIndexes.entries()) {
+		if (indexes.length > 1) {
+			duplicateIds.push({
+				id: tasks[indexes[0]]?.id ?? normalizedId,
+				indexes,
+			});
+		}
+	}
+
+	if (missingTaskIndexes.length === 0 && duplicateIds.length === 0) {
+		return undefined;
+	}
+
+	const problems: string[] = [];
+	if (missingTaskIndexes.length > 0) {
+		problems.push(`Missing task ids at indexes: ${missingTaskIndexes.join(", ")}`);
+	}
+	if (duplicateIds.length > 0) {
+		const details = duplicateIds.map(entry => `${entry.id} (indexes ${entry.indexes.join(", ")})`).join("; ");
+		problems.push(`Duplicate task ids detected (case-insensitive): ${details}`);
+	}
+	return `Invalid tasks: ${problems.join(". ")}`;
+}
+
+/**
+ * Process-level memo for create-time agent discovery, keyed by resolved cwd.
+ *
+ * `TaskTool.create` runs for every (sub)agent session in this process and the
+ * walk-up + plugin-registry scan in `discoverAgents` is identical for a given
+ * cwd, so repeat creations reuse the first scan. Execution-time discovery
+ * (`#executeSync`) intentionally stays fresh. The memo also tracks the live
+ * `discoverAgents` binding: test spies swap that binding, which invalidates
+ * the memo automatically.
+ */
+const discoveryMemo = new Map<string, Promise<DiscoveryResult>>();
+let discoveryMemoFn: typeof discoverAgents | undefined;
+
+function discoverAgentsForCreate(cwd: string): Promise<DiscoveryResult> {
+	const fn = discoverAgents;
+	if (discoveryMemoFn !== fn) {
+		discoveryMemoFn = fn;
+		discoveryMemo.clear();
+	}
+	const key = path.resolve(cwd);
+	let pending = discoveryMemo.get(key);
+	if (!pending) {
+		pending = fn(cwd);
+		discoveryMemo.set(key, pending);
+		pending.catch(() => {
+			if (discoveryMemo.get(key) === pending) discoveryMemo.delete(key);
+		});
+	}
+	return pending;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Tool Class
 // ═══════════════════════════════════════════════════════════════════════════
@@ -325,7 +407,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 	 * Create a TaskTool instance with async agent discovery.
 	 */
 	static async create(session: ToolSession): Promise<TaskTool> {
-		const { agents } = await discoverAgents(session.cwd);
+		const { agents } = await discoverAgentsForCreate(session.cwd);
 		return new TaskTool(session, agents);
 	}
 
@@ -363,6 +445,11 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			return this.#executeSync(_toolCallId, params, signal, onUpdate);
 		}
 
+		const taskIdProblem = validateTaskIds(taskItems);
+		if (taskIdProblem) {
+			return createTaskModeError(taskIdProblem);
+		}
+
 		const outputManager =
 			this.session.agentOutputManager ?? new AgentOutputManager(this.session.getArtifactsDir ?? (() => null));
 		const uniqueIds = await outputManager.allocateBatch(taskItems.map(t => t.id));
@@ -396,9 +483,13 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		let failedJobs = 0;
 
 		const getProgressSnapshot = (): AgentProgress[] => {
+			// Shallow copies: top-level fields are reassigned (never mutated in
+			// place) and the large nested payloads (extractedToolData) are
+			// immutable once attached — structuredClone here cost O(batch × payload)
+			// per progress event.
 			return Array.from(progressByTaskId.values())
 				.sort((a, b) => a.index - b.index)
-				.map(progress => structuredClone(progress));
+				.map(progress => ({ ...progress }));
 		};
 
 		const buildAsyncDetails = (state: "running" | "completed" | "failed", jobId: string): TaskToolDetails => ({
@@ -424,6 +515,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			const taskItem = taskItems[i];
 			if (signal?.aborted) {
 				failedSchedules.push(`${taskItem.id}: cancelled before scheduling`);
+				completedJobs += 1;
 				const progress = progressByTaskId.get(taskItem.id);
 				if (progress) {
 					progress.status = "aborted";
@@ -438,7 +530,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 				const jobId = manager.register(
 					"task",
 					label,
-					async ({ signal: runSignal, reportProgress }) => {
+					async ({ signal: runSignal, reportProgress, markRunning }) => {
 						const startedAt = Date.now();
 						const progress = progressByTaskId.get(taskItem.id);
 						await semaphore.acquire();
@@ -447,8 +539,11 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 							if (progress) {
 								progress.status = "aborted";
 							}
+							completedJobs += 1;
+							failedJobs += 1;
 							throw new Error("Aborted before execution");
 						}
+						markRunning();
 						if (progress) {
 							progress.status = "running";
 						}
@@ -462,12 +557,12 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 							]);
 							const finalText = result.content.find(part => part.type === "text")?.text ?? "(no output)";
 							const singleResult = result.details?.results[0];
+							// A missing per-task result means #executeSync failed at the
+							// tool level (results: []) — treat it as a failure, not success.
+							const resultFailed =
+								!singleResult || (singleResult.aborted ?? false) || singleResult.exitCode !== 0;
 							if (progress) {
-								progress.status = singleResult?.aborted
-									? "aborted"
-									: (singleResult?.exitCode ?? 0) === 0
-										? "completed"
-										: "failed";
+								progress.status = singleResult?.aborted ? "aborted" : resultFailed ? "failed" : "completed";
 								progress.durationMs = singleResult?.durationMs ?? Math.max(0, Date.now() - startedAt);
 								progress.tokens = singleResult?.tokens ?? 0;
 								progress.contextTokens = singleResult?.contextTokens;
@@ -478,7 +573,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 								progress.retryState = undefined;
 							}
 							completedJobs += 1;
-							if (singleResult && ((singleResult.aborted ?? false) || singleResult.exitCode !== 0)) {
+							if (resultFailed) {
 								failedJobs += 1;
 							}
 							const remaining = taskItems.length - completedJobs;
@@ -498,8 +593,15 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 									`Background task batch complete: ${completedJobs}/${taskItems.length} finished.`,
 								);
 							}
+							if (resultFailed) {
+								// Mark the job itself failed; counters above are already updated.
+								throw new TaskJobError(finalText);
+							}
 							return finalText;
 						} catch (error) {
+							if (error instanceof TaskJobError) {
+								throw error;
+							}
 							if (progress) {
 								progress.status = "failed";
 								progress.durationMs = Math.max(0, Date.now() - startedAt);
@@ -530,6 +632,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 					},
 					{
 						id: label,
+						queued: true,
 						ownerId: this.session.getAgentId?.() ?? undefined,
 						onProgress: (text, details) => {
 							const progressDetails =
@@ -543,6 +646,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			} catch (error) {
 				const message = error instanceof Error ? error.message : String(error);
 				failedSchedules.push(`${taskItem.id}: ${message}`);
+				completedJobs += 1;
 				const progress = progressByTaskId.get(taskItem.id);
 				if (progress) {
 					progress.status = "failed";
@@ -734,45 +838,10 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		}
 
 		const tasks = params.tasks;
-		const missingTaskIndexes: number[] = [];
-		const idIndexes = new Map<string, number[]>();
-
-		for (let i = 0; i < tasks.length; i++) {
-			const id = tasks[i]?.id;
-			if (typeof id !== "string" || id.trim() === "") {
-				missingTaskIndexes.push(i);
-				continue;
-			}
-			const normalizedId = id.toLowerCase();
-			const indexes = idIndexes.get(normalizedId);
-			if (indexes) {
-				indexes.push(i);
-			} else {
-				idIndexes.set(normalizedId, [i]);
-			}
-		}
-
-		const duplicateIds: Array<{ id: string; indexes: number[] }> = [];
-		for (const [normalizedId, indexes] of idIndexes.entries()) {
-			if (indexes.length > 1) {
-				duplicateIds.push({
-					id: tasks[indexes[0]]?.id ?? normalizedId,
-					indexes,
-				});
-			}
-		}
-
-		if (missingTaskIndexes.length > 0 || duplicateIds.length > 0) {
-			const problems: string[] = [];
-			if (missingTaskIndexes.length > 0) {
-				problems.push(`Missing task ids at indexes: ${missingTaskIndexes.join(", ")}`);
-			}
-			if (duplicateIds.length > 0) {
-				const details = duplicateIds.map(entry => `${entry.id} (indexes ${entry.indexes.join(", ")})`).join("; ");
-				problems.push(`Duplicate task ids detected (case-insensitive): ${details}`);
-			}
+		const taskIdProblem = validateTaskIds(tasks);
+		if (taskIdProblem) {
 			return {
-				content: [{ type: "text", text: `Invalid tasks: ${problems.join(". ")}` }],
+				content: [{ type: "text", text: taskIdProblem }],
 				details: {
 					projectAgentsDir,
 					results: [],
@@ -951,7 +1020,11 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			}
 			emitProgress();
 
-			const runTask = async (task: (typeof tasksWithUniqueIds)[number], index: number) => {
+			const runTask = async (
+				task: (typeof tasksWithUniqueIds)[number],
+				index: number,
+				workerSignal?: AbortSignal,
+			) => {
 				if (!isIsolated) {
 					return runSubprocess({
 						cwd: this.session.cwd,
@@ -973,12 +1046,13 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						artifactsDir: effectiveArtifactsDir,
 						contextFile: contextFilePath,
 						enableLsp: subagentLspEnabled,
-						signal,
+						signal: workerSignal ?? signal,
 						eventBus: this.session.eventBus,
 						onProgress: progress => {
-							progressMap.set(index, {
-								...structuredClone(progress),
-							});
+							// Shallow snapshot; recentTools is mutated in place by the
+							// executor, the rest is reassigned or immutable. A deep clone
+							// here cost O(extractedToolData) per progress event.
+							progressMap.set(index, { ...progress, recentTools: progress.recentTools.slice() });
 							emitProgress();
 						},
 						authStorage: this.session.authStorage,
@@ -1034,12 +1108,10 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						artifactsDir: effectiveArtifactsDir,
 						contextFile: contextFilePath,
 						enableLsp: subagentLspEnabled,
-						signal,
+						signal: workerSignal ?? signal,
 						eventBus: this.session.eventBus,
 						onProgress: progress => {
-							progressMap.set(index, {
-								...structuredClone(progress),
-							});
+							progressMap.set(index, { ...progress, recentTools: progress.recentTools.slice() });
 							emitProgress();
 						},
 						authStorage: this.session.authStorage,
@@ -1226,6 +1298,9 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 								const conflictPart = mergeResult.conflict ? `\nConflict: ${mergeResult.conflict}` : "";
 								mergeSummary = `\n\n<system-notification>Branch merge failed. ${mergedPart}${failedPart}${conflictPart}\nUnmerged branches remain for manual resolution.</system-notification>`;
 							}
+							if (mergeResult.stashConflict) {
+								mergeSummary += `\n\n<system-notification>${mergeResult.stashConflict}</system-notification>`;
+							}
 						}
 
 						// Clean up merged branches (keep failed ones for manual resolution)
@@ -1234,9 +1309,11 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 							await cleanupTaskBranches(repoRoot, allBranches);
 						}
 					} else {
-						// Patch mode: combine and apply patches
-						const patchesInOrder = results.map(result => result.patchPath).filter(Boolean) as string[];
-						const missingPatch = results.some(result => !result.patchPath);
+						// Patch mode: apply patches from successful tasks. Failed or
+						// aborted siblings must not block completed work from landing.
+						const successfulResults = results.filter(r => r.exitCode === 0 && !r.error && !r.aborted);
+						const patchesInOrder = successfulResults.map(result => result.patchPath).filter(Boolean) as string[];
+						const missingPatch = successfulResults.some(result => !result.patchPath);
 						if (missingPatch) {
 							changesApplied = false;
 							hadAnyChanges = false;

package/src/task/parallel.ts

@@ -20,13 +20,13 @@ export interface ParallelResult<R> {
  *
  * @param items - Items to process
  * @param concurrency - Maximum concurrent operations
- * @param fn - Async function to execute for each item
+ * @param fn - Async function to execute for each item; receives a worker signal that fires on abort or fail-fast so in-flight siblings can cancel
  * @param signal - Optional abort signal to stop scheduling new work
  */
 export async function mapWithConcurrencyLimit<T, R>(
 	items: T[],
 	concurrency: number,
-	fn: (item: T, index: number) => Promise<R>,
+	fn: (item: T, index: number, signal: AbortSignal) => Promise<R>,
 	signal?: AbortSignal,
 ): Promise<ParallelResult<R>> {
 	const normalizedConcurrency = Number.isFinite(concurrency) ? Math.floor(concurrency) : items.length;
@@ -52,7 +52,7 @@ export async function mapWithConcurrencyLimit<T, R>(
 			const index = nextIndex++;
 			if (index >= items.length) return;
 			try {
-				results[index] = await fn(items[index], index);
+				results[index] = await fn(items[index], index, workerSignal);
 			} catch (error) {
 				// On abort, the fn itself handles it and returns a result
 				// Only propagate non-abort errors

package/src/task/render.ts

@@ -541,7 +541,7 @@ function renderTaskItemLines(tasks: TaskItem[] | undefined, expanded: boolean, t
  * the merged result frame so the brief stays visible for the whole task
  * lifecycle — not just until the first progress snapshot replaces the call view.
  */
-type TaskRenderSection = { lines: string[] };
+type TaskRenderSection = { lines: readonly string[] };
 type ContextSectionRenderer = (width: number) => TaskRenderSection;
 
 // Default output-block layout is: left border + one-cell content inset + right
@@ -578,7 +578,7 @@ export function renderCall(
 	const header = renderStatusLine({ icon: "pending", title: "Task", description: args.agent }, theme);
 	const contextSectionRenderer = createContextSectionRenderer(args, theme);
 	return framedBlock(theme, width => {
-		const sections: Array<{ label?: string; lines: string[]; separator?: boolean }> = [];
+		const sections: Array<{ label?: string; lines: readonly string[]; separator?: boolean }> = [];
 
 		if (contextSectionRenderer) sections.push(contextSectionRenderer(width));
 

package/src/task/worktree.ts

@@ -5,6 +5,7 @@ import * as path from "node:path";
 import * as natives from "@oh-my-pi/pi-natives";
 import { getWorktreeDir, hashPath, logger, Snowflake } from "@oh-my-pi/pi-utils";
 import * as git from "../utils/git";
+import { mapWithConcurrencyLimit } from "./parallel";
 
 const { IsoBackendKind } = natives;
 type IsoBackendKind = natives.IsoBackendKind;
@@ -82,16 +83,16 @@ async function discoverNestedRepos(repoRoot: string): Promise<string[]> {
 async function captureUntrackedPatch(repoRoot: string, untracked: readonly string[]): Promise<string> {
 	if (untracked.length === 0) return "";
 	const nullPath = getGitNoIndexNullPath();
-	const untrackedDiffs = await Promise.all(
-		untracked.map(entry =>
-			git.diff(repoRoot, {
-				allowFailure: true,
-				binary: true,
-				noIndex: { left: nullPath, right: entry },
-			}),
-		),
+	// Bound concurrent git spawns; large untracked sets would otherwise fork one
+	// process per file at once.
+	const { results: untrackedDiffs } = await mapWithConcurrencyLimit([...untracked], 8, entry =>
+		git.diff(repoRoot, {
+			allowFailure: true,
+			binary: true,
+			noIndex: { left: nullPath, right: entry },
+		}),
 	);
-	return untrackedDiffs.filter(diff => diff.trim()).join("\n");
+	return untrackedDiffs.filter((diff): diff is string => !!diff?.trim()).join("\n");
 }
 
 async function captureRepoBaseline(repoRoot: string): Promise<RepoBaseline> {
@@ -427,6 +428,8 @@ export interface MergeBranchResult {
 	merged: string[];
 	failed: string[];
 	conflict?: string;
+	/** Set when cherry-picks landed on HEAD but restoring the stashed working tree failed. */
+	stashConflict?: string;
 }
 
 /**
@@ -438,64 +441,69 @@ export async function mergeTaskBranches(
 	repoRoot: string,
 	branches: Array<{ branchName: string; taskId: string; description?: string }>,
 ): Promise<MergeBranchResult> {
-	const merged: string[] = [];
-	const failed: string[] = [];
+	// Serialize against other in-process git mutations on this repo: concurrent
+	// background merges interleaving stash push/pop + cherry-pick would corrupt
+	// the working tree (lost uncommitted changes, mixed-up stash entries).
+	return git.withRepoLock(repoRoot, async () => {
+		const merged: string[] = [];
+		const failed: string[] = [];
 
-	// Stash dirty working tree so cherry-pick can operate on a clean HEAD.
-	// Without this, cherry-pick refuses to run when uncommitted changes exist.
-	const didStash = await git.stash.push(repoRoot, "omp-task-merge");
+		// Stash dirty working tree so cherry-pick can operate on a clean HEAD.
+		// Without this, cherry-pick refuses to run when uncommitted changes exist.
+		const didStash = await git.stash.push(repoRoot, "omp-task-merge");
 
-	let conflictResult: MergeBranchResult | undefined;
+		let conflictResult: MergeBranchResult | undefined;
 
-	try {
-		for (const { branchName } of branches) {
-			try {
-				await git.cherryPick(repoRoot, branchName);
-			} catch (err) {
+		try {
+			for (const { branchName } of branches) {
 				try {
-					await git.cherryPick.abort(repoRoot);
-				} catch {
-					/* no state to abort */
-				}
-				const stderr =
-					err instanceof git.GitCommandError
-						? err.result.stderr.trim()
-						: err instanceof Error
-							? err.message
-							: String(err);
-				failed.push(branchName);
-				conflictResult = {
-					merged,
-					failed: [...failed, ...branches.slice(merged.length + failed.length).map(b => b.branchName)],
-					conflict: `${branchName}: ${stderr}`,
-				};
-				break;
-			}
-
-			merged.push(branchName);
-		}
-	} finally {
-		if (didStash) {
-			try {
-				await git.stash.pop(repoRoot, { index: true });
-			} catch {
-				// Stash-pop conflicts mean the replayed changes clash with the user's
-				// uncommitted edits. Treat this as a merge failure so the caller preserves
-				// recovery branches instead of reporting success and deleting them.
-				logger.warn("Failed to restore stashed changes after task merge; stash entry preserved");
-				if (!conflictResult) {
+					await git.cherryPick(repoRoot, branchName);
+				} catch (err) {
+					try {
+						await git.cherryPick.abort(repoRoot);
+					} catch {
+						/* no state to abort */
+					}
+					const stderr =
+						err instanceof git.GitCommandError
+							? err.result.stderr.trim()
+							: err instanceof Error
+								? err.message
+								: String(err);
+					failed.push(branchName);
 					conflictResult = {
 						merged,
-						failed: merged,
-						conflict:
-							"stash pop: cherry-picked changes conflict with uncommitted edits. Run `git stash pop` and resolve manually.",
+						failed: [...failed, ...branches.slice(merged.length + failed.length).map(b => b.branchName)],
+						conflict: `${branchName}: ${stderr}`,
 					};
+					break;
+				}
+
+				merged.push(branchName);
+			}
+		} finally {
+			if (didStash) {
+				try {
+					await git.stash.pop(repoRoot, { index: true });
+				} catch {
+					// Stash-pop conflicts mean the replayed changes clash with the user's
+					// uncommitted edits. The cherry-picked commits are already on HEAD, so
+					// the merged branches DID land — report them as merged and surface the
+					// stash conflict separately instead of claiming they are unmerged.
+					logger.warn("Failed to restore stashed changes after task merge; stash entry preserved");
+					const stashConflict =
+						"stash pop: cherry-picked changes conflict with uncommitted edits. The merged commits are on HEAD; run `git stash pop` and resolve manually.";
+					if (conflictResult) {
+						conflictResult.stashConflict = stashConflict;
+					} else {
+						conflictResult = { merged, failed: [], stashConflict };
+					}
 				}
 			}
 		}
-	}
 
-	return conflictResult ?? { merged, failed };
+		return conflictResult ?? { merged, failed };
+	});
 }
 
 /** Clean up temporary task branches. */

package/src/thinking.ts

@@ -1,5 +1,6 @@
 import { type ResolvedThinkingLevel, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import { clampThinkingLevelForModel, Effort, getSupportedEfforts, type Model, THINKING_EFFORTS } from "@oh-my-pi/pi-ai";
+import { Effort, type Model, THINKING_EFFORTS } from "@oh-my-pi/pi-ai";
+import { clampThinkingLevelForModel, getSupportedEfforts } from "@oh-my-pi/pi-catalog/model-thinking";
 
 /**
  * Metadata used to render thinking selector values in the coding-agent UI.

package/src/tiny/title-client.ts

@@ -1,5 +1,5 @@
 import * as path from "node:path";
-import { $env, isCompiledBinary, logger } from "@oh-my-pi/pi-utils";
+import { $env, isBunTestRuntime, isCompiledBinary, logger, workerHostEntry } from "@oh-my-pi/pi-utils";
 import type { Subprocess } from "bun";
 import { settings } from "../config/settings";
 import { tinyModelDeviceSettingToEnv } from "./device";
@@ -108,17 +108,28 @@ function tinyWorkerEnv(): Record<string, string> {
 	for (const key in overlay) merged[key] = overlay[key];
 	return merged;
 }
+interface TinyWorkerSpawnCommand {
+	cmd: string[];
+	cwd?: string;
+}
 
 /**
- * Resolve the argv used to relaunch the agent CLI into tiny-worker mode. In a
- * compiled binary the entry point is the binary itself; in dev/source the
- * spawned `bun` needs the absolute path to `cli.ts` so it can resolve module
- * imports against the on-disk source tree.
+ * Resolve the command used to relaunch the agent CLI into tiny-worker mode.
+ * In a compiled binary the entry point is the binary itself (no script arg).
+ * Otherwise re-enter the declared worker-host entry (source cli.ts or
+ * npm-bundle cli.js) with a cwd-relative script path — Bun's subprocess IPC
+ * is more reliable that way than with an absolute `.ts` entry under
+ * `bun test` — and fall back to this package's own `src/cli.ts` when no host
+ * entry is declared (bun test, SDK embedding).
  */
-function tinyWorkerSpawnCmd(): string[] {
-	if (isCompiledBinary()) return [process.execPath, TINY_WORKER_ARG];
-	const cliPath = path.resolve(import.meta.dir, "..", "cli.ts");
-	return [process.execPath, cliPath, TINY_WORKER_ARG];
+function tinyWorkerSpawnCmd(): TinyWorkerSpawnCommand {
+	if (isCompiledBinary()) return { cmd: [process.execPath, TINY_WORKER_ARG] };
+	const hostEntry = workerHostEntry();
+	if (hostEntry) {
+		return { cmd: [process.execPath, path.basename(hostEntry), TINY_WORKER_ARG], cwd: path.dirname(hostEntry) };
+	}
+	const packageRoot = path.resolve(import.meta.dir, "..", "..");
+	return { cmd: [process.execPath, "src/cli.ts", TINY_WORKER_ARG], cwd: packageRoot };
 }
 
 interface SpawnedSubprocess {
@@ -143,8 +154,10 @@ export function createTinyTitleSubprocess(): SpawnedSubprocess {
 	const inbound = new Set<(message: TinyTitleWorkerOutbound) => void>();
 	const errors = new Set<(error: Error) => void>();
 	const intentionalExit = { value: false };
+	const spawnCommand = tinyWorkerSpawnCmd();
 	const proc = Bun.spawn({
-		cmd: tinyWorkerSpawnCmd(),
+		cmd: spawnCommand.cmd,
+		cwd: spawnCommand.cwd,
 		env: tinyWorkerEnv(),
 		stdin: "ignore",
 		stdout: "ignore",
@@ -175,7 +188,9 @@ export function createTinyTitleSubprocess(): SpawnedSubprocess {
 	});
 	// Don't keep the parent event loop alive on account of an idle worker; the
 	// agent dispose path calls `terminate()` explicitly when shutting down.
-	proc.unref();
+	// Bun's test runner can starve IPC delivery for unref'd subprocesses, so
+	// keep it referenced only under tests that assert the ping/pong contract.
+	if (!isBunTestRuntime()) proc.unref();
 	return { proc, inbound, errors, intentionalExit };
 }
 

package/src/tools/archive-reader.ts

@@ -6,6 +6,19 @@ import { inflateSync, strFromU8 } from "fflate";
 import { formatBytes } from "./render-utils";
 import { ToolError } from "./tool-errors";
 
+/**
+ * Cap on the on-disk size of tar/tar.gz archives, which are loaded fully into
+ * memory (and decompressed by `Bun.Archive`) just to index entries. ZIP is
+ * exempt: it is read via ranged central-directory access.
+ */
+const MAX_TAR_ARCHIVE_BYTES = 256 * 1024 * 1024;
+/**
+ * Cap on a single archive member's declared (uncompressed) size. The declared
+ * size is attacker-controlled metadata — a crafted ZIP entry can claim
+ * multi-GB sizes that would be allocated up front before any data inflates.
+ */
+const MAX_ARCHIVE_MEMBER_BYTES = 64 * 1024 * 1024;
+
 export type ArchiveFormat = "zip" | "tar" | "tar.gz";
 
 export interface ArchivePathCandidate {
@@ -646,6 +659,11 @@ export class ArchiveReader {
 		if (!entry.storage) {
 			throw new ToolError(`Archive file '${normalizedPath}' has no readable storage`);
 		}
+		if (entry.size > MAX_ARCHIVE_MEMBER_BYTES) {
+			throw new ToolError(
+				`Archive member '${normalizedPath}' is too large to extract in memory (${formatBytes(entry.size)} > ${formatBytes(MAX_ARCHIVE_MEMBER_BYTES)} limit)`,
+			);
+		}
 
 		const bytes =
 			entry.storage.type === "tar"
@@ -668,8 +686,18 @@ export async function openArchive(filePath: string): Promise<ArchiveReader> {
 		throw new ToolError(`Unsupported archive format: ${filePath}`);
 	}
 
-	const entries =
-		format === "zip" ? await readZipEntries(filePath) : await readTarEntries(await Bun.file(filePath).bytes());
+	if (format === "zip") {
+		return new ArchiveReader(format, await readZipEntries(filePath));
+	}
+
+	const file = Bun.file(filePath);
+	const archiveSize = file.size;
+	if (archiveSize > MAX_TAR_ARCHIVE_BYTES) {
+		throw new ToolError(
+			`Archive is too large to read in memory (${formatBytes(archiveSize)} > ${formatBytes(MAX_TAR_ARCHIVE_BYTES)} limit)`,
+		);
+	}
+	const entries = await readTarEntries(await file.bytes());
 	return new ArchiveReader(format, entries);
 }