@gajae-code/coding-agent 0.7.11 → 0.8.0

package/src/session/session-manager.ts

@@ -1461,9 +1461,25 @@ function materializeResidentEntrySync<T extends FileEntry | SessionEntry>(
 function materializeResidentEntriesSync<T extends FileEntry | SessionEntry>(
 	entries: T[],
 	stores: ResidentBlobStores,
+	missingPolicy: ResidentBlobMissingPolicy = "throw",
 ): T[] {
 	const cache = new Map<string, string>();
-	return entries.map(entry => materializeResidentEntrySync(entry, stores, cache));
+	return entries.map(entry => materializeResidentEntrySync(entry, stores, cache, missingPolicy));
+}
+
+function materializeResidentEntryForReadSync<T extends FileEntry | SessionEntry>(
+	entry: T,
+	stores: ResidentBlobStores,
+	cache: Map<string, string>,
+): T {
+	return materializeResidentEntrySync(entry, stores, cache, "placeholder");
+}
+
+function materializeResidentEntriesForReadSync<T extends FileEntry | SessionEntry>(
+	entries: T[],
+	stores: ResidentBlobStores,
+): T[] {
+	return materializeResidentEntriesSync(entries, stores, "placeholder");
 }
 
 function materializeResidentEntryForPersistenceSync<T extends FileEntry | SessionEntry>(
@@ -1520,12 +1536,24 @@ function cloneSessionEntry(entry: SessionEntry): SessionEntry {
 function materializeProviderVisibleEntrySync(entry: SessionEntry, stores: ResidentBlobStores): SessionEntry {
 	if (entry.type === "compaction") {
 		const cache = new Map<string, string>();
-		const summary = materializeResidentValueSync(entry.summary, stores, "summary", cache);
-		const shortSummary = materializeResidentValueSync(entry.shortSummary, stores, "shortSummary", cache);
+		const summary = materializeResidentValueSync(entry.summary, stores, "summary", cache, "placeholder");
+		const shortSummary = materializeResidentValueSync(
+			entry.shortSummary,
+			stores,
+			"shortSummary",
+			cache,
+			"placeholder",
+		);
 		const remote = entry.preserveData?.openaiRemoteCompaction;
 		const remoteRecord = isRecord(remote) ? remote : undefined;
 		const replacementHistory = remoteRecord
-			? materializeResidentValueSync(remoteRecord.replacementHistory, stores, "replacementHistory", cache)
+			? materializeResidentValueSync(
+					remoteRecord.replacementHistory,
+					stores,
+					"replacementHistory",
+					cache,
+					"placeholder",
+				)
 			: undefined;
 		const preserveData =
 			remoteRecord && replacementHistory !== undefined && replacementHistory !== remoteRecord.replacementHistory
@@ -1545,7 +1573,13 @@ function materializeProviderVisibleEntrySync(entry: SessionEntry, stores: Reside
 		};
 	}
 	if (entry.type === "branch_summary") {
-		const summary = materializeResidentValueSync(entry.summary, stores, "summary", new Map<string, string>());
+		const summary = materializeResidentValueSync(
+			entry.summary,
+			stores,
+			"summary",
+			new Map<string, string>(),
+			"placeholder",
+		);
 		return typeof summary === "string" ? { ...entry, summary } : { ...entry };
 	}
 	return cloneSessionEntry(entry);
@@ -2751,7 +2785,10 @@ export class SessionManager {
 	}
 
 	captureState(): SessionManagerStateSnapshot {
-		const materializedFileEntries = materializeResidentEntriesSync(this.#fileEntries, this.#residentBlobStores());
+		const materializedFileEntries = materializeResidentEntriesForReadSync(
+			this.#fileEntries,
+			this.#residentBlobStores(),
+		);
 		return {
 			sessionId: this.#sessionId,
 			sessionName: this.#sessionName,
@@ -2875,7 +2912,7 @@ export class SessionManager {
 
 		const oldSessionFile = this.#sessionFile;
 		const oldSessionId = this.#sessionId;
-		const materializedEntries = materializeResidentEntriesSync(this.#fileEntries, this.#residentBlobStores());
+		const materializedEntries = materializeResidentEntriesForReadSync(this.#fileEntries, this.#residentBlobStores());
 
 		// Close the current writer
 		await this.#closePersistWriter();
@@ -2947,7 +2984,10 @@ export class SessionManager {
 			hadSessionFile = this.storage.existsSync(oldSessionFile);
 			let movedSessionFile = false;
 			let movedArtifactDir = false;
-			const materializedEntries = materializeResidentEntriesSync(this.#fileEntries, this.#residentBlobStores());
+			const materializedEntries = materializeResidentEntriesForReadSync(
+				this.#fileEntries,
+				this.#residentBlobStores(),
+			);
 			const restoreResidentStateAfterFailure = (): void => {
 				this.#fileEntries = materializedEntries;
 				this.#resetResidentTextBlobStore();
@@ -4006,7 +4046,7 @@ export class SessionManager {
 	getLeafEntry(): SessionEntry | undefined {
 		if (!this.#leafId) return undefined;
 		const entry = this.#byId.get(this.#leafId);
-		return entry ? materializeResidentEntrySync(entry, this.#residentBlobStores(), new Map()) : undefined;
+		return entry ? materializeResidentEntryForReadSync(entry, this.#residentBlobStores(), new Map()) : undefined;
 	}
 
 	/**
@@ -4176,7 +4216,7 @@ export class SessionManager {
 		const entry = this.#byId.get(id);
 		return entry
 			? rehydrateColdSpillEntry(
-					materializeResidentEntrySync(entry, this.#residentBlobStores(), new Map()),
+					materializeResidentEntryForReadSync(entry, this.#residentBlobStores(), new Map()),
 					this.#blobStore,
 					this.#residentBlobStoresForColdRehydrate(),
 				)
@@ -4193,7 +4233,7 @@ export class SessionManager {
 			visited.add(current.id);
 			path.push(
 				rehydrateColdSpillEntry(
-					materializeResidentEntrySync(current, this.#residentBlobStores(), cache),
+					materializeResidentEntryForReadSync(current, this.#residentBlobStores(), cache),
 					this.#blobStore,
 					this.#residentBlobStoresForColdRehydrate(),
 				),
@@ -4233,7 +4273,7 @@ export class SessionManager {
 			.filter((entry): entry is SessionEntry => entry.type !== "session")
 			.map(entry =>
 				rehydrateColdSpillEntry(
-					materializeResidentEntrySync(entry, this.#residentBlobStores(), cache),
+					materializeResidentEntryForReadSync(entry, this.#residentBlobStores(), cache),
 					this.#blobStore,
 					this.#residentBlobStoresForColdRehydrate(),
 				),
@@ -4244,7 +4284,7 @@ export class SessionManager {
 		this.#publicMaterializerCallCount++;
 		this.#getEntryMaterializerCallCount++;
 		const entry = this.#byId.get(id);
-		return entry ? materializeResidentEntrySync(entry, this.#residentBlobStores(), new Map()) : undefined;
+		return entry ? materializeResidentEntryForReadSync(entry, this.#residentBlobStores(), new Map()) : undefined;
 	}
 
 	/**
@@ -4255,7 +4295,7 @@ export class SessionManager {
 		const children: SessionEntry[] = [];
 		for (const entry of this.#byId.values()) {
 			if (entry.parentId === parentId) {
-				children.push(materializeResidentEntrySync(entry, this.#residentBlobStores(), cache));
+				children.push(materializeResidentEntryForReadSync(entry, this.#residentBlobStores(), cache));
 			}
 		}
 		return children;
@@ -4310,7 +4350,7 @@ export class SessionManager {
 		while (current) {
 			if (visited.has(current.id)) break;
 			visited.add(current.id);
-			path.push(materializeResidentEntrySync(current, this.#residentBlobStores(), cache));
+			path.push(materializeResidentEntryForReadSync(current, this.#residentBlobStores(), cache));
 			current = current.parentId ? this.#byId.get(current.parentId) : undefined;
 		}
 		path.reverse();
@@ -4375,7 +4415,7 @@ export class SessionManager {
 		}
 		if (entry.type !== "message" && entry.type !== "custom_message")
 			return materializeProviderVisibleEntrySync(entry, this.#residentBlobStores());
-		const materialized = materializeResidentEntrySync(entry, this.#residentBlobStores(), new Map());
+		const materialized = materializeResidentEntryForReadSync(entry, this.#residentBlobStores(), new Map());
 		const rehydrated = rehydrateColdSpillEntry(
 			materialized,
 			this.#blobStore,
@@ -4434,7 +4474,7 @@ export class SessionManager {
 		const resolvedTextBlobCache = new Map<string, string>();
 		const materializedEntries = this.#fileEntries
 			.filter((e): e is SessionEntry => e.type !== "session")
-			.map(entry => materializeResidentEntrySync(entry, this.#residentBlobStores(), resolvedTextBlobCache));
+			.map(entry => materializeResidentEntryForReadSync(entry, this.#residentBlobStores(), resolvedTextBlobCache));
 		this.#materializedEntriesCache = materializedEntries;
 		this.#materializedEntriesRevision = this.#entryRevision;
 		return materializedEntries;
@@ -4591,7 +4631,7 @@ export class SessionManager {
 
 		// Filter out LabelEntry from path - we'll recreate them from the resolved map
 		const pathWithoutLabels = branchPath.filter(e => e.type !== "label");
-		const materializedPathWithoutLabels = materializeResidentEntriesSync(
+		const materializedPathWithoutLabels = materializeResidentEntriesForReadSync(
 			pathWithoutLabels,
 			this.#residentBlobStores(),
 		);

package/src/system-prompt.ts

@@ -356,6 +356,10 @@ export interface BuildSystemPromptOptions {
 	mcpDiscoveryMode?: boolean;
 	/** Discoverable MCP server summaries to advertise when discovery mode is active. */
 	mcpDiscoveryServerSummaries?: string[];
+	/** Whether built-in tool discovery ("all" mode) is active; enables the tool-discovery prompt block. */
+	toolDiscoveryActive?: boolean;
+	/** Hidden discoverable tools to advertise (name + one-line summary) when tool discovery is active. */
+	discoverableTools?: Array<{ name: string; summary: string }>;
 	/** Encourage the agent to delegate via tasks unless changes are trivial. */
 	eagerTasks?: boolean;
 	/** Rules with alwaysApply=true — their full content is injected into the prompt. */
@@ -394,6 +398,8 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		intentField,
 		mcpDiscoveryMode = false,
 		mcpDiscoveryServerSummaries = [],
+		toolDiscoveryActive = false,
+		discoverableTools = [],
 		eagerTasks = false,
 		secretsEnabled = false,
 		workspaceTree: providedWorkspaceTree,
@@ -572,6 +578,8 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		mcpDiscoveryMode,
 		hasMCPDiscoveryServers: mcpDiscoveryServerSummaries.length > 0,
 		mcpDiscoveryServerSummaries,
+		toolDiscoveryActive,
+		discoverableTools,
 		eagerTasks,
 		secretsEnabled,
 	};

package/src/task/executor.ts

@@ -1535,6 +1535,11 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					);
 					await awaitAbortable(session.waitForIdle());
 				} catch (err) {
+					// An abort (parent cancel, session shutdown, timeout) rejects
+					// awaitAbortable with ToolAbortError — a cancellation, not a prompt
+					// failure. Mirror the outer catch's `!abortSignal.aborted` guard so
+					// expected cancellations aren't logged at error level.
+					if (abortSignal.aborted || err instanceof ToolAbortError) break;
 					logger.error("Subagent prompt failed", {
 						error: err instanceof Error ? err.message : String(err),
 					});

package/src/tools/ast-grep.ts

@@ -223,13 +223,16 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 				const modelOut: string[] = [];
 				const displayOut: string[] = [];
 				const fileMatches = matchesByFile.get(relativePath) ?? [];
-				const lineNumberWidth = fileMatches.reduce((width, match) => {
-					const lineCount = match.text.split("\n").length;
-					const endLine = match.startLine + lineCount - 1;
-					return Math.max(width, String(match.startLine).length, String(endLine).length);
-				}, 0);
-				for (const match of fileMatches) {
-					const matchLines = match.text.split("\n");
+				const preparedMatches = fileMatches.map(match => {
+					const lines = match.text.split("\n");
+					const endLine = match.startLine + lines.length - 1;
+					return { match, lines, endLine };
+				});
+				const lineNumberWidth = preparedMatches.reduce(
+					(width, entry) => Math.max(width, String(entry.match.startLine).length, String(entry.endLine).length),
+					0,
+				);
+				for (const { match, lines: matchLines } of preparedMatches) {
 					for (let index = 0; index < matchLines.length; index++) {
 						const lineNumber = match.startLine + index;
 						const isMatch = index === 0;

package/src/tools/bash.ts

@@ -833,9 +833,22 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			});
 		}
 
+		// Route through the client terminal when the client advertises the terminal capability.
+		// Skip when pty=true (PTY needs the local terminal UI).
+		const clientBridge =
+			this.session.bashRestrictionProfile === "read-only" ? undefined : this.session.getClientBridge?.();
+		const clientTerminalActive = Boolean(clientBridge?.capabilities.terminal && clientBridge.createTerminal && !pty);
+
 		const autoBgManager = AsyncJobManager.instance();
-		if (this.#autoBackgroundEnabled && !pty && autoBgManager) {
-			const autoBackgroundWaitMs = this.#resolveAutoBackgroundWaitMs(timeoutMs);
+		// Run non-PTY bash through the managed job path so Ctrl+B-twice fold-on-demand works
+		// even when auto-background is disabled. When a client terminal will handle the
+		// command, keep the existing bridge path unless auto-background is enabled.
+		if (!pty && autoBgManager && (this.#autoBackgroundEnabled || !clientTerminalActive)) {
+			// With auto-background off, wait past the command's own timeout so the job only
+			// leaves the foreground on an explicit Ctrl+B fold, never on an auto-background timer.
+			const autoBackgroundWaitMs = this.#autoBackgroundEnabled
+				? this.#resolveAutoBackgroundWaitMs(timeoutMs)
+				: timeoutMs + 1_000;
 			const startBackgrounded = autoBackgroundWaitMs === 0;
 			const job = this.#startManagedBashJob({
 				command,
@@ -891,10 +904,6 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			});
 		}
 
-		// Route through the client terminal when the client advertises the terminal capability.
-		// Skip when pty=true (PTY needs the local terminal UI).
-		const clientBridge =
-			this.session.bashRestrictionProfile === "read-only" ? undefined : this.session.getClientBridge?.();
 		if (clientBridge?.capabilities.terminal && clientBridge.createTerminal && !pty) {
 			const handle = await clientBridge.createTerminal({
 				command,

package/src/tools/index.ts

@@ -325,7 +325,14 @@ export type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool |
 export type BuiltinToolLoadMode = "essential" | "discoverable";
 
 /** Default essential tool names when tools.essentialOverride is empty. */
-export const DEFAULT_ESSENTIAL_TOOL_NAMES: readonly string[] = ["read", "bash", "edit"] as const;
+export const DEFAULT_ESSENTIAL_TOOL_NAMES: readonly string[] = [
+	"read",
+	"bash",
+	"edit",
+	"write",
+	"search",
+	"find",
+] as const;
 
 /**
  * Resolve the active essential built-in tool names from settings.

package/src/workflow/workflow-intent-diff.ts

@@ -0,0 +1,199 @@
+export const WORKFLOW_INTENT_DIFF_CUSTOM_TYPE = "workflow-intent-diff";
+
+export type WorkflowIntentRoute = "direct" | "deep-interview" | "ralplan" | "ultragoal" | "team";
+export type DirectTrackingMode = "custom-entry-only" | "not-direct";
+export type RootCausePhaseStatus = "active" | "inactive";
+
+export interface WorkflowIntentDiff {
+	readonly version: 1;
+	readonly route: WorkflowIntentRoute;
+	readonly reason: string;
+	readonly directTracking: DirectTrackingMode;
+	readonly recommendedSkill?: Exclude<WorkflowIntentRoute, "direct">;
+	readonly recommendedInvocation?: string;
+	readonly triggers: readonly string[];
+	readonly rootCausePhase: {
+		readonly status: RootCausePhaseStatus;
+		readonly triggers: readonly string[];
+	};
+	readonly promptPreview: string;
+}
+
+interface RouteMatch {
+	readonly route: WorkflowIntentRoute;
+	readonly reason: string;
+	readonly recommendedInvocation?: string;
+	readonly triggers: readonly string[];
+}
+
+const PROMPT_PREVIEW_LIMIT = 240;
+
+const DURABLE_TRACKING_PATTERNS = [
+	/\bultragoal\b/i,
+	/\bdurable (?:goal|tracking|ledger|plan)\b/i,
+	/\b(?:goal|tracking|plan) ledger\b/i,
+	/\bcheckpoint(?:ed|ing)? (?:goal|plan|workflow|release|work)\b/i,
+	/\bcheckpoint (?:this|the) (?:goal|plan|workflow|release|work)\b/i,
+] as const;
+
+const AMBIGUOUS_REQUIREMENT_PATTERNS = [
+	/\bambiguous (?:requirement|requirements|request|requests|scope)\b/i,
+	/\bdeep[- ]interview\b/i,
+	/\binterview me\b/i,
+	/\bdon't assume\b/i,
+	/\bnot sure\b/i,
+	/\bunclear\b/i,
+	/\bvague\b/i,
+] as const;
+
+const ARCHITECTURE_SEQUENCE_PATTERNS = [
+	/\barchitecture\b/i,
+	/\barchitectural\b/i,
+	/\bsequence\b/i,
+	/\bmigrate\b/i,
+	/\bmigration\b/i,
+	/\bauth(?:entication|orization)? (?:migration|sequence|rollout|release|refactor|rewrite|transition)\b/i,
+	/\bsecurity\b/i,
+	/\bcompliance\b/i,
+	/\bPII\b/i,
+	/\bproduction (?:release|rollout|deployment|migration|incident|data|change|cutover)\b/i,
+	/\bdeploy(?:ing)? to production\b/i,
+	/\bbreaking change\b/i,
+	/\bdata loss\b/i,
+	/\bdestructive\b/i,
+] as const;
+
+const TEAM_PATTERNS = [
+	/\buse (?:a )?team\b/i,
+	/\bcoordinated (?:persistent )?workers\b/i,
+	/\bpersistent workers\b/i,
+	/\bworker coordination\b/i,
+] as const;
+
+const ROOT_CAUSE_TRIGGERS = [
+	{ name: "contradiction", pattern: /\bcontradict(?:ion|s|ory)?\b/i },
+	{ name: "regression", pattern: /\bregression\b/i },
+	{
+		name: "high-risk transition",
+		pattern:
+			/\b(?:migrate|migration|auth(?:entication|orization)? (?:migration|sequence|rollout|release|refactor|rewrite|transition)|security|breaking change|data loss|destructive|production (?:release|rollout|deployment|migration|incident|data|change|cutover)|deploy(?:ing)? to production|compliance|PII)\b/i,
+	},
+] as const;
+
+function matchesAny(text: string, patterns: readonly RegExp[]): boolean {
+	return patterns.some(pattern => pattern.test(text));
+}
+
+function withGlobal(pattern: RegExp): RegExp {
+	const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+	return new RegExp(pattern.source, flags);
+}
+
+function isNegatedAt(text: string, index: number): boolean {
+	const prefix = text.slice(Math.max(0, index - 48), index).toLowerCase();
+	const boundary = Math.max(
+		prefix.lastIndexOf("."),
+		prefix.lastIndexOf(","),
+		prefix.lastIndexOf(";"),
+		prefix.lastIndexOf(":"),
+		prefix.lastIndexOf("?"),
+		prefix.lastIndexOf("!"),
+		prefix.lastIndexOf("\n"),
+		prefix.lastIndexOf(" but "),
+		prefix.lastIndexOf(" however "),
+		prefix.lastIndexOf(" yet "),
+		prefix.lastIndexOf(" then "),
+	);
+	const localPrefix = boundary >= 0 ? prefix.slice(boundary + 1) : prefix;
+	return /(?:^|[\s([{])(?:no|not|without|excluding|exclude|absent|absence of|avoid)\b[^.,!?;:\n]{0,48}$/.test(
+		localPrefix,
+	);
+}
+
+function matchesAnyNonNegated(text: string, patterns: readonly RegExp[]): boolean {
+	return patterns.some(pattern => {
+		for (const match of text.matchAll(withGlobal(pattern))) {
+			if (!isNegatedAt(text, match.index ?? 0)) return true;
+		}
+		return false;
+	});
+}
+
+function collectRootCauseTriggers(text: string): readonly string[] {
+	return ROOT_CAUSE_TRIGGERS.filter(trigger => matchesAnyNonNegated(text, [trigger.pattern])).map(
+		trigger => trigger.name,
+	);
+}
+
+function buildPromptPreview(text: string): string {
+	const compact = text.replace(/\s+/g, " ").trim();
+	return compact.length > PROMPT_PREVIEW_LIMIT ? `${compact.slice(0, PROMPT_PREVIEW_LIMIT - 3)}...` : compact;
+}
+
+function classifyRoute(text: string): RouteMatch {
+	if (matchesAny(text, AMBIGUOUS_REQUIREMENT_PATTERNS)) {
+		return {
+			route: "deep-interview",
+			reason: "ambiguous requirements need clarification",
+			recommendedInvocation: "/skill:deep-interview",
+			triggers: ["ambiguous requirements"],
+		};
+	}
+
+	if (matchesAny(text, DURABLE_TRACKING_PATTERNS)) {
+		return {
+			route: "ultragoal",
+			reason: "durable tracking requested",
+			recommendedInvocation: "/skill:ultragoal",
+			triggers: ["durable tracking"],
+		};
+	}
+
+	if (matchesAnyNonNegated(text, ARCHITECTURE_SEQUENCE_PATTERNS)) {
+		return {
+			route: "ralplan",
+			reason: "architecture or sequence risk requires deliberate planning",
+			recommendedInvocation: "/skill:ralplan --deliberate",
+			triggers: ["architecture/sequence risk"],
+		};
+	}
+
+	if (matchesAny(text, TEAM_PATTERNS)) {
+		return {
+			route: "team",
+			reason: "coordinated persistent workers requested",
+			recommendedInvocation: "/skill:team",
+			triggers: ["coordinated workers"],
+		};
+	}
+
+	return {
+		route: "direct",
+		reason: "clear low-risk prompt stays on direct implementation path",
+		triggers: ["low-risk direct"],
+	};
+}
+
+export function buildWorkflowIntentDiff(text: string): WorkflowIntentDiff | null {
+	const promptPreview = buildPromptPreview(text);
+	if (!promptPreview) return null;
+
+	const route = classifyRoute(text);
+	const rootCauseTriggers = collectRootCauseTriggers(text);
+	const rootCauseActive = rootCauseTriggers.length > 0;
+	const direct = route.route === "direct";
+
+	return {
+		version: 1,
+		route: route.route,
+		reason: route.reason,
+		directTracking: direct ? "custom-entry-only" : "not-direct",
+		...(direct ? {} : { recommendedSkill: route.route, recommendedInvocation: route.recommendedInvocation }),
+		triggers: route.triggers,
+		rootCausePhase: {
+			status: rootCauseActive ? "active" : "inactive",
+			triggers: rootCauseTriggers,
+		},
+		promptPreview,
+	};
+}

package/dist/types/discovery/vscode.d.ts

@@ -1 +0,0 @@
-export {};

package/src/discovery/vscode.ts

@@ -1,105 +0,0 @@
-/**
- * VS Code Provider
- *
- * Loads config from `.vscode` directory (project-only).
- * Supports MCP server discovery from `mcp.json` with nested `mcp.servers` structure.
- */
-import { tryParseJson } from "@gajae-code/utils";
-import { registerProvider } from "../capability";
-import { readFile } from "../capability/fs";
-import { type MCPServer, mcpCapability } from "../capability/mcp";
-import type { LoadContext, LoadResult } from "../capability/types";
-import { createSourceMeta, expandEnvVarsDeep, getProjectPath } from "./helpers";
-
-const PROVIDER_ID = "vscode";
-const DISPLAY_NAME = "VS Code";
-const PRIORITY = 20;
-
-// =============================================================================
-// MCP Servers
-// =============================================================================
-
-registerProvider<MCPServer>(mcpCapability.id, {
-	id: PROVIDER_ID,
-	displayName: DISPLAY_NAME,
-	description: "Load MCP servers from .vscode/mcp.json",
-	priority: PRIORITY,
-	async load(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
-		const items: MCPServer[] = [];
-		const warnings: string[] = [];
-
-		// Project-only (VS Code doesn't support user-level MCP config)
-		const projectPath = getProjectPath(ctx, "vscode", "mcp.json");
-		if (projectPath) {
-			const result = await loadMCPConfig(ctx, projectPath, "project");
-			items.push(...result.items);
-			if (result.warnings) warnings.push(...result.warnings);
-		}
-
-		return { items, warnings };
-	},
-});
-
-/**
- * Load MCP servers from a mcp.json file.
- * VS Code uses nested structure: { "mcp": { "servers": { ... } } }
- */
-async function loadMCPConfig(
-	_ctx: LoadContext,
-	path: string,
-	level: "user" | "project",
-): Promise<LoadResult<MCPServer>> {
-	const items: MCPServer[] = [];
-	const warnings: string[] = [];
-
-	const content = await readFile(path);
-	if (!content) {
-		warnings.push(`Failed to read ${path}`);
-		return { items, warnings };
-	}
-
-	const parsed = tryParseJson<{ mcp?: { servers?: Record<string, unknown> } }>(content);
-	if (!parsed) {
-		warnings.push(`Invalid JSON in ${path}`);
-		return { items, warnings };
-	}
-
-	// VS Code uses nested structure: mcp.servers
-	const servers = parsed.mcp?.servers;
-	if (!servers || typeof servers !== "object") {
-		return { items, warnings };
-	}
-
-	for (const [name, config] of Object.entries(servers)) {
-		if (!config || typeof config !== "object") {
-			warnings.push(`Invalid config for server "${name}" in ${path}`);
-			continue;
-		}
-
-		const raw = config as Record<string, unknown>;
-
-		// Expand environment variables
-		const expanded = expandEnvVarsDeep(raw);
-
-		const server: MCPServer = {
-			name,
-			command: typeof expanded.command === "string" ? expanded.command : undefined,
-			args: Array.isArray(expanded.args) ? (expanded.args as string[]) : undefined,
-			env: expanded.env && typeof expanded.env === "object" ? (expanded.env as Record<string, string>) : undefined,
-			url: typeof expanded.url === "string" ? expanded.url : undefined,
-			headers:
-				expanded.headers && typeof expanded.headers === "object"
-					? (expanded.headers as Record<string, string>)
-					: undefined,
-			transport: ["stdio", "sse", "http"].includes(expanded.transport as string)
-				? (expanded.transport as "stdio" | "sse" | "http")
-				: undefined,
-			timeout: typeof expanded.timeout === "number" ? expanded.timeout : undefined,
-			_source: createSourceMeta(PROVIDER_ID, path, level),
-		};
-
-		items.push(server);
-	}
-
-	return { items, warnings };
-}