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

package/src/slash-commands/helpers/stats-dashboard.ts

@@ -0,0 +1,85 @@
+import * as stats from "@oh-my-pi/omp-stats";
+import * as openUtils from "../../utils/open";
+
+export const DEFAULT_STATS_DASHBOARD_PORT = 3847;
+
+interface StatsDashboardServer {
+	port: number;
+	stop: () => void;
+}
+
+export interface StatsDashboardArgs {
+	port: number;
+}
+
+export interface StatsDashboardLaunchResult {
+	url: string;
+	message: string;
+}
+
+let activeStatsServer: StatsDashboardServer | undefined;
+
+const STATS_DASHBOARD_USAGE = "Usage: /stats [--port <port>]";
+
+function parsePort(value: string | undefined): number | string {
+	if (!value) return `Missing port. ${STATS_DASHBOARD_USAGE}`;
+	if (!/^\d+$/.test(value)) return `Invalid port: ${value}`;
+	const port = Number(value);
+	if (!Number.isInteger(port) || port < 0 || port > 65_535) return `Invalid port: ${value}`;
+	return port;
+}
+
+export function parseStatsDashboardArgs(args: string): StatsDashboardArgs | { error: string } {
+	const tokens = args.split(/\s+/).filter(Boolean);
+	let port = DEFAULT_STATS_DASHBOARD_PORT;
+
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token === "--port" || token === "-p") {
+			const parsed = parsePort(tokens[++i]);
+			if (typeof parsed === "string") return { error: parsed };
+			port = parsed;
+			continue;
+		}
+		if (token.startsWith("--port=")) {
+			const parsed = parsePort(token.slice("--port=".length));
+			if (typeof parsed === "string") return { error: parsed };
+			port = parsed;
+			continue;
+		}
+		return { error: `Unknown option: ${token}. ${STATS_DASHBOARD_USAGE}` };
+	}
+
+	return { port };
+}
+
+export async function launchStatsDashboard(args: StatsDashboardArgs): Promise<StatsDashboardLaunchResult> {
+	const { processed, files } = await stats.syncAllSessions();
+	const total = await stats.getTotalMessageCount();
+	let requestedPortIgnored = false;
+
+	if (!activeStatsServer) {
+		activeStatsServer = await stats.startServer(args.port);
+	} else if (args.port !== activeStatsServer.port) {
+		requestedPortIgnored = true;
+	}
+
+	const url = `http://localhost:${activeStatsServer.port}`;
+	openUtils.openPath(url);
+
+	const serverLine = requestedPortIgnored
+		? `Dashboard already running at: ${url} (requested port ${args.port} ignored)`
+		: `Dashboard available at: ${url}`;
+
+	return {
+		url,
+		message: `Synced ${processed} new entries from ${files} files (${total} total)\n${serverLine}`,
+	};
+}
+
+export function stopStatsDashboard(): void {
+	if (!activeStatsServer) return;
+	activeStatsServer.stop();
+	activeStatsServer = undefined;
+	stats.closeDb();
+}

package/src/ssh/connection-manager.ts

@@ -355,6 +355,33 @@ export async function getHostInfoForHost(host: SSHConnectionTarget): Promise<SSH
 	return await loadHostInfoFromDisk(host);
 }
 
