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

package/src/task/executor.ts

@@ -6,12 +6,12 @@
 import path from "node:path";
 import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { SearchDb } from "@oh-my-pi/pi-natives";
-import { logger, untilAborted } from "@oh-my-pi/pi-utils";
+import { logger, prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
 import Ajv, { type ValidateFunction } from "ajv";
 import { ModelRegistry } from "../config/model-registry";
 import { resolveModelOverride } from "../config/model-resolver";
-import { type PromptTemplate, renderPromptTemplate } from "../config/prompt-templates";
+import type { PromptTemplate } from "../config/prompt-templates";
 import { Settings } from "../config/settings";
 import { SETTINGS_SCHEMA, type SettingPath } from "../config/settings-schema";
 import type { CustomTool } from "../extensibility/custom-tools/types";
@@ -38,6 +38,7 @@ import {
 	type ReviewFinding,
 	type SingleResult,
 	TASK_SUBAGENT_EVENT_CHANNEL,
+	TASK_SUBAGENT_LIFECYCLE_CHANNEL,
 	TASK_SUBAGENT_PROGRESS_CHANNEL,
 } from "./types";
 
@@ -630,6 +631,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				task,
 				assignment,
 				progress: { ...progress },
+				sessionFile: subtaskSessionFile,
 			});
 		}
 		lastProgressEmitMs = Date.now();
@@ -963,7 +965,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				skills: options.skills,
 				promptTemplates: options.promptTemplates,
 				systemPrompt: defaultPrompt =>
-					renderPromptTemplate(subagentSystemPromptTemplate, {
+					prompt.render(subagentSystemPromptTemplate, {
 						base: defaultPrompt,
 						agent: agent.systemPrompt,
 						worktree: worktree ?? "",
@@ -983,6 +985,19 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 			activeSession = session;
 
+			// Emit lifecycle start event
+			if (options.eventBus) {
+				options.eventBus.emit(TASK_SUBAGENT_LIFECYCLE_CHANNEL, {
+					id,
+					agent: agent.name,
+					agentSource: agent.source,
+					description: options.description,
+					status: "started",
+					sessionFile: subtaskSessionFile,
+					index,
+				});
+			}
+
 			const subagentToolNames = session.getActiveToolNames();
 			const parentOwnedToolNames = new Set(["todo_write"]);
 			const filteredSubagentTools = subagentToolNames.filter(name => !parentOwnedToolNames.has(name));
@@ -1091,7 +1106,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			while (!submitResultCalled && retryCount < MAX_SUBMIT_RESULT_RETRIES && !abortSignal.aborted) {
 				try {
 					retryCount++;
-					const reminder = renderPromptTemplate(submitReminderTemplate, {
+					const reminder = prompt.render(submitReminderTemplate, {
 						retryCount,
 						maxRetries: MAX_SUBMIT_RESULT_RETRIES,
 					});
@@ -1238,6 +1253,19 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	progress.status = wasAborted ? "aborted" : exitCode === 0 ? "completed" : "failed";
 	scheduleProgress(true);
 
+	// Emit lifecycle end event after finalization so submit_result status is reflected
+	if (options.eventBus) {
+		options.eventBus.emit(TASK_SUBAGENT_LIFECYCLE_CHANNEL, {
+			id,
+			agent: agent.name,
+			agentSource: agent.source,
+			description: options.description,
+			status: progress.status as "completed" | "failed" | "aborted",
+			sessionFile: subtaskSessionFile,
+			index,
+		});
+	}
+
 	return {
 		index,
 		id,

package/src/task/index.ts

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

package/src/task/template.ts

@@ -1,4 +1,4 @@
-import { renderPromptTemplate } from "../config/prompt-templates";
+import { prompt } from "@oh-my-pi/pi-utils";
 import subagentUserPromptTemplate from "../prompts/system/subagent-user-prompt.md" with { type: "text" };
 import type { TaskItem } from "./types";
 
@@ -25,7 +25,7 @@ export function renderTemplate(context: string | undefined, task: TaskItem): Ren
 		return { task: assignment || context!, assignment: assignment || context!, id, description };
 	}
 	return {
-		task: renderPromptTemplate(subagentUserPromptTemplate, { context, assignment }),
+		task: prompt.render(subagentUserPromptTemplate, { context, assignment }),
 		assignment,
 		id,
 		description,

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({