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

package/src/config/settings-schema.ts

@@ -233,7 +233,7 @@ interface StringDef {
 
 interface NumberDef {
 	type: "number";
-	default: number;
+	default: number | undefined;
 	ui?: UiNumber;
 }
 
@@ -1388,6 +1388,18 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"providers.anthropic.serverSideFallback": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "model",
+			group: "Retry & Fallback",
+			label: "Anthropic Server-Side Fallback (Fable 5)",
+			description:
+				"When a Claude Fable 5 / Mythos 5 request is blocked by Anthropic's safety classifier, retry it on Claude Opus 4.8 server-side (Anthropic `server-side-fallback-2026-06-01` beta). Opt-in — leaving this off preserves the pre-fallback behavior for every request.",
+		},
+	},
+
 	// ────────────────────────────────────────────────────────────────────────
 	// Interaction
 	// ────────────────────────────────────────────────────────────────────────
@@ -1997,7 +2009,11 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
-	"compaction.reserveTokens": { type: "number", default: 16384 },
+	// No default: an unset reserve tells the compaction layer the user never
+	// chose one, so small-window recovery may swap in the proportional reserve
+	// (see resolveBudgetReserveTokens). A materialized 16384 here would make
+	// every session look explicitly configured.
+	"compaction.reserveTokens": { type: "number", default: undefined },
 
 	"compaction.keepRecentTokens": { type: "number", default: 20000 },
 
