@oh-my-pi/pi-coding-agent 13.18.0 → 13.19.0

package/src/session/agent-session.ts

@@ -59,6 +59,7 @@ import {
 	extractExplicitThinkingSelector,
 	formatModelString,
 	parseModelString,
+	type ResolvedModelRoleValue,
 	resolveModelRoleValue,
 } from "../config/model-resolver";
 import { expandPromptTemplate, type PromptTemplate, renderPromptTemplate } from "../config/prompt-templates";
@@ -114,7 +115,7 @@ import planModeToolDecisionReminderPrompt from "../prompts/system/plan-mode-tool
 	type: "text",
 };
 import ttsrInterruptTemplate from "../prompts/system/ttsr-interrupt.md" with { type: "text" };
-import type { SecretObfuscator } from "../secrets/obfuscator";
+import { deobfuscateSessionContext, type SecretObfuscator } from "../secrets/obfuscator";
 import { resolveThinkingLevelForModel, toReasoningEffort } from "../thinking";
 import type { CheckpointState } from "../tools/checkpoint";
 import { outputMeta } from "../tools/output-meta";
@@ -162,7 +163,7 @@ import { getLatestCompactionEntry } from "./session-manager";
 /** Session-specific events that extend the core AgentEvent */
 export type AgentSessionEvent =
 	| AgentEvent
