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

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [8.5.0] - 2026-01-27
+
+### Added
+- Added subagent support for preloading skill contents into the system prompt instead of listing available skills
+- Added session init entries to capture system prompt, task, tools, and output schema for subagent session logs
+
+### Fixed
+- Reduced Task tool progress update overhead to keep the UI responsive during high-volume streaming output
+- Fixed subagent session logs dropping pre-assistant entries (user/task metadata) before the first assistant response
+
+### Removed
+- Removed enter-plan-mode tool
 ## [8.4.5] - 2026-01-26
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "8.4.5",
+	"version": "8.5.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -83,11 +83,11 @@
 		"test": "bun test"
 	},
 	"dependencies": {
-		"@oh-my-pi/omp-stats": "8.4.5",
-		"@oh-my-pi/pi-agent-core": "8.4.5",
-		"@oh-my-pi/pi-ai": "8.4.5",
-		"@oh-my-pi/pi-tui": "8.4.5",
-		"@oh-my-pi/pi-utils": "8.4.5",
+		"@oh-my-pi/omp-stats": "8.5.0",
+		"@oh-my-pi/pi-agent-core": "8.5.0",
+		"@oh-my-pi/pi-ai": "8.5.0",
+		"@oh-my-pi/pi-tui": "8.5.0",
+		"@oh-my-pi/pi-utils": "8.5.0",
 		"@openai/agents": "^0.4.3",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/modes/controllers/event-controller.ts

@@ -247,12 +247,6 @@ export class EventController {
 						this.ctx.setTodos(details.todos);
 					}
 				}
