pi-codebuddy-sdk 0.1.19 → 0.3.0

package/src/index.ts

@@ -1,22 +1,23 @@
 import { calculateCost, StringEnum, type AssistantMessage, type AssistantMessageEventStream, type Context, type Model, type SimpleStreamOptions, type Tool } from "@earendil-works/pi-ai";
 import * as piAi from "@earendil-works/pi-ai";
-
 import { buildSessionContext, compact, keyHint, type CompactionEntry, type ExtensionAPI, type ExtensionUIContext } from "@earendil-works/pi-coding-agent";
-import { query, type EffortLevel, type SDKMessage, type SDKUserMessage } from "@tencent-ai/agent-sdk";
-import type { Base64ImageSource, ContentBlockParam, MessageParam } from "@tencent-ai/agent-sdk";
+import { createSdkMcpServer, query, type Effort, type Message as CbMessage, type UserMessage as CbUserMessage } from "@tencent-ai/agent-sdk";
 import { Type } from "typebox";
 import { Text } from "@earendil-works/pi-tui";
+import { createSession, deleteSession } from "./cb-session-io.js";
 import { appendFileSync, mkdirSync, realpathSync, statSync } from "fs";
 import { homedir } from "os";
 import { dirname, join } from "path";
 import { PROVIDER_ID, messageContentToText, convertPiMessages } from "./convert.js";
-import { buildModels, codebuddyModelId, resolveModel as _resolveModel } from "./models.js";
-import { extractSkillsBlock } from "./skills.js";
-
+import { buildModels, codebuddyModelId, FALLBACK_MODELS, rawModelsFromSdk, resolveModel as _resolveModel, type PiModel } from "./models.js";
+import { MCP_SERVER_NAME, MCP_TOOL_PREFIX, buildCodebuddySystemPrompt } from "./skills.js";
+import { verifyWrittenSession as _verifyWrittenSession } from "./session-verify.js";
+import { extractAllToolResults as _extractAllToolResults, type McpResult } from "./extract-tool-results.js";
 import { QueryContext, ctx } from "./query-state.js";
 import { loadConfig, type Config } from "./config.js";
-import { extractAgentsAppend } from "./agents-md.js";
+import { jsonSchemaToZodShape } from "./typebox-to-zod.js";
 import { buildActionSummary, type ToolCallState } from "./askcodebuddy-ui.js";
+import { withSdkGate } from "./sdk-gate.js";
 
 // Compat (#2): use factory if available (pi-ai ≥0.66), else fall back to constructor (gsd-pi etc.)
 const _piAi = piAi as any;
@@ -26,11 +27,28 @@ const newAssistantMessageEventStream: () => AssistantMessageEventStream =
 		: () => new _piAi.AssistantMessageEventStream();
 
 // --- Debug logging ---
-// CODEBUDDY_DEBUG=1 enables debug logging to ~/.pi/agent/codebuddy-sdk.log
+// CODEBUDDY_SDK_DEBUG=1 enables local debug logs (metadata only; paths redacted; no prompt/tool bodies).
 
-const DEBUG = process.env.CODEBUDDY_DEBUG === "1";
-const DEBUG_LOG_PATH = process.env.CODEBUDDY_DEBUG_PATH || join(homedir(), ".pi", "agent", "codebuddy-sdk.log");
+const DEBUG = process.env.CODEBUDDY_SDK_DEBUG === "1";
+const DEBUG_LOG_PATH = process.env.CODEBUDDY_SDK_DEBUG_PATH || join(homedir(), ".pi", "agent", "codebuddy-sdk.log");
 const DIAG_LOG_PATH = join(homedir(), ".pi", "agent", "codebuddy-sdk-diag.log");
