@oh-my-pi/pi-coding-agent 16.1.15 → 16.1.17

package/src/task/isolation-runner.ts

@@ -0,0 +1,354 @@
+/**
+ * Reusable isolation lifecycle for subagent execution.
+ *
+ * Both `TaskTool` and the eval `agent()` bridge spawn subagents that can run
+ * inside a copy-on-write worktree, capture their changes, and (optionally)
+ * apply those changes back to the parent repo. The orchestration is identical
+ * for both callers; this module hosts the shared lifecycle so eval `agent()`
+ * does not need to round-trip through `TaskTool.#runSpawn`.
+ *
+ * Shape:
+ *   1. {@link prepareIsolationContext} — resolve git root + capture baseline.
+ *   2. {@link runIsolatedSubprocess}    — start worktree, run, capture
+ *                                        branch/patch, tear worktree down.
+ *   3. {@link mergeIsolatedChanges}     — apply captured changes back to the
+ *                                        parent repo (skip when the caller
+ *                                        opted out).
+ *
+ * Step 1 happens once per top-level call (the baseline is cloned per spawn
+ * before mutation); steps 2 and 3 are per-spawn.
+ */
+import * as path from "node:path";
+import type * as natives from "@oh-my-pi/pi-natives";
+import type { ToolSession } from "../tools";
+import { generateCommitMessage } from "../utils/commit-message-generator";
+import * as git from "../utils/git";
+import type { ExecutorOptions } from "./executor";
+import { runSubprocess } from "./executor";
+import type { SingleResult } from "./types";
+import {
+	applyNestedPatches,
+	captureBaseline,
+	captureDeltaPatch,
+	cleanupIsolation,
+	cleanupTaskBranches,
+	commitToBranch,
+	ensureIsolation,
+	getRepoRoot,
+	type IsolationHandle,
+	mergeTaskBranches,
+	type WorktreeBaseline,
+} from "./worktree";
+
+type IsoBackendKind = natives.IsoBackendKind;
+
+/** Resolved repo + baseline used by every isolated spawn in a single call. */
+export interface IsolationContext {
+	repoRoot: string;
+	baseline: WorktreeBaseline;
+}
+
+/**
+ * Resolve the git repo root and capture the worktree baseline used to diff
+ * each isolated spawn against. Throws when the cwd is not inside a git
+ * repository; callers surface the error as a task-tool failure.
+ */
+export async function prepareIsolationContext(cwd: string): Promise<IsolationContext> {
+	const repoRoot = await getRepoRoot(cwd);
+	const baseline = await captureBaseline(repoRoot);
+	return { repoRoot, baseline };
+}
+
+/** Build a commit-message callback for branch/nested commits; `undefined` ⇒ fall back to generic message. */
+export type BuildCommitMessage = () => undefined | ((diff: string) => Promise<string | null>);
+
+/**
+ * Construct the commit-message factory used by isolation branch commits and
+ * nested-repo patch commits. Returns a closure that, each time it's called,
+ * either yields an AI-backed `(diff) => Promise<string|null>` callback (when
+ * `task.isolation.commits === "ai"` and a model registry is available) or
+ * `undefined` so the caller falls back to a generic commit message.
+ *
+ * Centralized so `TaskTool` and the eval `agent()` bridge share one wiring;
+ * a drift here previously meant the two callers built subtly different
+ * generators for the same setting.
+ */
+export function makeIsolationCommitMessage(session: ToolSession): BuildCommitMessage {
+	return () => {
+		const style = session.settings.get("task.isolation.commits");
+		if (style !== "ai" || !session.modelRegistry) return undefined;
+		const registry = session.modelRegistry;
+		const settings = session.settings;
+		const sessionId = session.getSessionId?.() ?? undefined;
+		return async (diff: string) => generateCommitMessage(diff, registry, settings, sessionId);
+	};
+}
+
+export interface IsolatedRunOptions {
+	/**
+	 * Base run options handed to the subagent subprocess. This helper sets
+	 * `worktree`, clears `preloadedExtensionPaths` / `preloadedCustomToolPaths`
+	 * (isolated runs re-discover inside the worktree), and forwards everything
+	 * else unchanged.
+	 */
+	baseOptions: ExecutorOptions;
+	/** Context returned by {@link prepareIsolationContext}. Baseline is cloned per spawn. */
+	context: IsolationContext;
+	/** PAL backend hint from `parseIsolationMode(...)` (undefined ⇒ resolver picks). */
+	preferredBackend: IsoBackendKind | undefined;
+	/** Stable id used as the isolation worktree namespace and as the branch suffix. */
+	agentId: string;
+	/** Merge mode driving how changes are captured ("branch" commits, "patch" diffs). */
+	mergeMode: "patch" | "branch";
+	/** Output dir for `${agentId}.patch` artifacts (patch mode). */
+	artifactsDir: string;
+	/** Human description carried onto the branch commit (branch mode). */
+	description?: string;
+	/** Build a commit-message callback (`task.isolation.commits === "ai"`). */
+	buildCommitMessage?: BuildCommitMessage;
+	/**
+	 * Construct a `SingleResult` when isolation setup throws — the caller has
+	 * the full metadata (index, agent, assignment, modelOverride) needed to
+	 * build a result shape consistent with their non-isolated path.
+	 */
+	buildFailureResult: (err: unknown) => SingleResult;
+}
+
+/**
+ * Run a subagent inside an isolation worktree and capture its changes.
+ *
+ * Branch mode: on success, commits the diff onto `omp/task/${agentId}` and
+ * returns `branchName` + `nestedPatches`. On commit failure the branch is
+ * deleted and `result.error` carries the merge-failure message.
+ *
+ * Patch mode: on success, writes `${artifactsDir}/${agentId}.patch` and
+ * returns `patchPath` + `nestedPatches`.
+ *
+ * Failure paths preserve the underlying `SingleResult` whenever possible so
+ * the caller can still surface the subagent's output; only isolation setup
+ * itself routes through {@link IsolatedRunOptions.buildFailureResult}.
+ *
+ * The isolation handle is always torn down in `finally`.
+ */
+export async function runIsolatedSubprocess(opts: IsolatedRunOptions): Promise<SingleResult> {
+	let handle: IsolationHandle | undefined;
+	try {
+		const taskBaseline = structuredClone(opts.context.baseline);
+		handle = await ensureIsolation(opts.context.repoRoot, opts.agentId, opts.preferredBackend);
+		const isolationDir = handle.mergedDir;
+		const result = await runSubprocess({
+			...opts.baseOptions,
+			worktree: isolationDir,
+			preloadedExtensionPaths: undefined,
+			preloadedCustomToolPaths: undefined,
+		});
+		if (opts.mergeMode === "branch" && result.exitCode === 0) {
+			try {
+				const commitResult = await commitToBranch(
+					isolationDir,
+					taskBaseline,
+					opts.agentId,
+					opts.description,
+					opts.buildCommitMessage?.(),
+				);
+				return {
+					...result,
+					branchName: commitResult?.branchName,
+					nestedPatches: commitResult?.nestedPatches,
+				};
+			} catch (mergeErr) {
+				// Agent succeeded but branch commit failed — clean up stale branch
+				const branchName = `omp/task/${opts.agentId}`;
+				await git.branch.tryDelete(opts.context.repoRoot, branchName);
+				const msg = mergeErr instanceof Error ? mergeErr.message : String(mergeErr);
+				return { ...result, error: `Merge failed: ${msg}` };
+			}
+		}
+		if (result.exitCode === 0) {
+			try {
+				const delta = await captureDeltaPatch(isolationDir, taskBaseline);
+				const patchPath = path.join(opts.artifactsDir, `${opts.agentId}.patch`);
+				await Bun.write(patchPath, delta.rootPatch);
+				return {
+					...result,
+					patchPath,
+					nestedPatches: delta.nestedPatches,
+				};
+			} catch (patchErr) {
+				const msg = patchErr instanceof Error ? patchErr.message : String(patchErr);
+				return { ...result, error: `Patch capture failed: ${msg}` };
+			}
+		}
+		return result;
+	} catch (err) {
+		return opts.buildFailureResult(err);
+	} finally {
+		if (handle) {
+			await cleanupIsolation(handle);
+		}
+	}
+}
+
+export interface IsolationMergeOptions {
+	result: SingleResult;
+	repoRoot: string;
+	mergeMode: "patch" | "branch";
+}
+
+export interface IsolationMergeOutcome {
+	/** Trailing summary appended to the subagent's result text. May be empty. */
+	summary: string;
+	/**
+	 * Tri-state apply outcome:
+	 * - `true`  — merge ran (or had nothing to apply) and left the repo clean.
+	 * - `false` — merge attempted and failed; artifacts are preserved.
+	 * - `null`  — caller skipped the merge phase entirely (e.g. `apply=false`).
+	 */
+	changesApplied: boolean | null;
+	hadAnyChanges: boolean;
+	/** True iff the root branch actually merged — gates nested-repo patch application. */
+	mergedBranchForNestedPatches: boolean;
+}
+
+/**
+ * Apply changes captured by {@link runIsolatedSubprocess} back to the parent
+ * repo: patch apply (patch mode) or cherry-pick + cleanup (branch mode).
+ *
+ * The caller decides whether to run this at all — eval `agent()` with
+ * `apply=False` skips this step and surfaces the patch artifact / branch name
+ * instead.
+ */
+export async function mergeIsolatedChanges(opts: IsolationMergeOptions): Promise<IsolationMergeOutcome> {
+	const { result, repoRoot, mergeMode } = opts;
+	try {
+		if (mergeMode === "branch") {
+			const canApplyNestedOnly =
+				!result.branchName && result.exitCode === 0 && !result.aborted && (result.nestedPatches?.length ?? 0) > 0;
+			if (!result.branchName || result.exitCode !== 0 || result.aborted) {
+				return {
+					summary: canApplyNestedOnly
+						? "\n\nNo root changes to apply; nested repository patches captured."
+						: "\n\nNo changes to apply.",
+					changesApplied: true,
+					hadAnyChanges: canApplyNestedOnly,
+					mergedBranchForNestedPatches: canApplyNestedOnly,
+				};
+			}
+			const mergeResult = await mergeTaskBranches(repoRoot, [
+				{ branchName: result.branchName, taskId: result.id, description: result.description },
+			]);
+			const mergedBranchForNestedPatches = mergeResult.merged.includes(result.branchName);
+			const changesApplied = mergeResult.failed.length === 0;
+			const hadAnyChanges = changesApplied && mergeResult.merged.length > 0;
+
+			let summary: string;
+			if (changesApplied) {
+				summary = hadAnyChanges ? `\n\nMerged branch: ${result.branchName}` : "\n\nNo changes to apply.";
+			} else {
+				const conflictPart = mergeResult.conflict ? `\nConflict: ${mergeResult.conflict}` : "";
+				summary = `\n\n<system-notification>Branch merge failed: ${result.branchName}.${conflictPart}\nThe unmerged branch remains for manual resolution.</system-notification>`;
+			}
+			if (mergeResult.stashConflict) {
+				summary += `\n\n<system-notification>${mergeResult.stashConflict}</system-notification>`;
+			}
+
+			// Clean up the merged branch (keep failed ones for manual resolution)
+			if (changesApplied) {
+				await cleanupTaskBranches(repoRoot, [result.branchName]);
+			}
+			return { summary, changesApplied, hadAnyChanges, mergedBranchForNestedPatches };
+		}
+
+		// Patch mode: apply the patch from a successful run. A failed or
+		// aborted run has nothing to apply and must not block the result.
+		let changesApplied: boolean;
+		let hadAnyChanges: boolean;
+		const succeeded = result.exitCode === 0 && !result.error && !result.aborted;
+		if (!succeeded) {
+			changesApplied = true;
+			hadAnyChanges = false;
+		} else if (!result.patchPath) {
+			changesApplied = false;
+			hadAnyChanges = false;
+		} else {
+			const patchText = await Bun.file(result.patchPath).text();
+			if (!patchText.trim()) {
+				changesApplied = true;
+				hadAnyChanges = false;
+			} else {
+				const normalized = patchText.endsWith("\n") ? patchText : `${patchText}\n`;
+				changesApplied = await git.patch.canApplyText(repoRoot, normalized);
+				hadAnyChanges = false;
+				if (changesApplied) {
+					try {
+						await git.patch.applyText(repoRoot, normalized);
+						hadAnyChanges = true;
+					} catch {
+						changesApplied = false;
+					}
+				}
+			}
+		}
+
+		let summary: string;
+		if (changesApplied) {
+			summary = hadAnyChanges ? "\n\nApplied patches: yes" : "\n\nNo changes to apply.";
+		} else {
+			const notification =
+				"<system-notification>Patches were not applied and must be handled manually.</system-notification>";
+			const patchList = result.patchPath ? `\n\nPatch artifact:\n- ${result.patchPath}` : "";
+			summary = `\n\n${notification}${patchList}`;
+		}
+		return { summary, changesApplied, hadAnyChanges, mergedBranchForNestedPatches: false };
+	} catch (mergeErr) {
+		const msg = mergeErr instanceof Error ? mergeErr.message : String(mergeErr);
+		return {
+			summary: `\n\n<system-notification>Merge phase failed: ${msg}\nTask outputs are preserved but changes were not applied.</system-notification>`,
+			changesApplied: false,
+			hadAnyChanges: false,
+			mergedBranchForNestedPatches: false,
+		};
+	}
+}
+
+export interface NestedPatchApplyOptions {
+	/** Subagent result carrying `nestedPatches`/`exitCode`/`aborted`. */
+	result: SingleResult;
+	repoRoot: string;
+	mergeMode: "patch" | "branch";
+	/** Parent merge outcome — patch mode skips nested apply when this is `false`. */
+	changesApplied: boolean | null;
+	/** Branch mode gates nested apply on whether the root branch merged. */
+	mergedBranchForNestedPatches: boolean;
+	/** Optional AI commit-message callback for nested commits; falls back to a generic message. */
+	commitMessage?: (diff: string) => Promise<string | null>;
+}
+
+/**
+ * Apply nested-repo patches after the parent merge phase. Centralizes the
+ * three-way gate (exitCode/aborted, patch-mode failed parent, branch-mode
+ * branch-merged) and the non-fatal failure handling so `TaskTool` and the
+ * eval `agent()` bridge use one implementation.
+ *
+ * Returns a system-notification suffix to append to the parent merge summary,
+ * or an empty string when nothing was applied or the nested apply succeeded.
+ */
+export async function applyEligibleNestedPatches(opts: NestedPatchApplyOptions): Promise<string> {
+	const { result, repoRoot, mergeMode, changesApplied, mergedBranchForNestedPatches, commitMessage } = opts;
+	if (mergeMode === "patch" && changesApplied === false) return "";
+	const nestedPatches = result.nestedPatches ?? [];
+	const eligible =
+		nestedPatches.length > 0 &&
+		result.exitCode === 0 &&
+		!result.aborted &&
+		(mergeMode !== "branch" || mergedBranchForNestedPatches);
+	if (!eligible) return "";
+	try {
+		const warnings = await applyNestedPatches(repoRoot, nestedPatches, commitMessage);
+		if (warnings.length === 0) return "";
+		return `\n\n<system-notification>${warnings.join("\n")}</system-notification>`;
+	} catch {
+		// Nested patch failures are non-fatal to the parent merge.
+		return "\n\n<system-notification>Some nested repository patches failed to apply.</system-notification>";
+	}
+}

