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

package/src/task/types.ts

@@ -31,6 +31,31 @@ export const TASK_SUBAGENT_EVENT_CHANNEL = "task:subagent:event";
 /** EventBus channel for aggregated subagent progress */
 export const TASK_SUBAGENT_PROGRESS_CHANNEL = "task:subagent:progress";
 
+/** EventBus channel for subagent lifecycle (start/end) */
+export const TASK_SUBAGENT_LIFECYCLE_CHANNEL = "task:subagent:lifecycle";
+
+/** Payload emitted on TASK_SUBAGENT_PROGRESS_CHANNEL */
+export interface SubagentProgressPayload {
+	index: number;
+	agent: string;
+	agentSource: AgentSource;
+	task: string;
+	assignment?: string;
+	progress: AgentProgress;
+	sessionFile?: string;
+}
+
+/** Payload emitted on TASK_SUBAGENT_LIFECYCLE_CHANNEL */
+export interface SubagentLifecyclePayload {
+	id: string;
+	agent: string;
+	agentSource: AgentSource;
+	description?: string;
+	status: "started" | "completed" | "failed" | "aborted";
+	sessionFile?: string;
+	index: number;
+}
+
 /** Single task item for parallel execution */
 export const taskItemSchema = Type.Object({
 	id: Type.String({

package/src/task/worktree.ts

@@ -1,10 +1,11 @@
 import type { Dirent } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
-import path from "node:path";
+import * as path from "node:path";
 import { projfsOverlayStart, projfsOverlayStop } from "@oh-my-pi/pi-natives";
 import { getWorktreeDir, isEnoent, logger, Snowflake } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
+import * as git from "../utils/git";
 
 /** Baseline state for a single git repository. */
 export interface RepoBaseline {
@@ -27,14 +28,11 @@ export function getEncodedProjectName(cwd: string): string {
 }
 
 export async function getRepoRoot(cwd: string): Promise<string> {
-	const result = await $`git rev-parse --show-toplevel`.cwd(cwd).quiet().nothrow();
-	if (result.exitCode !== 0) {
-		throw new Error("Git repository not found for isolated task execution.");
-	}
-	const repoRoot = result.text().trim();
+	const repoRoot = await git.repo.root(cwd);
 	if (!repoRoot) {
-		throw new Error("Git repository root could not be resolved for isolated task execution.");
+		throw new Error("Git repository not found for isolated task execution.");
 	}
+
 	return repoRoot;
 }
 
@@ -54,26 +52,16 @@ export async function ensureWorktree(baseCwd: string, id: string): Promise<strin
 	const encodedProject = getEncodedProjectName(repoRoot);
 	const worktreeDir = getWorktreeDir(encodedProject, id);
 	await fs.mkdir(path.dirname(worktreeDir), { recursive: true });
-	await $`git worktree remove -f ${worktreeDir}`.cwd(repoRoot).quiet().nothrow();
+	await git.worktree.tryRemove(repoRoot, worktreeDir);
 	await fs.rm(worktreeDir, { recursive: true, force: true });
-	await $`git worktree add --detach ${worktreeDir} HEAD`.cwd(repoRoot).quiet();
+	await git.worktree.add(repoRoot, worktreeDir, "HEAD", { detach: true });
 	return worktreeDir;
 }
 
 /** Find nested git repositories (non-submodule) under the given root. */
 async function discoverNestedRepos(repoRoot: string): Promise<string[]> {
 	// Get submodule paths so we can exclude them
-	const submoduleRaw = await $`git submodule --quiet foreach --recursive 'echo $sm_path'`
-		.cwd(repoRoot)
-		.quiet()
-		.nothrow()
-		.text();
-	const submodulePaths = new Set(
-		submoduleRaw
-			.split("\n")
-			.map(l => l.trim())
-			.filter(Boolean),
-	);
+	const submodulePaths = new Set(await git.ls.submodules(repoRoot));
 
 	// Find all .git dirs/files that aren't the root or known submodules
 	const result: string[] = [];
@@ -109,14 +97,10 @@ async function discoverNestedRepos(repoRoot: string): Promise<string[]> {
 }
 
 async function captureRepoBaseline(repoRoot: string): Promise<RepoBaseline> {
-	const headCommit = (await $`git rev-parse HEAD`.cwd(repoRoot).quiet().text()).trim();
-	const staged = await $`git diff --cached --binary`.cwd(repoRoot).quiet().text();
-	const unstaged = await $`git diff --binary`.cwd(repoRoot).quiet().text();
-	const untrackedRaw = await $`git ls-files --others --exclude-standard`.cwd(repoRoot).quiet().text();
-	const untracked = untrackedRaw
-		.split("\n")
-		.map(line => line.trim())
-		.filter(line => line.length > 0);
+	const headCommit = (await git.head.sha(repoRoot)) ?? "";
+	const staged = await git.diff(repoRoot, { binary: true, cached: true });
+	const unstaged = await git.diff(repoRoot, { binary: true });
+	const untracked = await git.ls.untracked(repoRoot);
 	return { repoRoot, headCommit, staged, unstaged, untracked };
 }
 
@@ -131,35 +115,10 @@ export async function captureBaseline(repoRoot: string): Promise<WorktreeBaselin
 	return { root, nested };
 }
 
-async function writeTempPatchFile(patch: string): Promise<string> {
-	const tempPath = path.join(os.tmpdir(), `omp-task-patch-${Snowflake.next()}.patch`);
-	await Bun.write(tempPath, patch);
-	return tempPath;
-}
-
-async function applyPatch(
-	cwd: string,
-	patch: string,
-	options?: { cached?: boolean; env?: Record<string, string> },
-): Promise<void> {
-	if (!patch.trim()) return;
-	const tempPath = await writeTempPatchFile(patch);
-	try {
-		const command = options?.cached ? $`git apply --cached --binary ${tempPath}` : $`git apply --binary ${tempPath}`;
-		let runner = command.cwd(cwd).quiet();
-		if (options?.env) {
-			runner = runner.env(options.env);
-		}
-		await runner;
-	} finally {
-		await fs.rm(tempPath, { force: true });
-	}
-}
-
 async function applyRepoBaseline(worktreeDir: string, rb: RepoBaseline, sourceRoot: string): Promise<void> {
-	await applyPatch(worktreeDir, rb.staged, { cached: true });
-	await applyPatch(worktreeDir, rb.staged);
-	await applyPatch(worktreeDir, rb.unstaged);
+	await git.patch.applyText(worktreeDir, rb.staged, { cached: true });
+	await git.patch.applyText(worktreeDir, rb.staged);
+	await git.patch.applyText(worktreeDir, rb.unstaged);
 
 	for (const entry of rb.untracked) {
 		const source = path.join(sourceRoot, entry);
@@ -193,15 +152,12 @@ export async function applyBaseline(worktreeDir: string, baseline: WorktreeBasel
 		// Commit baseline state so captureRepoDeltaPatch can cleanly subtract it.
 		// Without this, `git add -A && git commit` by the task would include
 		// baseline untracked files in the diff-tree output.
-		const hasChanges = (
-			await $`git --no-optional-locks status --porcelain`.cwd(nestedDir).quiet().nothrow().text()
-		).trim();
-		if (hasChanges) {
-			await $`git add -A`.cwd(nestedDir).quiet();
-			await $`git commit -m omp-baseline --allow-empty`.cwd(nestedDir).quiet();
+		if ((await git.status(nestedDir)).trim().length > 0) {
+			await git.stage.files(nestedDir);
+			await git.commit(nestedDir, "omp-baseline", { allowEmpty: true });
 			// Update baseline to reflect the committed state — prevents double-apply
 			// in captureRepoDeltaPatch's temp-index path
-			entry.baseline.headCommit = (await $`git rev-parse HEAD`.cwd(nestedDir).quiet().text()).trim();
+			entry.baseline.headCommit = (await git.head.sha(nestedDir)) ?? "";
 			entry.baseline.staged = "";
 			entry.baseline.unstaged = "";
 			entry.baseline.untracked = [];
@@ -209,32 +165,9 @@ export async function applyBaseline(worktreeDir: string, baseline: WorktreeBasel
 	}
 }
 
-async function applyPatchToIndex(cwd: string, patch: string, indexFile: string): Promise<void> {
-	if (!patch.trim()) return;
-	const tempPath = await writeTempPatchFile(patch);
-	try {
-		await $`git apply --cached --binary ${tempPath}`
-			.cwd(cwd)
-			.env({
-				GIT_INDEX_FILE: indexFile,
-			})
-			.quiet();
-	} finally {
-		await fs.rm(tempPath, { force: true });
-	}
-}
-
-async function listUntracked(cwd: string): Promise<string[]> {
-	const raw = await $`git ls-files --others --exclude-standard`.cwd(cwd).quiet().text();
-	return raw
-		.split("\n")
-		.map(line => line.trim())
-		.filter(line => line.length > 0);
-}
-
 async function captureRepoDeltaPatch(repoDir: string, rb: RepoBaseline): Promise<string> {
 	// Check if HEAD advanced (task committed changes)
-	const currentHead = (await $`git rev-parse HEAD`.cwd(repoDir).quiet().nothrow().text()).trim();
+	const currentHead = (await git.head.sha(repoDir)) ?? "";
 	const headAdvanced = currentHead && currentHead !== rb.headCommit;
 
 	if (headAdvanced) {
@@ -242,28 +175,31 @@ async function captureRepoDeltaPatch(repoDir: string, rb: RepoBaseline): Promise
 		const parts: string[] = [];
 
 		// Committed changes since baseline
-		const committedDiff = await $`git diff-tree -r -p --binary ${rb.headCommit} ${currentHead}`
-			.cwd(repoDir)
-			.quiet()
-			.nothrow()
-			.text();
+		const committedDiff = await git.diff.tree(repoDir, rb.headCommit, currentHead, {
+			allowFailure: true,
+			binary: true,
+		});
 		if (committedDiff.trim()) parts.push(committedDiff);
 
 		// Uncommitted changes on top of the new HEAD
-		const staged = await $`git diff --cached --binary`.cwd(repoDir).quiet().text();
-		const unstaged = await $`git diff --binary`.cwd(repoDir).quiet().text();
+		const staged = await git.diff(repoDir, { binary: true, cached: true });
+		const unstaged = await git.diff(repoDir, { binary: true });
 		if (staged.trim()) parts.push(staged);
 		if (unstaged.trim()) parts.push(unstaged);
 
 		// New untracked files (relative to both baseline and current tracking)
-		const currentUntracked = await listUntracked(repoDir);
+		const currentUntracked = await git.ls.untracked(repoDir);
 		const baselineUntracked = new Set(rb.untracked);
 		const newUntracked = currentUntracked.filter(entry => !baselineUntracked.has(entry));
 		if (newUntracked.length > 0) {
 			const nullPath = getGitNoIndexNullPath();
 			const untrackedDiffs = await Promise.all(
 				newUntracked.map(entry =>
-					$`git diff --binary --no-index ${nullPath} ${entry}`.cwd(repoDir).quiet().nothrow().text(),
+					git.diff(repoDir, {
+						allowFailure: true,
+						binary: true,
+						noIndex: { left: nullPath, right: entry },
+					}),
 				),
 			);
 			parts.push(...untrackedDiffs.filter(d => d.trim()));
@@ -275,12 +211,23 @@ async function captureRepoDeltaPatch(repoDir: string, rb: RepoBaseline): Promise
 	// HEAD unchanged: use temp index approach (subtracts baseline from delta)
 	const tempIndex = path.join(os.tmpdir(), `omp-task-index-${Snowflake.next()}`);
 	try {
-		await $`git read-tree ${rb.headCommit}`.cwd(repoDir).env({ GIT_INDEX_FILE: tempIndex });
-		await applyPatchToIndex(repoDir, rb.staged, tempIndex);
-		await applyPatchToIndex(repoDir, rb.unstaged, tempIndex);
-		const diff = await $`git diff --binary`.cwd(repoDir).env({ GIT_INDEX_FILE: tempIndex }).quiet().text();
-
-		const currentUntracked = await listUntracked(repoDir);
+		await git.readTree(repoDir, rb.headCommit, {
+			env: { GIT_INDEX_FILE: tempIndex },
+		});
+		await git.patch.applyText(repoDir, rb.staged, {
+			cached: true,
+			env: { GIT_INDEX_FILE: tempIndex },
+		});
+		await git.patch.applyText(repoDir, rb.unstaged, {
+			cached: true,
+			env: { GIT_INDEX_FILE: tempIndex },
+		});
+		const diff = await git.diff(repoDir, {
+			binary: true,
+			env: { GIT_INDEX_FILE: tempIndex },
+		});
+
+		const currentUntracked = await git.ls.untracked(repoDir);
 		const baselineUntracked = new Set(rb.untracked);
 		const newUntracked = currentUntracked.filter(entry => !baselineUntracked.has(entry));
 
@@ -289,7 +236,11 @@ async function captureRepoDeltaPatch(repoDir: string, rb: RepoBaseline): Promise
 		const nullPath = getGitNoIndexNullPath();
 		const untrackedDiffs = await Promise.all(
 			newUntracked.map(entry =>
-				$`git diff --binary --no-index ${nullPath} ${entry}`.cwd(repoDir).quiet().nothrow().text(),
+				git.diff(repoDir, {
+					allowFailure: true,
+					binary: true,
+					noIndex: { left: nullPath, right: entry },
+				}),
 			),
 		);
 		return `${diff}${diff && !diff.endsWith("\n") ? "\n" : ""}${untrackedDiffs.join("\n")}`;
@@ -355,29 +306,25 @@ export async function applyNestedPatches(
 
 		const combinedDiff = repoPatches.map(p => p.patch).join("\n");
 		for (const { patch } of repoPatches) {
-			await applyPatch(nestedDir, patch);
+			await git.patch.applyText(nestedDir, patch);
 		}
 
 		// Commit so nested repo history reflects the task changes
-		const hasChanges = (
-			await $`git --no-optional-locks status --porcelain`.cwd(nestedDir).quiet().nothrow().text()
-		).trim();
-		if (hasChanges) {
+		if ((await git.status(nestedDir)).trim().length > 0) {
 			const msg = (await commitMessage?.(combinedDiff)) ?? "changes from isolated task(s)";
-			await $`git add -A`.cwd(nestedDir).quiet();
-			await $`git commit -m ${msg}`.cwd(nestedDir).quiet();
+			await git.stage.files(nestedDir);
+			await git.commit(nestedDir, msg);
 		}
 	}
 }
 
 export async function cleanupWorktree(dir: string): Promise<void> {
 	try {
-		const commonDirRaw = await $`git rev-parse --git-common-dir`.cwd(dir).quiet().nothrow().text();
-		const commonDir = commonDirRaw.trim();
-		if (commonDir) {
-			const resolvedCommon = path.resolve(dir, commonDir);
-			const repoRoot = path.dirname(resolvedCommon);
-			await $`git worktree remove -f ${dir}`.cwd(repoRoot).quiet().nothrow();
+		const repository = await git.repo.resolve(dir);
+		const commonDir = repository?.commonDir ?? "";
+		if (commonDir && path.basename(commonDir) === ".git") {
+			const repoRoot = path.dirname(commonDir);
+			await git.worktree.tryRemove(repoRoot, dir);
 		}
 	} finally {
 		await fs.rm(dir, { recursive: true, force: true });
@@ -518,33 +465,31 @@ export async function commitToBranch(
 
 	// Only create a branch if the root repo has changes
 	if (rootPatch.trim()) {
-		await $`git branch ${branchName} HEAD`.cwd(repoRoot).quiet();
+		await git.branch.create(repoRoot, branchName);
 		const tmpDir = path.join(os.tmpdir(), `omp-branch-${Snowflake.next()}`);
 		try {
-			await $`git worktree add ${tmpDir} ${branchName}`.cwd(repoRoot).quiet();
-			const patchPath = path.join(os.tmpdir(), `omp-branch-patch-${Snowflake.next()}.patch`);
+			await git.worktree.add(repoRoot, tmpDir, branchName);
 			try {
-				await Bun.write(patchPath, rootPatch);
-				const applyResult = await $`git apply --binary ${patchPath}`.cwd(tmpDir).quiet().nothrow();
-				if (applyResult.exitCode !== 0) {
-					const stderr = applyResult.stderr.toString().slice(0, 2000);
+				await git.patch.applyText(tmpDir, rootPatch);
+			} catch (err) {
+				if (err instanceof git.GitCommandError) {
+					const stderr = err.result.stderr.slice(0, 2000);
 					logger.error("commitToBranch: git apply failed", {
 						taskId,
-						exitCode: applyResult.exitCode,
+						exitCode: err.result.exitCode,
 						stderr,
 						patchSize: rootPatch.length,
 						patchHead: rootPatch.slice(0, 500),
 					});
 					throw new Error(`git apply failed for task ${taskId}: ${stderr}`);
 				}
-			} finally {
-				await fs.rm(patchPath, { force: true });
+				throw err;
 			}
-			await $`git add -A`.cwd(tmpDir).quiet();
+			await git.stage.files(tmpDir);
 			const msg = (commitMessage && (await commitMessage(rootPatch))) || fallbackMessage;
-			await $`git commit -m ${msg}`.cwd(tmpDir).quiet();
+			await git.commit(tmpDir, msg);
 		} finally {
-			await $`git worktree remove -f ${tmpDir}`.cwd(repoRoot).quiet().nothrow();
+			await git.worktree.tryRemove(repoRoot, tmpDir);
 			await fs.rm(tmpDir, { recursive: true, force: true });
 		}
 	}
@@ -570,29 +515,66 @@ export async function mergeTaskBranches(
 	const merged: string[] = [];
 	const failed: string[] = [];
 
-	for (const { branchName } of branches) {
-		const result = await $`git cherry-pick ${branchName}`.cwd(repoRoot).quiet().nothrow();
-
-		if (result.exitCode !== 0) {
-			await $`git cherry-pick --abort`.cwd(repoRoot).quiet().nothrow();
-			const stderr = result.stderr.toString().trim();
-			failed.push(branchName);
-			return {
-				merged,
-				failed: [...failed, ...branches.slice(merged.length + failed.length).map(b => b.branchName)],
-				conflict: `${branchName}: ${stderr}`,
-			};
-		}
+	// Stash dirty working tree so cherry-pick can operate on a clean HEAD.
+	// Without this, cherry-pick refuses to run when uncommitted changes exist.
+	const didStash = await git.stash.push(repoRoot, "omp-task-merge");
+
+	let conflictResult: MergeBranchResult | undefined;
 
-		merged.push(branchName);
+	try {
+		for (const { branchName } of branches) {
+			try {
+				await git.cherryPick(repoRoot, branchName);
+			} catch (err) {
+				try {
+					await git.cherryPick.abort(repoRoot);
+				} catch {
+					/* no state to abort */
+				}
+				const stderr =
+					err instanceof git.GitCommandError
+						? err.result.stderr.trim()
+						: err instanceof Error
+							? err.message
+							: String(err);
+				failed.push(branchName);
+				conflictResult = {
+					merged,
+					failed: [...failed, ...branches.slice(merged.length + failed.length).map(b => b.branchName)],
+					conflict: `${branchName}: ${stderr}`,
+				};
+				break;
+			}
+
+			merged.push(branchName);
+		}
+	} finally {
+		if (didStash) {
+			try {
+				await git.stash.pop(repoRoot, { index: true });
+			} catch {
+				// Stash-pop conflicts mean the replayed changes clash with the user's
+				// uncommitted edits. Treat this as a merge failure so the caller preserves
+				// recovery branches instead of reporting success and deleting them.
+				logger.warn("Failed to restore stashed changes after task merge; stash entry preserved");
+				if (!conflictResult) {
+					conflictResult = {
+						merged,
+						failed: merged,
+						conflict:
+							"stash pop: cherry-picked changes conflict with uncommitted edits. Run `git stash pop` and resolve manually.",
+					};
+				}
+			}
+		}
 	}
 
-	return { merged, failed };
+	return conflictResult ?? { merged, failed };
 }
 
 /** Clean up temporary task branches. */
 export async function cleanupTaskBranches(repoRoot: string, branches: string[]): Promise<void> {
 	for (const branch of branches) {
-		await $`git branch -D ${branch}`.cwd(repoRoot).quiet().nothrow();
+		await git.branch.tryDelete(repoRoot, branch);
 	}
 }

package/src/tools/exit-plan-mode.ts

@@ -46,6 +46,7 @@ export class ExitPlanModeTool implements AgentTool<typeof exitPlanModeSchema, Ex
 	readonly description: string;
 	readonly parameters = exitPlanModeSchema;
 	readonly strict = true;
+	readonly concurrency = "exclusive";
 
 	constructor(private readonly session: ToolSession) {
 		this.description = renderPromptTemplate(exitPlanModeDescription);