@oh-my-pi/pi-coding-agent 8.4.3 → 8.5.0

package/src/task/executor.ts

@@ -75,6 +75,7 @@ export interface ExecutorOptions {
 	eventBus?: EventBus;
 	contextFiles?: ContextFileEntry[];
 	skills?: Skill[];
+	preloadedSkills?: Skill[];
 	promptTemplates?: PromptTemplate[];
 	mcpManager?: MCPManager;
 	authStorage?: AuthStorage;
@@ -361,6 +362,8 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 	const outputChunks: string[] = [];
 	const finalOutputChunks: string[] = [];
+	const RECENT_OUTPUT_TAIL_BYTES = 8 * 1024;
+	let recentOutputTail = "";
 	let stderr = "";
 	let resolved = false;
 	type AbortReason = "signal" | "terminate";
@@ -513,7 +516,11 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		signal.addEventListener("abort", onAbort, { once: true, signal: listenerSignal });
 	}
 
-	const emitProgress = () => {
+	const PROGRESS_COALESCE_MS = 150;
+	let lastProgressEmitMs = 0;
+	let progressTimeoutId: ReturnType<typeof setTimeout> | null = null;
+
+	const emitProgressNow = () => {
 		progress.durationMs = Date.now() - startTime;
 		onProgress?.({ ...progress });
 		if (options.eventBus) {
@@ -525,6 +532,33 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				progress: { ...progress },
 			});
 		}
+		lastProgressEmitMs = Date.now();
+	};
+
+	const scheduleProgress = (flush = false) => {
+		if (flush) {
+			if (progressTimeoutId) {
+				clearTimeout(progressTimeoutId);
+				progressTimeoutId = null;
+			}
+			emitProgressNow();
+			return;
+		}
+		const now = Date.now();
+		const elapsed = now - lastProgressEmitMs;
+		if (lastProgressEmitMs === 0 || elapsed >= PROGRESS_COALESCE_MS) {
+			if (progressTimeoutId) {
+				clearTimeout(progressTimeoutId);
+				progressTimeoutId = null;
+			}
+			emitProgressNow();
+			return;
+		}
+		if (progressTimeoutId) return;
+		progressTimeoutId = setTimeout(() => {
+			progressTimeoutId = null;
+			emitProgressNow();
+		}, PROGRESS_COALESCE_MS - elapsed);
 	};
 
 	const getMessageContent = (message: unknown): unknown => {
@@ -541,6 +575,40 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		return undefined;
 	};
 
+	const updateRecentOutputLines = () => {
+		const lines = recentOutputTail.split("\n").filter(line => line.trim());
+		progress.recentOutput = lines.slice(-8).reverse();
+	};
+
+	const appendRecentOutputTail = (text: string) => {
+		if (!text) return;
+		recentOutputTail += text;
+		if (recentOutputTail.length > RECENT_OUTPUT_TAIL_BYTES) {
+			recentOutputTail = recentOutputTail.slice(-RECENT_OUTPUT_TAIL_BYTES);
+		}
+		updateRecentOutputLines();
+	};
+
+	const replaceRecentOutputFromContent = (content: unknown[]) => {
+		recentOutputTail = "";
+		for (const block of content) {
+			if (!block || typeof block !== "object") continue;
+			const record = block as { type?: unknown; text?: unknown };
+			if (record.type !== "text" || typeof record.text !== "string") continue;
+			if (!record.text) continue;
+			recentOutputTail += record.text;
+			if (recentOutputTail.length > RECENT_OUTPUT_TAIL_BYTES) {
+				recentOutputTail = recentOutputTail.slice(-RECENT_OUTPUT_TAIL_BYTES);
+			}
+		}
+		updateRecentOutputLines();
+	};
+
+	const resetRecentOutput = () => {
+		recentOutputTail = "";
+		progress.recentOutput = [];
+	};
+
 	const processEvent = (event: AgentEvent) => {
 		if (resolved) return;
 
@@ -555,8 +623,15 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		}
 
 		const now = Date.now();
+		let flushProgress = false;
 
 		switch (event.type) {
+			case "message_start":
+				if (event.message?.role === "assistant") {
+					resetRecentOutput();
+				}
+				break;
+
 			case "tool_execution_start":
 				progress.toolCount++;
 				progress.currentTool = event.toolName;
@@ -616,23 +691,28 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						schedulePendingTermination();
 					}
 				}