+const ISSUES_URL = "https://github.com/RealAlexandreAI/pi-codebuddy-sdk/issues/new";
+
+function redactForLog(value: string): string {
+	const home = homedir();
+	return home && value.includes(home) ? value.split(home).join("~") : value;
+}
+
+function redactLogValue(value: unknown): unknown {
+	if (typeof value === "string") return redactForLog(value);
+	if (Array.isArray(value)) return value.map(redactLogValue);
+	if (value && typeof value === "object") {
+		const out: Record<string, unknown> = {};
+		for (const [k, v] of Object.entries(value)) out[k] = redactLogValue(v);
+		return out;
+	}
+	return value;
+}
 
 // Ensure log directories exist when debug is enabled
 if (DEBUG) {
@@ -49,46 +67,36 @@ function debug(...args: unknown[]) {
 	if (!DEBUG) return;
 	const ts = new Date().toISOString();
 	const fmt = (a: unknown): string => {
-		if (typeof a === "string") return a;
-		if (a instanceof Error) return `${a.name}: ${a.message}${a.stack ? "\n" + a.stack : ""}`;
-		return JSON.stringify(a);
+		if (typeof a === "string") return redactForLog(a);
+		if (a instanceof Error) return redactForLog(`${a.name}: ${a.message}`);
+		return redactForLog(JSON.stringify(a));
 	};
 	const msg = args.map(fmt).join(" ");
 	appendFileSync(DEBUG_LOG_PATH, `[${ts}] [${moduleInstanceId}] ${msg}\n`);
 }
 
-// Per-query CLI debug capture. When CODEBUDDY_DEBUG=1, ask the CodeBuddy
-// CLI subprocess to write its own debug log to a file we choose, and also
-// forward its stderr into our debug stream. Drops straight into the real SDK's
-// Options — see @tencent-ai/agent-sdk sdk.d.ts:1245 (debug, debugFile,
-// stderr). Without this, CC's internal view of the world is invisible to us
-// and "No conversation found" / empty-error reports are unactionable.
+// Per-query CLI debug capture. When CODEBUDDY_SDK_DEBUG=1, ask the CodeBuddy CLI
+// subprocess to write its own debug log locally. We do not forward stderr (may
+// contain prompt or credential hints).
 let nextCliDebugSeq = 1;
-function makeCliDebugOptions(tag: string): { debug?: boolean; debugFile?: string; stderr?: (data: string) => void } {
+function makeCliDebugOptions(tag: string): { debug?: boolean; debugFile?: string } {
 	if (!DEBUG) return {};
 	const seq = nextCliDebugSeq++;
 	const ts = new Date().toISOString().replace(/[:.]/g, "-");
-	const logDir = join(dirname(DEBUG_LOG_PATH), "cc-cli-logs");
+	const logDir = join(dirname(DEBUG_LOG_PATH), "cb-cli-logs");
 	try { mkdirSync(logDir, { recursive: true }); } catch { /* ignore */ }
 	const debugFile = join(logDir, `${ts}-${tag}-${seq}.log`);
-	debug(`cli-debug: ${tag} #${seq} → ${debugFile}`);
-	return {
-		debug: true,
-		debugFile,
-		stderr: (data: string) => {
-			for (const line of data.split(/\r?\n/)) {
-				if (line) debug(`[cli-stderr ${tag}#${seq}] ${line}`);
-			}
-		},
-	};
+	debug(`cli-debug: ${tag} #${seq} → ${redactForLog(debugFile)}`);
+	return { debug: true, debugFile };
 }
 
-/** Unconditional diagnostic dump — for "should never happen" paths */
+/** Diagnostic dump for "should never happen" paths — only when debug is enabled */
 function diagDump(label: string, data: Record<string, unknown>) {
+	if (!DEBUG) return;
 	const ts = new Date().toISOString();
-	const entry = { ts, moduleInstanceId, label, ...data };
+	const entry = { ts, moduleInstanceId, label, ...redactLogValue(data) as Record<string, unknown> };
 	appendFileSync(DIAG_LOG_PATH, JSON.stringify(entry) + "\n");
-	debug(`DIAG: ${label} (see ${DIAG_LOG_PATH})`);
+	debug(`DIAG: ${label} (see ${redactForLog(DIAG_LOG_PATH)})`);
 }
 
 // --- Constants ---
@@ -113,18 +121,16 @@ const SDK_TO_PI_TOOL_NAME: Record<string, string> = {
 	read: "read", write: "write", edit: "edit", bash: "bash",
 };
 
-// MODELS — hardcoded for CodeBuddy provider
-const MODELS = buildModels([
-  { id: "hy3-preview-agent-ioa", name: "Hunyuan 3", reasoning: false, input: ["text"], contextWindow: 131072, maxTokens: 8192 },
-  { id: "claude-sonnet-4.6", name: "Claude Sonnet 4.6", reasoning: true, input: ["text", "image"], contextWindow: 200000, maxTokens: 8192 },
-  { id: "deepseek-v4-pro-ioa", name: "DeepSeek V4 Pro", reasoning: false, input: ["text"], contextWindow: 131072, maxTokens: 8192 },
-  { id: "glm-5.2-ioa", name: "GLM 5.2", reasoning: false, input: ["text"], contextWindow: 131072, maxTokens: 8192 },
-] as any);
+let MODELS: PiModel[] = buildModels(FALLBACK_MODELS);
 let providerSettings: NonNullable<Config["provider"]> = {};
-let longContextSettings: any = { plan: "pro", longContextExtraUsage: false };
+
+type ContentBlockParam =
+	| { type: "text"; text: string }
+	| { type: "image"; source: { type: "base64"; media_type: string; data: string } };
+type SettingSource = "user" | "project" | "local";
 
 function resolveModel(input: string) {
-	return _resolveModel(MODELS, input) as any;
+	return _resolveModel(MODELS, input);
 }
 
 // --- Error handling ---
@@ -206,29 +212,25 @@ function convertAndImportMessages(
 	debug(`convertAndImportMessages: imported roles:`, anthropicMessages.map((m, i) => {
 		const c = m.content;
 		if (typeof c === "string") return `[${i}]${m.role}:text`;
-		if (Array.isArray(c)) return `[${i}]${m.role}:${(c).map((b) => b.type).join("+")}`;
+		if (Array.isArray(c)) return `[${i}]${m.role}:${c.map((b: { type?: string }) => b.type).join("+")}`;
 		return `[${i}]${m.role}:?`;
 	}).join(" "));
 	if (sanitizedIds.size > 0) {
 		debug(`convertAndImportMessages: sanitized ${sanitizedIds.size} tool IDs:`,
 			[...sanitizedIds.entries()].map(([orig, clean]) => orig === clean ? orig : `${orig}→${clean}`).join(", "));
 	}
-	// Pre-repair for debug logging; importMessages also repairs internally (idempotent).
-	const repaired = repairToolPairing(anthropicMessages);
-	if (repaired.length !== anthropicMessages.length) {
-		debug(`convertAndImportMessages: repairToolPairing ${anthropicMessages.length} → ${repaired.length} msgs`);
-	}
-	if (repaired.length) session.importMessages(repaired);
+	if (messages.length) session.importPiMessages(messages);
 }
 
 // Pi doesn't pass tool results directly — it appends them to the context and calls
+// the provider again. Thin wrapper over extract-tool-results.js that adds per-turn
 // debug logging at the extraction boundary.
 function extractAllToolResults(context: Context): McpResult[] {
 	const { results, stopIdx } = _extractAllToolResults(context.messages as unknown as Array<{ role: string; [key: string]: unknown }>);
 	debug(`extractAllToolResults: ${results.length} results from ${context.messages.length} msgs, stopped at index ${stopIdx}`);
 	debug(`extractAllToolResults: all msg roles:`, context.messages.map((m, i) => `[${i}]${m.role}`).join(" "));
 	for (let r = 0; r < results.length; r++) {
-		debug(`extractAllToolResults: result[${r}] id=${results[r].toolCallId}${results[r].isError ? " ERROR" : ""} preview:`, JSON.stringify(results[r].content).slice(0, 150));
+		debug(`extractAllToolResults: result[${r}] id=${results[r].toolCallId}${results[r].isError ? " ERROR" : ""} contentLen=${JSON.stringify(results[r].content).length}`);
 	}
 	return results;
 }
@@ -269,18 +271,19 @@ function extractUserPromptBlocks(messages: Context["messages"]): ContentBlockPar
 			hasImage = true;
 			blocks.push({
 				type: "image",
-				source: { type: "base64", media_type: block.mimeType as Base64ImageSource["media_type"], data: block.data },
+				source: { type: "base64", media_type: block.mimeType, data: block.data },
 			});
 		}
 	}
 	return hasImage ? blocks : null;
 }
 