@@ -4129,7 +4145,7 @@ export const SETTINGS_SCHEMA = {
 			group: "Subagents",
 			label: "Soft Subagent Request Budget",
 			description:
-				"Soft per-subagent request budget (assistant requests per run). Crossing it injects one steering notice asking the subagent to wrap up; at 1.5x the budget the run is aborted gracefully, salvaging partial output. 0 disables the guard. Bundled explore/sonic agents use a lower built-in budget.",
+				"Soft per-subagent request budget (assistant requests per run). Crossing it can inject a steering notice when task.softRequestBudgetNotice is enabled; at 1.5x the budget the run is aborted gracefully, salvaging partial output. 0 disables the guard. Bundled explore/sonic agents use a lower built-in budget.",
 			options: [
 				{ value: "0", label: "Disabled" },
 				{ value: "40", label: "40 requests" },
@@ -4139,6 +4155,18 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"task.softRequestBudgetNotice": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "tasks",
+			group: "Subagents",
+			label: "Soft Request Budget Notice",
+			description:
+				"Inject one steering notice when a subagent crosses its soft request budget. Off by default; enabling it asks the child to wrap up before the 1.5x graceful abort guard.",
+		},
+	},
+
 	"task.disabledAgents": {
 		type: "array",
 		default: [] as string[],
@@ -4930,17 +4958,19 @@ export type SettingValue<P extends SettingPath> = Schema[P] extends { type: "boo
 		? boolean
 		: Schema[P] extends { type: "string" }
 			? string | undefined
-			: Schema[P] extends { type: "number" }
-				? number
-				: Schema[P] extends { type: "enum"; values: infer V }
-					? V extends readonly string[]
-						? V[number]
-						: never
-					: Schema[P] extends { type: "array"; default: infer D }
-						? D
-						: Schema[P] extends { type: "record"; default: infer D }
+			: Schema[P] extends { type: "number"; default: undefined }
+				? number | undefined
+				: Schema[P] extends { type: "number" }
+					? number
+					: Schema[P] extends { type: "enum"; values: infer V }
+						? V extends readonly string[]
+							? V[number]
+							: never
+						: Schema[P] extends { type: "array"; default: infer D }
 							? D
-							: never;
+							: Schema[P] extends { type: "record"; default: infer D }
+								? D
+								: never;
 
 /** Get the default value for a setting path */
 export function getDefault<P extends SettingPath>(path: P): SettingValue<P> {
@@ -5002,7 +5032,7 @@ export interface CompactionSettings {
 	strategy: "context-full" | "handoff" | "shake" | "snapcompact" | "off";
 	thresholdPercent: number;
 	thresholdTokens: number;
-	reserveTokens: number;
+	reserveTokens: number | undefined;
 	keepRecentTokens: number;
 	midTurnEnabled: boolean;
 	handoffSaveToDisk: boolean;

package/src/edit/hashline/diff.ts

@@ -180,7 +180,8 @@ function resolvePreviewEdits(args: {
 }): readonly Edit[] {
 	const { section, absolutePath, normalized, snapshots, expected, liveMatches, edits } = args;
 	if (!hasBlockEdit(edits)) return edits;
-	const baseText = expected === undefined || liveMatches ? normalized : snapshots.byHash(absolutePath, expected)?.text;
+	const baseText =
+		expected === undefined || liveMatches ? normalized : snapshots.byHashExact(absolutePath, expected)?.text;
 	if (baseText === undefined) {
 		throw createMismatchError(section, absolutePath, normalized, snapshots, expected ?? "");
 	}
@@ -199,7 +200,17 @@ function applyPreviewEdits(args: {
 	if (!options.skipHashValidation && expected === undefined) {
 		throw new Error(missingSnapshotTagMessage(section.path));
 	}
-	const liveMatches = expected !== undefined && computeFileHash(normalized) === expected;
+	// A 16-bit tag can collide across two different file states, so hash
+	// equality alone does not prove the live text IS the snapshot the model's
+	// anchors were minted against (mirrors Patcher's apply-time guard). When
+	// the store retains text for the tag, require it to be unambiguous and
+	// byte-identical to live; otherwise fall through to recovery/reject below
+	// exactly as if the hash had not matched.
+	const liveMatches =
+		expected !== undefined &&
+		computeFileHash(normalized) === expected &&
+		(snapshots.byHash(absolutePath, expected) === null ||
+			snapshots.byHashExact(absolutePath, expected)?.text === normalized);
 	const edits = parsePreviewEdits(section, options.streaming);
 	const resolved = resolvePreviewEdits({ section, absolutePath, normalized, snapshots, expected, liveMatches, edits });
 	if (options.skipHashValidation || expected === undefined || liveMatches) return applyEdits(normalized, resolved);

package/src/edit/index.ts

@@ -7,6 +7,7 @@ import { prompt } from "@oh-my-pi/pi-utils";
 import {
 	createLspWritethrough,
 	type FileDiagnosticsResult,
+	flushLspWritethroughBatch,
 	type WritethroughCallback,
 	type WritethroughDeferredHandle,
 	writethroughNoop,
@@ -129,6 +130,8 @@ async function executeApplyPatchPerFile(
 		run: (batchRequest: LspBatchRequest | undefined) => Promise<AgentToolResult<EditToolDetails>>;
 	}[],
 	outerBatchRequest: LspBatchRequest | undefined,
+	cwd: string,
+	signal: AbortSignal | undefined,
 	onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 ): Promise<AgentToolResult<EditToolDetails, TInput>> {
 	if (fileEntries.length === 1) {
@@ -138,10 +141,15 @@ async function executeApplyPatchPerFile(
 
 	const perFileResults: EditToolPerFileResult[] = [];
 	const contentTexts: string[] = [];
+	let hasError = false;
 
 	for (let i = 0; i < fileEntries.length; i++) {
 		const { path, run } = fileEntries[i];
 		const isLast = i === fileEntries.length - 1;
+		// Per-file writes join the outer LSP write batch; only the last entry
+		// flushes it, so cross-file writes coalesce into a single
+		// format+diagnostics pass. The failure path below flushes explicitly
+		// when the loop stops early.
 		const batchRequest: LspBatchRequest | undefined = outerBatchRequest
 			? { id: outerBatchRequest.id, flush: isLast && outerBatchRequest.flush }
 			: undefined;
@@ -169,6 +177,36 @@ async function executeApplyPatchPerFile(
 			const displayErrorText = err instanceof HashlineMismatchError ? err.displayMessage : undefined;
 			perFileResults.push({ path, diff: "", isError: true, errorText, displayErrorText });
 			contentTexts.push(`Error editing ${path}: ${errorText}`);
+			hasError = true;
+			// Later entries were authored assuming this file's post-state; a
+			// partial cascade after failure typically compounds damage. Stop
+			// here, report applied vs. skipped, and let the caller re-issue
+			// only the failed and unapplied files. Matches
+			// `executeSinglePathEntries` semantics.
+			if (i > 0) {
+				const appliedPaths = fileEntries
+					.slice(0, i)
+					.map(e => e.path)
+					.join(", ");
+				contentTexts.push(`Files already applied: ${appliedPaths}.`);
+			}
+			if (i + 1 < fileEntries.length) {
+				const skippedPaths = fileEntries
+					.slice(i + 1)
+					.map(e => e.path)
+					.join(", ");
+				contentTexts.push(
+					`Files NOT applied: ${skippedPaths}; re-read the affected files and re-issue only the failed and unapplied files.`,
+				);
+			}
+			// Stopping early skips the last-entry flush above; finalize the
+			// already-written files so an intervening failure cannot leave them
+			// sitting in an unfinalized LSP write batch (mirrors the delete-path
+			// flush in executePatchSingle).
+			if (outerBatchRequest?.flush) {
+				await flushLspWritethroughBatch(outerBatchRequest.id, cwd, signal);
+			}
+			break;
 		}
 
 		// Emit partial result after each file so UI shows progressive completion
@@ -197,6 +235,10 @@ async function executeApplyPatchPerFile(
 			firstChangedLine: perFileResults.find(r => r.firstChangedLine)?.firstChangedLine,
 			perFileResults,
 		}),
+		// Any per-file failure marks the aggregate result as an error so the
+		// agent loop and renderer take the error branch instead of treating
+		// a mixed partial application as a successful edit.
+		...(hasError ? { isError: true } : {}),
 	};
 }
 
@@ -204,7 +246,9 @@ async function executeSinglePathEntries(
 	path: string,
 	runs: ((batchRequest: LspBatchRequest | undefined) => Promise<AgentToolResult<EditToolDetails>>)[],
 	outerBatchRequest: LspBatchRequest | undefined,
-	onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
+	onUpdate: ((partialResult: AgentToolResult<EditToolDetails, TInput>) => void) | undefined,
+	cwd: string,
+	signal: AbortSignal | undefined,
 ): Promise<AgentToolResult<EditToolDetails, TInput>> {
 	if (runs.length === 1) {
 		return runs[0](outerBatchRequest);
@@ -213,7 +257,7 @@ async function executeSinglePathEntries(
 	const contentTexts: string[] = [];
 	const diffTexts: string[] = [];
 	let firstChangedLine: number | undefined;
-	let errorCount = 0;
+	let hasError = false;
 	let metadataPath: string | undefined;
 	let hasFirstOldText = false;
 	let firstOldText: string | undefined;
@@ -264,10 +308,13 @@ async function executeSinglePathEntries(
 						`; re-read the file and re-issue only the failed and unapplied entries.`,
 				);
 			}
-			errorCount++;
+			hasError = true;
 			// Stop at the first failure: later entries were authored against
 			// line numbers/content that assumed this entry succeeded, and
 			// applying them after a failure compounds the damage.
+			if (outerBatchRequest?.flush) {
+				await flushLspWritethroughBatch(outerBatchRequest.id, cwd, signal);
+			}
 			break;
 		}
 
@@ -278,7 +325,7 @@ async function executeSinglePathEntries(
 					diff: diffTexts.join("\n"),
 					firstChangedLine,
 				},
-				...(errorCount > 0 ? { isError: true } : {}),
+				...(hasError ? { isError: true } : {}),
 			});
 		}
 	}
@@ -300,7 +347,7 @@ async function executeSinglePathEntries(
 		// renderer takes the error branch instead of falling through to the
 		// streaming-edit preview (which displays the *proposed* diff and looks
 		// indistinguishable from success).
-		...(errorCount > 0 ? { isError: true } : {}),
+		...(hasError ? { isError: true } : {}),
 	};
 }
 
@@ -498,11 +545,14 @@ export class EditTool implements AgentTool<TInput> {
 								batchRequest: br,
 								allowFuzzy: tool.#allowFuzzy,
 								fuzzyThreshold: tool.#fuzzyThreshold,
+								// The JSON grammar has no `*** Update File`; its `op: "create"`
+								// doubles as the documented full-file overwrite (patch.md <avoid>).
+								allowCreateOverwrite: true,
 								writethrough: tool.#writethrough,
 								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
 							}),
 					);
-					return executeSinglePathEntries(path, runs, batchRequest, onUpdate);
+					return executeSinglePathEntries(path, runs, batchRequest, onUpdate, tool.session.cwd, signal);
 				},
 			},
 			apply_patch: {
@@ -542,7 +592,7 @@ export class EditTool implements AgentTool<TInput> {
 								}),
 						};
 					});