+				flushProgress = true;
 				break;
 			}
 
 			case "message_update": {
-				// Extract text for progress display only (replace, don't accumulate)
+				if (event.message?.role !== "assistant") break;
+				const assistantEvent = (
+					event as AgentEvent & {
+						assistantMessageEvent?: { type?: string; delta?: string };
+					}
+				).assistantMessageEvent;
+				if (assistantEvent?.type === "text_delta" && typeof assistantEvent.delta === "string") {
+					appendRecentOutputTail(assistantEvent.delta);
+					break;
+				}
+				if (assistantEvent && assistantEvent.type !== "text_delta") {
+					break;
+				}
 				const updateContent =
 					getMessageContent(event.message) || (event as AgentEvent & { content?: unknown }).content;
 				if (updateContent && Array.isArray(updateContent)) {
-					const allText: string[] = [];
-					for (const block of updateContent) {
-						if (block.type === "text" && block.text) {
-							const lines = block.text.split("\n").filter((l: string) => l.trim());
-							allText.push(...lines);
-						}
-					}
-					// Show last 8 lines from current state (not accumulated)
-					progress.recentOutput = allText.slice(-8).reverse();
+					replaceRecentOutputFromContent(updateContent);
 				}
 				break;
 			}
@@ -698,10 +778,11 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						}
 					}
 				}
+				flushProgress = true;
 				break;
 		}
 
-		emitProgress();
+		scheduleProgress(flushProgress);
 	};
 
 	const startMessage: SubagentWorkerRequest = {
@@ -724,6 +805,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			pythonPreludeDocs: pythonPreludeDocsPayload,
 			contextFiles: options.contextFiles,
 			skills: options.skills,
+			preloadedSkills: options.preloadedSkills,
 			promptTemplates: options.promptTemplates,
 			mcpTools: options.mcpManager ? extractMCPToolMetadata(options.mcpManager) : undefined,
 			pythonToolProxy: pythonProxyEnabled,
@@ -972,6 +1054,10 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		clearTimeout(terminationTimeoutId);
 		terminationTimeoutId = null;
 	}