-async function* wrapPromptStream(blocks: ContentBlockParam[]): AsyncIterable<SDKUserMessage> {
+async function* wrapPromptStream(blocks: ContentBlockParam[]): AsyncIterable<CbUserMessage> {
 	yield {
 		type: "user",
-		message: { role: "user", content: blocks } as MessageParam,
+		session_id: "",
 		parent_tool_use_id: null,
+		message: { role: "user", content: blocks as any },
 	};
 }
 
@@ -311,8 +314,8 @@ function extractIsolatedSummaryPrompt(messages: Context["messages"]): string {
 	return promptText;
 }
 
-function resultErrorText(message: SDKMessage): string {
-	const result = message as SDKMessage & { subtype?: string; errors?: unknown; error?: unknown };
+function resultErrorText(message: CbMessage): string {
+	const result = message as CbMessage & { subtype?: string; errors?: unknown; error?: unknown };
 	if (Array.isArray(result.errors)) return result.errors.map(String).join("\n");
 	if (typeof result.error === "string") return result.error;
 	return `CodeBuddy summary failed: ${result.subtype ?? "unknown result"}`;
@@ -341,7 +344,7 @@ async function runIsolatedSummary(
 	try {
 		const promptText = extractIsolatedSummaryPrompt(context.messages);
 		const cwd = (options as { cwd?: string } | undefined)?.cwd ?? process.cwd();
-		const claudeExecutable = loadConfig(cwd).provider?.pathToClaudeCodeExecutable;
+		const codebuddyExecutable = loadConfig(cwd).provider?.pathToCodebuddyCode;
 		const cliModel = codebuddyModelId(model);
 		debug(`compact summary: spawn model=${cliModel} registeredModel=${model.id} promptLen=${promptText.length}`);
 
@@ -349,16 +352,15 @@ async function runIsolatedSummary(
 			prompt: promptText,
 			options: {
 				cwd,
-				env: { ...process.env, DISABLE_AUTO_COMPACT: "1", CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1" },
+				env: { ...process.env, DISABLE_AUTO_COMPACT: "1" },
 				tools: [],
 				strictMcpConfig: true,
-				
-				skills: [],
+				settingSources: [] as SettingSource[],
 				persistSession: false,
 				systemPrompt: context.systemPrompt,
 				model: cliModel,
 				maxTurns: 1,
-				...(claudeExecutable ? { pathToClaudeCodeExecutable: claudeExecutable } : {}),
+				...(codebuddyExecutable ? { pathToCodebuddyCode: codebuddyExecutable } : {}),
 				...makeCliDebugOptions("compact-summary"),
 			},
 		});
@@ -459,13 +461,13 @@ function verifyWrittenSession(
 	for (const msg of warnings) {
 		debug(`WARNING session verify: ${msg}`);
 		piUI?.notify(
-			`Session file issue: ${msg}\n` +
-			`cwd=${cwd} realpath=${safeRealpath(cwd)} CLAUDE_CONFIG_DIR=${process.env.CLAUDE_CONFIG_DIR ?? "(unset)"}\n` +
-			`Please copy and paste this message into a new issue at https://github.com/elidickinson/pi-codebuddy-sdk/issues/new` +
-			(DEBUG ? ` and attach ${DEBUG_LOG_PATH}` : ` (rerun with CODEBUDDY_DEBUG=1 to capture a debug log)`),
+			`Session sync issue: ${msg}. ` +
+			`cwd=${redactForLog(cwd)}` +
+			(DEBUG ? ` (see ${redactForLog(DEBUG_LOG_PATH)})` : ` (set CODEBUDDY_SDK_DEBUG=1 for a local log)`) +
+			`. Report: ${ISSUES_URL}`,
 			"warning",
 		);
-		diagDump("session_verify_fail", { msg, jsonlPath, cwd, realpath: safeRealpath(cwd), claudeConfigDir: process.env.CLAUDE_CONFIG_DIR ?? null });
+		diagDump("session_verify_fail", { msg, jsonlPath, cwd, realpath: safeRealpath(cwd), codebuddyConfigDir: process.env.CODEBUDDY_CONFIG_DIR ?? null });
 	}
 }
 
@@ -475,7 +477,7 @@ function safeRealpath(p: string): string {
 
 // Diagnostic snapshot of where a session file was just written. Catches the
 // class of bugs where pi writes to ~/.claude/projects/<X> but CC SDK reads
-// from ~/.claude/projects/<Y> (symlinks, CLAUDE_CONFIG_DIR, hash mismatch).
+// from ~/.claude/projects/<Y> (symlinks, CODEBUDDY_CONFIG_DIR, hash mismatch).
 function debugSessionPaths(label: string, cwd: string, jsonlPath: string): void {
 	const realCwd = safeRealpath(cwd);
 	let fileSize: number | null = null;
@@ -485,11 +487,10 @@ function debugSessionPaths(label: string, cwd: string, jsonlPath: string): void
 		fileExists = true;
 		fileSize = st.size;
 	} catch { /* file may not exist yet */ }
-	debug(`${label}: cwd=${cwd}`);
-	if (realCwd !== cwd) debug(`${label}: realpath(cwd)=${realCwd} (DIFFERS — symlink-resolved path is what CC SDK uses)`);
-	debug(`${label}: jsonlPath=${jsonlPath}`);
+	debug(`${label}: cwd=${redactForLog(cwd)}`);
+	if (realCwd !== cwd) debug(`${label}: realpath(cwd)=${redactForLog(realCwd)} (symlink-resolved)`);
+	debug(`${label}: jsonlPath=${redactForLog(jsonlPath)}`);
 	debug(`${label}: fileExists=${fileExists}${fileSize != null ? ` size=${fileSize}` : ""}`);
-	debug(`${label}: env.CLAUDE_CONFIG_DIR=${process.env.CLAUDE_CONFIG_DIR ?? "(unset)"} HOME=${process.env.HOME ?? "(unset)"}`);
 }
 
 // Two semantic paths:
@@ -570,11 +571,11 @@ function syncSharedSession(
 	const preserveId = previousSessionId !== undefined && !sharedSession?.forceRotate;
 	if (preserveId) {
 		// Wipe prior jsonl + companion dir (no-op if nothing to wipe).
-		deleteSession(previousSessionId!, cwd, process.env.CLAUDE_CONFIG_DIR);
+		deleteSession(previousSessionId!, cwd, process.env.CODEBUDDY_CONFIG_DIR);
 	}
 	const session = createSession({
 		projectPath: cwd,
-		claudeDir: process.env.CLAUDE_CONFIG_DIR,
+		codebuddyDir: process.env.CODEBUDDY_CONFIG_DIR,
 		...(preserveId ? { sessionId: previousSessionId } : {}),
 		...(modelId ? { model: modelId } : {}),
 	});
@@ -675,6 +676,29 @@ function contextForToolResults(results: McpResult[]): QueryContext | undefined {
 	return undefined;
 }
 
+function resolveMcpTools(context: Context, excludeToolName?: string): {
+	mcpTools: Tool[];
+	customToolNameToSdk: Map<string, string>;
+	customToolNameToPi: Map<string, string>;
+} {
+	const mcpTools: Tool[] = [];
+	const customToolNameToSdk = new Map<string, string>();
+	const customToolNameToPi = new Map<string, string>();
+
+	if (!context.tools) return { mcpTools, customToolNameToSdk, customToolNameToPi };
+
+	for (const tool of context.tools) {
+		if (tool.name === excludeToolName) continue;
+		const sdkName = `${MCP_TOOL_PREFIX}${tool.name}`;
+		mcpTools.push(tool);
+		customToolNameToSdk.set(tool.name, sdkName);
+		customToolNameToSdk.set(tool.name.toLowerCase(), sdkName);
+		customToolNameToPi.set(sdkName, tool.name);
+		customToolNameToPi.set(sdkName.toLowerCase(), tool.name);
+	}
+
+	return { mcpTools, customToolNameToSdk, customToolNameToPi };
+}
 
 // Creates an MCP server that bridges pi tools to the SDK. Each tool handler
 // blocks on a Promise until pi delivers the tool result via streamSimple.
@@ -682,7 +706,31 @@ function contextForToolResults(results: McpResult[]): QueryContext | undefined {
 // emits tool_use blocks). Results are matched by ID, not position.
 // Handlers close over the captured `queryCtx`, ensuring they operate on the
 // correct query's state while multiple queries run concurrently.
-// ponytail: MCP bridge function removed
+function buildMcpServers(tools: Tool[], queryCtx: QueryContext): Record<string, ReturnType<typeof createSdkMcpServer>> | undefined {
+	if (!tools.length) return undefined;
+	const mcpTools = tools.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		inputSchema: jsonSchemaToZodShape(tool.parameters),
+		handler: async () => {
+			const toolCallId = queryCtx.turnToolCallIds[queryCtx.nextHandlerIdx++];
+			if (!toolCallId) debug(`WARNING: mcp handler ${tool.name} has no toolCallId (idx=${queryCtx.nextHandlerIdx - 1}, available=${queryCtx.turnToolCallIds.length})`);
+			if (toolCallId && queryCtx.pendingResults.has(toolCallId)) {
+				const result = queryCtx.pendingResults.get(toolCallId)!;
+				queryCtx.pendingResults.delete(toolCallId);
+				debug(`mcp handler: ${tool.name} [${toolCallId}] → resolved from queue (${queryCtx.pendingResults.size} remaining)`);
+				return result;
+			}
+			debug(`mcp handler: ${tool.name} [${toolCallId}] → waiting`);
+			return new Promise<McpResult>((resolve) => {
+				queryCtx.pendingToolCalls.set(toolCallId, { toolName: tool.name, resolve });
+			});
+		},
+	}));
+	const server = createSdkMcpServer({ name: MCP_SERVER_NAME, version: "1.0.0", tools: mcpTools });
+	return { [MCP_SERVER_NAME]: server };
+}
+
 // --- Usage helpers ---
 
 function updateUsage(output: AssistantMessage, usage: Record<string, number | undefined>, model: Model<any>): void {
@@ -707,7 +755,7 @@ function updateUsage(output: AssistantMessage, usage: Record<string, number | un
 // match the docs — e.g. bare Opus served 200K on Pro, or [1m] not honored.
 // The result message's modelUsage is otherwise discarded; this makes the
 // gap observable. See issue #18.
-function logServedContextWindow(label: string, message: SDKMessage, model: Model<any>): void {
+function logServedContextWindow(label: string, message: CbMessage, model: Model<any>): void {
 	const modelUsage = (message as any).modelUsage as Record<string, { contextWindow?: number; maxOutputTokens?: number }> | undefined;
 	if (!modelUsage) return;
 	for (const [k, v] of Object.entries(modelUsage)) {
@@ -718,8 +766,8 @@ function logServedContextWindow(label: string, message: SDKMessage, model: Model
 // --- Effort level mapping ---
 // Pi reasoning levels → CC SDK effort levels
 
-const REASONING_TO_EFFORT: Record<string, EffortLevel> = {
-	minimal: "low", low: "low", medium: "medium", high: "high", xhigh: "max",
+const REASONING_TO_EFFORT: Record<string, Effort> = {
+	minimal: "low", low: "low", medium: "medium", high: "high", xhigh: "xhigh",
 };
 
 // --- Provider helpers: misc ---
@@ -775,7 +823,7 @@ function ensureTurnStarted(c: QueryContext): void {
 
 function finalizeCurrentStream(c: QueryContext, stopReason?: string): void {
 	if (!c.currentPiStream || !c.turnOutput) return;
-	debug(`provider: finalizeCurrentStream called, stopReason=${stopReason}, turnOutput=${JSON.stringify({stopReason: c.turnOutput!.stopReason, error: c.turnOutput!.errorMessage})}`);
+	debug(`provider: finalizeCurrentStream called, stopReason=${stopReason}, outputStop=${c.turnOutput!.stopReason}`);
 	if (!c.turnStarted) ensureTurnStarted(c);
 	const reason = stopReason === "length" ? "length" : "stop";
 	const stream = c.currentPiStream;
@@ -788,14 +836,14 @@ function finalizeCurrentStream(c: QueryContext, stopReason?: string): void {
 /** Maps Anthropic stream events to pi stream events (text, thinking, toolcall).
  *  On message_stop with tool_use: ends currentPiStream so pi can execute the tool. */
 function processStreamEvent(
-	message: SDKMessage,
+	message: CbMessage,
 	customToolNameToPi: Map<string, string>,
 	model: Model<any>,
 	c: QueryContext,
 ): void {
 	if (!c.currentPiStream || !c.turnOutput) return;
 	c.turnSawStreamEvent = true;
-	const event = (message as SDKMessage & { event: any }).event;
+	const event = (message as CbMessage & { event: any }).event;
 
 	if (event?.type === "message_start") {
 		c.turnToolCallIds = [];
@@ -904,7 +952,7 @@ function processStreamEvent(
 // arrives before any stream_events, this is the primary content path. Must maintain
 // the same stream lifecycle as processStreamEvent — including ending the stream on
 // tool_use to prevent deadlock with the MCP handler.
-function processAssistantMessage(message: SDKMessage, model: Model<any>, customToolNameToPi: Map<string, string>, c: QueryContext): void {
+function processAssistantMessage(message: CbMessage, model: Model<any>, customToolNameToPi: Map<string, string>, c: QueryContext): void {
 	if (c.turnSawStreamEvent) return;
 	const assistantMsg = (message as any).message;
 	if (!assistantMsg?.content) return;
@@ -975,18 +1023,19 @@ async function consumeQuery(
 		if (wasAborted()) break;
 		if (!queryCtx.currentPiStream || !queryCtx.turnOutput) continue;
 
-		switch (message.type) {
+		switch ((message as { type: string }).type) {
 			case "stream_event":
 				processStreamEvent(message, customToolNameToPi, model, queryCtx);
 				break;
 			case "assistant":
 				processAssistantMessage(message, model, customToolNameToPi, queryCtx);
 				break;
-			case "result":
+			case "result": {
+				const resultMsg = message as Extract<CbMessage, { type: "result" }>;
 				logServedContextWindow("result", message, model);
-				if (!queryCtx.turnSawStreamEvent && message.subtype === "success") {
+				if (!queryCtx.turnSawStreamEvent && resultMsg.subtype === "success") {
 					ensureTurnStarted(queryCtx);
-					const text = message.result || "";
+					const text = resultMsg.result || "";
 					queryCtx.turnBlocks.push({ type: "text", text });
 					const idx = queryCtx.turnBlocks.length - 1;
 					queryCtx.currentPiStream?.push({ type: "text_start", contentIndex: idx, partial: queryCtx.turnOutput });
@@ -994,21 +1043,23 @@ async function consumeQuery(
 					queryCtx.currentPiStream?.push({ type: "text_end", contentIndex: idx, content: text, partial: queryCtx.turnOutput });
 				}
 				break;
+			}
 			case "system":
 				if ((message as any).subtype === "init" && (message as any).session_id) {
 					capturedSessionId = (message as any).session_id;
 				}
 				break;
 			case "user":
-				break; // SDK echo of user prompt — not needed
+			case "file-history-snapshot":
+				break;
 			case "rate_limit_event": {
 				const info = (message as any).rate_limit_info;
 				debug("consumeQuery: rate_limit_event", JSON.stringify(info).slice(0, 300));
 				if (info?.status === "rejected") {
 					const resetsAt = info.resetsAt ? new Date(info.resetsAt).toLocaleTimeString() : "unknown";
-					piUI?.notify(`Claude rate limited (${info.rateLimitType ?? "unknown"}) — resets at ${resetsAt}`, "warning");
+					piUI?.notify(`CodeBuddy rate limited (${info.rateLimitType ?? "unknown"}) — resets at ${resetsAt}`, "warning");
 				} else if (info?.status === "allowed_warning") {
-					piUI?.notify(`Claude rate limit warning: ${Math.round(info.utilization ?? 0)}% used (${info.rateLimitType ?? ""})`, "warning");
+					piUI?.notify(`CodeBuddy rate limit warning: ${Math.round(info.utilization ?? 0)}% used (${info.rateLimitType ?? ""})`, "warning");
 				}
 				break;
 			}
@@ -1026,12 +1077,12 @@ async function consumeQuery(
 
 /** Provider entry point. Pi calls this for each new prompt and each tool result.
  *  Two cases: tool result delivery (active query) or fresh query. */
-function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream {
+function streamCodebuddySdk(model: Model<any>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream {
 	const stream = newAssistantMessageEventStream();
 
 	// DEBUG: trace followUp message triggering
 	const lastMsgRole = context.messages[context.messages.length - 1]?.role;
-	debug(`provider: streamClaudeAgentSdk called, activeQuery=${!!ctx().activeQuery}, lastMsgRole=${lastMsgRole}, isReentrant=${ctx().activeQuery !== null}`);
+	debug(`provider: streamCodebuddySdk called, activeQuery=${!!ctx().activeQuery}, lastMsgRole=${lastMsgRole}, isReentrant=${ctx().activeQuery !== null}`);
 
 	const activeQuery = ctx().activeQuery !== null;
 	const allResults = activeQueryContexts.size > 0 ? extractAllToolResults(context) : [];
@@ -1054,7 +1105,7 @@ function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: Sim
 			if (id && resultCtx.pendingToolCalls.has(id)) {
 				const pending = resultCtx.pendingToolCalls.get(id)!;
 				resultCtx.pendingToolCalls.delete(id);
-				debug(`provider: resolving ${pending.toolName} [${id}]${result.isError ? " (error)" : ""}`, JSON.stringify(result.content).slice(0, 200));
+				debug(`provider: resolving ${pending.toolName} [${id}]${result.isError ? " (error)" : ""} contentLen=${JSON.stringify(result.content).length}`);
 				pending.resolve(result);
 			} else if (id) {
 				resultCtx.pendingResults.set(id, result);
@@ -1068,7 +1119,7 @@ function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: Sim
 		}
 		if (resultCtx.pendingToolCalls.size > 0) {
 			debug(`WARNING: ${resultCtx.pendingToolCalls.size} MCP handlers still waiting after delivering ${allResults.length} results`);
-			piUI?.notify(`Claude bridge: ${resultCtx.pendingToolCalls.size} tool handler(s) still waiting — provider may be stuck`, "warning");
+			piUI?.notify(`CodeBuddy SDK: ${resultCtx.pendingToolCalls.size} tool handler(s) still waiting — provider may be stuck`, "warning");
 		}
 
 		// Detect user messages (steer/followUp) that pi injected into context
@@ -1083,7 +1134,7 @@ function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: Sim
 			const userPrompt = extractUserPrompt(context.messages);
 			if (userPrompt) {
 				resultCtx.deferredUserMessages.push(userPrompt);
-				debug(`provider: deferred user message for replay after query: ${userPrompt.slice(0, 60)}`);
+				debug(`provider: deferred user message for replay after query (len=${userPrompt.length})`);
 			}
 		}
 
@@ -1126,10 +1177,7 @@ function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: Sim
 	queryCtx.resetTurnState(model);
 	queryCtx.latestCursor = 0;
 
-	// ponytail: MCP bridge removed — CodeBuddy uses native tools
-	const mcpTools: any[] = [];
-	const customToolNameToSdk = new Map<string, string>();
-	const customToolNameToPi = new Map<string, string>();
+	const { mcpTools, customToolNameToSdk, customToolNameToPi } = resolveMcpTools(context, askCodebuddyToolName);
 	const cwd = (options as { cwd?: string } | undefined)?.cwd ?? process.cwd();
 	const syncResult = syncSharedSession(context.messages, cwd, customToolNameToSdk, model.id);
 	const { sessionId: resumeSessionId } = syncResult;
@@ -1152,34 +1200,31 @@ function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: Sim
 		promptText = "[continue]";
 	}
 
-	const prompt: string | AsyncIterable<SDKUserMessage> = promptBlocks
+	const prompt: string | AsyncIterable<CbUserMessage> = promptBlocks
 		? wrapPromptStream(promptBlocks)
 		: promptText;
-	// ponytail: MCP bridge removed
-	const mcpServers = {};
+	const mcpServers = buildMcpServers(mcpTools, queryCtx);
 	const appendSystemPrompt = providerSettings.appendSystemPrompt !== false;
-	const agentsAppend = appendSystemPrompt ? extractAgentsAppend() : undefined;
-	const skillsAppend = appendSystemPrompt ? extractSkillsBlock(context.systemPrompt) : undefined;
-	const appendParts = [agentsAppend, skillsAppend].filter((part): part is string => Boolean(part));
-	const systemPromptAppend = appendParts.length > 0 ? appendParts.join("\n\n") : undefined;
+	const systemPrompt = appendSystemPrompt
+		? buildCodebuddySystemPrompt(context.systemPrompt)
+		: undefined;
 
 	// MCP auto-loading suppression: CC reads MCP servers from ~/.claude.json (top-level
 	// + per-project) and .mcp.json. Since pi executes tools (not CC), those are pure
 	// token overhead. --strict-mcp-config tells the binary to use ONLY mcpServers passed
 	// programmatically and ignore filesystem MCP entries — applied unconditionally because
 	// settingSources=undefined does NOT give isolation (the CC default loads all sources).
-	// ponytail: removed settingSources for CodeBuddy
-	const settingSources = undefined
+	const settingSources: SettingSource[] | undefined = appendSystemPrompt
 		? undefined
 		: providerSettings.settingSources ?? ["user", "project"];
 	const strictMcpConfigEnabled = providerSettings.strictMcpConfig !== false;
-	const claudeExecutable = providerSettings.pathToClaudeCodeExecutable;
+	const codebuddyExecutable = providerSettings.pathToCodebuddyCode;
 
 	// Prefer the model's own thinkingLevelMap when present (pi-ai 0.72+ ships
 	// per-model overrides — e.g. opus-4-7 wants xhigh→xhigh, not xhigh→max).
 	// Fall back to our generic table for older pi-ai or unmapped levels.
 	const effort = options?.reasoning
-		? ((model as any).thinkingLevelMap?.[options.reasoning] as EffortLevel | undefined)
+		? ((model as any).thinkingLevelMap?.[options.reasoning] as Effort | undefined)
 			?? REASONING_TO_EFFORT[options.reasoning]
 		: undefined;
 
@@ -1188,35 +1233,21 @@ function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: Sim
 	const cliModel = codebuddyModelId(model);
 	const extraArgs: Record<string, string | null> = { model: cliModel };
 	if (strictMcpConfigEnabled) extraArgs["strict-mcp-config"] = null;
-	// Opus 4.7 defaults thinking.display to "omitted" (empty thinking text in stream).
-	// Force summarized so thinking_delta events arrive. See anthropics/claude-agent-sdk-python#830.
-	if (effort) extraArgs["thinking-display"] = "summarized";
-
-	// Suppress claude.ai cloud MCP servers (Figma/Canva/etc. auto-discovered via OAuth
-	// when the user is logged into Anthropic). These are a separate code path from
-	// filesystem MCP and are NOT blocked by --strict-mcp-config or settingSources=undefined.
-	// The native CC binary gates them on env var ENABLE_CLAUDEAI_MCP_SERVERS: setting it
-	// to "0"/"false"/"no"/"off" makes the loader return early before any cloud fetch.
-	// DISABLE_AUTO_COMPACT=1: pi owns context-management and propagates its own
-	// /compact via session_compact (see handler in default export). Letting CC
-	// also autocompact would double-flush the prompt cache and races pi's
-	// threshold with CC's, including CC's anti-thrashing guard (issue #8).
-	// Manual /compact in CC still works (we never invoke it).
-	const childEnv = { ...process.env, ENABLE_CLAUDEAI_MCP_SERVERS: "0", DISABLE_AUTO_COMPACT: "1" };
+
+	const childEnv = { ...process.env, DISABLE_AUTO_COMPACT: "1" };
 	const queryOptions: NonNullable<Parameters<typeof query>[0]["options"]> = {
 		cwd,
 		env: childEnv,
 		tools: [],
 		permissionMode: "bypassPermissions",
 		includePartialMessages: true,
-		systemPrompt: {
-			type: "preset", preset: "codebuddy",
-			append: systemPromptAppend ? systemPromptAppend : undefined,
-		},
+		systemPrompt,
 		extraArgs,
 		...(effort ? { effort } : {}),
-						...(resumeSessionId ? { resume: resumeSessionId } : {}),
-		...(claudeExecutable ? { pathToClaudeCodeExecutable: claudeExecutable } : {}),
+		...(settingSources ? { settingSources } : {}),
+		...(mcpServers ? { mcpServers } : {}),
+		...(resumeSessionId ? { resume: resumeSessionId } : {}),
+		...(codebuddyExecutable ? { pathToCodebuddyCode: codebuddyExecutable } : {}),
 		...makeCliDebugOptions("provider"),
 	};
 
@@ -1224,26 +1255,18 @@ function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: Sim
 		`model=${cliModel} msgs=${context.messages.length} tools=${mcpTools.length}`,
 		`resume=${resumeSessionId?.slice(0, 8) ?? "none"} effort=${effort ?? "default"}`,
 		`appendSys=${appendSystemPrompt} strictMcp=${strictMcpConfigEnabled}`,
-		`prompt=${promptText.slice(0, 60)}${promptBlocks ? " [+images]" : ""}`);
+		`promptLen=${promptText.length}${promptBlocks ? " [+images]" : ""}`);
 
-	// 3. Start SDK query and claim it for this context
+	// 3. Start SDK query (wait for model discovery + serialize SDK subprocess access)
 	let wasAborted = false;
-	const sdkQuery = query({ prompt, options: queryOptions });
-	queryCtx.activeQuery = sdkQuery;
-	activeQueryContexts.add(queryCtx);
-
-	// 4. Capture context for abort handling
+	let sdkQuery: ReturnType<typeof query> | undefined;
 	const abortCtx = queryCtx;
 
 	const requestAbort = () => {
-		// interrupt() asks the CLI to stop gracefully; close() kills it immediately.
-		// Both are needed — interrupt alone lets the current API call finish.
-		void sdkQuery.interrupt().catch(() => {});
-		try { sdkQuery.interrupt(); } catch {}
+		void sdkQuery?.interrupt().catch(() => {});
 	};
 	const onAbort = () => {
 		wasAborted = true;
-		// Prevent stale deferred messages from being replayed by parent on pop
 		abortCtx.deferredUserMessages = [];
 		for (const pending of abortCtx.pendingToolCalls.values()) { pending.resolve({ content: [{ type: "text", text: "Operation aborted" }] }); }
 		abortCtx.pendingToolCalls.clear();
@@ -1255,12 +1278,16 @@ function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: Sim
 		else options.signal.addEventListener("abort", onAbort, { once: true });
 	}
 
-	// Background consumer — runs until query ends
-	consumeQuery(sdkQuery, customToolNameToPi, model, () => wasAborted, queryCtx)
-		.then(async ({ capturedSessionId }) => {
+	void (async () => {
+		await ensureModelsDiscovered();
+		sdkQuery = query({ prompt, options: queryOptions });
+		queryCtx.activeQuery = sdkQuery;
+		activeQueryContexts.add(queryCtx);
+
+		try {
+			const { capturedSessionId } = await consumeQuery(sdkQuery, customToolNameToPi, model, () => wasAborted, queryCtx);
 			debug(`provider: consumeQuery completed, stopReason=${queryCtx.turnOutput?.stopReason}, error=${queryCtx.turnOutput?.errorMessage}, aborted=${wasAborted}`);
 
-			// --- Abort detection in normal completion path ---
 			if (wasAborted || options?.signal?.aborted) {
 				if (sharedSession) sharedSession = { ...sharedSession, needsRebuild: true, forceRotate: true };
 				queryCtx.deferredUserMessages = [];
@@ -1269,19 +1296,18 @@ function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: Sim
 					queryCtx.turnOutput.stopReason = "aborted";
 					queryCtx.turnOutput.errorMessage = "Operation aborted";
 				}
-				const stream = queryCtx.currentPiStream;
-				stream?.push({ type: "error", reason: "aborted", error: queryCtx.turnOutput! });
-				markStreamComplete(stream);
-				stream?.end();
+				const errStream = queryCtx.currentPiStream;
+				errStream?.push({ type: "error", reason: "aborted", error: queryCtx.turnOutput! });
+				markStreamComplete(errStream);
+				errStream?.end();
 				queryCtx.currentPiStream = null;
 				return;
 			}
 
-			// --- Capture session ID ---
 			const sessionId = capturedSessionId ?? sharedSession?.sessionId;
 			if (syncResult.preserveSharedSession) {
 				if (capturedSessionId && capturedSessionId !== sharedSession?.sessionId) {
-					deleteSession(capturedSessionId, cwd, process.env.CLAUDE_CONFIG_DIR);
+					deleteSession(capturedSessionId, cwd, process.env.CODEBUDDY_CONFIG_DIR);
 					debug(`provider: query done, deleted ephemeral session ${capturedSessionId.slice(0, 8)} to preserve shared session`);
 				}
 				debug(`provider: query done, ignoring captured session ${capturedSessionId?.slice(0, 8) ?? "none"} to preserve shared session`);
@@ -1291,49 +1317,42 @@ function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: Sim
 				sharedSession = { sessionId, cursor, cwd };
 			}
 
-			// --- Replay deferred user messages as continuation queries ---
-			try {
-				while (queryCtx.deferredUserMessages.length > 0 && !isReentrant && !wasAborted) {
-					const steerPrompt = queryCtx.deferredUserMessages.shift()!;
-					debug(`provider: replaying deferred user message: ${steerPrompt.slice(0, 60)}`);
-					queryCtx.resetTurnState(model);
-
-					const resumeId = sharedSession?.sessionId;
-					if (!resumeId) {
-						debug(`WARNING: no session to resume for deferred message, dropping`);
-						break;
-					}
+			while (queryCtx.deferredUserMessages.length > 0 && !isReentrant && !wasAborted) {
+				const steerPrompt = queryCtx.deferredUserMessages.shift()!;
+				debug(`provider: replaying deferred user message (len=${steerPrompt.length})`);
+				queryCtx.resetTurnState(model);
 
-					const contOptions = { ...queryOptions, resume: resumeId, ...makeCliDebugOptions("continuation") };
-					const contQuery = query({ prompt: steerPrompt, options: contOptions });
-					queryCtx.activeQuery = contQuery;
+				const resumeId = sharedSession?.sessionId;
+				if (!resumeId) {
+					debug(`WARNING: no session to resume for deferred message, dropping`);
+					break;
+				}
 
-					debug(`provider: continuation query, model=${cliModel}, resume=${resumeId.slice(0, 8)}, prompt=${steerPrompt.slice(0, 60)}`);
+				const contOptions = { ...queryOptions, resume: resumeId, ...makeCliDebugOptions("continuation") };
+				const contQuery = query({ prompt: steerPrompt, options: contOptions });
+				queryCtx.activeQuery = contQuery;
+				debug(`provider: continuation query, model=${cliModel}, resume=${resumeId.slice(0, 8)}, promptLen=${steerPrompt.length}`);
 
-					try {
-						const { capturedSessionId: contSid } = await consumeQuery(contQuery, customToolNameToPi, model, () => wasAborted, queryCtx);
-						const sid = contSid ?? sharedSession?.sessionId;
-						if (sid) {
-							sharedSession = { sessionId: sid, cursor: sharedSession?.cursor ?? 0, cwd };
-						}
-					} catch (contError) {
-						debug(`provider: continuation query error:`, contError);
-						break;
-					} finally {
-						contQuery.interrupt();
+				try {
+					const { capturedSessionId: contSid } = await consumeQuery(contQuery, customToolNameToPi, model, () => wasAborted, queryCtx);
+					const sid = contSid ?? sharedSession?.sessionId;
+					if (sid) sharedSession = { sessionId: sid, cursor: sharedSession?.cursor ?? 0, cwd };
+				} catch (contError) {
+					debug(`provider: continuation query error:`, contError);
+					break;
+				} finally {
+					if (wasAborted || options?.signal?.aborted) {
+						await contQuery.return().catch(() => {});
 					}
 				}
-			} finally {
-				queryCtx.activeQuery = sdkQuery;
 			}
 
-			if (!isReentrant && queryCtx.activeQuery === sdkQuery) {
+			if (!isReentrant) {
 				debug("provider: clearing activeQuery before final stream completion");
 				queryCtx.activeQuery = null;
 			}
 			finalizeCurrentStream(queryCtx, queryCtx.turnOutput?.stopReason);
-		})
-		.catch((error) => {
+		} catch (error) {
 			debug(`provider: query error, model=${cliModel}, aborted=${Boolean(options?.signal?.aborted)}, error=`, error);
 			if ((wasAborted || options?.signal?.aborted) && sharedSession) {
 				sharedSession = { ...sharedSession, needsRebuild: true, forceRotate: true };
@@ -1345,31 +1364,28 @@ function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: Sim
 				queryCtx.turnOutput.stopReason = options?.signal?.aborted ? "aborted" : "error";
 				queryCtx.turnOutput.errorMessage = error instanceof Error ? error.message : String(error);
 			}
-			if (!isReentrant && queryCtx.activeQuery === sdkQuery) {
+			if (!isReentrant) {
 				for (const pending of queryCtx.pendingToolCalls.values()) { pending.resolve({ content: [{ type: "text", text: "Query ended" }] }); }
 				queryCtx.pendingToolCalls.clear();
 				queryCtx.pendingResults.clear();
-				debug("provider: clearing activeQuery before error stream completion");
 				queryCtx.activeQuery = null;
 			}
-			const stream = queryCtx.currentPiStream;
-			stream?.push({ type: "error", reason: (queryCtx.turnOutput?.stopReason ?? "error") as "aborted" | "error", error: queryCtx.turnOutput! });
-			markStreamComplete(stream);
-			stream?.end();
+			const errStream = queryCtx.currentPiStream;
+			errStream?.push({ type: "error", reason: (queryCtx.turnOutput?.stopReason ?? "error") as "aborted" | "error", error: queryCtx.turnOutput! });
+			markStreamComplete(errStream);
+			errStream?.end();
 			queryCtx.currentPiStream = null;
-		})
-		.finally(() => {
+		} finally {
 			if (options?.signal) options.signal.removeEventListener("abort", onAbort);
 			if (queryCtx.activeQuery === sdkQuery) {
-				// Drain pending handlers for this query
 				for (const pending of queryCtx.pendingToolCalls.values()) { pending.resolve({ content: [{ type: "text", text: "Query ended" }] }); }
 				queryCtx.pendingToolCalls.clear();
 				queryCtx.pendingResults.clear();
 				queryCtx.activeQuery = null;
 			}
 			activeQueryContexts.delete(queryCtx);
-			sdkQuery.interrupt();
-		});
+		}
+	})();
 
 	return stream;
 }
@@ -1418,43 +1434,42 @@ async function promptAndWait(
 	// Mode → disallowed tools
 	const disallowedTools = MODE_DISALLOWED_TOOLS[mode] ?? [];
 
-	// Skills append
-	const skillsBlock = options?.appendSkills !== false && options?.systemPrompt
-		? extractSkillsBlock(options.systemPrompt) : undefined;
+	const askSystemPrompt = options?.systemPrompt
+		? buildCodebuddySystemPrompt(options.systemPrompt, {
+			includeSkills: options.appendSkills !== false,
+		})
+		: undefined;
 
 	// Effort
 	const effort = options?.thinking && options.thinking !== "off"
 		? REASONING_TO_EFFORT[options.thinking] : undefined;
 
-	const claudeExecutable = providerSettings.pathToClaudeCodeExecutable;
+	const codebuddyExecutable = providerSettings.pathToCodebuddyCode;
 
 	const extraArgs: Record<string, string | null> = {
 		"strict-mcp-config": null,
 		model: cliModel,
 	};
-	if (effort) extraArgs["thinking-display"] = "summarized";
 
 	debug("askCodebuddy:",
 		`mode=${mode} model=${modelId} cliModel=${cliModel} effort=${effort ?? "default"}`,
 		`isolated=${options?.isolated ?? false} resume=${resumeSessionId?.slice(0, 8) ?? "none"}`,
-		`skills=${Boolean(skillsBlock)} promptLen=${prompt.length}`);
+		`sysPrompt=${Boolean(askSystemPrompt)} promptLen=${prompt.length}`);
 
 	const sdkQuery = query({
 		prompt,
 		options: {
 			cwd,
-			env: { ...process.env, ENABLE_CLAUDEAI_MCP_SERVERS: "0", DISABLE_AUTO_COMPACT: "1" },
+			env: { ...process.env, DISABLE_AUTO_COMPACT: "1" },
 			permissionMode: "bypassPermissions",
 			...(disallowedTools.length ? { disallowedTools } : {}),
 			...(effort ? { effort } : {}),
-			systemPrompt: skillsBlock
-				? { type: "preset", preset: "codebuddy", append: skillsBlock }
-				: undefined,
-			
+			systemPrompt: askSystemPrompt,
+			settingSources: ["user", "project"] as SettingSource[],
 			extraArgs,
 			...(resumeSessionId ? { resume: resumeSessionId } : {}),
 			...(options?.isolated ? { persistSession: false } : {}),
-			...(claudeExecutable ? { pathToClaudeCodeExecutable: claudeExecutable } : {}),
+			...(codebuddyExecutable ? { pathToCodebuddyCode: codebuddyExecutable } : {}),
 			...makeCliDebugOptions("askclaude"),
 		},
 	});
@@ -1463,7 +1478,7 @@ async function promptAndWait(
 	let wasAborted = false;
 	const onAbort = () => {
 		wasAborted = true;
-		sdkQuery.interrupt().catch(() => { try { sdkQuery.interrupt(); } catch {} });
+		sdkQuery.interrupt().catch(() => {});
 	};
 	if (signal?.aborted) { onAbort(); throw new Error("Aborted"); }
 	signal?.addEventListener("abort", onAbort, { once: true });
@@ -1480,7 +1495,7 @@ async function promptAndWait(
 
 			switch (message.type) {
 				case "stream_event": {
-					const event = (message as SDKMessage & { event: any }).event;
+					const event = (message as CbMessage & { event: any }).event;
 					// Text deltas → accumulate and stream
 					if (event?.type === "content_block_delta" && event.delta?.type === "text_delta") {
 						responseText += event.delta.text;
@@ -1532,7 +1547,7 @@ async function promptAndWait(
 		return { responseText, stopReason };
 	} finally {
 		signal?.removeEventListener("abort", onAbort);
-		sdkQuery.interrupt();
+		void sdkQuery.interrupt().catch(() => {});
 	}
 }
 
@@ -1545,22 +1560,52 @@ const PREVIEW_MAX_CHARS = 1000;
 const PREVIEW_MAX_LINES = 6;
 
 let askCodebuddyToolName = "AskCodebuddy";
+let piApi: ExtensionAPI | null = null;
+let modelsDiscovered = false;
 
-export default function (pi: ExtensionAPI) {
-	// Disable non-essential CodeBuddy traffic (update checks, MCP registry, telemetry)
-	process.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
+let discoverInFlight: Promise<void> | null = null;
+
+async function discoverModels(pi: ExtensionAPI): Promise<void> {
+	await withSdkGate(async () => {
+		try {
+			const q = query({ prompt: " ", options: { maxTurns: 0, permissionMode: "bypassPermissions", tools: [] } });
+			const supported = await q.supportedModels();
+			await q.return().catch(() => {});
+			if (!supported.length) return;
+			MODELS = buildModels(rawModelsFromSdk(supported as any));
+			const g = globalThis as Record<symbol, any>;
+			const streamFn = g[ACTIVE_STREAM_SIMPLE_KEY] ?? streamCodebuddySdk;
+			pi.registerProvider(PROVIDER_ID, {
+				name: "CodeBuddy",
+				baseUrl: PROVIDER_ID,
+				apiKey: "not-used",
+				api: "codebuddy-sdk",
+				models: MODELS as any,
+				streamSimple: streamFn as any,
+			});
+			modelsDiscovered = true;
+			debug(`discoverModels: registered ${MODELS.length} models from SDK`);
+		} catch (err) {
+			debug("discoverModels: failed, using fallback models", err);
+		}
+	});
+}
+
+async function ensureModelsDiscovered(): Promise<void> {
+	if (modelsDiscovered || !piApi) return;
+	discoverInFlight ??= discoverModels(piApi);
+	await discoverInFlight;
+}
 
+export default function (pi: ExtensionAPI) {
+	piApi = pi;
 	const config = loadConfig(process.cwd());
 	debug("loadConfig:", JSON.stringify(config));
 	providerSettings = config.provider ?? {};
-	// We need these settings to know if we're eligible for 1M context on certain models
-	longContextSettings = {
-		plan: providerSettings.plan ?? "pro",
-		longContextExtraUsage: providerSettings.longContextExtraUsage ?? false,
-	};
-	const registeredModels = MODELS; // ponytail: no long-context suffix for CodeBuddy
+	const registeredModels = MODELS;
+
+	discoverInFlight = discoverModels(pi);
 
-	// Reset shared session on pi session lifecycle events
 	const clearSession = (event: string) => {
 		debug(`${event}: clearing session ${sharedSession?.sessionId?.slice(0, 8) ?? "none"}`);
 		sharedSession = null;
@@ -1569,7 +1614,7 @@ export default function (pi: ExtensionAPI) {
 		// This allows /reload to work — the old instance clears the flag so
 		// the new instance can register fresh without wrapping stale state.
 		const g = globalThis as Record<symbol, any>;
-		if (g[ACTIVE_STREAM_SIMPLE_KEY] === streamClaudeAgentSdk) {
+		if (g[ACTIVE_STREAM_SIMPLE_KEY] === streamCodebuddySdk) {
 			debug(`${event}: clearing ACTIVE_STREAM_SIMPLE_KEY`);
 			g[ACTIVE_STREAM_SIMPLE_KEY] = undefined;
 		}
@@ -1583,7 +1628,7 @@ export default function (pi: ExtensionAPI) {
 	pi.on("session_shutdown", () => clearSession("session_shutdown"));
 
 	pi.on("session_before_compact", async (event, ctx) => {
-		if (ctx.model?.baseUrl !== "codebuddy-local") return undefined;
+		if (ctx.model?.baseUrl !== PROVIDER_ID) return undefined;
 		debug(
 			`session_before_compact: takeover reason=${event.reason} willRetry=${event.willRetry} ` +
 			`isSplitTurn=${event.preparation.isSplitTurn} messages=${event.preparation.messagesToSummarize.length} ` +
@@ -1608,7 +1653,7 @@ export default function (pi: ExtensionAPI) {
 			const msg = errorMessage(err);
 			debug("session_before_compact: takeover failed; cancelling to avoid native compact fallback", err);
 			ctx.ui?.notify?.(
-				`Claude bridge compact failed (${msg}); cancelled to avoid known hang. Retry, switch model, or reduce context.`,
+				`CodeBuddy SDK compact failed (${redactForLog(msg)}). Retry, switch model, or reduce context.`,
 				"error",
 			);
 			return { cancel: true };
@@ -1641,14 +1686,15 @@ export default function (pi: ExtensionAPI) {
 	const g = globalThis as Record<symbol, any>;
 	if (!g[ACTIVE_STREAM_SIMPLE_KEY]) {
 		// First instance: store our streamSimple and register.
-		g[ACTIVE_STREAM_SIMPLE_KEY] = streamClaudeAgentSdk;
+		g[ACTIVE_STREAM_SIMPLE_KEY] = streamCodebuddySdk;
 		pi.registerProvider(PROVIDER_ID, {
-			baseUrl: "codebuddy-local",
+			name: "CodeBuddy",
+			baseUrl: PROVIDER_ID,
 			apiKey: "not-used",
 			api: "codebuddy-sdk",
-			models: registeredModels,
+			models: registeredModels as any,
 			// Cast: pi-ai AssistantMessageEventStream diamond dep between pi-coding-agent and pi-agent-core
-			streamSimple: streamClaudeAgentSdk as any,
+			streamSimple: streamCodebuddySdk as any,
 		});
 	} else {
 		// Subsequent instance (subagent session): skip registration entirely.
@@ -1730,7 +1776,7 @@ export default function (pi: ExtensionAPI) {
 			},
 			async execute(_id, params, signal, onUpdate, ctx) {
 				// Guard: circular delegation
-				if (ctx.model?.baseUrl === "codebuddy-local") {
+				if (ctx.model?.baseUrl === PROVIDER_ID) {
 					debug("askCodebuddy: blocked circular delegation (active provider is codebuddy-sdk)");
 					return {
 						content: [{ type: "text" as const, text: "Error: AskCodebuddy cannot be used when the active provider is codebuddy-sdk — you're already running through CodeBuddy." }],