@oh-my-pi/pi-coding-agent 4.2.1 → 4.2.3

package/src/core/skills.ts

@@ -1,10 +1,11 @@
-import { readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { realpath } from "node:fs/promises";
 import { basename, join } from "node:path";
 import { minimatch } from "minimatch";
 import { skillCapability } from "../capability/skill";
 import type { SourceMeta } from "../capability/types";
 import type { Skill as CapabilitySkill, SkillFrontmatter as ImportedSkillFrontmatter } from "../discovery";
-import { loadSync } from "../discovery";
+import { loadCapability } from "../discovery";
 import { parseFrontmatter } from "../discovery/helpers";
 import type { SkillsSettings } from "./settings-manager";
 
@@ -215,7 +216,7 @@ export interface LoadSkillsOptions extends SkillsSettings {
  * Load skills from all configured locations.
  * Returns skills and any validation warnings.
  */
-export function loadSkills(options: LoadSkillsOptions = {}): LoadSkillsResult {
+export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadSkillsResult> {
 	const {
 		cwd = process.cwd(),
 		enabled = true,
@@ -247,7 +248,7 @@ export function loadSkills(options: LoadSkillsOptions = {}): LoadSkillsResult {
 	}
 
 	// Use capability API to load all skills
-	const result = loadSync<CapabilitySkill>(skillCapability.id, { cwd });
+	const result = await loadCapability<CapabilitySkill>(skillCapability.id, { cwd });
 
 	const skillMap = new Map<string, Skill>();
 	const realPathSet = new Set<string>();
@@ -265,28 +266,33 @@ export function loadSkills(options: LoadSkillsOptions = {}): LoadSkillsResult {
 		return ignoredSkills.some((pattern) => minimatch(name, pattern));
 	}
 
-	// Helper to add a skill to the map
-	function addSkill(capSkill: CapabilitySkill, sourceProvider: string) {
-		// Apply ignore filter (glob patterns) - takes precedence over include
-		if (matchesIgnorePatterns(capSkill.name)) {
-			return;
-		}
-		// Apply include filter (glob patterns)
-		if (!matchesIncludePatterns(capSkill.name)) {
-			return;
-		}
+	// Filter skills by source and patterns first
+	const filteredSkills = result.items.filter((capSkill) => {
+		if (!isSourceEnabled(capSkill._source)) return false;
+		if (matchesIgnorePatterns(capSkill.name)) return false;
+		if (!matchesIncludePatterns(capSkill.name)) return false;
+		return true;
+	});
+
+	// Batch resolve all real paths in parallel
+	const realPaths = await Promise.all(
+		filteredSkills.map(async (capSkill) => {
+			try {
+				return await realpath(capSkill.path);
+			} catch {
+				return capSkill.path;
+			}
+		}),
+	);
 
-		// Resolve symlinks to detect duplicate files
-		let realPath: string;
-		try {
-			realPath = realpathSync(capSkill.path);
-		} catch {
-			realPath = capSkill.path;
-		}
+	// Process skills with resolved paths
+	for (let i = 0; i < filteredSkills.length; i++) {
+		const capSkill = filteredSkills[i];
+		const resolvedPath = realPaths[i];
 
 		// Skip silently if we've already loaded this exact file (via symlink)
-		if (realPathSet.has(realPath)) {
-			return;
+		if (realPathSet.has(resolvedPath)) {
+			continue;
 		}
 
 		const existing = skillMap.get(capSkill.name);
@@ -302,46 +308,61 @@ export function loadSkills(options: LoadSkillsOptions = {}): LoadSkillsResult {
 				description: capSkill.frontmatter?.description || "",
 				filePath: capSkill.path,
 				baseDir: capSkill.path.replace(/\/SKILL\.md$/, ""),
-				source: `${sourceProvider}:${capSkill.level}`,
+				source: `${capSkill._source.provider}:${capSkill.level}`,
 				_source: capSkill._source,
 			};
 			skillMap.set(capSkill.name, skill);
-			realPathSet.add(realPath);
-		}
-	}
-
-	// Process skills from capability API
-	for (const capSkill of result.items) {
-		// Check if this source is enabled
-		if (!isSourceEnabled(capSkill._source)) {
-			continue;
+			realPathSet.add(resolvedPath);
 		}
-
-		addSkill(capSkill, capSkill._source.provider);
 	}
 
 	// Process custom directories - scan directly without using full provider system
+	const allCustomSkills: Array<{ skill: Skill; path: string }> = [];
 	for (const dir of customDirectories) {
 		const customSkills = scanDirectoryForSkills(dir);
 		for (const s of customSkills.skills) {
-			// Convert to capability format for addSkill processing
-			const capSkill: CapabilitySkill = {
-				name: s.name,
-				path: s.filePath,
-				content: "",
-				frontmatter: { description: s.description },
-				level: "user",
-				_source: {
-					provider: "custom",
-					providerName: "Custom",
-					path: s.filePath,
-					level: "user",
+			if (matchesIgnorePatterns(s.name)) continue;
+			if (!matchesIncludePatterns(s.name)) continue;
+			allCustomSkills.push({
+				skill: {
+					name: s.name,
+					description: s.description,
+					filePath: s.filePath,
+					baseDir: s.filePath.replace(/\/SKILL\.md$/, ""),
+					source: "custom:user",
+					_source: { provider: "custom", providerName: "Custom", path: s.filePath, level: "user" },
 				},
-			};
-			addSkill(capSkill, "custom");
+				path: s.filePath,
+			});
 		}
-		for (const warning of customSkills.warnings) {
-			collisionWarnings.push(warning);
+		collisionWarnings.push(...customSkills.warnings);
+	}
+
+	// Batch resolve custom skill paths
+	const customRealPaths = await Promise.all(
+		allCustomSkills.map(async ({ path }) => {
+			try {
+				return await realpath(path);
+			} catch {
+				return path;
+			}
+		}),
+	);
+
+	for (let i = 0; i < allCustomSkills.length; i++) {
+		const { skill } = allCustomSkills[i];
+		const resolvedPath = customRealPaths[i];
+		if (realPathSet.has(resolvedPath)) continue;
+
+		const existing = skillMap.get(skill.name);
+		if (existing) {
+			collisionWarnings.push({
+				skillPath: skill.filePath,
+				message: `name collision: "${skill.name}" already loaded from ${existing.filePath}, skipping this one`,
+			});
+		} else {
+			skillMap.set(skill.name, skill);
+			realPathSet.add(resolvedPath);
 		}
 	}
 

package/src/core/slash-commands.ts

@@ -1,6 +1,6 @@
 import { slashCommandCapability } from "../capability/slash-command";
 import type { SlashCommand } from "../discovery";
-import { loadSync } from "../discovery";
+import { loadCapability } from "../discovery";
 import { parseFrontmatter } from "../discovery/helpers";
 import { renderPromptTemplate } from "./prompt-templates";
 import { EMBEDDED_COMMAND_TEMPLATES } from "./tools/task/commands";
@@ -108,8 +108,8 @@ export interface LoadSlashCommandsOptions {
  * Load all custom slash commands using the capability API.
  * Loads from all registered providers (builtin, user, project).
  */
-export function loadSlashCommands(options: LoadSlashCommandsOptions = {}): FileSlashCommand[] {
-	const result = loadSync<SlashCommand>(slashCommandCapability.id, { cwd: options.cwd });
+export async function loadSlashCommands(options: LoadSlashCommandsOptions = {}): Promise<FileSlashCommand[]> {
+	const result = await loadCapability<SlashCommand>(slashCommandCapability.id, { cwd: options.cwd });
 
 	const fileCommands: FileSlashCommand[] = result.items.map((cmd) => {
 		const { description, body } = parseCommandTemplate(cmd.content);

package/src/core/system-prompt.ts

@@ -8,7 +8,7 @@ import { join } from "node:path";
 import chalk from "chalk";
 import { contextFileCapability } from "../capability/context-file";
 import { systemPromptCapability } from "../capability/system-prompt";
-import { type ContextFile, loadSync, type SystemPrompt as SystemPromptFile } from "../discovery/index";
+import { type ContextFile, loadCapability, type SystemPrompt as SystemPromptFile } from "../discovery/index";
 import customSystemPromptTemplate from "../prompts/system/custom-system-prompt.md" with { type: "text" };
 import systemPromptTemplate from "../prompts/system/system-prompt.md" with { type: "text" };
 import { renderPromptTemplate } from "./prompt-templates";
@@ -558,12 +558,12 @@ export interface LoadContextFilesOptions {
  * Returns {path, content, depth} entries for all discovered context files.
  * Files are sorted by depth (descending) so files closer to cwd appear last/more prominent.
  */
-export function loadProjectContextFiles(
+export async function loadProjectContextFiles(
 	options: LoadContextFilesOptions = {},
-): Array<{ path: string; content: string; depth?: number }> {
+): Promise<Array<{ path: string; content: string; depth?: number }>> {
 	const resolvedCwd = options.cwd ?? process.cwd();
 
-	const result = loadSync(contextFileCapability.id, { cwd: resolvedCwd });
+	const result = await loadCapability(contextFileCapability.id, { cwd: resolvedCwd });
 
 	// Convert ContextFile items and preserve depth info
 	const files = result.items.map((item) => {
@@ -590,10 +590,10 @@ export function loadProjectContextFiles(
  * Load system prompt customization files (SYSTEM.md).
  * Returns combined content from all discovered SYSTEM.md files.
  */
-export function loadSystemPromptFiles(options: LoadContextFilesOptions = {}): string | null {
+export async function loadSystemPromptFiles(options: LoadContextFilesOptions = {}): Promise<string | null> {
 	const resolvedCwd = options.cwd ?? process.cwd();
 
-	const result = loadSync<SystemPromptFile>(systemPromptCapability.id, { cwd: resolvedCwd });
+	const result = await loadCapability<SystemPromptFile>(systemPromptCapability.id, { cwd: resolvedCwd });
 
 	if (result.items.length === 0) return null;
 
@@ -631,7 +631,7 @@ export interface BuildSystemPromptOptions {
 }
 
 /** Build the system prompt with tools, guidelines, and context */
-export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): string {
+export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}): Promise<string> {
 	const {
 		customPrompt,
 		tools,
@@ -648,7 +648,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	const resolvedAppendPrompt = resolvePromptInput(appendSystemPrompt, "append system prompt");
 
 	// Load SYSTEM.md customization (prepended to prompt)
-	const systemPromptCustomization = loadSystemPromptFiles({ cwd: resolvedCwd });
+	const systemPromptCustomization = await loadSystemPromptFiles({ cwd: resolvedCwd });
 
 	const now = new Date();
 	const dateTime = now.toLocaleString("en-US", {
@@ -663,7 +663,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	});
 
 	// Resolve context files: use provided or discover
-	const contextFiles = providedContextFiles ?? loadProjectContextFiles({ cwd: resolvedCwd });
+	const contextFiles = providedContextFiles ?? (await loadProjectContextFiles({ cwd: resolvedCwd }));
 	const agentsMdSearch = buildAgentsMdSearch(resolvedCwd);
 
 	// Build tool descriptions array
@@ -688,7 +688,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 	// Resolve skills: use provided or discover
 	const skills =
 		providedSkills ??
-		(skillsSettings?.enabled !== false ? loadSkills({ ...skillsSettings, cwd: resolvedCwd }).skills : []);
+		(skillsSettings?.enabled !== false ? (await loadSkills({ ...skillsSettings, cwd: resolvedCwd })).skills : []);
 
 	// Get git context
 	const git = loadGitContext(resolvedCwd);

package/src/core/tools/edit.ts

@@ -19,7 +19,7 @@ import {
 	stripBom,
 } from "./edit-diff";
 import type { ToolSession } from "./index";
-import { createLspWritethrough, type FileDiagnosticsResult } from "./lsp/index";
+import { createLspWritethrough, type FileDiagnosticsResult, writethroughNoop } from "./lsp/index";
 import { resolveToCwd } from "./path-utils";
 import { createToolUIKit, getDiffStats, shortenPath, truncateDiffByHunk } from "./render-utils";
 
@@ -43,9 +43,12 @@ export interface EditToolDetails {
 
 export function createEditTool(session: ToolSession): AgentTool<typeof editSchema> {
 	const allowFuzzy = session.settings?.getEditFuzzyMatch() ?? true;
-	const enableDiagnostics = session.settings?.getLspDiagnosticsOnEdit() ?? false;
-	const enableFormat = session.settings?.getLspFormatOnWrite() ?? true;
-	const writethrough = createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics });
+	const enableLsp = session.enableLsp ?? true;
+	const enableDiagnostics = enableLsp ? (session.settings?.getLspDiagnosticsOnEdit() ?? false) : false;
+	const enableFormat = enableLsp ? (session.settings?.getLspFormatOnWrite() ?? true) : false;
+	const writethrough = enableLsp
+		? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics })
+		: writethroughNoop;
 	return {
 		name: "edit",
 		label: "Edit",

package/src/core/tools/find.ts

@@ -20,7 +20,7 @@ const findSchema = Type.Object({
 	}),
 	path: Type.Optional(Type.String({ description: "Directory to search in (default: current directory)" })),
 	limit: Type.Optional(Type.Number({ description: "Maximum number of results (default: 1000)" })),
-	hidden: Type.Optional(Type.Boolean({ description: "Include hidden files (default: false)" })),
+	hidden: Type.Optional(Type.Boolean({ description: "Include hidden files (default: true)" })),
 	sortByMtime: Type.Optional(
 		Type.Boolean({ description: "Sort results by modification time, most recent first (default: false)" }),
 	),
@@ -143,7 +143,7 @@ export function createFindTool(session: ToolSession, options?: FindToolOptions):
 				})();
 				const effectiveLimit = limit ?? DEFAULT_LIMIT;
 				const effectiveType = type ?? "all";
-				const includeHidden = hidden ?? false;
+				const includeHidden = hidden ?? true;
 				const shouldSortByMtime = sortByMtime ?? false;
 
 				// If custom operations provided with glob, use that instead of fd

package/src/core/tools/index.test.ts

@@ -34,6 +34,22 @@ describe("createTools", () => {
 		expect(names).toContain("web_search");
 	});
 
+	it("excludes lsp tool when session disables LSP", async () => {
+		const session = createTestSession({ enableLsp: false });
+		const tools = await createTools(session, ["read", "lsp", "write"]);
+		const names = tools.map((t) => t.name);
+
+		expect(names).toEqual(["read", "write"]);
+	});
+
+	it("excludes lsp tool when disabled", async () => {
+		const session = createTestSession({ enableLsp: false });
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).not.toContain("lsp");
+	});
+
 	it("respects requested tool subset", async () => {
 		const session = createTestSession();
 		const tools = await createTools(session, ["read", "write"]);

package/src/core/tools/index.ts

@@ -92,6 +92,8 @@ export interface ToolSession {
 	cwd: string;
 	/** Whether UI is available */
 	hasUI: boolean;
+	/** Whether LSP integrations are enabled */
+	enableLsp?: boolean;
 	/** Event bus for tool/extension communication */
 	eventBus?: EventBus;
 	/** Output schema for structured completion (subagents) */
@@ -106,6 +108,12 @@ export interface ToolSession {
 	getModelString?: () => string | undefined;
 	/** Get the current session model string, regardless of how it was chosen */
 	getActiveModelString?: () => string | undefined;
+	/** Auth storage for passing to subagents (avoids re-discovery) */
+	authStorage?: import("../auth-storage").AuthStorage;
+	/** Model registry for passing to subagents (avoids re-discovery) */
+	modelRegistry?: import("../model-registry").ModelRegistry;
+	/** MCP manager for proxying MCP calls through parent */
+	mcpManager?: import("../mcp/manager").MCPManager;
 	/** Settings manager (optional) */
 	settings?: {
 		getImageAutoResize(): boolean;
@@ -154,23 +162,28 @@ export type ToolName = keyof typeof BUILTIN_TOOLS;
  */
 export async function createTools(session: ToolSession, toolNames?: string[]): Promise<Tool[]> {
 	const includeComplete = session.requireCompleteTool === true;
+	const enableLsp = session.enableLsp ?? true;
 	const requestedTools = toolNames && toolNames.length > 0 ? [...new Set(toolNames)] : undefined;
 	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS, ...HIDDEN_TOOLS };
+	const isToolAllowed = (name: string) => (name === "lsp" ? enableLsp : true);
 	if (includeComplete && requestedTools && !requestedTools.includes("complete")) {
 		requestedTools.push("complete");
 	}
 
-	const entries = requestedTools
-		? requestedTools.filter((name) => name in allTools).map((name) => [name, allTools[name]] as const)
-		: [
-				...Object.entries(BUILTIN_TOOLS),
-				...(includeComplete ? ([["complete", HIDDEN_TOOLS.complete]] as const) : []),
-			];
+	const filteredRequestedTools = requestedTools?.filter((name) => name in allTools && isToolAllowed(name));
+
+	const entries =
+		filteredRequestedTools !== undefined
+			? filteredRequestedTools.map((name) => [name, allTools[name]] as const)
+			: [
+					...Object.entries(BUILTIN_TOOLS).filter(([name]) => isToolAllowed(name)),
+					...(includeComplete ? ([["complete", HIDDEN_TOOLS.complete]] as const) : []),
+				];
 	const results = await Promise.all(entries.map(([, factory]) => factory(session)));
 	const tools = results.filter((t): t is Tool => t !== null);
 
-	if (requestedTools) {
-		const allowed = new Set(requestedTools);
+	if (filteredRequestedTools !== undefined) {
+		const allowed = new Set(filteredRequestedTools);
 		return tools.filter((tool) => allowed.has(tool.name));
 	}
 

package/src/core/tools/lsp/index.ts

@@ -734,7 +734,10 @@ export function createLspWritethrough(cwd: string, options?: WritethroughOptions
 }
 
 /** Create an LSP tool */
-export function createLspTool(session: ToolSession): AgentTool<typeof lspSchema, LspToolDetails, Theme> {
+export function createLspTool(session: ToolSession): AgentTool<typeof lspSchema, LspToolDetails, Theme> | null {
+	if (session.enableLsp === false) {
+		return null;
+	}
 	return {
 		name: "lsp",
 		label: "LSP",

package/src/core/tools/ssh.ts

@@ -4,7 +4,7 @@ import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
 import type { SSHHost } from "../../capability/ssh";
 import { sshCapability } from "../../capability/ssh";
-import { loadSync } from "../../discovery/index";
+import { loadCapability } from "../../discovery/index";
 import type { Theme } from "../../modes/interactive/theme/theme";
 import sshDescriptionBase from "../../prompts/tools/ssh.md" with { type: "text" };
 import type { RenderResultOptions } from "../custom-tools/types";
@@ -97,11 +97,11 @@ function buildRemoteCommand(command: string, cwd: string | undefined, info: SSHH
 	return `cd -- ${quoteRemotePath(cwd)} && ${command}`;
 }
 
-function loadHosts(session: ToolSession): {
+async function loadHosts(session: ToolSession): Promise<{
 	hostNames: string[];
 	hostsByName: Map<string, SSHHost>;
-} {
-	const result = loadSync<SSHHost>(sshCapability.id, { cwd: session.cwd });
+}> {
+	const result = await loadCapability<SSHHost>(sshCapability.id, { cwd: session.cwd });
 	const hostsByName = new Map<string, SSHHost>();
 	for (const host of result.items) {
 		if (!hostsByName.has(host.name)) {
@@ -112,8 +112,8 @@ function loadHosts(session: ToolSession): {
 	return { hostNames, hostsByName };
 }
 
-export function createSshTool(session: ToolSession): AgentTool<typeof sshSchema> | null {
-	const { hostNames, hostsByName } = loadHosts(session);
+export async function createSshTool(session: ToolSession): Promise<AgentTool<typeof sshSchema> | null> {
+	const { hostNames, hostsByName } = await loadHosts(session);
 	if (hostNames.length === 0) {
 		return null;
 	}

package/src/core/tools/task/commands.ts

@@ -6,16 +6,14 @@
 
 import * as path from "node:path";
 import { type SlashCommand, slashCommandCapability } from "../../../capability/slash-command";
-import { loadSync } from "../../../discovery";
+import { loadCapability } from "../../../discovery";
 
 // Embed command markdown files at build time
 import initMd from "../../../prompts/agents/init.md" with { type: "text" };
-import plannerMd from "../../../prompts/agents/planner.md" with { type: "text" };
 import { renderPromptTemplate } from "../../prompt-templates";
 
 const EMBEDDED_COMMANDS: { name: string; content: string }[] = [
 	{ name: "init.md", content: renderPromptTemplate(initMd) },
-	{ name: "planner.md", content: renderPromptTemplate(plannerMd) },
 ];
 
 export const EMBEDDED_COMMAND_TEMPLATES: ReadonlyArray<{ name: string; content: string }> = EMBEDDED_COMMANDS;
@@ -97,11 +95,11 @@ export function loadBundledCommands(): WorkflowCommand[] {
  *
  * Precedence (highest wins): .omp > .pi > .claude (project before user), then bundled
  */
-export function discoverCommands(cwd: string): WorkflowCommand[] {
+export async function discoverCommands(cwd: string): Promise<WorkflowCommand[]> {
 	const resolvedCwd = path.resolve(cwd);
 
 	// Load slash commands from capability API
-	const result = loadSync<SlashCommand>(slashCommandCapability.id, { cwd: resolvedCwd });
+	const result = await loadCapability<SlashCommand>(slashCommandCapability.id, { cwd: resolvedCwd });
 
 	const commands: WorkflowCommand[] = [];
 	const seen = new Set<string>();

package/src/core/tools/task/executor.ts

@@ -5,7 +5,11 @@
  */
 
 import type { AgentEvent } from "@oh-my-pi/pi-agent-core";
+import type { AuthStorage } from "../../auth-storage";
 import type { EventBus } from "../../event-bus";
+import { callTool } from "../../mcp/client";
+import type { MCPManager } from "../../mcp/manager";
+import type { ModelRegistry } from "../../model-registry";
 import { ensureArtifactsDir, getArtifactPaths } from "./artifacts";
 import { resolveModelPattern } from "./model-resolver";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
@@ -18,7 +22,12 @@ import {
 	TASK_SUBAGENT_EVENT_CHANNEL,
 	TASK_SUBAGENT_PROGRESS_CHANNEL,
 } from "./types";
-import type { SubagentWorkerRequest, SubagentWorkerResponse } from "./worker-protocol";
+import type {
+	MCPToolCallRequest,
+	MCPToolMetadata,
+	SubagentWorkerRequest,
+	SubagentWorkerResponse,
+} from "./worker-protocol";
 
 /** Options for worker execution */
 export interface ExecutorOptions {
@@ -31,12 +40,16 @@ export interface ExecutorOptions {
 	context?: string;
 	modelOverride?: string;
 	outputSchema?: unknown;
+	enableLsp?: boolean;
 	signal?: AbortSignal;
 	onProgress?: (progress: AgentProgress) => void;
 	sessionFile?: string | null;
 	persistArtifacts?: boolean;
 	artifactsDir?: string;
 	eventBus?: EventBus;
+	mcpManager?: MCPManager;
+	authStorage?: AuthStorage;
+	modelRegistry?: ModelRegistry;
 }
 
 /**
@@ -133,11 +146,45 @@ function getUsageTokens(usage: unknown): number {
 	return input + output + cacheRead + cacheWrite;
 }
 
+/**
+ * Parse MCP tool name to extract server and tool names.
+ * Format: mcp_<serverName>_<toolName>
+ * Note: Uses lastIndexOf to handle server names with underscores.
+ */
+function parseMCPToolName(fullName: string): { serverName: string; toolName: string } | undefined {
+	if (!fullName.startsWith("mcp_")) return undefined;
+	const rest = fullName.slice(4);
+	const underscoreIndex = rest.lastIndexOf("_");
+	if (underscoreIndex === -1) return undefined;
+	return {
+		serverName: rest.slice(0, underscoreIndex),
+		toolName: rest.slice(underscoreIndex + 1),
+	};
+}
+
+/**
+ * Extract MCP tool metadata from MCPManager for passing to worker.
+ */
+function extractMCPToolMetadata(mcpManager: MCPManager): MCPToolMetadata[] {
+	return mcpManager.getTools().map((tool) => {
+		const parsed = parseMCPToolName(tool.name);
+		return {
+			name: tool.name,
+			label: tool.label ?? tool.name,
+			description: tool.description ?? "",
+			parameters: tool.parameters,
+			serverName: parsed?.serverName ?? "",
+			mcpToolName: parsed?.toolName ?? "",
+		};
+	});
+}
+
 /**
  * Run a single agent in a worker.
  */
 export async function runSubprocess(options: ExecutorOptions): Promise<SingleResult> {
-	const { cwd, agent, task, index, taskId, context, modelOverride, outputSchema, signal, onProgress } = options;
+	const { cwd, agent, task, index, taskId, context, modelOverride, outputSchema, enableLsp, signal, onProgress } =
+		options;
 	const startTime = Date.now();
 
 	// Initialize progress
@@ -208,7 +255,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	}
 
 	// Resolve and add model
-	const resolvedModel = resolveModelPattern(modelOverride || agent.model);
+	const resolvedModel = await resolveModelPattern(modelOverride || agent.model);
 	const sessionFile = subtaskSessionFile ?? options.sessionFile ?? null;
 	const spawnsEnv = agent.spawns === undefined ? "" : agent.spawns === "*" ? "*" : agent.spawns.join(",");
 
@@ -535,6 +582,10 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			outputSchema,
 			sessionFile,
 			spawnsEnv,
+			enableLsp,
+			serializedAuth: options.authStorage?.serialize(),
+			serializedModels: options.modelRegistry?.serialize(),
+			mcpTools: options.mcpManager ? extractMCPToolMetadata(options.mcpManager) : undefined,
 		},
 	};
 
@@ -556,9 +607,43 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			cleanup();
 			resolve(message);
 		};
+		const handleMCPCall = async (request: MCPToolCallRequest) => {
+			const mcpManager = options.mcpManager;
+			if (!mcpManager) {
+				worker.postMessage({
+					type: "mcp_tool_result",
+					callId: request.callId,
+					error: "MCP not available",
+				});
+				return;
+			}
+			try {
+				const parsed = parseMCPToolName(request.toolName);
+				if (!parsed) throw new Error(`Invalid MCP tool name: ${request.toolName}`);
+				const connection = mcpManager.getConnection(parsed.serverName);
+				if (!connection) throw new Error(`MCP server not connected: ${parsed.serverName}`);
+				const result = await callTool(connection, parsed.toolName, request.params);
+				worker.postMessage({
+					type: "mcp_tool_result",
+					callId: request.callId,
+					result: { content: result.content ?? [], isError: result.isError },
+				});
+			} catch (error) {
+				worker.postMessage({
+					type: "mcp_tool_result",
+					callId: request.callId,
+					error: error instanceof Error ? error.message : String(error),
+				});
+			}
+		};
+
 		const onMessage = (event: WorkerMessageEvent<SubagentWorkerResponse>) => {
 			const message = event.data;
 			if (!message || resolved) return;
+			if (message.type === "mcp_tool_call") {
+				handleMCPCall(message as MCPToolCallRequest);
+				return;
+			}
 			if (message.type === "event") {
 				try {
 					processEvent(message.event);

package/src/core/tools/task/index.ts

@@ -349,12 +349,16 @@ export async function createTaskTool(
 							sessionFile,
 							persistArtifacts: !!artifactsDir,
 							artifactsDir: effectiveArtifactsDir,
+							enableLsp: false,
 							signal,
 							eventBus: undefined,
 							onProgress: (progress) => {
 								progressMap.set(index, structuredClone(progress));
 								emitProgress();
 							},
+							authStorage: session.authStorage,
+							modelRegistry: session.modelRegistry,
+							mcpManager: session.mcpManager,
 						});
 					},
 					signal,