-	| { type: "auto_compaction_start"; reason: "threshold" | "overflow"; action: "context-full" | "handoff" }
+	| { type: "auto_compaction_start"; reason: "threshold" | "overflow" | "idle"; action: "context-full" | "handoff" }
 	| {
 			type: "auto_compaction_end";
 			action: "context-full" | "handoff";
@@ -539,7 +540,7 @@ export class AgentSession {
 		this.#defaultSelectedMCPServerNames = new Set(config.defaultSelectedMCPServerNames ?? []);
 		this.#defaultSelectedMCPToolNames = new Set(config.defaultSelectedMCPToolNames ?? []);
 		this.#pruneSelectedMCPToolNames();
-		const persistedSelectedMCPToolNames = this.sessionManager.buildSessionContext().selectedMCPToolNames;
+		const persistedSelectedMCPToolNames = this.buildDisplaySessionContext().selectedMCPToolNames;
 		const currentSelectedMCPToolNames = this.getSelectedMCPToolNames();
 		const persistInitialMCPToolSelection =
 			config.persistInitialMCPToolSelection ?? this.sessionManager.getBranch().length === 0;
@@ -668,7 +669,22 @@ export class AgentSession {
 			}
 		}
 
-		await this.#emitSessionEvent(event);
+		// Deobfuscate assistant message content for display emission — the LLM echoes back
+		// obfuscated placeholders, but listeners (TUI, extensions, exporters) must see real
+		// values. The original event.message stays obfuscated so the persistence path below
+		// writes `#HASH#` tokens to the session file; convertToLlm re-obfuscates outbound
+		// traffic on the next turn. Walks text, thinking, and toolCall arguments/intent.
+		let displayEvent: AgentEvent = event;
+		const obfuscator = this.#obfuscator;
+		if (obfuscator && event.type === "message_end" && event.message.role === "assistant") {
+			const message = event.message;
+			const deobfuscatedContent = obfuscator.deobfuscateObject(message.content);
+			if (deobfuscatedContent !== message.content) {
+				displayEvent = { ...event, message: { ...message, content: deobfuscatedContent } };
+			}
+		}
+
+		await this.#emitSessionEvent(displayEvent);
 
 		if (event.type === "turn_start") {
 			this.#resetStreamingEditState();
@@ -1968,7 +1984,7 @@ export class AgentSession {
 
 		this.#setDiscoverableMCPTools(this.#collectDiscoverableMCPToolsFromRegistry());
 		this.#pruneSelectedMCPToolNames();
-		if (!this.sessionManager.buildSessionContext().hasPersistedMCPToolSelection) {
+		if (!this.buildDisplaySessionContext().hasPersistedMCPToolSelection) {
 			this.#selectedMCPToolNames = new Set([
 				...this.#selectedMCPToolNames,
 				...this.#getConfiguredDefaultSelectedMCPToolNames(),
@@ -1993,6 +2009,10 @@ export class AgentSession {
 		return this.agent.state.messages;
 	}
 
+	buildDisplaySessionContext(): SessionContext {
+		return deobfuscateSessionContext(this.sessionManager.buildSessionContext(), this.#obfuscator);
+	}
+
 	/** Convert session messages using the same pre-LLM pipeline as the active session. */
 	async convertMessagesToLlm(messages: AgentMessage[], signal?: AbortSignal): Promise<Message[]> {
 		const transformedMessages = await this.#transformContext(messages, signal);
@@ -2103,7 +2123,16 @@ export class AgentSession {
 	}
 
 	resolveRoleModel(role: string): Model | undefined {
-		return this.#resolveRoleModel(role, this.#modelRegistry.getAvailable(), this.model);
+		return this.#resolveRoleModelFull(role, this.#modelRegistry.getAvailable(), this.model).model;
+	}
+
+	/**
+	 * Resolve a role to its model AND thinking level.
+	 * Unlike resolveRoleModel(), this preserves the thinking level suffix
+	 * from role configuration (e.g., "anthropic/claude-sonnet-4-5:xhigh").
+	 */
+	resolveRoleModelWithThinking(role: string): ResolvedModelRoleValue {
+		return this.#resolveRoleModelFull(role, this.#modelRegistry.getAvailable(), this.model);
 	}
 
 	get promptTemplates(): ReadonlyArray<PromptTemplate> {
@@ -3182,7 +3211,7 @@ export class AgentSession {
 	 * Validates API key, saves to session log but NOT to settings.
 	 * @throws Error if no API key available for the model
 	 */
-	async setModelTemporary(model: Model): Promise<void> {
+	async setModelTemporary(model: Model, thinkingLevel?: ThinkingLevel): Promise<void> {
 		const apiKey = await this.#modelRegistry.getApiKey(model, this.sessionId);
 		if (!apiKey) {
 			throw new Error(`No API key for ${model.provider}/${model.id}`);
@@ -3193,8 +3222,8 @@ export class AgentSession {
 		this.sessionManager.appendModelChange(`${model.provider}/${model.id}`, "temporary");
 		this.settings.getStorage()?.recordModelUsage(`${model.provider}/${model.id}`);
 
-		// Re-apply the current thinking level for the newly selected model
-		this.setThinkingLevel(this.thinkingLevel);
+		// Apply explicit thinking level, or re-clamp current level to new model's capabilities
+		this.setThinkingLevel(thinkingLevel ?? this.thinkingLevel);
 	}
 
 	/**
@@ -3267,13 +3296,12 @@ export class AgentSession {
 		const next = roleModels[nextIndex];
 
 		if (options?.temporary) {
-			await this.setModelTemporary(next.model);
+			await this.setModelTemporary(next.model, next.explicitThinkingLevel ? next.thinkingLevel : undefined);
 		} else {
 			await this.setModel(next.model, next.role);
-		}
-
-		if (next.explicitThinkingLevel && next.thinkingLevel !== undefined) {
-			this.setThinkingLevel(next.thinkingLevel);
+			if (next.explicitThinkingLevel && next.thinkingLevel !== undefined) {
+				this.setThinkingLevel(next.thinkingLevel);
+			}
 		}
 
 		return { model: next.model, thinkingLevel: this.thinkingLevel, role: next.role };
@@ -3473,7 +3501,7 @@ export class AgentSession {
 		}
 
 		await this.sessionManager.rewriteEntries();
-		const sessionContext = this.sessionManager.buildSessionContext();
+		const sessionContext = this.buildDisplaySessionContext();
 		this.agent.replaceMessages(sessionContext.messages);
 		this.#syncTodoPhasesFromBranch();
 		this.#closeCodexProviderSessionsForHistoryRewrite();
@@ -3599,7 +3627,7 @@ export class AgentSession {
 				preserveData,
 			);
 			const newEntries = this.sessionManager.getEntries();
-			const sessionContext = this.sessionManager.buildSessionContext();
+			const sessionContext = this.buildDisplaySessionContext();
 			this.agent.replaceMessages(sessionContext.messages);
 			this.#syncTodoPhasesFromBranch();
 			this.#closeCodexProviderSessionsForHistoryRewrite();
@@ -3646,6 +3674,12 @@ export class AgentSession {
 		this.#handoffAbortController?.abort();
 	}
 
+	/** Trigger idle compaction through the auto-compaction flow (with UI events). */
+	async runIdleCompaction(): Promise<void> {
+		if (this.isStreaming || this.isCompacting) return;
+		await this.#runAutoCompaction("idle", false, true);
+	}
+
 	/**
 	 * Cancel in-progress branch summarization.
 	 */
@@ -3814,7 +3848,7 @@ export class AgentSession {
 			}
 
 			// Rebuild agent messages from session
-			const sessionContext = this.sessionManager.buildSessionContext();
+			const sessionContext = this.buildDisplaySessionContext();
 			this.agent.replaceMessages(sessionContext.messages);
 			this.#syncTodoPhasesFromBranch();
 
@@ -4364,19 +4398,25 @@ export class AgentSession {
 		return availableModels.find(m => m.provider === currentModel.provider && m.id === configuredTarget);
 	}
 
-	#resolveRoleModel(role: string, availableModels: Model[], currentModel: Model | undefined): Model | undefined {
+	#resolveRoleModelFull(
+		role: string,
+		availableModels: Model[],
+		currentModel: Model | undefined,
+	): ResolvedModelRoleValue {
 		const roleModelStr =
 			role === "default"
 				? (this.settings.getModelRole("default") ??
 					(currentModel ? `${currentModel.provider}/${currentModel.id}` : undefined))
 				: this.settings.getModelRole(role);
 
-		if (!roleModelStr) return undefined;
+		if (!roleModelStr) {
+			return { model: undefined, thinkingLevel: undefined, explicitThinkingLevel: false, warning: undefined };
+		}
 
 		return resolveModelRoleValue(roleModelStr, availableModels, {
 			settings: this.settings,
 			matchPreferences: { usageOrder: this.settings.getStorage()?.getModelUsageOrder() },
-		}).model;
+		});
 	}
 
 	#getCompactionModelCandidates(availableModels: Model[]): Model[] {
@@ -4393,7 +4433,7 @@ export class AgentSession {
 
 		const currentModel = this.model;
 		for (const role of MODEL_ROLE_IDS) {
-			addCandidate(this.#resolveRoleModel(role, availableModels, currentModel));
+			addCandidate(this.#resolveRoleModelFull(role, availableModels, currentModel).model);
 		}
 
 		const sortedByContext = [...availableModels].sort((a, b) => b.contextWindow - a.contextWindow);
@@ -4410,11 +4450,16 @@ export class AgentSession {
 	/**
 	 * Internal: Run auto-compaction with events.
 	 */
-	async #runAutoCompaction(reason: "overflow" | "threshold", willRetry: boolean, deferred = false): Promise<void> {
+	async #runAutoCompaction(
+		reason: "overflow" | "threshold" | "idle",
+		willRetry: boolean,
+		deferred = false,
+	): Promise<void> {
 		const compactionSettings = this.settings.getGroup("compaction");
-		if (!compactionSettings.enabled || compactionSettings.strategy === "off") return;
+		if (compactionSettings.strategy === "off") return;
+		if (reason !== "idle" && !compactionSettings.enabled) return;
 		const generation = this.#promptGeneration;
-		if (!deferred && reason !== "overflow" && compactionSettings.strategy === "handoff") {
+		if (!deferred && reason !== "overflow" && reason !== "idle" && compactionSettings.strategy === "handoff") {
 			this.#schedulePostPromptTask(
 				async signal => {
 					await Promise.resolve();
@@ -4689,7 +4734,7 @@ export class AgentSession {
 				preserveData,
 			);
 			const newEntries = this.sessionManager.getEntries();
-			const sessionContext = this.sessionManager.buildSessionContext();
+			const sessionContext = this.buildDisplaySessionContext();
 			this.agent.replaceMessages(sessionContext.messages);
 			this.#syncTodoPhasesFromBranch();
 			this.#closeCodexProviderSessionsForHistoryRewrite();
@@ -4717,7 +4762,7 @@ export class AgentSession {
 			};
 			await this.#emitSessionEvent({ type: "auto_compaction_end", action, result, aborted: false, willRetry });
 
-			if (!willRetry && compactionSettings.autoContinue !== false) {
+			if (!willRetry && reason !== "idle" && compactionSettings.autoContinue !== false) {
 				const continuePrompt = async () => {
 					await this.#promptWithMessage(
 						{
@@ -5516,7 +5561,7 @@ export class AgentSession {
 		// Flush pending writes before switching so restore snapshots reflect committed state.
 		await this.sessionManager.flush();
 		const previousSessionState = this.sessionManager.captureState();
-		const previousSessionContext = this.sessionManager.buildSessionContext();
+		const previousSessionContext = this.buildDisplaySessionContext();
 		// switchSession replaces these arrays wholesale during load/rollback, so retaining
 		// the existing message objects is sufficient and avoids structured-clone failures for
 		// extension/custom metadata that is valid to persist but not cloneable.
@@ -5545,7 +5590,7 @@ export class AgentSession {
 			await this.sessionManager.setSessionFile(sessionPath);
 			this.agent.sessionId = this.sessionManager.getSessionId();
 
-			const sessionContext = this.sessionManager.buildSessionContext();
+			const sessionContext = this.buildDisplaySessionContext();
 			const didReloadConversationChange =
 				!switchingToDifferentSession &&
 				this.#didSessionMessagesChange(previousSessionContext.messages, sessionContext.messages);
@@ -5711,7 +5756,7 @@ export class AgentSession {
 		this.agent.sessionId = this.sessionManager.getSessionId();
 
 		// Reload messages from entries (works for both file and in-memory mode)
-		const sessionContext = this.sessionManager.buildSessionContext();
+		const sessionContext = this.buildDisplaySessionContext();
 
 		await this.#restoreMCPSelectionsForSessionContext(sessionContext);
 
@@ -5882,7 +5927,7 @@ export class AgentSession {
 		}
 
 		// Update agent state
-		const sessionContext = this.sessionManager.buildSessionContext();
+		const sessionContext = this.buildDisplaySessionContext();
 		await this.#restoreMCPSelectionsForSessionContext(sessionContext);
 		this.agent.replaceMessages(sessionContext.messages);
 		this.#syncTodoPhasesFromBranch();

package/src/session/session-manager.ts

@@ -1390,6 +1390,7 @@ export class SessionManager {
 	#sessionFile: string | undefined;
 	#flushed: boolean = false;
 	#needsFullRewriteOnNextPersist: boolean = false;
+	#ensuredOnDisk: boolean = false;
 	#fileEntries: FileEntry[] = [];
 	#byId: Map<string, SessionEntry> = new Map();
 	#labelsById: Map<string, string> = new Map();
@@ -1496,12 +1497,14 @@ export class SessionManager {
 
 			this.#buildIndex();
 			this.#flushed = true;
+			this.#ensuredOnDisk = true;
 		} else {
 			const explicitPath = this.#sessionFile;
 			this.#newSessionSync();
 			this.#sessionFile = explicitPath; // preserve explicit path from --session flag
 			await this.#rewriteFile();
 			this.#flushed = true;
+			this.#ensuredOnDisk = true;
 			return;
 		}
 	}
@@ -1678,6 +1681,7 @@ export class SessionManager {
 		this.#leafId = null;
 		this.#flushed = false;
 		this.#needsFullRewriteOnNextPersist = false;
+		this.#ensuredOnDisk = false;
 		this.#usageStatistics = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, premiumRequests: 0, cost: 0 };
 		this.#inMemoryArtifacts = null;
 		this.#inMemoryArtifactCounter = 0;
@@ -1839,6 +1843,7 @@ export class SessionManager {
 		if (!this.persist || !this.#sessionFile) return;
 		if (this.#flushed && !this.#needsFullRewriteOnNextPersist) return;
 		await this.#rewriteFile();
+		this.#ensuredOnDisk = true;
 	}
 
 	/** Flush pending writes to disk. Call before switching sessions or on shutdown. */
@@ -1972,11 +1977,16 @@ export class SessionManager {
 		if (!this.persist || !this.#sessionFile) return;
 		if (this.#persistError) throw this.#persistError;
 
-		const hasAssistant = this.#fileEntries.some(e => e.type === "message" && e.message.role === "assistant");
-		if (!hasAssistant) {
-			// Mark as not flushed so when assistant arrives, all entries get written.
-			this.#flushed = false;
-			return;
+		// Normally we wait for the first assistant message before persisting to avoid
+		// creating files for sessions that never produce output. Once ensureOnDisk() has
+		// been called, the session is already on disk and every entry must be flushed.
+		if (!this.#ensuredOnDisk) {
+			const hasAssistant = this.#fileEntries.some(e => e.type === "message" && e.message.role === "assistant");
+			if (!hasAssistant) {
+				// Mark as not flushed so when assistant arrives, all entries get written.
+				this.#flushed = false;
+				return;
+			}
 		}
 
 		if (this.#needsFullRewriteOnNextPersist || !this.#flushed) {

package/src/system-prompt.ts

@@ -432,6 +432,8 @@ export interface BuildSystemPromptOptions {
 	eagerTasks?: boolean;
 	/** Rules with alwaysApply=true — their full content is injected into the prompt. */
 	alwaysApplyRules?: AlwaysApplyRule[];
+	/** Whether secret obfuscation is active. When true, explains the redaction format in the prompt. */
+	secretsEnabled?: boolean;
 }
 
 /** Build the system prompt with tools, guidelines, and context */
@@ -456,6 +458,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		mcpDiscoveryMode = false,
 		mcpDiscoveryServerSummaries = [],
 		eagerTasks = false,
+		secretsEnabled = false,
 	} = options;
 	const resolvedCwd = cwd ?? getProjectDir();
 
@@ -603,6 +606,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		hasMCPDiscoveryServers: mcpDiscoveryServerSummaries.length > 0,
 		mcpDiscoveryServerSummaries,
 		eagerTasks,
+		secretsEnabled,
 	};
 	return renderPromptTemplate(resolvedCustomPrompt ? customSystemPromptTemplate : systemPromptTemplate, data);
 }

package/src/task/executor.ts

@@ -38,6 +38,7 @@ import {
 	type ReviewFinding,
 	type SingleResult,
 	TASK_SUBAGENT_EVENT_CHANNEL,
+	TASK_SUBAGENT_LIFECYCLE_CHANNEL,
 	TASK_SUBAGENT_PROGRESS_CHANNEL,
 } from "./types";
 
@@ -630,6 +631,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				task,
 				assignment,
 				progress: { ...progress },
+				sessionFile: subtaskSessionFile,
 			});
 		}
 		lastProgressEmitMs = Date.now();
@@ -983,6 +985,19 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 			activeSession = session;
 
+			// Emit lifecycle start event
+			if (options.eventBus) {
+				options.eventBus.emit(TASK_SUBAGENT_LIFECYCLE_CHANNEL, {
+					id,
+					agent: agent.name,
+					agentSource: agent.source,
+					description: options.description,
+					status: "started",
+					sessionFile: subtaskSessionFile,
+					index,
+				});
+			}
+
 			const subagentToolNames = session.getActiveToolNames();
 			const parentOwnedToolNames = new Set(["todo_write"]);
 			const filteredSubagentTools = subagentToolNames.filter(name => !parentOwnedToolNames.has(name));
@@ -1238,6 +1253,19 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	progress.status = wasAborted ? "aborted" : exitCode === 0 ? "completed" : "failed";
 	scheduleProgress(true);
 
+	// Emit lifecycle end event after finalization so submit_result status is reflected
+	if (options.eventBus) {
+		options.eventBus.emit(TASK_SUBAGENT_LIFECYCLE_CHANNEL, {
+			id,
+			agent: agent.name,
+			agentSource: agent.source,
+			description: options.description,
+			status: progress.status as "completed" | "failed" | "aborted",
+			sessionFile: subtaskSessionFile,
+			index,
+		});
+	}
+
 	return {
 		index,
 		id,

package/src/task/index.ts

@@ -18,7 +18,6 @@ import path from "node:path";
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
 import { $env, Snowflake } from "@oh-my-pi/pi-utils";
-import { $ } from "bun";
 import type { ToolSession } from "..";
 import { resolveAgentModelPatterns } from "../config/model-resolver";
 import { renderPromptTemplate } from "../config/prompt-templates";
@@ -30,6 +29,7 @@ import { formatBytes, formatDuration } from "../tools/render-utils";
 // Import review tools for side effects (registers subagent tool handlers)
 import "../tools/review";
 import { generateCommitMessage } from "../utils/commit-message-generator";
+import * as git from "../utils/git";
 import { discoverAgents, getAgent } from "./discovery";
 import { runSubprocess } from "./executor";
 import { resolveIsolationBackendForTaskExecution } from "./isolation-backend";
@@ -109,8 +109,21 @@ export { loadBundledAgents as BUNDLED_AGENTS } from "./agents";
 export { discoverCommands, expandCommand, getCommand } from "./commands";
 export { discoverAgents, getAgent } from "./discovery";
 export { AgentOutputManager } from "./output-manager";
-export type { AgentDefinition, AgentProgress, SingleResult, TaskParams, TaskToolDetails } from "./types";
-export { taskSchema } from "./types";
+export type {
+	AgentDefinition,
+	AgentProgress,
+	SingleResult,
+	SubagentLifecyclePayload,
+	SubagentProgressPayload,
+	TaskParams,
+	TaskToolDetails,
+} from "./types";
+export {
+	TASK_SUBAGENT_EVENT_CHANNEL,
+	TASK_SUBAGENT_LIFECYCLE_CHANNEL,
+	TASK_SUBAGENT_PROGRESS_CHANNEL,
+	taskSchema,
+} from "./types";
 
 /**
  * Render the tool description from a cached agent list and current settings.
@@ -766,7 +779,7 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 						contextFile: contextFilePath,
 						enableLsp: false,
 						signal,
-						eventBus: undefined,
+						eventBus: this.session.eventBus,
 						onProgress: progress => {
 							progressMap.set(index, {
 								...structuredClone(progress),
@@ -820,7 +833,7 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 						contextFile: contextFilePath,
 						enableLsp: false,
 						signal,
-						eventBus: undefined,
+						eventBus: this.session.eventBus,
 						onProgress: progress => {
 							progressMap.set(index, {
 								...structuredClone(progress),
@@ -864,7 +877,7 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 						} catch (mergeErr) {
 							// Agent succeeded but branch commit failed — clean up stale branch
 							const branchName = `omp/task/${task.id}`;
-							await $`git branch -D ${branchName}`.cwd(repoRoot).quiet().nothrow();
+							await git.branch.tryDelete(repoRoot, branchName);
 							const msg = mergeErr instanceof Error ? mergeErr.message : String(mergeErr);
 							return { ...result, error: `Merge failed: ${msg}` };
 						}
@@ -978,93 +991,90 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 			let changesApplied: boolean | null = null;
 			let mergedBranchesForNestedPatches: Set<string> | null = null;
 			if (isIsolated && repoRoot) {
-				if (mergeMode === "branch") {
-					// Branch mode: merge task branches sequentially
-					const branchEntries = results
-						.filter(r => r.branchName && r.exitCode === 0 && !r.aborted)
-						.map(r => ({ branchName: r.branchName!, taskId: r.id, description: r.description }));
-
-					if (branchEntries.length === 0) {
-						changesApplied = true;
-					} else {
-						const mergeResult = await mergeTaskBranches(repoRoot, branchEntries);
-						mergedBranchesForNestedPatches = new Set(mergeResult.merged);
-						changesApplied = mergeResult.failed.length === 0;
+				try {
+					if (mergeMode === "branch") {
+						// Branch mode: merge task branches sequentially
+						const branchEntries = results
+							.filter(r => r.branchName && r.exitCode === 0 && !r.aborted)
+							.map(r => ({ branchName: r.branchName!, taskId: r.id, description: r.description }));
 
-						if (changesApplied) {
-							mergeSummary = `\n\nMerged ${mergeResult.merged.length} branch${mergeResult.merged.length === 1 ? "" : "es"}: ${mergeResult.merged.join(", ")}`;
+						if (branchEntries.length === 0) {
+							changesApplied = true;
 						} else {
-							const mergedPart =
-								mergeResult.merged.length > 0 ? `Merged: ${mergeResult.merged.join(", ")}.\n` : "";
-							const failedPart = `Failed: ${mergeResult.failed.join(", ")}.`;
-							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>`;
+							const mergeResult = await mergeTaskBranches(repoRoot, branchEntries);
+							mergedBranchesForNestedPatches = new Set(mergeResult.merged);
+							changesApplied = mergeResult.failed.length === 0;
+
+							if (changesApplied) {
+								mergeSummary = `\n\nMerged ${mergeResult.merged.length} branch${mergeResult.merged.length === 1 ? "" : "es"}: ${mergeResult.merged.join(", ")}`;
+							} else {
+								const mergedPart =
+									mergeResult.merged.length > 0 ? `Merged: ${mergeResult.merged.join(", ")}.\n` : "";
+								const failedPart = `Failed: ${mergeResult.failed.join(", ")}.`;
+								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>`;
+							}
 						}
-					}
 
-					// Clean up merged branches (keep failed ones for manual resolution)
-					const allBranches = branchEntries.map(b => b.branchName);
-					if (changesApplied) {
-						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);
-					if (missingPatch) {
-						changesApplied = false;
+						// Clean up merged branches (keep failed ones for manual resolution)
+						const allBranches = branchEntries.map(b => b.branchName);
+						if (changesApplied) {
+							await cleanupTaskBranches(repoRoot, allBranches);
+						}
 					} else {
-						const patchStats = await Promise.all(
-							patchesInOrder.map(async patchPath => ({
-								patchPath,
-								size: (await fs.stat(patchPath)).size,
-							})),
-						);
-						const nonEmptyPatches = patchStats.filter(patch => patch.size > 0).map(patch => patch.patchPath);
-						if (nonEmptyPatches.length === 0) {
-							changesApplied = true;
+						// Patch mode: combine and apply patches
+						const patchesInOrder = results.map(result => result.patchPath).filter(Boolean) as string[];
+						const missingPatch = results.some(result => !result.patchPath);
+						if (missingPatch) {
+							changesApplied = false;
 						} else {
-							const patchTexts = await Promise.all(
-								nonEmptyPatches.map(async patchPath => Bun.file(patchPath).text()),
+							const patchStats = await Promise.all(
+								patchesInOrder.map(async patchPath => ({
+									patchPath,
+									size: (await fs.stat(patchPath)).size,
+								})),
 							);
-							const combinedPatch = patchTexts.map(text => (text.endsWith("\n") ? text : `${text}\n`)).join("");
-							if (!combinedPatch.trim()) {
+							const nonEmptyPatches = patchStats.filter(patch => patch.size > 0).map(patch => patch.patchPath);
+							if (nonEmptyPatches.length === 0) {
 								changesApplied = true;
 							} else {
-								const combinedPatchPath = path.join(os.tmpdir(), `omp-task-combined-${Snowflake.next()}.patch`);
-								try {
-									await Bun.write(combinedPatchPath, combinedPatch);
-									const checkResult = await $`git apply --check --binary ${combinedPatchPath}`
-										.cwd(repoRoot)
-										.quiet()
-										.nothrow();
-									if (checkResult.exitCode !== 0) {
-										changesApplied = false;
-									} else {
-										const applyResult = await $`git apply --binary ${combinedPatchPath}`
-											.cwd(repoRoot)
-											.quiet()
-											.nothrow();
-										changesApplied = applyResult.exitCode === 0;
+								const patchTexts = await Promise.all(
+									nonEmptyPatches.map(async patchPath => Bun.file(patchPath).text()),
+								);
+								const combinedPatch = patchTexts
+									.map(text => (text.endsWith("\n") ? text : `${text}\n`))
+									.join("");
+								if (!combinedPatch.trim()) {
+									changesApplied = true;
+								} else {
+									changesApplied = await git.patch.canApplyText(repoRoot, combinedPatch);
+									if (changesApplied) {
+										try {
+											await git.patch.applyText(repoRoot, combinedPatch);
+										} catch {
+											changesApplied = false;
+										}
 									}
-								} finally {
-									await fs.rm(combinedPatchPath, { force: true });
 								}
 							}
 						}
-					}
 
-					if (changesApplied) {
-						mergeSummary = "\n\nApplied patches: yes";
-					} else {
-						const notification =
-							"<system-notification>Patches were not applied and must be handled manually.</system-notification>";
-						const patchList =
-							patchPaths.length > 0
-								? `\n\nPatch artifacts:\n${patchPaths.map(patch => `- ${patch}`).join("\n")}`
-								: "";
-						mergeSummary = `\n\n${notification}${patchList}`;
+						if (changesApplied) {
+							mergeSummary = "\n\nApplied patches: yes";
+						} else {
+							const notification =
+								"<system-notification>Patches were not applied and must be handled manually.</system-notification>";
+							const patchList =
+								patchPaths.length > 0
+									? `\n\nPatch artifacts:\n${patchPaths.map(patch => `- ${patch}`).join("\n")}`
+									: "";
+							mergeSummary = `\n\n${notification}${patchList}`;
+						}
 					}
+				} catch (mergeErr) {
+					const msg = mergeErr instanceof Error ? mergeErr.message : String(mergeErr);
+					changesApplied = false;
+					mergeSummary = `\n\n<system-notification>Merge phase failed: ${msg}\nTask outputs are preserved but changes were not applied.</system-notification>`;
 				}
 			}