package/src/task/parallel.ts

@@ -85,6 +85,10 @@ export async function mapWithConcurrencyLimit<T, R>(
 
 /**
  * Simple counting semaphore for limiting concurrency across independently-scheduled async work.
+ *
+ * `max <= 0` (or any non-finite input) means unbounded — every `acquire()` resolves
+ * immediately — matching `task.maxConcurrency = 0`'s "Unlimited" semantics in the
+ * settings UI ([#3305](https://github.com/can1357/oh-my-pi/issues/3305)).
  */
 export class Semaphore {
 	#max: number;
@@ -92,7 +96,8 @@ export class Semaphore {
 	#queue: Array<() => void> = [];
 
 	constructor(max: number) {
-		this.#max = Math.max(1, max);
+		const normalizedMax = Number.isFinite(max) ? Math.trunc(max) : 0;
+		this.#max = normalizedMax > 0 ? normalizedMax : Number.POSITIVE_INFINITY;
 	}
 
 	async acquire(): Promise<void> {

package/src/task/worktree.ts

@@ -194,6 +194,19 @@ export async function captureDeltaPatch(isolationDir: string, baseline: Worktree
 
 /**
  * Apply nested repo patches directly to their working directories after parent merge.
+ *
+ * Pre-existing dirty state in a nested repo is stashed before the patch is
+ * applied and popped back (with `--index` so staged WIP stays staged) after
+ * the commit, so unrelated user edits never get folded into the agent's
+ * commit. A failing `git stash pop` (e.g. user edits collide with the patched
+ * lines) leaves the stash entry intact, emits a `logger.warn`, and is
+ * returned to the caller as a human-readable warning string — the agent
+ * commit already landed, so this is a partial success the workflow needs to
+ * see, not a thrown failure.
+ *
+ * Returns the collected stash-restore warnings (empty when every nested repo
+ * was restored cleanly). Throws when the patch apply itself fails.
+ *
  * @param commitMessage Optional async function to generate a commit message from the combined diff.
  *                      If omitted or returns null, falls back to a generic message.
  */
@@ -201,7 +214,8 @@ export async function applyNestedPatches(
 	repoRoot: string,
 	patches: NestedRepoPatch[],
 	commitMessage?: (diff: string) => Promise<string | null>,
-): Promise<void> {
+): Promise<string[]> {
+	const warnings: string[] = [];
 	// Group patches by target repo to apply all at once and commit
 	const byRepo = new Map<string, NestedRepoPatch[]>();
 	for (const p of patches) {
@@ -220,17 +234,40 @@ export async function applyNestedPatches(
 		}
 
 		const combinedDiff = repoPatches.map(p => p.patch).join("\n");
-		for (const { patch } of repoPatches) {
-			await git.patch.applyText(nestedDir, patch);
-		}
 
-		// Commit so nested repo history reflects the task changes
-		if ((await git.status(nestedDir)).trim().length > 0) {
-			const msg = (await commitMessage?.(combinedDiff)) ?? "changes from isolated task(s)";
-			await git.stage.files(nestedDir);
-			await git.commit(nestedDir, msg);
+		// Preserve any pre-existing dirty state (tracked + untracked) so we
+		// commit only the agent delta, not the user's in-flight work.
+		const stashed =
+			(await git.status(nestedDir)).trim().length > 0
+				? await git.stash.push(nestedDir, `omp-isolation-${Snowflake.next()}`)
+				: false;
+		try {
+			for (const { patch } of repoPatches) {
+				await git.patch.applyText(nestedDir, patch);
+			}
+			if ((await git.status(nestedDir)).trim().length > 0) {
+				const msg = (await commitMessage?.(combinedDiff)) ?? "changes from isolated task(s)";
+				await git.stage.files(nestedDir);
+				await git.commit(nestedDir, msg);
+			}
+		} finally {
+			if (stashed) {
+				try {
+					await git.stash.pop(nestedDir, { index: true });
+				} catch (popErr) {
+					const message = popErr instanceof Error ? popErr.message : String(popErr);
+					logger.warn("Pre-existing nested-repo dirty state could not be auto-restored", {
+						nestedDir,
+						error: message,
+					});
+					warnings.push(
+						`Pre-existing dirty state in nested repo \`${relativePath}\` could not be auto-restored after the agent commit; stash entry preserved (${message}).`,
+					);
+				}
+			}
 		}
 	}
+	return warnings;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════

package/src/thinking.ts

@@ -153,6 +153,26 @@ export function getConfiguredThinkingLevelMetadata(level: ConfiguredThinkingLeve
 	return level === AUTO_THINKING ? AUTO_THINKING_METADATA : getThinkingLevelMetadata(level);
 }
 
+/**
+ * Thinking selectors accepted by the `--thinking` CLI flag, in display order:
+ * `off`, every concrete effort (`minimal`..`xhigh`), then `auto`. Single source
+ * for the flag's `options` list, shell completions, and the "invalid level"
+ * warning so all three stay in sync.
+ */
+export const CLI_THINKING_LEVELS: readonly string[] = [ThinkingLevel.Off, ...THINKING_EFFORTS, AUTO_THINKING];
+
+/**
+ * Parses a `--thinking` CLI value. Accepts every {@link parseConfiguredThinkingLevel}
+ * selector (`off`, `auto`, `minimal`..`xhigh`, plus the `max` alias) but rejects
+ * `inherit`: an explicit `inherit` on the command line would suppress the
+ * settings/scoped-model fallback during startup resolution only to resolve back
+ * to the provider default, which is never what the user means.
+ */
+export function parseCliThinkingLevel(value: string | null | undefined): ConfiguredThinkingLevel | undefined {
+	const level = parseConfiguredThinkingLevel(value);
+	return level === ThinkingLevel.Inherit ? undefined : level;
+}
+
 /**
  * Resolves an auto-classified effort against the active model's supported
  * range. Unlike {@link clampThinkingLevelForModel}, `auto` never resolves below
@@ -160,10 +180,17 @@ export function getConfiguredThinkingLevelMetadata(level: ConfiguredThinkingLeve
  * above Low (falling back to the full supported set only when the model maxes
  * out below Low). Within that pool the request snaps to the highest level not
  * exceeding it, or the pool minimum when the request is below the pool.
+ *
+ * Returns `undefined` for reasoning-capable models without a controllable
+ * effort surface (`thinking.efforts` empty — e.g. devin-agent models, where
+ * Cascade selects effort by routing to sibling model ids). Matches
+ * {@link clampThinkingLevelForModel}: with no effort to pick, `auto` must not
+ * forward a concrete effort that would then trip {@link requireSupportedEffort}
+ * downstream.
  */
-export function clampAutoThinkingEffort(model: Model | undefined, effort: Effort): Effort {
+export function clampAutoThinkingEffort(model: Model | undefined, effort: Effort): Effort | undefined {
 	const supported = model ? getSupportedEfforts(model) : THINKING_EFFORTS;
-	if (supported.length === 0) return effort;
+	if (supported.length === 0) return undefined;
 	const lowIndex = THINKING_EFFORTS.indexOf(Effort.Low);
 	const eligible = supported.filter(level => THINKING_EFFORTS.indexOf(level) >= lowIndex);
 	const pool = eligible.length > 0 ? eligible : supported;