-					return executeApplyPatchPerFile(perFile, batchRequest, onUpdate);
+					return executeApplyPatchPerFile(perFile, batchRequest, tool.session.cwd, signal, onUpdate);
 				},
 			},
 			hashline: {
@@ -591,7 +641,7 @@ export class EditTool implements AgentTool<TInput> {
 								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
 							}),
 					);
-					return executeSinglePathEntries(path, runs, batchRequest, onUpdate);
+					return executeSinglePathEntries(path, runs, batchRequest, onUpdate, tool.session.cwd, signal);
 				},
 			},
 		}[this.mode];

package/src/edit/modes/patch.ts

@@ -96,6 +96,14 @@ export interface ApplyPatchOptions {
 	fuzzyThreshold?: number;
 	allowFuzzy?: boolean;
 	fs?: FileSystem;
+	/**
+	 * Permit `op: "create"` to replace an existing file (full-file overwrite).
+	 * The JSON `patch` edit mode sanctions create-as-overwrite for major
+	 * restructures (see prompts/tools/patch.md); the Codex `apply_patch`
+	 * envelope documents `*** Add File` as strictly non-overwriting and must
+	 * leave this unset.
+	 */
+	allowCreateOverwrite?: boolean;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -455,7 +463,8 @@ function trimCommonContext(oldLines: string[], newLines: string[]): HunkVariant
 }
 
 function collapseConsecutiveSharedLines(oldLines: string[], newLines: string[]): HunkVariant | undefined {
-	const shared = new Set(oldLines.filter(line => newLines.includes(line)));
+	const newSet = new Set(newLines);
+	const shared = new Set(oldLines.filter(line => newSet.has(line)));
 	const collapse = (lines: string[]): string[] => {
 		const out: string[] = [];
 		let i = 0;
@@ -480,31 +489,32 @@ function collapseConsecutiveSharedLines(oldLines: string[], newLines: string[]):
 }
 
 function collapseRepeatedBlocks(oldLines: string[], newLines: string[]): HunkVariant | undefined {
-	const shared = new Set(oldLines.filter(line => newLines.includes(line)));
+	const newSet = new Set(newLines);
+	const shared = new Set(oldLines.filter(line => newSet.has(line)));
 	const collapse = (lines: string[]): string[] => {
 		const output = [...lines];
 		let changed = false;
 		let i = 0;
 		while (i < output.length) {
 			let collapsed = false;
-			for (let size = Math.floor((output.length - i) / 2); size >= 2; size--) {
-				const first = output.slice(i, i + size);
-				const second = output.slice(i + size, i + size * 2);
-				if (first.length !== second.length || first.length === 0) continue;
-				if (!first.every(line => shared.has(line))) continue;
-				let same = true;
-				for (let idx = 0; idx < size; idx++) {
-					if (first[idx] !== second[idx]) {
-						same = false;
+			// Only blocks whose lines are all shared are collapsible; if the first line
+			// is not shared no size can match, so skip the size search entirely.
+			if (shared.has(output[i])) {
+				for (let size = Math.floor((output.length - i) / 2); size >= 2; size--) {
+					let same = true;
+					for (let idx = 0; idx < size; idx++) {
+						if (output[i + idx] !== output[i + size + idx] || !shared.has(output[i + idx])) {
+							same = false;
+							break;
+						}
+					}
+					if (same) {
+						output.splice(i + size, size);
+						changed = true;
+						collapsed = true;
 						break;
 					}
 				}
-				if (same) {
-					output.splice(i + size, size);
-					changed = true;
-					collapsed = true;
-					break;
-				}
 			}
 			if (!collapsed) {
 				i++;
@@ -1479,6 +1489,7 @@ async function applyNormalizedPatch(input: PatchInput, options: ApplyPatchOption
 		fs = defaultFileSystem,
 		fuzzyThreshold = DEFAULT_FUZZY_THRESHOLD,
 		allowFuzzy = true,
+		allowCreateOverwrite = false,
 	} = options;
 
 	const resolvePath = (p: string): string => resolveToCwd(p, cwd);
@@ -1490,6 +1501,14 @@ async function applyNormalizedPatch(input: PatchInput, options: ApplyPatchOption
 		if (destPath === absolutePath) {
 			throw new ApplyPatchError("rename path is the same as source path");
 		}
+		// The `*** Move to` / rename contract is strictly non-overwriting:
+		// reject before the update path reads or writes anything, so both
+		// source and pre-existing destination remain untouched. Callers who
+		// really need to replace the destination must delete it in an
+		// earlier hunk.
+		if (await fs.exists(destPath)) {
+			throw new ApplyPatchError(`Cannot rename ${input.path} to ${input.rename}: destination already exists.`);
+		}
 	}
 
 	// Handle CREATE operation
@@ -1497,6 +1516,17 @@ async function applyNormalizedPatch(input: PatchInput, options: ApplyPatchOption
 		if (!input.diff) {
 			throw new ApplyPatchError("Create operation requires diff (file content)");
 		}
+		// The `*** Add File` contract of the apply_patch envelope is strictly
+		// non-overwriting: reject before mkdir/write so pre-existing content
+		// stays intact and the caller can re-issue as an explicit
+		// `*** Update File` (or a delete+add pair) if overwrite is genuinely
+		// intended. The JSON `patch` mode opts out via `allowCreateOverwrite`,
+		// where `op: "create"` doubles as a sanctioned full-file overwrite.
+		if (!allowCreateOverwrite && (await fs.exists(absolutePath))) {
+			throw new ApplyPatchError(
+				`Cannot create ${input.path}: file already exists. Use *** Update File to modify it in place.`,
+			);
+		}
 		// Strip + prefixes if present (handles diffs formatted as additions)
 		const normalizedContent = normalizeCreateContent(input.diff);
 		const content = normalizedContent.endsWith("\n") ? normalizedContent : `${normalizedContent}\n`;
@@ -1602,7 +1632,7 @@ export async function previewPatch(input: PatchInput, options: ApplyPatchOptions
 export async function computePatchDiff(
 	input: PatchInput,
 	cwd: string,
-	options?: { fuzzyThreshold?: number; allowFuzzy?: boolean },
+	options?: { fuzzyThreshold?: number; allowFuzzy?: boolean; allowCreateOverwrite?: boolean },
 ): Promise<
 	| {
 			diff: string;
@@ -1617,6 +1647,7 @@ export async function computePatchDiff(
 			cwd,
 			fuzzyThreshold: options?.fuzzyThreshold,
 			allowFuzzy: options?.allowFuzzy,
+			allowCreateOverwrite: options?.allowCreateOverwrite,
 		});
 		const oldContent = result.change.oldContent ?? "";
 		const newContent = result.change.newContent ?? "";
@@ -1656,6 +1687,8 @@ export interface ExecutePatchSingleOptions {
 	batchRequest?: LspBatchRequest;
 	allowFuzzy: boolean;
 	fuzzyThreshold: number;
+	/** See {@link ApplyPatchOptions.allowCreateOverwrite}; set by the JSON `patch` mode only. */
+	allowCreateOverwrite?: boolean;
 	writethrough: WritethroughCallback;
 	beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
 }
@@ -1763,6 +1796,7 @@ export async function executePatchSingle(
 		batchRequest,
 		allowFuzzy,
 		fuzzyThreshold,
+		allowCreateOverwrite,
 		writethrough,
 		beginDeferredDiagnosticsForPath,
 	} = options;
@@ -1808,6 +1842,7 @@ export async function executePatchSingle(
 		fs: patchFileSystem,
 		fuzzyThreshold,
 		allowFuzzy,
+		allowCreateOverwrite,
 	});
 
 	// Post-write verification: only meaningful for in-place updates where the

package/src/edit/streaming.ts

@@ -207,19 +207,18 @@ function groupApplyPatchEntriesByPath(entries: readonly ApplyPatchEntry[]): Map<
  * `create` op), otherwise an empty string (grammar-only payloads).
  */
 function extractAddedLines(text: string, fallbackToWhole: boolean): string {
-	let added: string | undefined;
+	const added: string[] = [];
 	let lineStart = 0;
 	while (lineStart <= text.length) {
 		let lineEnd = text.indexOf("\n", lineStart);
 		if (lineEnd === -1) lineEnd = text.length;
 		if (text.charCodeAt(lineStart) === 43 /* + */ && !text.startsWith("+++ ", lineStart)) {
-			const line = text.slice(lineStart + 1, lineEnd);
-			added = added === undefined ? line : `${added}\n${line}`;
+			added.push(text.slice(lineStart + 1, lineEnd));
 		}
 		lineStart = lineEnd + 1;
 	}
-	if (added === undefined) return fallbackToWhole ? text : "";
-	return added;
+	if (added.length === 0) return fallbackToWhole ? text : "";
+	return added.join("\n");
 }
 
 /**
@@ -394,7 +393,9 @@ const patchStrategy: EditStreamingStrategy<PatchArgs> = {
 		const result = await computePatchDiff(
 			{ path: args.path, op: first.op ?? "update", rename: first.rename, diff: first.diff },
 			ctx.cwd,
-			{ fuzzyThreshold: ctx.fuzzyThreshold, allowFuzzy: ctx.allowFuzzy },
+			// Match the apply path: JSON-mode `op: "create"` is a sanctioned
+			// full-file overwrite, so the preview must not reject it either.
+			{ fuzzyThreshold: ctx.fuzzyThreshold, allowFuzzy: ctx.allowFuzzy, allowCreateOverwrite: true },
 		);
 		ctx.signal.throwIfAborted();
 		return [toPerFilePreview(args.path, result)];

package/src/eval/__tests__/agent-bridge.test.ts

@@ -219,6 +219,48 @@ describe("runEvalAgent", () => {
 		expect(runSpy.mock.calls[0]?.[0].agent.name).toBe("reviewer");
 	});
 
+	it("honors task.maxRecursionDepth on top of the hard eval ceiling", async () => {
+		mockAgents();
+		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => singleResult(options));
+
+		// task.maxRecursionDepth=0 means "no spawning at all" — even depth 0 (the
+		// top-level agent) must be blocked, matching canSpawnAtDepth().
+		await expect(
+			runEvalAgent(
+				{ prompt: "hello" },
+				{
+					session: makeSession({
+						settings: Settings.isolated({
+							"async.enabled": false,
+							"task.isolation.mode": "none",
+							"task.maxRecursionDepth": 0,
+						}),
+					}),
+				},
+			),
+		).rejects.toThrow("maximum depth is 0");
+
+		// task.maxRecursionDepth=1 ("Single") lets the top spawn but a depth-1
+		// subagent cannot spawn further — even though the hard ceiling is 3.
+		await expect(
+			runEvalAgent(
+				{ prompt: "hello" },
+				{
+					session: makeSession({
+						depth: 1,
+						settings: Settings.isolated({
+							"async.enabled": false,
+							"task.isolation.mode": "none",
+							"task.maxRecursionDepth": 1,
+						}),
+					}),
+				},
+			),
+		).rejects.toThrow("maximum depth is 1");
+
+		expect(runSpy).not.toHaveBeenCalled();
+	});
+
 	it("throws instead of spawning from plan mode", async () => {
 		mockAgents();
 		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => singleResult(options));
@@ -234,7 +276,19 @@ describe("runEvalAgent", () => {
 		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => singleResult(options));
 		const abortController = new AbortController();
 		const schema = { type: "object", properties: { ok: { type: "boolean" } } };
-		const session = makeSession({ depth: 2, activeModel: "p/current", modelString: "p/fallback" });
+		const session = makeSession({
+			depth: 2,
+			activeModel: "p/current",
+			modelString: "p/fallback",
+			settings: Settings.isolated({
+				"async.enabled": false,
+				"task.isolation.mode": "none",
+				"task.enableLsp": true,
+				// Default task.maxRecursionDepth is 2, which would now (correctly)
+				// block depth=2 — widen it so the test still exercises depth=2.
+				"task.maxRecursionDepth": -1,
+			}),
+		});
 
 		await runEvalAgent(
 			{ prompt: " hello ", label: "My Agent", model: "p/override", schema },
@@ -249,10 +303,12 @@ describe("runEvalAgent", () => {
 		expect(firstOptions.signal).toBe(abortController.signal);
 		expect(firstOptions.parentActiveModelPattern).toBe("p/current");
 		expect(firstOptions.outputSchema).toBe(schema);
+		expect(firstOptions.outputSchemaOverridesAgent).toBe(true);
 		expect(firstOptions.assignment).toBe("hello");
 		expect(firstOptions.description).toBe("My Agent");
 		expect(firstOptions.modelOverride).toEqual(["p/override"]);
 		expect(secondOptions.outputSchema).toBeUndefined();
+		expect(secondOptions.outputSchemaOverridesAgent).toBeUndefined();
 	});
 
 	it("forces LSP off for bridge subagents even when task.enableLsp is on", async () => {

package/src/eval/agent-bridge.ts

@@ -25,7 +25,7 @@ import {
 } from "../task/isolation-runner";
 import { AgentOutputManager } from "../task/output-manager";
 import { resolveSpawnPolicy } from "../task/spawn-policy";
-import type { AgentDefinition, AgentProgress, SingleResult } from "../task/types";
+import { type AgentDefinition, type AgentProgress, canSpawnAtDepth, type SingleResult } from "../task/types";
 import { type NestedRepoPatch, parseIsolationMode } from "../task/worktree";
 import type { ToolSession } from "../tools";
 import { ToolError } from "../tools/tool-errors";
@@ -37,7 +37,11 @@ import "../tools/review";
 /** Synthetic bridge name reserved for the `agent()` helper across both runtimes. */
 export const EVAL_AGENT_BRIDGE_NAME = "__agent__";
 
-/** Hard recursion limit for eval-driven subagents. */
+/**
+ * Hard recursion ceiling for eval-driven subagents. The user setting
+ * `task.maxRecursionDepth` is honored on top of this — whichever is tighter
+ * wins, so a maintainer-friendly cap can't get raised by a user setting.
+ */
 export const EVAL_AGENT_MAX_DEPTH = 3;
 
 const DEFAULT_AGENT_LABEL = "EvalAgent";
@@ -131,9 +135,15 @@ function parseAgentArgs(args: unknown): EvalAgentArgs {
 
 function assertDepthAllowed(session: ToolSession): void {
 	const taskDepth = session.taskDepth ?? 0;
-	if (taskDepth >= EVAL_AGENT_MAX_DEPTH) {
+	// Honor the user's `task.maxRecursionDepth` (mirroring the task tool's gate
+	// in tools/index.ts) but never above the hard ceiling. `< 0` means
+	// "Unlimited" in the same schema `canSpawnAtDepth` reads, so it falls back
+	// to the hard ceiling instead of going past it.
+	const settingMax = session.settings.get("task.maxRecursionDepth") ?? 2;
+	const effectiveMax = settingMax < 0 ? EVAL_AGENT_MAX_DEPTH : Math.min(settingMax, EVAL_AGENT_MAX_DEPTH);
+	if (!canSpawnAtDepth(effectiveMax, taskDepth)) {
 		throw new ToolError(
-			`agent() cannot spawn another agent at task depth ${taskDepth}; maximum depth is ${EVAL_AGENT_MAX_DEPTH}.`,
+			`agent() cannot spawn another agent at task depth ${taskDepth}; maximum depth is ${effectiveMax} (task.maxRecursionDepth=${settingMax}, hard ceiling=${EVAL_AGENT_MAX_DEPTH}).`,
 		);
 	}
 }
@@ -368,7 +378,7 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 		modelOverride,
 		parentActiveModelPattern,
 		thinkingLevel: effectiveAgent.thinkingLevel,
-		outputSchema: structured ? parsed.schema : undefined,
+		...(structured ? { outputSchema: parsed.schema, outputSchemaOverridesAgent: true } : {}),
 		sessionFile,
 		persistArtifacts: Boolean(sessionFile),
 		artifactsDir,