+	if (progressTimeoutId) {
+		clearTimeout(progressTimeoutId);
+		progressTimeoutId = null;
+	}
 	cancelPendingTermination();
 	if (!terminated) {
 		terminated = true;
@@ -1066,7 +1152,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	// Update final progress
 	const wasAborted = abortedViaComplete || (!hasComplete && (done.aborted || signal?.aborted || false));
 	progress.status = wasAborted ? "aborted" : exitCode === 0 ? "completed" : "failed";
-	emitProgress();
+	scheduleProgress(true);
 
 	return {
 		index,

package/src/task/index.ts

@@ -391,12 +391,57 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			// Build full prompts with context prepended
 			const tasksWithContext = tasksWithUniqueIds.map(t => renderTemplate(context, t));
 			const contextFiles = this.session.contextFiles;
-			const skills = this.session.skills;
+			const availableSkills = this.session.skills;
+			const availableSkillList = availableSkills ?? [];
 			const promptTemplates = this.session.promptTemplates;
+			const skillLookup = new Map(availableSkillList.map(skill => [skill.name, skill]));
+			const missingSkillsByTask: Array<{ id: string; missing: string[] }> = [];
+			const tasksWithSkills = tasksWithContext.map(task => {
+				if (task.skills === undefined) {
+					return { ...task, resolvedSkills: availableSkills, preloadedSkills: undefined };
+				}
+				const requested = task.skills;
+				const resolved = [] as typeof availableSkillList;
+				const missing: string[] = [];
+				const seen = new Set<string>();
+				for (const name of requested) {
+					const trimmed = name.trim();
+					if (!trimmed || seen.has(trimmed)) continue;
+					seen.add(trimmed);
+					const skill = skillLookup.get(trimmed);
+					if (skill) {
+						resolved.push(skill);
+					} else {
+						missing.push(trimmed);
+					}
+				}
+				if (missing.length > 0) {
+					missingSkillsByTask.push({ id: task.id, missing });
+				}
+				return { ...task, resolvedSkills: resolved, preloadedSkills: resolved };
+			});
+
+			if (missingSkillsByTask.length > 0) {
+				const available = availableSkillList.map(skill => skill.name).join(", ") || "none";
+				const details = missingSkillsByTask.map(entry => `${entry.id}: ${entry.missing.join(", ")}`).join("; ");
+				return {
+					content: [
+						{
+							type: "text",
+							text: `Unknown skills requested: ${details}. Available skills: ${available}`,
+						},
+					],
+					details: {
+						projectAgentsDir,
+						results: [],
+						totalDurationMs: Date.now() - startTime,
+					},
+				};
+			}
 
 			// Initialize progress for all tasks
-			for (let i = 0; i < tasksWithContext.length; i++) {
-				const t = tasksWithContext[i];
+			for (let i = 0; i < tasksWithSkills.length; i++) {
+				const t = tasksWithSkills[i];
 				progressMap.set(i, {
 					index: i,
 					id: t.id,
@@ -416,7 +461,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			}
 			emitProgress();
 
-			const runTask = async (task: (typeof tasksWithContext)[number], index: number) => {
+			const runTask = async (task: (typeof tasksWithSkills)[number], index: number) => {
 				if (!isIsolated) {
 					return runSubprocess({
 						cwd: this.session.cwd,
@@ -438,7 +483,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						onProgress: progress => {
 							progressMap.set(index, {
 								...structuredClone(progress),
-								args: tasksWithContext[index]?.args,
+								args: tasksWithSkills[index]?.args,
 							});
 							emitProgress();
 						},
@@ -447,7 +492,8 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						settingsManager: this.session.settingsManager,
 						mcpManager: this.session.mcpManager,
 						contextFiles,
-						skills,
+						skills: task.resolvedSkills,
+						preloadedSkills: task.preloadedSkills,
 						promptTemplates,
 					});
 				}
@@ -481,7 +527,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						onProgress: progress => {
 							progressMap.set(index, {
 								...structuredClone(progress),
-								args: tasksWithContext[index]?.args,
+								args: tasksWithSkills[index]?.args,
 							});
 							emitProgress();
 						},
@@ -490,7 +536,8 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						settingsManager: this.session.settingsManager,
 						mcpManager: this.session.mcpManager,
 						contextFiles,
-						skills,
+						skills: task.resolvedSkills,
+						preloadedSkills: task.preloadedSkills,
 						promptTemplates,
 					});
 					const patch = await captureDeltaPatch(worktreeDir, baseline);
@@ -527,7 +574,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 
 			// Execute in parallel with concurrency limit
 			const { results: partialResults, aborted } = await mapWithConcurrencyLimit(
-				tasksWithContext,
+				tasksWithSkills,
 				MAX_CONCURRENCY,
 				runTask,
 				signal,
@@ -538,10 +585,10 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 				if (result !== undefined) {
 					return {
 						...result,
-						args: tasksWithContext[index]?.args,
+						args: tasksWithSkills[index]?.args,
 					};
 				}
-				const task = tasksWithContext[index];
+				const task = tasksWithSkills[index];
 				return {
 					index,
 					id: task.id,

package/src/task/template.ts

@@ -5,10 +5,11 @@ type RenderResult = {
 	args: Record<string, string>;
 	id: string;
 	description: string;
+	skills?: string[];
 };
 
 export function renderTemplate(template: string, task: TaskItem): RenderResult {
-	const { id, description, args } = task;
+	const { id, description, args, skills } = task;
 
 	let usedPlaceholder = false;
 	const unknownArguments: string[] = [];
@@ -43,5 +44,6 @@ export function renderTemplate(template: string, task: TaskItem): RenderResult {
 		args: { id, description, ...args },
 		id,
 		description,
+		skills,
 	};
 }

package/src/task/types.ts

@@ -49,6 +49,11 @@ export const taskItemSchema = Type.Object({
 			description: "Arguments to fill {{placeholders}} in context",
 		}),
 	),
+	skills: Type.Optional(
+		Type.Array(Type.String(), {
+			description: "Skill names to preload into the subagent system prompt",
+		}),
+	),
 });
 
 export type TaskItem = Static<typeof taskItemSchema>;

package/src/task/worker-protocol.ts

@@ -107,6 +107,7 @@ export interface SubagentWorkerStartPayload {
 	pythonPreludeDocs?: PreludeHelper[];
 	contextFiles?: ContextFileEntry[];
 	skills?: Skill[];
+	preloadedSkills?: Skill[];
 	promptTemplates?: PromptTemplate[];
 	mcpTools?: MCPToolMetadata[];
 	pythonToolProxy?: boolean;

package/src/task/worker.ts

@@ -608,6 +608,7 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 			requireCompleteTool: true,
 			contextFiles: payload.contextFiles,
 			skills: payload.skills,
+			preloadedSkills: payload.preloadedSkills,
 			promptTemplates: payload.promptTemplates,
 			// Append system prompt (equivalent to CLI's --append-system-prompt)
 			systemPrompt: defaultPrompt =>
@@ -627,6 +628,14 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 		runState.session = session;
 		checkAbort();
 
+		// Write session init metadata for debugging/replay
+		session.sessionManager.appendSessionInit({
+			systemPrompt: session.agent.state.systemPrompt,
+			task: payload.task,
+			tools: session.getAllToolNames(),
+			outputSchema: payload.outputSchema,
+		});
+
 		signal.addEventListener(
 			"abort",
 			() => {

package/src/tools/bash.ts

@@ -85,10 +85,8 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 			throw new ToolError(`Working directory is not a directory: ${commandCwd}`);
 		}
 
-		// Auto-convert milliseconds to seconds if value > 1000 (16+ min is unreasonable)
-		let timeoutSec = rawTimeout > 1000 ? rawTimeout / 1000 : rawTimeout;
 		// Clamp to reasonable range: 1s - 3600s (1 hour)
-		timeoutSec = Math.max(1, Math.min(3600, timeoutSec));
+		const timeoutSec = Math.max(1, Math.min(3600, rawTimeout));
 		const timeoutMs = timeoutSec * 1000;
 
 		// Track output for streaming updates (tail only)