@oh-my-pi/pi-coding-agent 16.3.0 → 16.3.3

package/src/subprocess/worker-client.ts

@@ -1,3 +1,5 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import {
 	$env,
@@ -64,7 +66,7 @@ export interface RefCountedWorkerHandle<Inbound, Outbound> extends WorkerHandle<
 
 /** The raw spawned subprocess plus the parent-side fan-out sets. */
 export interface SpawnedSubprocess<Outbound> {
-	proc: Subprocess<"ignore", "ignore", "ignore">;
+	proc: Subprocess<"ignore", "ignore", number | "ignore">;
 	inbound: Set<(message: Outbound) => void>;
 	errors: Set<(error: Error) => void>;
 	/**
@@ -74,8 +76,23 @@ export interface SpawnedSubprocess<Outbound> {
 	 * worker error so callers don't await forever.
 	 */
 	intentionalExit: { value: boolean };
+	/**
+	 * Resolves when the file-backed stderr capture has drained after worker
+	 * exit. `onExit` waits on this before surfacing the crash so the exit-error
+	 * carries the *whole* tail, not whatever happened to be flushed before the
+	 * exit event fired. Tests can await it deterministically instead of racing
+	 * wall-clock timers.
+	 */
+	stderrDrained: Promise<void>;
 }
 
+/**
+ * Bound on the tail of worker stderr surfaced with a crash. Sized to comfortably
+ * hold a full ONNX Runtime/glibc traceback (a few KiB) without letting a chatty
+ * native runtime OOM the parent on repeated warnings.
+ */
+const STDERR_TAIL_LIMIT_BYTES = 16 * 1024;
+
 export interface WorkerSpawnCommand {
 	cmd: string[];
 	cwd?: string;
@@ -126,11 +143,17 @@ export function workerEnvFromParent(overlay?: Record<string, string>): Record<st
 }
 
 /**
- * Spawn an inference worker subprocess and wire its IPC fan-out. The child
- * inherits no stdio (native model runtimes may otherwise print progress or
- * decoded text and corrupt the chat scrollback) and is `unref`'d outside `bun
- * test` so an idle worker never blocks process exit. `exitLabel` prefixes the
- * worker-error message surfaced for an unexpected (non-intentional) exit.
+ * Spawn an inference worker subprocess and wire its IPC fan-out. Stdio is
+ * captured (stderr redirected to a temp file, stdout ignored) so native
+ * runtimes can't corrupt the chat scrollback while the crash reason still
+ * reaches the parent. The file-backed capture deliberately avoids Bun
+ * `ReadableStream` pipes: even an unref'd child with a piped stderr stream can
+ * keep the parent event loop alive. After the worker exits, the last
+ * {@link STDERR_TAIL_LIMIT_BYTES} are appended to the `onExit` error so
+ * `tts/mnemopi/…: worker error` lines carry the actual stack instead of a bare
+ * exit code (issue #4324). The child is `unref`'d outside `bun test` so an idle
+ * worker never blocks process exit. `exitLabel` prefixes the worker-error
+ * message surfaced for an unexpected (non-intentional) exit.
  */
 export function createWorkerSubprocess<Outbound>(options: {
 	spawnCommand: WorkerSpawnCommand;
@@ -140,19 +163,29 @@ export function createWorkerSubprocess<Outbound>(options: {
 	const inbound = new Set<(message: Outbound) => void>();
 	const errors = new Set<(error: Error) => void>();
 	const intentionalExit = { value: false };
+	const stderrTail = new StderrTail(STDERR_TAIL_LIMIT_BYTES);
+	const stderrDrained = Promise.withResolvers<void>();
+	const stderrCapture = createStderrCapture(options.exitLabel);
+	let stderrDrainStarted = false;
+	const startStderrDrain = (): void => {
+		if (stderrDrainStarted) return;
+		stderrDrainStarted = true;
+		void drainStderrCapture(stderrCapture, options.exitLabel, stderrTail).finally(() => stderrDrained.resolve());
+	};
 	const proc = Bun.spawn({
 		cmd: options.spawnCommand.cmd,
 		cwd: options.spawnCommand.cwd,
 		env: options.env,
 		stdin: "ignore",
 		stdout: "ignore",
-		stderr: "ignore",
+		stderr: stderrCapture.target,
 		serialization: "advanced",
 		windowsHide: true,
 		ipc(message) {
 			for (const handler of inbound) handler(message as Outbound);
 		},
 		onExit(_proc, exitCode, signalCode) {
+			startStderrDrain();
 			if (exitCode === 0) return;
 			// Swallow only the expected SIGKILL from `terminate()`; every other
 			// signal exit (SIGSEGV from a native fault, OOM SIGKILL, operator
@@ -160,15 +193,133 @@ export function createWorkerSubprocess<Outbound>(options: {
 			// requests so callers don't await forever.
 			if (exitCode === null && intentionalExit.value) return;
 			const reason = exitCode !== null ? `code ${exitCode}` : `signal ${signalCode ?? "unknown"}`;
-			const err = new Error(`${options.exitLabel} exited with ${reason}`);
-			for (const handler of errors) handler(err);
+			// The stderr target is drained only after exit so idle unref'd
+			// workers do not keep the parent alive; wait for that drain before
+			// surfacing the error so the tail is complete.
+			void stderrDrained.promise.finally(() => {
+				const suffix = stderrTail.suffix();
+				const err = new Error(`${options.exitLabel} exited with ${reason}${suffix}`);
+				for (const handler of errors) handler(err);
+			});
 		},
 	});
 	// Don't keep the parent event loop alive on an idle worker; the dispose
 	// path calls `terminate()` explicitly. Bun's test runner starves IPC for
 	// unref'd subprocesses, so keep it referenced only under tests.
 	if (!isBunTestRuntime()) proc.unref();
-	return { proc, inbound, errors, intentionalExit };
+	return { proc, inbound, errors, intentionalExit, stderrDrained: stderrDrained.promise };
+}
+
+/**
+ * Bounded buffer of the *tail* of a stderr stream. Appended chunks are
+ * concatenated and truncated from the front once they exceed `limit`, so the
+ * final `suffix()` always reflects the most recent output — where native
+ * crash tracebacks land.
+ */
+class StderrTail {
+	#chunks: Uint8Array[] = [];
+	#bytes = 0;
+	constructor(readonly limit: number) {}
+
+	append(chunk: Uint8Array): void {
+		if (chunk.length === 0) return;
+		this.#chunks.push(chunk);
+		this.#bytes += chunk.length;
+		while (this.#bytes > this.limit && this.#chunks.length > 1) {
+			const head = this.#chunks.shift();
+			if (head) this.#bytes -= head.length;
+		}
+		if (this.#bytes > this.limit && this.#chunks.length === 1) {
+			const only = this.#chunks[0];
+			const start = only.length - this.limit;
+			this.#chunks[0] = only.subarray(start);
+			this.#bytes = this.limit;
+		}
+	}
+
+	/** Human-readable trailer for an exit error, or `""` when nothing was captured. */
+	suffix(): string {
+		if (this.#bytes === 0) return "";
+		const merged = new Uint8Array(this.#bytes);
+		let offset = 0;
+		for (const chunk of this.#chunks) {
+			merged.set(chunk, offset);
+			offset += chunk.length;
+		}
+		const text = new TextDecoder().decode(merged).replace(/\s+$/u, "");
+		if (text.length === 0) return "";
+		return `: ${text}`;
+	}
+}
+
+interface StderrCapture {
+	target: number | "ignore";
+	fd: number | null;
+	dir: string | null;
+	cleanupOnExit: (() => void) | null;
+}
+
+/** Create a file-backed stderr target that does not pin Bun's event loop. */
+function createStderrCapture(exitLabel: string): StderrCapture {
+	try {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "omp-worker-stderr-"));
+		const fd = fs.openSync(path.join(dir, "stderr.log"), "w+");
+		const cleanupOnExit = (): void => cleanupStderrCapture({ target: fd, fd, dir, cleanupOnExit: null });
+		process.once("exit", cleanupOnExit);
+		return { target: fd, fd, dir, cleanupOnExit };
+	} catch (error) {
+		logger.debug(`${exitLabel} stderr capture unavailable`, {
+			error: error instanceof Error ? error.message : String(error),
+		});
+		return { target: "ignore", fd: null, dir: null, cleanupOnExit: null };
+	}
+}
+
+function cleanupStderrCapture(capture: StderrCapture): void {
+	if (capture.cleanupOnExit) process.off("exit", capture.cleanupOnExit);
+	if (capture.fd !== null) {
+		try {
+			fs.closeSync(capture.fd);
+		} catch {
+			// Already closed.
+		}
+		capture.fd = null;
+	}
+	if (capture.dir) {
+		try {
+			fs.rmSync(capture.dir, { recursive: true, force: true });
+		} catch {
+			// Best-effort temp cleanup.
+		}
+		capture.dir = null;
+	}
+}
+
+/**
+ * Drain a worker's file-backed stderr target after it exits: forward each
+ * decoded tail line to `logger.debug`, and record the bytes in `tail` so the
+ * eventual exit error can carry the most recent output. Never rejects — cleanup
+ * failures must not fault the parent.
+ */
+async function drainStderrCapture(capture: StderrCapture, exitLabel: string, tail: StderrTail): Promise<void> {
+	try {
+		if (capture.fd === null) return;
+		const size = fs.fstatSync(capture.fd).size;
+		if (size <= 0) return;
+		const length = Math.min(size, tail.limit);
+		const buffer = new Uint8Array(length);
+		fs.readSync(capture.fd, buffer, 0, length, size - length);
+		tail.append(buffer);
+		for (const rawLine of new TextDecoder().decode(buffer).split("\n")) {
+			const line = rawLine.replace(/\r$/u, "");
+			if (line.length > 0) logger.debug(`${exitLabel} stderr`, { line });
+		}
+	} catch {
+		// The worker may have exited while the parent is already tearing down,
+		// or the temp file may have been removed by process-exit cleanup.
+	} finally {
+		cleanupStderrCapture(capture);
+	}
 }
 
 /**

package/src/task/discovery.ts

@@ -4,6 +4,11 @@
  * Discovers agent definitions from OMP-native task-agent roots:
  *   - ~/.omp/agent/agents/*.md (user-level)
  *   - .omp/agents/*.md (project-level)
+ *   - <ext>/agents/*.md for every OMP extension package wired through
+ *     `listOmpExtensionRoots` (CLI `--extension` roots, `extensions:` in
+ *     settings, and enabled npm/link plugins under `<plugins>/node_modules/`).
+ *     Mirrors the same sub-discovery convention applied to `skills/`,
+ *     `hooks/`, `tools/`, etc. by `discovery/omp-plugins.ts`.
  *
  * Claude Code marketplace plugin agents are discovered separately via the
  * claude-plugins provider. Direct cross-harness roots such as .claude/agents
@@ -19,6 +24,7 @@ import { logger } from "@oh-my-pi/pi-utils";
 import { isProviderEnabled } from "../capability";
 import { findAllNearestProjectConfigDirs, getConfigDirs } from "../config";
 import { listClaudePluginRoots } from "../discovery/helpers";
+import { listOmpExtensionRoots } from "../discovery/omp-extension-roots";
 import { loadBundledAgents, parseAgent } from "./agents";
 import type { AgentDefinition, AgentSource } from "./types";
 
@@ -54,8 +60,11 @@ async function loadAgentsFromDir(dir: string, source: AgentSource): Promise<Agen
 
 /**
  * Discover agents from filesystem and merge with bundled agents.
- *
- * Precedence (highest wins): project .omp, user .omp, Claude plugin agents, then bundled
+ * Precedence (highest wins): project `.omp/agents`, user `.omp/agents`,
+ * OMP extension-package agents in `listOmpExtensionRoots` source order
+ * (CLI roots > project `extensions:` settings > user `extensions:` settings >
+ * installed npm/link plugins), Claude marketplace plugin agents (project
+ * scope before user), then bundled.
  * @param cwd - Current working directory for project agent discovery
  */
 export async function discoverAgents(cwd: string, home: string = os.homedir()): Promise<DiscoveryResult> {
@@ -81,6 +90,20 @@ export async function discoverAgents(cwd: string, home: string = os.homedir()):
 	const user = userDirs[0];
 	if (user) orderedDirs.push({ dir: user.path, source: "user" });
 
+	// OMP extension-package agents/ dirs. `listOmpExtensionRoots` returns roots in
+	// source-precedence order (CLI > project `extensions:` settings > user
+	// `extensions:` settings > installed npm/link plugins, with marketplace
+	// installs already excluded by realpath) — consume that order verbatim so the
+	// `task` agent surface dedups identically to the sibling skills/hooks/tools
+	// surface in `discovery/omp-plugins.ts`. Gate on `omp-plugins` so
+	// disabledProviders suppresses the whole extension-package surface.
+	const extensionRoots = isProviderEnabled("omp-plugins")
+		? await listOmpExtensionRoots({ cwd: resolvedCwd, home, repoRoot: null })
+		: [];
+	for (const root of extensionRoots) {
+		orderedDirs.push({ dir: path.join(root.path, "agents"), source: root.level });
+	}
+
 	// Load agents from Claude Code marketplace plugins (respects disabledProviders)
 	const { roots: pluginRoots } = isProviderEnabled("claude-plugins")
 		? await listClaudePluginRoots(home, resolvedCwd)

package/src/task/executor.ts

@@ -882,6 +882,7 @@ function createSubagentRunMonitor(args: RunMonitorArgs): SubagentRunMonitor {
 	const finalOutputChunks: string[] = [];
 	const RECENT_OUTPUT_TAIL_BYTES = 8 * 1024;
 	let recentOutputTail = "";
+	let tailLastLineRepresentable = false;
 	let resolved = false;
 	let abortSent = false;
 	let abortReason: AbortReason | undefined;
@@ -1060,17 +1061,35 @@ function createSubagentRunMonitor(args: RunMonitorArgs): SubagentRunMonitor {
 	};
 
 	const updateRecentOutputLines = () => {
-		const lines = recentOutputTail.split("\n").filter(line => line.trim());
-		progress.recentOutput = lines.slice(-8).reverse();
+		const lines = recentOutputTail.split("\n");
+		const filtered = lines.filter(line => line.trim());
+		progress.recentOutput = filtered.slice(-8).reverse();
+		// The tail's last raw segment (after its final newline) is "represented"
+		// in recentOutput only when it trims non-empty — an empty/whitespace-only
+		// trailing segment is filtered out, so recentOutput[0] is then the line
+		// before it, not the tail's true last line.
+		tailLastLineRepresentable = lines[lines.length - 1].trim().length > 0;
 	};
 
 	const appendRecentOutputTail = (text: string) => {
 		if (!text) return;
 		recentOutputTail += text;
-		if (recentOutputTail.length > RECENT_OUTPUT_TAIL_BYTES) {
+		const truncated = recentOutputTail.length > RECENT_OUTPUT_TAIL_BYTES;
+		if (truncated) {
 			recentOutputTail = recentOutputTail.slice(-RECENT_OUTPUT_TAIL_BYTES);
 		}
-		updateRecentOutputLines();
+		// Fast path: a token without a newline only extends the current last line.
+		// This runs on every text_delta token (hundreds/thousands per second while
+		// streaming), so skip re-splitting the whole (up to 8KB) tail unless the line
+		// structure actually changed. Requires no truncation AND the tail's last line
+		// already represented (trims non-empty) — otherwise boundaries shift and a
+		// full recompute is required. Appending to a non-empty line keeps it non-empty,
+		// so the flag stays valid across consecutive fast-path tokens.
+		if (truncated || text.includes("\n") || !tailLastLineRepresentable || progress.recentOutput.length === 0) {
+			updateRecentOutputLines();
+		} else {
+			progress.recentOutput = [progress.recentOutput[0] + text, ...progress.recentOutput.slice(1)];
+		}
 	};
 
 	const replaceRecentOutputFromContent = (content: unknown[]) => {
@@ -1090,6 +1109,7 @@ function createSubagentRunMonitor(args: RunMonitorArgs): SubagentRunMonitor {
 
 	const resetRecentOutput = () => {
 		recentOutputTail = "";
+		tailLastLineRepresentable = false;
 		progress.recentOutput = [];
 	};
 

package/src/task/render.ts

@@ -151,9 +151,9 @@ function normalizeReportFindings(value: unknown): ReportFindingDetails[] {
 const REVIEWER_ARRAY_LABELS: ReadonlySet<string> = new Set(["findings"]);
 
 function extractIncrementalReviewResult(
-	value: unknown,
+	items: RenderYieldItem[],
 ): { summary: SubmitReviewDetails; findings: ReportFindingDetails[] } | undefined {
-	const yieldItems: YieldItem[] = normalizeYieldData(value).map(item => ({
+	const yieldItems: YieldItem[] = items.map(item => ({
 		data: item.data,
 		type: item.type,
 		status: item.status === "aborted" ? "aborted" : item.status === "success" ? "success" : undefined,
@@ -962,7 +962,7 @@ function renderAgentProgress(
 		// yield sections. Fall back to the legacy `report_finding` side-channel.
 		if (progress.status === "completed") {
 			const completeData = normalizeYieldData(progress.extractedToolData.yield);
-			const incrementalReview = extractIncrementalReviewResult(progress.extractedToolData.yield);
+			const incrementalReview = extractIncrementalReviewResult(completeData);
 			const reportFindingData = normalizeReportFindings(progress.extractedToolData.report_finding);
 			if (incrementalReview) {
 				lines.push(
@@ -1253,7 +1253,7 @@ function renderAgentResult(
 	// is not a function` when the slot is a plain object (see issue #1987).
 	const completeData = normalizeYieldData(result.extractedToolData?.yield);
 	const reportFindingData = normalizeReportFindings(result.extractedToolData?.report_finding);
-	const incrementalReview = extractIncrementalReviewResult(result.extractedToolData?.yield);
+	const incrementalReview = extractIncrementalReviewResult(completeData);
 
 	if (incrementalReview) {
 		lines.push(
@@ -1491,9 +1491,27 @@ export function renderResult(
 	}
 
 	const hasResults = Boolean(details.results && details.results.length > 0);
-	const aborted = hasResults && details.results.some(r => r.aborted);
-	const failed = hasResults && details.results.some(r => !r.aborted && r.exitCode !== 0);
-	const mergeFailed = hasResults && details.results.some(r => !r.aborted && r.exitCode === 0 && Boolean(r.error));
+	// Single pass over details.results derives the header booleans AND the footer
+	// counts/totals. This block re-runs ~30×/sec via the 33ms spinner render; the
+	// previous form did 3× `.some()` here plus 3× `.filter()` + `.reduce()` again
+	// inside the frame below (7+ full passes per tick).
+	let abortedCount = 0;
+	let failCount = 0;
+	let mergeFailedCount = 0;
+	let successCount = 0;
+	let requestTotal = 0;
+	if (hasResults) {
+		for (const r of details.results) {
+			requestTotal += r.requests ?? 0;
+			if (r.aborted) abortedCount++;
+			else if (r.exitCode !== 0) failCount++;
+			else if (r.error) mergeFailedCount++;
+			else successCount++;
+		}
+	}
+	const aborted = abortedCount > 0;
+	const failed = failCount > 0;
+	const mergeFailed = mergeFailedCount > 0;
 	const isError = aborted || failed;
 	const agentCount = hasResults ? details.results.length : (details.progress?.length ?? 0);
 	const icon: ToolUIStatus = options.isPartial ? "running" : isError ? "error" : mergeFailed ? "warning" : "success";
@@ -1552,16 +1570,12 @@ export function renderResult(
 				);
 			}
 
-			const abortedCount = details.results.filter(r => r.aborted).length;
-			const mergeFailedCount = details.results.filter(r => !r.aborted && r.exitCode === 0 && r.error).length;
-			const successCount = details.results.filter(r => !r.aborted && r.exitCode === 0 && !r.error).length;
-			const failCount = details.results.length - successCount - mergeFailedCount - abortedCount;
 			const summaryParts: string[] = [];
 			if (abortedCount > 0) summaryParts.push(theme.fg("error", `${abortedCount} aborted`));
 			if (successCount > 0) summaryParts.push(theme.fg("success", `${successCount} succeeded`));
 			if (mergeFailedCount > 0) summaryParts.push(theme.fg("warning", `${mergeFailedCount} merge failed`));
 			if (failCount > 0) summaryParts.push(theme.fg("error", `${failCount} failed`));
-			const totalRequests = details.results.reduce((sum, r) => sum + (r.requests ?? 0), 0);
+			const totalRequests = requestTotal;
 			if (totalRequests > 0) summaryParts.push(theme.fg("dim", `${formatNumber(totalRequests)} req`));
 			summaryParts.push(theme.fg("dim", formatDuration(details.totalDurationMs)));
 			// Wrap the run summary in the theme's bracket glyphs (dim chrome, colored

package/src/task/renderer.ts

@@ -11,4 +11,5 @@ export const taskToolRenderer = {
 	renderCall,
 	renderResult,
 	mergeCallAndResult: true,
+	animatedPartialResult: true,
 } as const;

package/src/task/worktree.ts

@@ -481,41 +481,148 @@ function baselineHasRootWip(baseline: RepoBaseline): boolean {
 	return !!(baseline.staged.trim() || baseline.unstaged.trim() || baseline.untrackedPatch.trim());
 }
 
+/**
+ * Baseline WIP context needed to safely apply a delta patch whose hunks were
+ * captured against `HEAD + WIP` (see {@link captureRepoDeltaPatch}). Passed
+ * whenever {@link baselineHasRootWip} is true so
+ * {@link commitPatchToBranchWorktree} can replay the WIP into the temp
+ * worktree first, then rewind WIP-only files after applying the delta.
+ */
+interface BaselineWipContext {
+	readonly staged: string;
+	readonly unstaged: string;
+	readonly untrackedPatch: string;
+	/** Untracked file paths present in the baseline (never in HEAD). */
+	readonly untracked: readonly string[];
+}
+
+function collectWipPatches(wip: BaselineWipContext | undefined): string[] {
+	if (!wip) return [];
+	return [wip.staged, wip.unstaged, wip.untrackedPatch].filter(p => p.trim());
+}
+
 async function commitPatchToBranchWorktree(
 	tmpDir: string,
 	taskId: string,
 	patchText: string,
 	message: string,
 	author?: git.CommitAuthor,
+	baselineWip?: BaselineWipContext,
 ): Promise<void> {
+	// Try the two clean paths first — they yield an agent-only commit and are
+	// the happy case when the temp worktree can resolve the patch against
+	// HEAD directly:
+	//
+	//   1. Plain apply — works when WIP context happens to match HEAD (e.g.
+	//      WIP-touched files that the delta patch doesn't reference).
+	//   2. `--3way`   — works when the WIP-side blob is tracked in HEAD and
+	//      lives in the shared ODB (captureDeltaPatch seeded it while writing
+	//      the synthetic baseline tree). The 3-way merge subtracts WIP,
+	//      producing an agent-only commit even when WIP and agent modify the
+	//      same tracked file at unrelated lines.
+	//
+	// If both fail (untracked WIP files, staged-new WIP files, or overlap that
+	// --3way can't resolve — see #4136), replay the WIP into the worktree
+	// first so the delta's context lines match, then rewind WIP-only files so
+	// they don't leak into the commit. Files touched by BOTH WIP and delta
+	// keep their combined state; the parent's stash-pop reconciles the WIP
+	// side via 3-way merge on merge-back.
+	let plainErr: git.GitCommandError | undefined;
 	try {
 		await git.patch.applyText(tmpDir, patchText);
 	} catch (err) {
 		if (!(err instanceof git.GitCommandError)) throw err;
-		// Plain apply rejects when the parent checkout carries unrelated dirty
-		// context near the task's edits; retry with --3way before giving up.
+		plainErr = err;
+	}
+	if (plainErr) {
+		let threeWayErr: git.GitCommandError | undefined;
 		try {
 			await git.patch.applyText(tmpDir, patchText, { threeWay: true });
-		} catch (threeWayErr) {
-			if (threeWayErr instanceof git.GitCommandError) {
+		} catch (err) {
+			if (!(err instanceof git.GitCommandError)) throw err;
+			threeWayErr = err;
+		}
+		if (threeWayErr) {
+			const wipPatches = collectWipPatches(baselineWip);
+			if (wipPatches.length === 0 || !baselineWip) {
 				const stderr = threeWayErr.result.stderr.slice(0, 2000);
 				logger.error("commitToBranch: git apply --3way failed", {
 					taskId,
 					exitCode: threeWayErr.result.exitCode,
 					stderr,
-					initialStderr: err.result.stderr.slice(0, 2000),
+					initialStderr: plainErr.result.stderr.slice(0, 2000),
 					patchSize: patchText.length,
 					patchHead: patchText.slice(0, 500),
 				});
 				throw new Error(`git apply --3way failed for task ${taskId}: ${stderr}`);
 			}
-			throw threeWayErr;
+			try {
+				// `git apply --3way` leaves conflict markers in `U` files when
+				// it can't resolve; reset the worktree so the WIP-seeded retry
+				// starts from a clean HEAD tree.
+				await git.reset(tmpDir, { hard: true, target: "HEAD" });
+				await applyDeltaOverBaselineWip(tmpDir, taskId, patchText, wipPatches, baselineWip);
+			} catch (wipErr) {
+				if (!(wipErr instanceof git.GitCommandError)) throw wipErr;
+				const stderr = wipErr.result.stderr.slice(0, 2000);
+				logger.error("commitToBranch: git apply with baseline WIP failed", {
+					taskId,
+					exitCode: wipErr.result.exitCode,
+					stderr,
+					threeWayStderr: threeWayErr.result.stderr.slice(0, 2000),
+					initialStderr: plainErr.result.stderr.slice(0, 2000),
+					patchSize: patchText.length,
+					patchHead: patchText.slice(0, 500),
+				});
+				throw new Error(`git apply with baseline WIP failed for task ${taskId}: ${stderr}`);
+			}
 		}
 	}
+
 	await git.stage.files(tmpDir);
 	await git.commit(tmpDir, message, author ? { author } : {});
 }
 
+/**
+ * Replay baseline WIP into the temp worktree so the delta patch's HEAD+WIP
+ * context matches, apply the delta, then rewind files WIP touched but the
+ * delta didn't — HEAD-tracked files are restored via `git restore`, untracked
+ * or staged-new WIP files are removed from the worktree. The commit that
+ * follows reflects agent's delta plus any overlap with WIP; parent's
+ * stash-pop reconciles the WIP side on merge-back.
+ */
+async function applyDeltaOverBaselineWip(
+	tmpDir: string,
+	_taskId: string,
+	patchText: string,
+	wipPatches: readonly string[],
+	baselineWip: BaselineWipContext,
+): Promise<void> {
+	for (const wip of wipPatches) {
+		await git.patch.applyText(tmpDir, wip);
+	}
+	await git.patch.applyText(tmpDir, patchText);
+
+	const wipFiles = new Set(wipPatches.flatMap(patchTouchedFiles));
+	const deltaFiles = new Set(patchTouchedFiles(patchText));
+	const wipOnly = [...wipFiles].filter(f => !deltaFiles.has(f));
+	if (wipOnly.length === 0) return;
+
+	// Any wipOnly file baselined as untracked cannot be in HEAD.
+	// Everything else may or may not — verify against HEAD's tree.
+	const untrackedSet = new Set(baselineWip.untracked);
+	const candidates = wipOnly.filter(f => !untrackedSet.has(f));
+	const inHead = candidates.length > 0 ? new Set(await git.ls.tree(tmpDir, "HEAD", candidates)) : new Set<string>();
+	const toRestore = candidates.filter(f => inHead.has(f));
+	const toRemove = wipOnly.filter(f => !toRestore.includes(f));
+	if (toRestore.length > 0) {
+		await git.restore(tmpDir, { source: "HEAD", staged: true, worktree: true, files: toRestore });
+	}
+	for (const rel of toRemove) {
+		await fs.rm(path.join(tmpDir, rel), { force: true });
+	}
+}
+
 interface FilteredAgentReplayOptions {
 	baseline: WorktreeBaseline;
 	branchName: string;
@@ -542,6 +649,7 @@ async function replayFilteredAgentCommits(opts: FilteredAgentReplayOptions): Pro
 			opts.baseline.root.untrackedPatch,
 		]);
 		let previousFilteredTree = baselineSha;
+		let filteredCommitsApplied = 0;
 
 		for (const commitSha of agentCommits) {
 			const taskStatePatch = await git.diff.tree(opts.isolationDir, dirtyBaselineTree, `${commitSha}^{tree}`, {
@@ -562,18 +670,37 @@ async function replayFilteredAgentCommits(opts: FilteredAgentReplayOptions): Pro
 					details.message || commitSha,
 					details.author,
 				);
+				filteredCommitsApplied++;
 			}
 			previousFilteredTree = currentFilteredTree;
 		}
-
-		const finalFilteredTree = await writeSyntheticTree(opts.repoRoot, baselineSha, [opts.rootPatch]);
-		const leftoverPatch = await git.diff.tree(opts.repoRoot, previousFilteredTree, finalFilteredTree, {
-			allowFailure: true,
-			binary: true,
-		});
-		if (leftoverPatch.trim()) {
-			const msg = (opts.commitMessage && (await opts.commitMessage(leftoverPatch))) || opts.fallbackMessage;
-			await commitPatchToBranchWorktree(tmpDir, opts.taskId, leftoverPatch, msg);
+		if (filteredCommitsApplied === 0) {
+			// No filtered commit landed — tmpDir is still pinned at baselineSha.
+			// The `finalFilteredTree = writeSyntheticTree(HEAD, [rootPatch])`
+			// path here fails hard whenever rootPatch's WIP-context can't be
+			// applied to a HEAD-only index (untracked WIP + agent modifies,
+			// staged-new WIP + agent modifies — see #4136). Bypass the synthesis
+			// entirely and collapse the isolation output onto a single commit
+			// with WIP seed, matching the no-agent-commit path in commitToBranch.
+			// This also handles the "agent committed only baseline WIP" corner
+			// case where every filtered patch collapsed to empty.
+			if (opts.rootPatch.trim()) {
+				const msg = (opts.commitMessage && (await opts.commitMessage(opts.rootPatch))) || opts.fallbackMessage;
+				await commitPatchToBranchWorktree(tmpDir, opts.taskId, opts.rootPatch, msg, undefined, opts.baseline.root);
+			}
+		} else {
+			// A filtered commit landed; tmpDir has advanced past baselineSha and
+			// previousFilteredTree is HEAD-derived, so writeSyntheticTree +
+			// leftoverPatch stay HEAD-based and no WIP seed is needed.
+			const finalFilteredTree = await writeSyntheticTree(opts.repoRoot, baselineSha, [opts.rootPatch]);
+			const leftoverPatch = await git.diff.tree(opts.repoRoot, previousFilteredTree, finalFilteredTree, {
+				allowFailure: true,
+				binary: true,
+			});
+			if (leftoverPatch.trim()) {
+				const msg = (opts.commitMessage && (await opts.commitMessage(leftoverPatch))) || opts.fallbackMessage;
+				await commitPatchToBranchWorktree(tmpDir, opts.taskId, leftoverPatch, msg);
+			}
 		}
 	} finally {
 		await git.worktree.tryRemove(opts.repoRoot, tmpDir);
@@ -674,7 +801,8 @@ export async function commitToBranch(
 			await git.worktree.add(repoRoot, tmpDir, branchName);
 
 			const msg = (commitMessage && (await commitMessage(rootPatch))) || fallbackMessage;
-			await commitPatchToBranchWorktree(tmpDir, taskId, rootPatch, msg);
+			const wip = baselineHasRootWip(baseline.root) ? baseline.root : undefined;
+			await commitPatchToBranchWorktree(tmpDir, taskId, rootPatch, msg, undefined, wip);
 		} finally {
 			await git.worktree.tryRemove(repoRoot, tmpDir);
 			await fs.rm(tmpDir, { recursive: true, force: true });