-				if (event.toolName === "enter_plan_mode" && !event.isError) {
-					const details = event.result.details as import("../../tools").EnterPlanModeDetails | undefined;
-					if (details) {
-						await this.ctx.handleEnterPlanModeTool(details);
-					}
-				}
 				if (event.toolName === "exit_plan_mode" && !event.isError) {
 					const details = event.result.details as ExitPlanModeDetails | undefined;
 					if (details) {

package/src/modes/interactive-mode.ts

@@ -29,7 +29,7 @@ import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 import { HistoryStorage } from "../session/history-storage";
 import type { SessionContext, SessionManager } from "../session/session-manager";
 import { getRecentSessions } from "../session/session-manager";
-import type { EnterPlanModeDetails, ExitPlanModeDetails } from "../tools";
+import type { ExitPlanModeDetails } from "../tools";
 import { setTerminalTitle } from "../utils/title-generator";
 import type { AssistantMessageComponent } from "./components/assistant-message";
 import type { BashExecutionComponent } from "./components/bash-execution";
@@ -631,25 +631,6 @@ export class InteractiveMode implements InteractiveModeContext {
 		await this.enterPlanMode();
 	}
 
-	async handleEnterPlanModeTool(details: EnterPlanModeDetails): Promise<void> {
-		if (this.planModeEnabled) {
-			this.showWarning("Plan mode is already active.");
-			return;
-		}
-
-		const confirmed = await this.showHookConfirm(
-			"Enter plan mode?",
-			"This enables read-only planning and creates a plan file for approval.",
-		);
-		if (!confirmed) {
-			return;
-		}
-
-		const planFilePath = details.planFilePath || this.getPlanFilePath();
-		this.planModePlanFilePath = planFilePath;
-		await this.enterPlanMode({ planFilePath, workflow: details.workflow });
-	}
-
 	async handleExitPlanModeTool(details: ExitPlanModeDetails): Promise<void> {
 		if (!this.planModeEnabled) {
 			this.showWarning("Plan mode is not active.");

package/src/modes/types.ts

@@ -178,7 +178,6 @@ export interface InteractiveModeContext {
 	openExternalEditor(): void;
 	registerExtensionShortcuts(): void;
 	handlePlanModeCommand(): Promise<void>;
-	handleEnterPlanModeTool(details: import("../tools").EnterPlanModeDetails): Promise<void>;
 	handleExitPlanModeTool(details: ExitPlanModeDetails): Promise<void>;
 
 	// Hook UI methods

package/src/prompts/system/custom-system-prompt.md

@@ -43,6 +43,20 @@ Use the read tool to load a skill's file when the task matches its description.
 {{/list}}
 </available_skills>
 {{/if}}
+{{#if preloadedSkills.length}}
+The following skills are preloaded in full. Apply their instructions directly.
+
+<preloaded_skills>
+{{#list preloadedSkills join="\n"}}
+<skill name="{{name}}">
+<location>skill://{{escapeXml name}}</location>
+<content>
+{{content}}
+</content>
+</skill>
+{{/list}}
+</preloaded_skills>
+{{/if}}
 {{#if rules.length}}
 The following rules define project-specific guidelines and constraints:
 

package/src/prompts/system/system-prompt.md

@@ -264,6 +264,18 @@ If a skill covers what you're producing, read it before proceeding.
 {{/list}}
 </skills>
 {{/if}}
+{{#if preloadedSkills.length}}
+<preloaded_skills>
+The following skills are preloaded in full. Apply their instructions directly.
+
+{{#list preloadedSkills join="\n"}}
+<skill name="{{name}}">
+<location>skill://{{escapeXml name}}</location>
+{{content}}
+</skill>
+{{/list}}
+</preloaded_skills>
+{{/if}}
 {{#if rules.length}}
 <rules>
 Rules are local constraints.

package/src/prompts/tools/task.md

@@ -38,6 +38,7 @@ Agents with `output="structured"` have a fixed schema enforced via frontmatter;
 		- `id`: Short CamelCase identifier (max 32 chars, e.g., "SessionStore", "LspRefactor")
 		- `description`: Short human-readable description of what the task does
 		- `args`: Object with keys matching `\{{placeholders}}` in context (always include this, even if empty)
+		- `skills`: (optional) Array of skill names to preload into this task's system prompt. When set, the skills index section is omitted and the full SKILL.md contents are embedded.
 - `output`: (optional) JTD schema for structured subagent output (used by the complete tool)
 </parameters>
 

package/src/sdk.ts

@@ -156,6 +156,8 @@ export interface CreateAgentSessionOptions {
 
 	/** Skills. Default: discovered from multiple locations */
 	skills?: Skill[];
+	/** Skills to inline into the system prompt instead of listing available skills. */
+	preloadedSkills?: Skill[];
 	/** Context files (AGENTS.md content). Default: discovered walking up from cwd */
 	contextFiles?: Array<{ path: string; content: string }>;
 	/** Prompt templates. Default: discovered from cwd/.omp/prompts/ + agentDir/prompts/ */
@@ -993,6 +995,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		const defaultPrompt = await buildSystemPromptInternal({
 			cwd,
 			skills,
+			preloadedSkills: options.preloadedSkills,
 			contextFiles,
 			tools,
 			toolNames,
@@ -1007,6 +1010,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			return await buildSystemPromptInternal({
 				cwd,
 				skills,
+				preloadedSkills: options.preloadedSkills,
 				contextFiles,
 				tools,
 				toolNames,

package/src/session/session-manager.ts

@@ -110,6 +110,19 @@ export interface TtsrInjectionEntry extends SessionEntryBase {
 	injectedRules: string[];
 }
 
+/** Session init entry - captures initial context for subagent sessions (debugging/replay). */
+export interface SessionInitEntry extends SessionEntryBase {
+	type: "session_init";
+	/** Full system prompt sent to the model */
+	systemPrompt: string;
+	/** Initial task/user message */
+	task: string;
+	/** Tools available to the agent */
+	tools: string[];
+	/** Output schema if structured output was requested */
+	outputSchema?: unknown;
+}
+
 /**
  * Custom message entry for extensions to inject messages into LLM context.
  * Use customType to identify your extension's entries.
@@ -140,7 +153,8 @@ export type SessionEntry =
 	| CustomEntry
 	| CustomMessageEntry
 	| LabelEntry
-	| TtsrInjectionEntry;
+	| TtsrInjectionEntry
+	| SessionInitEntry;
 
 /** Raw file entry (includes header) */
 export type FileEntry = SessionHeader | SessionEntry;
@@ -1263,7 +1277,7 @@ export class SessionManager {
 		if (this.persistError) throw this.persistError;
 
 		const hasAssistant = this.fileEntries.some(e => e.type === "message" && e.message.role === "assistant");
-		if (!hasAssistant) return;
+		if (!hasAssistant && !this.flushed) return;
 
 		if (!this.flushed) {
 			this.flushed = true;
@@ -1368,6 +1382,19 @@ export class SessionManager {
 		return entry.id;
 	}
 
+	/** Append session init metadata (for subagent debugging/replay). Returns entry id. */
+	appendSessionInit(init: { systemPrompt: string; task: string; tools: string[]; outputSchema?: unknown }): string {
+		const entry: SessionInitEntry = {
+			type: "session_init",
+			id: generateId(this.byId),
+			parentId: this.leafId,
+			timestamp: new Date().toISOString(),
+			...init,
+		};
+		this._appendEntry(entry);
+		return entry.id;
+	}
+
 	/** Append a compaction summary as child of current leaf, then advance leaf. Returns entry id. */
 	appendCompaction<T = unknown>(
 		summary: string,

package/src/system-prompt.ts

@@ -23,6 +23,24 @@ interface GitContext {
 	commits: string;
 }
 
+type PreloadedSkill = { name: string; content: string };
+
+async function loadPreloadedSkillContents(preloadedSkills: Skill[]): Promise<PreloadedSkill[]> {
+	const contents = await Promise.all(
+		preloadedSkills.map(async skill => {
+			try {
+				const content = await Bun.file(skill.filePath).text();
+				return { name: skill.name, content };
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				throw new Error(`Failed to load skill "${skill.name}" from ${skill.filePath}: ${message}`);
+			}
+		}),
+	);
+
+	return contents;
+}
+
 /**
  * Load git context for the system prompt.
  * Returns structured git data or null if not in a git repo.
@@ -643,6 +661,8 @@ export interface BuildSystemPromptOptions {
 	contextFiles?: Array<{ path: string; content: string; depth?: number }>;
 	/** Pre-loaded skills (skips discovery if provided). */
 	skills?: Skill[];
+	/** Skills to inline into the system prompt instead of listing available skills. */
+	preloadedSkills?: Skill[];
 	/** Pre-loaded rulebook rules (rules with descriptions, excluding TTSR and always-apply). */
 	rules?: Array<{ name: string; description?: string; path: string; globs?: string[] }>;
 }
@@ -662,6 +682,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		cwd,
 		contextFiles: providedContextFiles,
 		skills: providedSkills,
+		preloadedSkills: providedPreloadedSkills,
 		rules,
 	} = options;
 	const resolvedCwd = cwd ?? process.cwd();
@@ -707,13 +728,15 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 	const skills =
 		providedSkills ??
 		(skillsSettings?.enabled !== false ? (await loadSkills({ ...skillsSettings, cwd: resolvedCwd })).skills : []);
+	const preloadedSkills = providedPreloadedSkills;
+	const preloadedSkillContents = preloadedSkills ? await loadPreloadedSkillContents(preloadedSkills) : [];
 
 	// Get git context
 	const git = await loadGitContext(resolvedCwd);
 
 	// Filter skills to only include those with read tool
 	const hasRead = tools?.has("read");
-	const filteredSkills = hasRead ? skills : [];
+	const filteredSkills = preloadedSkills === undefined && hasRead ? skills : [];
 
 	if (resolvedCustomPrompt) {
 		return renderPromptTemplate(customSystemPromptTemplate, {
@@ -724,6 +747,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 			agentsMdSearch,
 			git,
 			skills: filteredSkills,
+			preloadedSkills: preloadedSkillContents,
 			rules: rules ?? [],
 			dateTime,
 			cwd: resolvedCwd,
@@ -738,6 +762,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		agentsMdSearch,
 		git,
 		skills: filteredSkills,
+		preloadedSkills: preloadedSkillContents,
 		rules: rules ?? [],
 		dateTime,
 		cwd: resolvedCwd,

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/index.ts

@@ -19,7 +19,6 @@ import { AskTool } from "./ask";
 import { BashTool } from "./bash";
 import { CalculatorTool } from "./calculator";
 import { CompleteTool } from "./complete";
-import { EnterPlanModeTool } from "./enter-plan-mode";
 import { ExitPlanModeTool } from "./exit-plan-mode";
 import { FetchTool } from "./fetch";
 import { FindTool } from "./find";
@@ -73,7 +72,6 @@ export { AskTool, type AskToolDetails } from "./ask";
 export { BashTool, type BashToolDetails, type BashToolOptions } from "./bash";
 export { CalculatorTool, type CalculatorToolDetails } from "./calculator";
 export { CompleteTool } from "./complete";
-export { type EnterPlanModeDetails, EnterPlanModeTool } from "./enter-plan-mode";
 export { type ExitPlanModeDetails, ExitPlanModeTool } from "./exit-plan-mode";
 export { FetchTool, type FetchToolDetails } from "./fetch";
 export { type FindOperations, FindTool, type FindToolDetails, type FindToolOptions } from "./find";
@@ -199,7 +197,6 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	fetch: s => new FetchTool(s),
 	web_search: s => new WebSearchTool(s),
 	write: s => new WriteTool(s),
-	enter_plan_mode: s => new EnterPlanModeTool(s),
 };
 
 export const HIDDEN_TOOLS: Record<string, ToolFactory> = {

package/src/prompts/tools/enter-plan-mode.md

@@ -1,98 +0,0 @@
-Transitions to plan mode for designing implementation approaches before writing code.
-
-<conditions>
-Prefer using EnterPlanMode for implementation tasks unless they're simple. Use it when ANY of these conditions apply:
-1. **New Feature Implementation**: Adding meaningful new functionality
-   - Example: "Add a logout button" — where should it go? What should happen on click?
-   - Example: "Add form validation" — what rules? What error messages?
-2. **Multiple Valid Approaches**: The task can be solved in several different ways
-   - Example: "Add caching to the API" — could use Redis, in-memory, file-based, etc.
-   - Example: "Improve performance" — many optimization strategies possible
-3. **Code Modifications**: Changes that affect existing behavior or structure
-   - Example: "Update the login flow" — what exactly should change?
-   - Example: "Refactor this component" — what's the target architecture?
-4. **Architectural Decisions**: The task requires choosing between patterns or technologies
-   - Example: "Add real-time updates" — WebSockets vs SSE vs polling
-   - Example: "Implement state management" — Redux vs Context vs custom solution
-5. **Multi-File Changes**: The task will likely touch more than 2-3 files
-   - Example: "Refactor the authentication system"
-   - Example: "Add a new API endpoint with tests"
-6. **Unclear Requirements**: You need to explore before understanding the full scope
-   - Example: "Make the app faster" — need to profile and identify bottlenecks
-   - Example: "Fix the bug in checkout" — need to investigate root cause
-7. **User Preferences Matter**: The implementation could reasonably go multiple ways
-   - If you would use `ask` to clarify the approach, use EnterPlanMode instead
-   - Plan mode lets you explore first, then present options with context
-</conditions>
-
-<instruction>
-In plan mode:
-1. Explore codebase with `find`, `grep`, `read`, `ls`
-2. Understand existing patterns and architecture
-3. Design implementation approach
-4. Use `ask` if clarification needed
-5. Call `exit_plan_mode` when ready
-</instruction>
-
-<output>
-Requires user approval to enter. Once approved, you enter read-only exploration mode with restricted tool access.
-</output>
-
-<parameters>
-Optional parameters:
-  - `parallel`: Explore independent threads in parallel before synthesizing.
-  - `iterative`: One thread at a time with checkpoints between steps.
-</parameters>
-
-<example name="auth">
-User: "Add user authentication to the app"
-→ Use plan mode: architectural decisions (session vs JWT, where to store tokens, middleware structure)
-</example>
-
-<example name="optimization">
-User: "Optimize the database queries"
-→ Use plan mode: multiple approaches possible, need to profile first, significant impact
-</example>
-
-<example name="dark-mode">
-User: "Implement dark mode"
-→ Use plan mode: architectural decision on theme system, affects many components
-</example>
-
-<example name="delete-button">
-User: "Add a delete button to the user profile"
-→ Use plan mode: seems simple but involves placement, confirmation dialog, API call, error handling, state updates
-</example>
-
-<example name="error-handling">
-User: "Update the error handling in the API"
-→ Use plan mode: affects multiple files, user should approve the approach
-</example>
-
-<example name="typo-skip">
-User: "Fix the typo in the README"
-→ Skip plan mode: straightforward, no planning needed
-</example>
-
-<example name="debug-skip">
-User: "Add a console.log to debug this function"
-→ Skip plan mode: simple, obvious implementation
-</example>
-
-<example name="research-skip">
-User: "What files handle routing?"
-→ Skip plan mode: research task, not implementation planning
-</example>
-
-<avoid>
-- Single-line or few-line fixes (typos, obvious bugs)
-- Adding a single function with clear requirements
-- Tasks with very specific, detailed instructions
-- Pure research/exploration tasks
-</avoid>
-
-<critical>
-- This tool REQUIRES user approval — they must consent to entering plan mode
-- If unsure whether to use it, err on the side of planning — alignment upfront beats rework
-- Users appreciate being consulted before significant changes are made to their codebase
-</critical>

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

@@ -1,81 +0,0 @@
-import * as fs from "node:fs/promises";
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { StringEnum } from "@oh-my-pi/pi-ai";
-import { isEnoent } from "@oh-my-pi/pi-utils";
-import { Type } from "@sinclair/typebox";
-import { renderPromptTemplate } from "../config/prompt-templates";
-import { resolvePlanUrlToPath } from "../internal-urls";
-import enterPlanModeDescription from "../prompts/tools/enter-plan-mode.md" with { type: "text" };
-import type { ToolSession } from ".";
-import { ToolError } from "./tool-errors";
-
-const enterPlanModeSchema = Type.Object({
-	workflow: Type.Optional(
-		StringEnum(["parallel", "iterative"], {
-			description: "Planning workflow to use",
-		}),
-	),
-});
-
-export interface EnterPlanModeDetails {
-	planFilePath: string;
-	planExists: boolean;
-	workflow?: "parallel" | "iterative";
-}
-
-export class EnterPlanModeTool implements AgentTool<typeof enterPlanModeSchema, EnterPlanModeDetails> {
-	public readonly name = "enter_plan_mode";
-	public readonly label = "EnterPlanMode";
-	public readonly description: string;
-	public readonly parameters = enterPlanModeSchema;
-
-	private readonly session: ToolSession;
-
-	constructor(session: ToolSession) {
-		this.session = session;
-		this.description = renderPromptTemplate(enterPlanModeDescription);
-	}
-
-	public async execute(
-		_toolCallId: string,
-		params: { workflow?: "parallel" | "iterative" },
-		_signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<EnterPlanModeDetails>,
-		_context?: AgentToolContext,
-	): Promise<AgentToolResult<EnterPlanModeDetails>> {
-		const state = this.session.getPlanModeState?.();
-		if (state?.enabled) {
-			throw new ToolError("Plan mode is already active.");
-		}
-
-		const sessionId = this.session.getSessionId?.();
-		if (!sessionId) {
-			throw new ToolError("Plan mode requires an active session.");
-		}
-
-		const settingsManager = this.session.settingsManager;
-		if (!settingsManager) {
-			throw new ToolError("Settings manager unavailable for plan mode.");
-		}
-
-		const planFilePath = `plan://${sessionId}/plan.md`;
-		const resolvedPlanPath = resolvePlanUrlToPath(planFilePath, {
-			getPlansDirectory: settingsManager.getPlansDirectory.bind(settingsManager),
-			cwd: this.session.cwd,
-		});
-		let planExists = false;
-		try {
-			const stat = await fs.stat(resolvedPlanPath);
-			planExists = stat.isFile();
-		} catch (error) {
-			if (!isEnoent(error)) {
-				throw error;
-			}
-		}
-
-		return {
-			content: [{ type: "text", text: "Plan mode requested." }],
-			details: { planFilePath, planExists, workflow: params.workflow },
-		};
-	}
-}