@gajae-code/coding-agent 0.10.2 → 0.11.1

package/src/daemon/builtin.ts

@@ -1,19 +1,20 @@
 /**
  * Static built-in daemon controller map.
  *
- * Intentionally a static map keyed by daemon kind rather than a mutable plugin
- * registry: there is exactly one kind today (`telegram`). Promote to a richer
- * registry only when a second daemon kind exists.
+ * Controllers are deliberately static rather than a mutable plugin registry.
  */
 
 import type { Settings } from "../config/settings";
-import { type TelegramDaemonControlDeps, TelegramDaemonController } from "../notifications/telegram-daemon-control";
+import { type ChatDaemonControlDeps, ChatDaemonController } from "../sdk/bus/chat-daemon-control";
+import { type TelegramDaemonControlDeps, TelegramDaemonController } from "../sdk/bus/telegram-daemon-control";
 import type { BuiltInDaemonController, DaemonKind } from "./control-types";
 
-export const BUILT_IN_DAEMON_KINDS = ["telegram"] as const satisfies readonly DaemonKind[];
+export const BUILT_IN_DAEMON_KINDS = ["telegram", "discord", "slack"] as const satisfies readonly DaemonKind[];
 
 export interface BuiltInDaemonControllerDeps {
 	telegram?: TelegramDaemonControlDeps;
+	discord?: ChatDaemonControlDeps;
+	slack?: ChatDaemonControlDeps;
 }
 
 export function createBuiltInDaemonControllers(
@@ -22,6 +23,8 @@ export function createBuiltInDaemonControllers(
 ): Record<DaemonKind, BuiltInDaemonController> {
 	return {
 		telegram: new TelegramDaemonController(settings, deps.telegram),
+		discord: new ChatDaemonController(settings, "discord", deps.discord),
+		slack: new ChatDaemonController(settings, "slack", deps.slack),
 	};
 }
 

package/src/daemon/control-types.ts

@@ -6,7 +6,7 @@
  * a richer registry is intentionally deferred until a second kind exists.
  */
 
-export type DaemonKind = "telegram";
+export type DaemonKind = "telegram" | "discord" | "slack";
 
 export type DaemonAction = "list" | "status" | "stop" | "reload";
 

package/src/defaults/gjc/skills/team/SKILL.md

@@ -311,10 +311,10 @@ Worker protocol:
 Useful runtime env vars:
 
 - `GJC_TMUX_COMMAND` / `GJC_TEAM_TMUX_COMMAND`
-  - tmux binary/name override (default `tmux` on POSIX, `psmux` / `pmux` / `tmux` on native Windows when one of those resolves on PATH). `GJC_TMUX_COMMAND` applies to every GJC tmux flow; `GJC_TEAM_TMUX_COMMAND` is honored as an alias by the team path. Both resolve through the same resolver, so the team leader and `gjc session ...` always target the same multiplexer. These values are executable path/name overrides, not shell command lines; do not include flags such as `psmux -L <namespace>` in the env var.
-  - Native Windows psmux support: psmux is the supported tmux-compatible multiplexer for native Windows `gjc --tmux`, `gjc session`, and `gjc team`. Psmux can be exposed as `psmux.exe` or as its `tmux.exe`/`pmux.exe` aliases. GJC probes `psmux` / `pmux` / `tmux` on Windows PATH, picks the first that resolves, and treats that binary as the multiplexer. Worker commands on Windows are emitted with PowerShell-safe `$env:VAR = 'value';` assignments so psmux's ConPTY panes inherit `GJC_TEAM_*` correctly.
-  - Multiplexer detection knobs (Windows): `GJC_PSMUX_COMMAND` forces a wrapper to be treated as psmux, `GJC_PSMUX_DETECTION=off` skips detection, `GJC_PSMUX_FORCE_DETECT=1` re-probes every call. The mouse / set-clipboard / mode-style UX profile is filtered out for psmux; the `@gjc-profile` ownership tag and branch / project / session identity markers still round-trip and are required for `gjc session` and `gjc team`.
-  - Windows psmux namespace boundary: psmux `-c <path>` cwd/start-directory flags do not isolate the server namespace; psmux uses the tmux-compatible global `-L <namespace>` flag for isolated server instances. GJC does not currently expose structured runtime `-L` support, because launch, `gjc session`, and `gjc team` must all carry the same namespace prefix together. If you need isolated psmux servers, start `psmux -L <namespace>` yourself before `gjc --tmux` and let GJC attach to it; do not pass `-L` through `GJC_TMUX_COMMAND`.
+  - tmux executable override (default `tmux` on POSIX; `psmux` / `pmux` / `tmux` resolution on native Windows). `GJC_TMUX_COMMAND` applies to every GJC tmux flow; `GJC_TEAM_TMUX_COMMAND` is honored as a team-path alias. Values are executable paths/names, not shell command lines.
+  - Native Windows psmux boundary: a generic-banner `tmux.exe` alias is classified by matching its executable identity with resolved `psmux.exe` / `pmux.exe` companions. Unresolved or conflicting identity evidence fails closed with `gjc_tmux_provider_ambiguous`; `GJC_PSMUX_COMMAND` must resolve to the same executable identity as the selected alias.
+  - Managed psmux session creation, attachment, lifecycle mutation, and team startup remain unsupported because psmux cannot provide the immutable native session identity required by the owner-isolation contract. Use WSL or verified native tmux for live team workers.
+  - Windows psmux namespace boundary: psmux uses the tmux-compatible global `-L <namespace>` flag for server isolation, but GJC does not accept flags in `GJC_TMUX_COMMAND` or expose structured runtime `-L` support.
 - `GJC_TEAM_WORKER_COMMAND`
   - worker command override (default resolves to active GJC entrypoint or `gjc`)
 - `GJC_TEAM_STATE_ROOT`

package/src/discovery/mcp-json.ts

@@ -6,6 +6,8 @@
  *
  * Priority: 5 (low, as this is a fallback after tool-specific providers)
  */
+import * as fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
 import * as path from "node:path";
 import { logger, tryParseJson } from "@gajae-code/utils";
 import { registerProvider } from "../capability";
@@ -16,6 +18,7 @@ import { createSourceMeta, expandEnvVarsDeep } from "./helpers";
 
 const PROVIDER_ID = "mcp-json";
 const DISPLAY_NAME = "MCP Config";
+const PROTOTYPE_SENSITIVE_SERVER_NAMES = new Set(["__proto__", "prototype", "constructor"]);
 
 /**
  * Raw MCP JSON format (matches Anthropic model Desktop's format).
@@ -51,12 +54,100 @@ interface MCPConfigFile {
 			};
 		}
 	>;
+	disabledServers?: string[];
+}
+export interface MCPJsonLoadResult extends LoadResult<MCPServer> {
+	disabledServers: string[];
+}
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value: unknown): value is string[] {
+	return Array.isArray(value) && value.every(item => typeof item === "string");
+}
+function isStringRecord(value: unknown): value is Record<string, string> {
+	return isRecord(value) && Object.values(value).every(item => typeof item === "string");
+}
+function isOptionalBoolean(value: unknown): boolean {
+	return value === undefined || typeof value === "boolean";
+}
+function isOptionalString(value: unknown): boolean {
+	return value === undefined || typeof value === "string";
+}
+function isValidAuthConfig(value: unknown): boolean {
+	return (
+		isRecord(value) &&
+		(value.type === "oauth" || value.type === "apikey") &&
+		isOptionalString(value.credentialId) &&
+		isOptionalString(value.tokenUrl) &&
+		isOptionalString(value.clientId) &&
+		isOptionalString(value.clientSecret)
+	);
+}
+function isValidOAuthConfig(value: unknown): boolean {
+	return (
+		isRecord(value) &&
+		isOptionalString(value.clientId) &&
+		isOptionalString(value.clientSecret) &&
+		isOptionalString(value.redirectUri) &&
+		(value.callbackPort === undefined ||
+			(typeof value.callbackPort === "number" &&
+				Number.isInteger(value.callbackPort) &&
+				value.callbackPort >= 1 &&
+				value.callbackPort <= 65_535)) &&
+		isOptionalString(value.callbackPath)
+	);
+}
+function isValidExactServerConfig(value: unknown): boolean {
+	if (!isRecord(value)) return false;
+	return (
+		isOptionalBoolean(value.enabled) &&
+		isOptionalBoolean(value.autoload) &&
+		isOptionalBoolean(value.noInheritEnv) &&
+		(value.timeout === undefined ||
+			(typeof value.timeout === "number" && Number.isFinite(value.timeout) && value.timeout > 0)) &&
+		isOptionalString(value.command) &&
+		(value.args === undefined || isStringArray(value.args)) &&
+		(value.env === undefined || isStringRecord(value.env)) &&
+		isOptionalString(value.cwd) &&
+		isOptionalString(value.url) &&
+		(value.headers === undefined || isStringRecord(value.headers)) &&
+		(value.type === undefined || value.type === "stdio" || value.type === "sse" || value.type === "http") &&
+		(value.auth === undefined || isValidAuthConfig(value.auth)) &&
+		(value.oauth === undefined || isValidOAuthConfig(value.oauth))
+	);
+}
+function validateExactMCPConfig(config: unknown): {
+	config: MCPConfigFile | null;
+	hasInvalidServer: boolean;
+} {
+	if (!isRecord(config)) return { config: null, hasInvalidServer: false };
+	if (config.disabledServers !== undefined && !isStringArray(config.disabledServers)) {
+		return { config: null, hasInvalidServer: false };
+	}
+	if (config.mcpServers === undefined) {
+		return { config: config as MCPConfigFile, hasInvalidServer: false };
+	}
+	if (!isRecord(config.mcpServers)) return { config: null, hasInvalidServer: false };
+	const validServers: Record<string, unknown> = Object.create(null);
+	let hasInvalidServer = false;
+	for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+		if (PROTOTYPE_SENSITIVE_SERVER_NAMES.has(name) || !isValidExactServerConfig(serverConfig)) {
+			hasInvalidServer = true;
+			continue;
+		}
+		validServers[name] = serverConfig;
+	}
+	return {
+		config: { ...config, mcpServers: validServers } as MCPConfigFile,
+		hasInvalidServer,
+	};
 }
 
 /**
  * Transform raw MCP config to canonical MCPServer format.
  */
-function transformMCPConfig(config: MCPConfigFile, source: SourceMeta): MCPServer[] {
+function transformMCPConfig(config: MCPConfigFile, source: SourceMeta, quiet = false): MCPServer[] {
 	const servers: MCPServer[] = [];
 
 	if (config.mcpServers) {
@@ -66,7 +157,7 @@ function transformMCPConfig(config: MCPConfigFile, source: SourceMeta): MCPServe
 			if (serverConfig.enabled !== undefined) {
 				if (typeof serverConfig.enabled === "boolean") {
 					enabled = serverConfig.enabled;
-				} else {
+				} else if (!quiet) {
 					logger.warn("MCP server has invalid 'enabled' value, ignoring", { name, value: serverConfig.enabled });
 				}
 			}
@@ -79,7 +170,7 @@ function transformMCPConfig(config: MCPConfigFile, source: SourceMeta): MCPServe
 					serverConfig.timeout > 0
 				) {
 					timeout = serverConfig.timeout;
-				} else {
+				} else if (!quiet) {
 					logger.warn("MCP server has invalid 'timeout' value, ignoring", { name, value: serverConfig.timeout });
 				}
 			}
@@ -88,7 +179,7 @@ function transformMCPConfig(config: MCPConfigFile, source: SourceMeta): MCPServe
 			if (serverConfig.autoload !== undefined) {
 				if (typeof serverConfig.autoload === "boolean") {
 					autoload = serverConfig.autoload;
-				} else {
+				} else if (!quiet) {
 					logger.warn("MCP server has invalid 'autoload' value, ignoring", { name, value: serverConfig.autoload });
 				}
 			}
@@ -97,7 +188,7 @@ function transformMCPConfig(config: MCPConfigFile, source: SourceMeta): MCPServe
 			if (serverConfig.noInheritEnv !== undefined) {
 				if (typeof serverConfig.noInheritEnv === "boolean") {
 					noInheritEnv = serverConfig.noInheritEnv;
-				} else {
+				} else if (!quiet) {
 					logger.warn("MCP server has invalid 'noInheritEnv' value, ignoring", {
 						name,
 						value: serverConfig.noInheritEnv,
@@ -139,33 +230,249 @@ function transformMCPConfig(config: MCPConfigFile, source: SourceMeta): MCPServe
 	return servers;
 }
 
+interface ExactMCPConfigIdentity {
+	dev: bigint;
+	ino: bigint;
+	mode: bigint;
+}
+
+interface ExactMCPConfigFileState extends ExactMCPConfigIdentity {
+	size: bigint;
+	mtimeNs: bigint;
+	ctimeNs: bigint;
+	nlink: bigint;
+}
+
+interface ExactMCPConfigPathState {
+	ancestors: ExactMCPConfigIdentity[];
+	file: ExactMCPConfigFileState;
+}
+
+function exactMCPConfigIdentity(stat: fs.BigIntStats): ExactMCPConfigIdentity {
+	return {
+		dev: stat.dev,
+		ino: stat.ino,
+		mode: stat.mode,
+	};
+}
+
+function exactMCPConfigFileState(stat: fs.BigIntStats): ExactMCPConfigFileState | null {
+	if (stat.isSymbolicLink() || !stat.isFile() || stat.nlink !== 1n) return null;
+	return {
+		...exactMCPConfigIdentity(stat),
+		size: stat.size,
+		mtimeNs: stat.mtimeNs,
+		ctimeNs: stat.ctimeNs,
+		nlink: stat.nlink,
+	};
+}
+
+function exactMCPConfigDirectoryIdentity(stat: fs.BigIntStats): ExactMCPConfigIdentity | null {
+	if (stat.isSymbolicLink() || !stat.isDirectory()) return null;
+	return exactMCPConfigIdentity(stat);
+}
+
+async function exactMCPConfigPathState(filePath: string): Promise<ExactMCPConfigPathState | null> {
+	if (!path.isAbsolute(filePath)) return null;
+
+	const root = path.parse(filePath).root;
+	const components = filePath
+		.slice(root.length)
+		.split(process.platform === "win32" ? /[\\/]+/ : path.sep)
+		.filter(component => component.length > 0);
+	if (
+		root.length === 0 ||
+		components.length === 0 ||
+		components.some(component => component === "." || component === "..")
+	) {
+		return null;
+	}
+
+	let componentPath = root;
+	const rootIdentity = exactMCPConfigDirectoryIdentity(await fsPromises.lstat(componentPath, { bigint: true }));
+	if (!rootIdentity) return null;
+	const ancestors = [rootIdentity];
+
+	for (const [index, component] of components.entries()) {
+		componentPath = path.join(componentPath, component);
+		const componentState = await fsPromises.lstat(componentPath, { bigint: true });
+		if (index === components.length - 1) {
+			const file = exactMCPConfigFileState(componentState);
+			return file ? { ancestors, file } : null;
+		}
+		const directoryIdentity = exactMCPConfigDirectoryIdentity(componentState);
+		if (!directoryIdentity) return null;
+		ancestors.push(directoryIdentity);
+	}
+
+	return null;
+}
+
+function isSameExactMCPConfigIdentity(expected: ExactMCPConfigIdentity, actual: ExactMCPConfigIdentity): boolean {
+	return expected.dev === actual.dev && expected.ino === actual.ino && expected.mode === actual.mode;
+}
+
+function isSameExactMCPConfigFileState(expected: ExactMCPConfigFileState, actual: ExactMCPConfigFileState): boolean {
+	return (
+		isSameExactMCPConfigIdentity(expected, actual) &&
+		expected.size === actual.size &&
+		expected.mtimeNs === actual.mtimeNs &&
+		expected.ctimeNs === actual.ctimeNs &&
+		expected.nlink === actual.nlink
+	);
+}
+
+function isSameExactMCPConfigPathState(expected: ExactMCPConfigPathState, actual: ExactMCPConfigPathState): boolean {
+	return (
+		expected.ancestors.length === actual.ancestors.length &&
+		expected.ancestors.every((identity, index) => {
+			const actualIdentity = actual.ancestors[index];
+			return actualIdentity !== undefined && isSameExactMCPConfigIdentity(identity, actualIdentity);
+		}) &&
+		isSameExactMCPConfigFileState(expected.file, actual.file)
+	);
+}
+
+function isExpectedExactMCPConfigReadError(error: unknown): boolean {
+	if (!isRecord(error) || typeof error.code !== "string") return false;
+	return ["EACCES", "EISDIR", "ELOOP", "ENOENT", "ENAMETOOLONG", "ENOTDIR", "EPERM", "ESTALE"].includes(error.code);
+}
+
+async function readExactMCPConfigDescriptorBytes(handle: fsPromises.FileHandle, size: bigint): Promise<Buffer | null> {
+	if (size > BigInt(Number.MAX_SAFE_INTEGER)) return null;
+
+	const bytes = Buffer.allocUnsafe(Number(size));
+	let offset = 0;
+	while (offset < bytes.length) {
+		const { bytesRead } = await handle.read(bytes, offset, bytes.length - offset, offset);
+		if (bytesRead === 0) return null;
+		offset += bytesRead;
+	}
+	return bytes;
+}
+
+// Windows does not support O_NOFOLLOW. The lstat/fstat checks below remain required there.
+const EXACT_MCP_CONFIG_OPEN_FLAGS =
+	fs.constants.O_RDONLY | (process.platform === "win32" ? 0 : (fs.constants.O_NOFOLLOW ?? 0));
+
+/**
+ * Exact-file trust policy for quiet explicit MCP configs:
+ * the supplied absolute path must contain only non-link components before and after reading;
+ * the root and every ancestor directory must retain their identities; the leaf must be a regular,
+ * non-link file with one link; and one descriptor supplies all content and exact byte revalidation.
+ */
+async function readExactMCPConfigFile(filePath: string): Promise<string | null> {
+	let handle: fsPromises.FileHandle | undefined;
+	let content: string | null = null;
+	let primaryFailure: unknown;
+	let hasPrimaryFailure = false;
+	try {
+		const initialPathState = await exactMCPConfigPathState(filePath);
+		if (initialPathState) {
+			handle = await fsPromises.open(filePath, EXACT_MCP_CONFIG_OPEN_FLAGS);
+			const openedFileState = exactMCPConfigFileState(await handle.stat({ bigint: true }));
+			const beforeReadPathState = await exactMCPConfigPathState(filePath);
+			if (
+				openedFileState &&
+				beforeReadPathState &&
+				isSameExactMCPConfigFileState(initialPathState.file, openedFileState) &&
+				isSameExactMCPConfigPathState(initialPathState, beforeReadPathState)
+			) {
+				const candidate = await handle.readFile();
+				const afterReadFileState = exactMCPConfigFileState(await handle.stat({ bigint: true }));
+				const afterReadPathState = await exactMCPConfigPathState(filePath);
+				if (
+					afterReadFileState &&
+					afterReadPathState &&
+					isSameExactMCPConfigFileState(initialPathState.file, afterReadFileState) &&
+					isSameExactMCPConfigPathState(initialPathState, afterReadPathState)
+				) {
+					const revalidated = await readExactMCPConfigDescriptorBytes(handle, initialPathState.file.size);
+					const afterRevalidationFileState = exactMCPConfigFileState(await handle.stat({ bigint: true }));
+					const afterRevalidationPathState = await exactMCPConfigPathState(filePath);
+					if (
+						revalidated &&
+						candidate.equals(revalidated) &&
+						afterRevalidationFileState &&
+						afterRevalidationPathState &&
+						isSameExactMCPConfigFileState(initialPathState.file, afterRevalidationFileState) &&
+						isSameExactMCPConfigPathState(initialPathState, afterRevalidationPathState)
+					) {
+						content = candidate.toString("utf8");
+					}
+				}
+			}
+		}
+	} catch (error) {
+		if (!isExpectedExactMCPConfigReadError(error)) {
+			hasPrimaryFailure = true;
+			primaryFailure = error;
+		}
+	}
+
+	let closeFailure: unknown;
+	let hasCloseFailure = false;
+	if (handle) {
+		try {
+			await handle.close();
+		} catch (error) {
+			hasCloseFailure = true;
+			closeFailure = error;
+		}
+	}
+	if (hasPrimaryFailure) throw primaryFailure;
+	if (hasCloseFailure) throw closeFailure;
+	return content;
+}
+
 /**
  * Load MCP servers from a JSON file.
  */
-async function loadMCPJsonFile(
-	_ctx: LoadContext,
-	path: string,
+export async function loadMCPJsonFile(
+	filePath: string,
 	level: "user" | "project",
-): Promise<LoadResult<MCPServer>> {
+	options?: { quiet?: boolean; useCache?: boolean },
+): Promise<MCPJsonLoadResult> {
 	const warnings: string[] = [];
 	const items: MCPServer[] = [];
 
-	const content = await readFile(path);
+	const content = options?.quiet
+		? await readExactMCPConfigFile(filePath)
+		: options?.useCache === false
+			? await Bun.file(filePath)
+					.text()
+					.catch(() => null)
+			: await readFile(filePath);
 	if (content === null) {
-		return { items, warnings };
+		if (options?.quiet) warnings.push("MCP configuration unavailable");
+		return { items, warnings, disabledServers: [] };
 	}
 
-	const config = tryParseJson<MCPConfigFile>(content);
+	const config = tryParseJson<unknown>(content);
 	if (!config) {
-		warnings.push(`Failed to parse JSON in ${path}`);
-		return { items, warnings };
+		warnings.push(options?.quiet ? "MCP configuration unavailable" : `Failed to parse JSON in ${filePath}`);
+		return { items, warnings, disabledServers: [] };
 	}
+	let validConfig: MCPConfigFile;
+	if (options?.quiet) {
+		const validation = validateExactMCPConfig(config);
+		if (!validation.config) {
+			warnings.push("MCP configuration unavailable");
+			return { items, warnings, disabledServers: [] };
+		}
+		if (validation.hasInvalidServer) warnings.push("MCP configuration unavailable");
+		validConfig = validation.config;
+	} else {
+		validConfig = config as MCPConfigFile;
+	}
+	const source = createSourceMeta(PROVIDER_ID, filePath, level);
+	items.push(...transformMCPConfig(validConfig, source, options?.quiet));
 
-	const source = createSourceMeta(PROVIDER_ID, path, level);
-	const servers = transformMCPConfig(config, source);
-	items.push(...servers);
-
-	return { items, warnings };
+	return {
+		items,
+		warnings,
+		disabledServers: isStringArray(validConfig.disabledServers) ? validConfig.disabledServers : [],
+	};
 }
 
 /**
@@ -174,7 +481,7 @@ async function loadMCPJsonFile(
 async function load(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
 	const filenames = ["mcp.json", ".mcp.json"];
 	const results = await Promise.all(
-		filenames.map(filename => loadMCPJsonFile(ctx, path.join(ctx.cwd, filename), "project")),
+		filenames.map(filename => loadMCPJsonFile(path.join(ctx.cwd, filename), "project")),
 	);
 
 	const allItems = results.flatMap(r => r.items);

package/src/extensibility/custom-tools/types.ts

@@ -47,7 +47,7 @@ export interface CustomToolAPI {
 	exec(command: string, args: string[], options?: ExecOptions): Promise<ExecResult>;
 	/** UI methods for user interaction (select, confirm, input, notify, custom) */
 	ui: CustomToolUIContext;
-	/** Whether UI is available (false in print/RPC mode) */
+	/** Whether an interactive UI is available */
 	hasUI: boolean;
 	/** File logger for error/warning/debug messages */
 	logger: typeof import("@gajae-code/utils").logger;

package/src/extensibility/extensions/compact-handler.ts

@@ -3,7 +3,7 @@
  *
  * Extension-facing APIs accept `string | CompactOptions`, but `AgentSession.compact`
  * takes two positional arguments `(instructions, options)`. This helper splits the
- * union so the same adapter can be reused by print-mode, rpc-mode, and the executor.
+ * union so the same adapter can be reused by print, SDK, ACP, and executor callers.
  */
 import type { Model } from "@gajae-code/ai";
 import type { CompactOptions } from "./types";
@@ -24,7 +24,7 @@ export async function runExtensionCompact(
 
 interface SetModelCapableSession {
 	modelRegistry: { getApiKey(model: Model): Promise<string | undefined> };
-	setModel(model: Model): Promise<unknown>;
+	setModel(model: Model, role?: string, options?: { cause?: string }): Promise<unknown>;
 }
 
 /**
@@ -35,6 +35,6 @@ interface SetModelCapableSession {
 export async function runExtensionSetModel(session: SetModelCapableSession, model: Model): Promise<boolean> {
 	const key = await session.modelRegistry.getApiKey(model);
 	if (!key) return false;
-	await session.setModel(model);
+	await session.setModel(model, "default", { cause: "user-selection" });
 	return true;
 }

package/src/extensibility/extensions/get-commands-handler.ts

@@ -2,8 +2,8 @@
  * Helper for wiring the `getCommands` action of {@link ExtensionAPI}.
  *
  * Centralizes the union over the three slash-command sources the runtime
- * exposes so the five wiring sites (interactive UI, ACP, RPC, print, child
- * task executor) cannot drift:
+ * exposes so the interactive UI, ACP, SDK, print, and child task executor wiring
+ * sites cannot drift:
  *   - extension-registered hook commands (`source: "extension"`)
  *   - prompt commands loaded as `LoadedCustomCommand` — user/project/bundled
  *     custom commands and MCP prompts (`source: "prompt"`)

package/src/extensibility/extensions/loader.ts

@@ -5,7 +5,7 @@ import type * as fs1 from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { ThinkingLevel } from "@gajae-code/agent-core";
-import type { ImageContent, Model, TextContent } from "@gajae-code/ai";
+import type { ImageContent, Model, TextContent, UsageReport } from "@gajae-code/ai";
 import type { KeyId } from "@gajae-code/tui";
 import { hasFsCode, isEacces, isEnoent, logger } from "@gajae-code/utils";
 import * as Zod from "zod/v4";
@@ -62,7 +62,7 @@ export class ExtensionRuntime implements IExtensionRuntime {
 		throw new ExtensionRuntimeNotInitializedError();
 	}
 
-	sendUserMessage(): void {
+	sendUserMessage(): Promise<void> {
 		throw new ExtensionRuntimeNotInitializedError();
 	}
 
@@ -102,6 +102,38 @@ export class ExtensionRuntime implements IExtensionRuntime {
 		throw new ExtensionRuntimeNotInitializedError();
 	}
 
+	getThinkingVisibility(): "visible" | "hidden" {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
+	setThinkingVisibility(): void {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
+	cycleThinkingLevel(): ThinkingLevel | undefined {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
+	setThinkingLevelForControl(): Promise<void> {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
+	setThinkingVisibilityForControl(): Promise<void> {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
+	setModelTemporaryForControl(): Promise<boolean> {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
+	fetchUsageReportsForControl(): Promise<UsageReport[] | null> {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
+	getThinkingScopeForControl(): "session" | "global config" {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
 	getSessionName(): string | undefined {
 		throw new ExtensionRuntimeNotInitializedError();
 	}
@@ -204,9 +236,9 @@ class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
 
 	sendUserMessage(
 		content: string | (TextContent | ImageContent)[],
-		options?: { deliverAs?: "steer" | "followUp" },
-	): void {
-		this.runtime.sendUserMessage(content, options);
+		options?: { deliverAs?: "steer" | "followUp"; onPreflightAccepted?: () => void },
+	): Promise<void> {
+		return Promise.resolve(this.runtime.sendUserMessage(content, options));
 	}
 
 	appendEntry(customType: string, data?: unknown): void {
@@ -245,6 +277,38 @@ class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
 		this.runtime.setThinkingLevel(level, persist);
 	}
 
+	getThinkingVisibility(): "visible" | "hidden" {
+		return this.runtime.getThinkingVisibility();
+	}
+
+	setThinkingVisibility(visibility: "visible" | "hidden", persist?: boolean): void {
+		this.runtime.setThinkingVisibility(visibility, persist);
+	}
+
+	cycleThinkingLevel(): ThinkingLevel | undefined {
+		return this.runtime.cycleThinkingLevel();
+	}
+
+	setThinkingLevelForControl(level: ThinkingLevel, persist: boolean): Promise<void> {
+		return this.runtime.setThinkingLevelForControl(level, persist);
+	}
+
+	setThinkingVisibilityForControl(visibility: "visible" | "hidden", persist: boolean): Promise<void> {
+		return this.runtime.setThinkingVisibilityForControl(visibility, persist);
+	}
+
+	setModelTemporaryForControl(model: Model, expectedSessionId?: string): Promise<boolean> {
+		return this.runtime.setModelTemporaryForControl(model, expectedSessionId);
+	}
+
+	fetchUsageReportsForControl(): Promise<UsageReport[] | null> {
+		return this.runtime.fetchUsageReportsForControl();
+	}
+
+	getThinkingScopeForControl(): "session" | "global config" {
+		return this.runtime.getThinkingScopeForControl();
+	}
+
 	getSessionName(): string | undefined {
 		return this.runtime.getSessionName();
 	}