+/**
+ * Synchronous, probe-free host info lookup for startup paths.
+ *
+ * Checks the in-memory cache, then falls back to a synchronous read of the
+ * persisted host-info cache file. Never opens a connection or probes the
+ * remote host — callers get `undefined` when nothing is cached yet.
+ */
+export function getCachedHostInfoSync(host: SSHConnectionTarget): SSHHostInfo | undefined {
+	const cached = hostInfoCache.get(host.name);
+	if (cached) {
+		const resolved = applyCompatOverride(host, cached);
+		if (resolved !== cached) hostInfoCache.set(host.name, resolved);
+		return resolved;
+	}
+	try {
+		const parsed = parseHostInfo(JSON.parse(fs.readFileSync(getHostInfoPath(host.name), "utf-8")));
+		if (!parsed) return undefined;
+		const resolved = applyCompatOverride(host, parsed);
+		hostInfoCache.set(host.name, resolved);
+		return resolved;
+	} catch (err) {
+		if (isEnoent(err)) return undefined;
+		logger.warn("Failed to load SSH host info", { host: host.name, error: String(err) });
+		return undefined;
+	}
+}
+
 export async function ensureHostInfo(host: SSHConnectionTarget): Promise<SSHHostInfo> {
 	const cached = hostInfoCache.get(host.name);
 	if (cached) {

package/src/task/commands.ts

@@ -120,7 +120,8 @@ export function getCommand(commands: WorkflowCommand[], name: string): WorkflowC
  * Replaces $@ with the provided input.
  */
 export function expandCommand(command: WorkflowCommand, input: string): string {
-	return command.instructions.replace(/\$@/g, input);
+	// Function replacement so `$`-patterns in user input ($$, $&, ...) stay literal.
+	return command.instructions.replace(/\$@/g, () => input);
 }
 
 /**

package/src/task/discovery.ts

@@ -1,13 +1,14 @@
 /**
  * Agent discovery from filesystem.
  *
- * Discovers agent definitions from:
- *   - ~/.omp/agent/agents/*.md (user-level, primary)
- *   - ~/.pi/agent/agents/*.md (user-level, legacy)
- *   - ~/.claude/agents/*.md (user-level, legacy)
- *   - .omp/agents/*.md (project-level, primary)
- *   - .pi/agents/*.md (project-level, legacy)
- *   - .claude/agents/*.md (project-level, legacy)
+ * Discovers agent definitions from OMP-native task-agent roots:
+ *   - ~/.omp/agent/agents/*.md (user-level)
+ *   - .omp/agents/*.md (project-level)
+ *
+ * Claude Code marketplace plugin agents are discovered separately via the
+ * claude-plugins provider. Direct cross-harness roots such as .claude/agents
+ * are intentionally skipped because their frontmatter schema is not the OMP
+ * task-agent contract.
  *
  * Agent files use markdown with YAML frontmatter.
  */
@@ -21,6 +22,8 @@ import { listClaudePluginRoots } from "../discovery/helpers";
 import { loadBundledAgents, parseAgent } from "./agents";
 import type { AgentDefinition, AgentSource } from "./types";
 
+const TASK_AGENT_CONFIG_SOURCE = ".omp";
+
 /** Result of agent discovery */
 export interface DiscoveryResult {
 	agents: AgentDefinition[];
@@ -52,41 +55,31 @@ async function loadAgentsFromDir(dir: string, source: AgentSource): Promise<Agen
 /**
  * Discover agents from filesystem and merge with bundled agents.
  *
- * Precedence (highest wins): .omp > .pi > .claude (project before user), then bundled
- *
+ * Precedence (highest wins): project .omp, user .omp, Claude plugin agents, then bundled
  * @param cwd - Current working directory for project agent discovery
  */
 export async function discoverAgents(cwd: string, home: string = os.homedir()): Promise<DiscoveryResult> {
 	const resolvedCwd = path.resolve(cwd);
-	const agentSources = Array.from(new Set(getConfigDirs("", { project: false }).map(entry => entry.source)));
 
-	// Get user directories (priority order: .omp, .pi, .claude, ...)
 	const userDirs = getConfigDirs("agents", { project: false })
-		.filter(entry => agentSources.includes(entry.source))
+		.filter(entry => entry.source === TASK_AGENT_CONFIG_SOURCE)
 		.map(entry => ({
 			...entry,
 			path: path.resolve(entry.path),
 		}));
 
-	// Get project directories by walking up from cwd (priority order)
 	const projectDirs = findAllNearestProjectConfigDirs("agents", resolvedCwd)
-		.filter(entry => agentSources.includes(entry.source))
+		.filter(entry => entry.source === TASK_AGENT_CONFIG_SOURCE)
 		.map(entry => ({
 			...entry,
 			path: path.resolve(entry.path),
 		}));
 
-	const orderedSources = agentSources.filter(
-		source => userDirs.some(entry => entry.source === source) || projectDirs.some(entry => entry.source === source),
-	);
-
 	const orderedDirs: Array<{ dir: string; source: AgentSource }> = [];
-	for (const source of orderedSources) {
-		const project = projectDirs.find(entry => entry.source === source);
-		if (project) orderedDirs.push({ dir: project.path, source: "project" });
-		const user = userDirs.find(entry => entry.source === source);
-		if (user) orderedDirs.push({ dir: user.path, source: "user" });
-	}
+	const project = projectDirs[0];
+	if (project) orderedDirs.push({ dir: project.path, source: "project" });
+	const user = userDirs[0];
+	if (user) orderedDirs.push({ dir: user.path, source: "user" });
 
 	// Load agents from Claude Code marketplace plugins (respects disabledProviders)
 	const { roots: pluginRoots } = isProviderEnabled("claude-plugins")

package/src/task/executor.ts

@@ -1285,59 +1285,67 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 			const { normalized: normalizedOutputSchema } = normalizeSchema(outputSchema);
 
-			const { session } = await awaitAbortable(
-				createAgentSession({
-					cwd: worktree ?? cwd,
-					authStorage,
-					modelRegistry,
-					settings: subagentSettings,
-					model,
-					thinkingLevel: effectiveThinkingLevel,
-					toolNames,
-					outputSchema,
-					requireYieldTool: true,
-					contextFiles: options.contextFiles,
-					skills: options.skills,
-					promptTemplates: options.promptTemplates,
-					workspaceTree: options.workspaceTree,
-					rules: options.rules,
-					preloadedExtensionPaths: options.preloadedExtensionPaths,
-					preloadedCustomToolPaths: options.preloadedCustomToolPaths,
-					systemPrompt: defaultPrompt => {
-						const subagentPrompt = prompt.render(subagentSystemPromptTemplate, {
-							agent: agent.systemPrompt,
-							context: options.context?.trim() ?? "",
-							planReference: options.planReference?.content ?? "",
-							planReferencePath: options.planReference?.path ?? "",
-							worktree: worktree ?? "",
-							outputSchema: normalizedOutputSchema,
-							contextFile: contextFileForPrompt,
-							ircPeers: ircEnabled ? renderIrcPeerRoster(id) : "",
-							ircSelfId: ircEnabled ? id : "",
-						});
-						return defaultPrompt.length === 0
-							? [subagentPrompt]
-							: [...defaultPrompt.slice(0, -1), subagentPrompt, defaultPrompt[defaultPrompt.length - 1]];
-					},
-					sessionManager,
-					hasUI: false,
-					spawns: spawnsEnv,
-					taskDepth: childDepth,
-					parentHindsightSessionState: options.parentHindsightSessionState,
-					parentMnemopiSessionState: options.parentMnemopiSessionState,
-					parentTaskPrefix: id,
-					agentId: id,
-					agentDisplayName: agent.name,
-					enableLsp: lspEnabled,
-					skipPythonPreflight,
-					enableMCP,
-					mcpManager: options.mcpManager,
-					customTools: mcpProxyTools.length > 0 ? mcpProxyTools : undefined,
-					localProtocolOptions: options.localProtocolOptions,
-					telemetry: subagentTelemetry,
-					parentEvalSessionId: options.parentEvalSessionId,
-				}),
-			);
+			const sessionPromise = createAgentSession({
+				cwd: worktree ?? cwd,
+				authStorage,
+				modelRegistry,
+				settings: subagentSettings,
+				model,
+				thinkingLevel: effectiveThinkingLevel,
+				toolNames,
+				outputSchema,
+				requireYieldTool: true,
+				contextFiles: options.contextFiles,
+				skills: options.skills,
+				promptTemplates: options.promptTemplates,
+				workspaceTree: options.workspaceTree,
+				rules: options.rules,
+				preloadedExtensionPaths: options.preloadedExtensionPaths,
+				preloadedCustomToolPaths: options.preloadedCustomToolPaths,
+				systemPrompt: defaultPrompt => {
+					const subagentPrompt = prompt.render(subagentSystemPromptTemplate, {
+						agent: agent.systemPrompt,
+						context: options.context?.trim() ?? "",
+						planReference: options.planReference?.content ?? "",
+						planReferencePath: options.planReference?.path ?? "",
+						worktree: worktree ?? "",
+						outputSchema: normalizedOutputSchema,
+						contextFile: contextFileForPrompt,
+						ircPeers: ircEnabled ? renderIrcPeerRoster(id) : "",
+						ircSelfId: ircEnabled ? id : "",
+					});
+					return defaultPrompt.length === 0
+						? [subagentPrompt]
+						: [...defaultPrompt.slice(0, -1), subagentPrompt, defaultPrompt[defaultPrompt.length - 1]];
+				},
+				sessionManager,
+				hasUI: false,
+				spawns: spawnsEnv,
+				taskDepth: childDepth,
+				parentHindsightSessionState: options.parentHindsightSessionState,
+				parentMnemopiSessionState: options.parentMnemopiSessionState,
+				parentTaskPrefix: id,
+				agentId: id,
+				agentDisplayName: agent.name,
+				enableLsp: lspEnabled,
+				skipPythonPreflight,
+				enableMCP,
+				mcpManager: options.mcpManager,
+				customTools: mcpProxyTools.length > 0 ? mcpProxyTools : undefined,
+				localProtocolOptions: options.localProtocolOptions,
+				telemetry: subagentTelemetry,
+				parentEvalSessionId: options.parentEvalSessionId,
+			});
+			let session: AgentSession;
+			try {
+				({ session } = await awaitAbortable(sessionPromise));
+			} catch (err) {
+				// Abort raced session startup. The session may still resolve later
+				// holding live LSP/MCP child processes — dispose it when it does so
+				// a cancelled subagent cannot leak them.
+				void sessionPromise.then(created => created.session.dispose()).catch(() => {});
+				throw err;
+			}
 
 			activeSession = session;
 

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;