@gajae-code/coding-agent 0.8.1 → 0.8.2

package/src/cli/config-cli.ts

@@ -33,6 +33,7 @@ export interface ConfigCommandArgs {
 	value?: string;
 	flags: {
 		json?: boolean;
+		showSecrets?: boolean;
 	};
 }
 // =============================================================================
@@ -47,6 +48,19 @@ type CliSettingDef = {
 };
 
 const ALL_SETTING_PATHS = Object.keys(SETTINGS_SCHEMA) as SettingPath[];
+const REDACTED_SECRET_VALUE = "<redacted>";
+const SECRET_SETTING_SEGMENT_PATTERN = /(?:api[-_]?key|token|secret|password|passwd|pwd|credential)/i;
+
+function isSecretSettingPath(path: string): boolean {
+	return path.split(".").some(segment => SECRET_SETTING_SEGMENT_PATTERN.test(segment));
+}
+
+function redactConfigValue(path: string, value: unknown, showSecrets?: boolean): unknown {
+	if (showSecrets || typeof value !== "string" || !isSecretSettingPath(path)) {
+		return value;
+	}
+	return REDACTED_SECRET_VALUE;
+}
 
 /** Find setting definition by path */
 function findSettingDef(path: string): CliSettingDef | undefined {
@@ -105,6 +119,8 @@ export function parseConfigArgs(args: string[]): ConfigCommandArgs | undefined {
 		const arg = args[i];
 		if (arg === "--json") {
 			result.flags.json = true;
+		} else if (arg === "--show-secrets") {
+			result.flags.showSecrets = true;
 		} else if (!arg.startsWith("-")) {
 			positionalArgs.push(arg);
 		}
@@ -265,14 +281,15 @@ export async function runConfigCommand(cmd: ConfigCommandArgs): Promise<void> {
 	}
 }
 
-function handleList(flags: { json?: boolean }): void {
+function handleList(flags: { json?: boolean; showSecrets?: boolean }): void {
 	const defs = ALL_SETTING_PATHS.map(path => findSettingDef(path)).filter((def): def is CliSettingDef => !!def);
 
 	if (flags.json) {
 		const result: Record<string, { value: unknown; type: string; description: string }> = {};
 		for (const def of defs) {
+			const value = settings.get(def.path);
 			result[def.path] = {
-				value: settings.get(def.path),
+				value: redactConfigValue(def.path, value, flags.showSecrets),
 				type: def.type,
 				description: def.description,
 			};
@@ -301,7 +318,8 @@ function handleList(flags: { json?: boolean }): void {
 		console.log(chalk.bold.blue(`[${group}]`));
 		for (const def of groups[group]) {
 			const value = settings.get(def.path);
-			const valueStr = formatValue(value);
+			const displayValue = redactConfigValue(def.path, value, flags.showSecrets);
+			const valueStr = formatValue(displayValue);
 			const typeStr = getTypeDisplay(def);
 			console.log(`  ${chalk.white(def.path)} = ${valueStr} ${chalk.dim(typeStr)}`);
 		}
@@ -309,7 +327,7 @@ function handleList(flags: { json?: boolean }): void {
 	}
 }
 
-function handleGet(key: string | undefined, flags: { json?: boolean }): void {
+function handleGet(key: string | undefined, flags: { json?: boolean; showSecrets?: boolean }): void {
 	if (!key) {
 		console.error(chalk.red(`Usage: ${APP_NAME} config get <key>`));
 		console.error(chalk.dim(`\nRun '${APP_NAME} config list' to see available keys`));
@@ -324,16 +342,23 @@ function handleGet(key: string | undefined, flags: { json?: boolean }): void {
 	}
 
 	const value = settings.get(def.path);
+	const displayValue = redactConfigValue(def.path, value, flags.showSecrets);
 
 	if (flags.json) {
-		console.log(JSON.stringify({ key: def.path, value, type: def.type, description: def.description }, null, 2));
+		console.log(
+			JSON.stringify({ key: def.path, value: displayValue, type: def.type, description: def.description }, null, 2),
+		);
 		return;
 	}
 
-	console.log(formatValue(value));
+	console.log(formatValue(displayValue));
 }
 
-async function handleSet(key: string | undefined, value: string | undefined, flags: { json?: boolean }): Promise<void> {
+async function handleSet(
+	key: string | undefined,
+	value: string | undefined,
+	flags: { json?: boolean; showSecrets?: boolean },
+): Promise<void> {
 	if (!key || value === undefined) {
 		console.error(chalk.red(`Usage: ${APP_NAME} config set <key> <value>`));
 		console.error(chalk.dim(`\nRun '${APP_NAME} config list' to see available keys`));
@@ -355,11 +380,12 @@ async function handleSet(key: string | undefined, value: string | undefined, fla
 	}
 
 	const newValue = settings.get(def.path);
+	const displayValue = redactConfigValue(def.path, newValue, flags.showSecrets);
 
 	if (flags.json) {
-		console.log(JSON.stringify({ key: def.path, value: newValue }));
+		console.log(JSON.stringify({ key: def.path, value: displayValue }));
 	} else {
-		console.log(chalk.green(`${theme.status.success} Set ${def.path} = ${formatValue(newValue)}`));
+		console.log(chalk.green(`${theme.status.success} Set ${def.path} = ${formatValue(displayValue)}`));
 	}
 }
 
@@ -409,6 +435,7 @@ ${chalk.bold("Commands:")}
 
 ${chalk.bold("Options:")}
   --json             Output as JSON
+  --show-secrets     Show secret-like setting values without redaction (unsafe)
 
 ${chalk.bold("Examples:")}
   ${APP_NAME} config list
@@ -418,6 +445,7 @@ ${chalk.bold("Examples:")}
   ${APP_NAME} config set defaultThinkingLevel medium
   ${APP_NAME} config reset steeringMode
   ${APP_NAME} config list --json
+  ${APP_NAME} config get auth.broker.token --show-secrets
   ${APP_NAME} config init-xdg
 
 ${chalk.bold("Boolean Values:")}

package/src/cli/fast-help.ts

@@ -15,6 +15,7 @@ export function getExtraHelpText(): string {
   ${APP_NAME} deep-interview       - Run requirements interview workflow
   ${APP_NAME} skills               - List/read embedded workflow skills
   ${APP_NAME} config               - List, get, and set configuration values
+  ${APP_NAME} stats                - View AI usage statistics (tokens, cost, requests)
   ${APP_NAME} notify               - Send or test notifications
   ${APP_NAME} daemon               - Manage background daemon helpers
   ${APP_NAME} mcp                  - Manage MCP server registrations

package/src/cli/notify-cli.ts

@@ -58,6 +58,11 @@ interface TelegramUser {
 	allows_users_to_create_topics?: boolean;
 }
 
+interface TelegramChat {
+	id?: number | string;
+	type?: string;
+}
+
 type ThreadedModeState = "enabled" | "disabled" | "unknown";
 type ThreadedModeFinalLabel = "verified" | "unverified" | "unknown";
 
@@ -148,6 +153,7 @@ async function runSetup(deps: NotifyCommandDeps): Promise<void> {
 	let chatId: string;
 	if (deps.setupChatId?.trim()) {
 		chatId = deps.setupChatId.trim();
+		await verifyPrivateChatId(fetchImpl, apiBase, token, chatId);
 		process.stdout.write(`Using provided chat id ${chatId} (non-interactive).\n`);
 	} else {
 		const stale = await getUpdates(fetchImpl, apiBase, token, { timeout: 0, allowed_updates: ["message"] });
@@ -170,16 +176,76 @@ async function runSetup(deps: NotifyCommandDeps): Promise<void> {
 	);
 }
 
-async function promptForToken(): Promise<string> {
-	if (!process.stdin.isTTY) {
+type TokenPromptInput = NodeJS.ReadStream & {
+	isRaw?: boolean;
+	setRawMode?: (mode: boolean) => unknown;
+};
+
+type TokenPromptOutput = Pick<NodeJS.WriteStream, "write">;
+
+export async function promptForToken(
+	input: TokenPromptInput = process.stdin,
+	output: TokenPromptOutput = process.stdout,
+): Promise<string> {
+	if (!input.isTTY) {
 		throw new Error("notify setup requires an interactive TTY unless setupToken is injected.");
 	}
-	const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
-	try {
-		return (await rl.question("Telegram BotFather token: ")).trim();
-	} finally {
-		rl.close();
+	if (typeof input.setRawMode !== "function") {
+		throw new Error("notify setup requires a TTY with raw input support unless setupToken is injected.");
 	}
+
+	output.write("Telegram BotFather token: ");
+	const wasRaw = input.isRaw === true;
+	input.setRawMode(true);
+
+	return await new Promise<string>((resolve, reject) => {
+		let value = "";
+		let settled = false;
+
+		const cleanup = () => {
+			input.off("data", onData);
+			input.off("error", onError);
+			input.setRawMode?.(wasRaw);
+			output.write("\n");
+		};
+
+		const finish = (callback: () => void) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			callback();
+		};
+
+		const accept = () => finish(() => resolve(value.trim()));
+		const cancel = () => finish(() => reject(new Error("Telegram bot token prompt cancelled.")));
+		const onError = (error: Error) => finish(() => reject(error));
+		const onData = (chunk: Buffer | string) => {
+			for (const char of String(chunk)) {
+				if (char === "\r" || char === "\n") {
+					accept();
+					return;
+				}
+				if (char === "\u0003") {
+					cancel();
+					return;
+				}
+				if (char === "\u0004") {
+					if (value) accept();
+					else cancel();
+					return;
+				}
+				if (char === "\u007f" || char === "\b") {
+					value = value.slice(0, -1);
+					continue;
+				}
+				if (char >= " ") value += char;
+			}
+		};
+
+		input.on("data", onData);
+		input.once("error", onError);
+		input.resume();
+	});
 }
 
 const THREADED_ENABLED_SUCCESS =
@@ -223,6 +289,24 @@ async function getMe(fetchImpl: typeof fetch, apiBase: string, token: string): P
 	return user;
 }
 
+async function verifyPrivateChatId(
+	fetchImpl: typeof fetch,
+	apiBase: string,
+	token: string,
+	chatId: string,
+): Promise<void> {
+	const chat = (await callTelegram<unknown>(fetchImpl, apiBase, token, "getChat", { chat_id: chatId })) as
+		| TelegramChat
+		| undefined;
+	if (!chat || typeof chat !== "object") {
+		throw new Error("Telegram getChat returned invalid Telegram response: missing valid Chat result.");
+	}
+	if (chat.type !== "private") {
+		const type = typeof chat.type === "string" && chat.type ? chat.type : "unknown";
+		throw new Error(`Provided chat id ${chatId} is a ${type} chat; pairing requires a private Telegram chat.`);
+	}
+}
+
 function threadedModeState(user: TelegramUser): ThreadedModeState {
 	if (user.has_topics_enabled === true) return "enabled";
 	if (user.has_topics_enabled === false) return "disabled";

package/src/cli.ts

@@ -36,6 +36,7 @@ export const commands: CommandEntry[] = [
 	{ name: "gc", load: () => import("./commands/gc").then(m => m.default) },
 	{ name: "ralplan", load: () => import("./commands/ralplan").then(m => m.default) },
 	{ name: "config", load: () => import("./commands/config").then(m => m.default) },
+	{ name: "stats", load: () => import("./commands/stats").then(m => m.default) },
 	{ name: "notify", load: () => import("./commands/notify").then(m => m.default) },
 	{ name: "daemon", load: () => import("./commands/daemon").then(m => m.default) },
 	{ name: "web-search", aliases: ["q"], load: () => import("./commands/web-search").then(m => m.default) },
@@ -52,6 +53,7 @@ export const commands: CommandEntry[] = [
 	{ name: "rlm", load: () => import("./commands/rlm").then(m => m.default) },
 	{ name: "update", load: () => import("./commands/update").then(m => m.default) },
 	{ name: "plugin", load: () => import("./commands/plugin").then(m => m.default) },
+	{ name: "completion", load: () => import("./commands/completion").then(m => m.default) },
 	{ name: "launch", load: () => import("./commands/launch").then(m => m.default) },
 ];
 
@@ -110,7 +112,7 @@ function hasRootVersionFlag(argv: string[]): boolean {
 	return hasRootFastFlag(argv, versionFlags);
 }
 
-class RootHelpCommand extends Command {
+export class RootHelpCommand extends Command {
 	static description = "Red-claw AI coding assistant";
 	static hidden = true;
 	static args = {

package/src/commands/completion.ts

@@ -0,0 +1,84 @@
+/**
+ * Generate shell completion specs for external completion engines.
+ */
+import { Args, Command, Flags } from "@gajae-code/utils/cli";
+import { commands, RootHelpCommand } from "../cli";
+import {
+	buildGjcFigSpec,
+	defaultInshellisenseSpecDir,
+	type InstallGjcInshellisenseSpecResult,
+	installGjcInshellisenseSpec,
+	renderFigSpecModule,
+} from "../cli/completion-cli";
+
+const TARGETS = ["inshellisense", "fig"] as const;
+
+type CompletionTarget = (typeof TARGETS)[number];
+
+function normalizeTarget(target: CompletionTarget): "inshellisense" {
+	return target === "fig" ? "inshellisense" : target;
+}
+
+function formatInstallResult(result: InstallGjcInshellisenseSpecResult, customDir: boolean): string {
+	const lines = [
+		"Installed GJC inshellisense completion spec:",
+		`  spec:  ${result.specPath}`,
+		`  index: ${result.indexPath} (${result.indexStatus})`,
+	];
+	if (customDir) {
+		lines.push(
+			"Add the install directory to inshellisense's [specs].path setting, then restart the inshellisense session.",
+		);
+	} else {
+		lines.push("Restart the inshellisense session, or run `is reinit` if your shell integration needs a refresh.");
+	}
+	return `${lines.join("\n")}\n`;
+}
+
+export default class Completion extends Command {
+	static description = "Generate shell completion specs";
+
+	static args = {
+		target: Args.string({
+			description: "Completion format",
+			required: false,
+			options: TARGETS,
+		}),
+	};
+
+	static flags = {
+		install: Flags.boolean({ description: "Install the generated spec for inshellisense" }),
+		dir: Flags.string({ description: "Install directory (defaults to ~/.fig/autocomplete/build)" }),
+		force: Flags.boolean({ description: "Overwrite an existing non-GJC inshellisense index.js" }),
+		json: Flags.boolean({ description: "Output JSON instead of JavaScript or status text" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Completion);
+		const target = normalizeTarget((args.target ?? "inshellisense") as CompletionTarget);
+		if (target !== "inshellisense") {
+			process.stderr.write(`Unsupported completion target: ${target}\n`);
+			process.exitCode = 1;
+			return;
+		}
+		if ((flags.dir || flags.force) && !flags.install) {
+			process.stderr.write("--dir and --force only apply with --install\n");
+			process.exitCode = 1;
+			return;
+		}
+
+		const spec = await buildGjcFigSpec(commands, RootHelpCommand);
+		if (!flags.install) {
+			process.stdout.write(flags.json ? `${JSON.stringify(spec, null, 2)}\n` : renderFigSpecModule(spec));
+			return;
+		}
+
+		const directory = flags.dir ?? defaultInshellisenseSpecDir();
+		const result = await installGjcInshellisenseSpec(spec, { dir: directory, force: flags.force });
+		if (flags.json) {
+			process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+			return;
+		}
+		process.stdout.write(formatInstallResult(result, flags.dir !== undefined));
+	}
+}

package/src/commands/config.ts

@@ -29,6 +29,7 @@ export default class Config extends Command {
 
 	static flags = {
 		json: Flags.boolean({ description: "Output JSON" }),
+		"show-secrets": Flags.boolean({ description: "Show secret-like setting values without redaction (unsafe)" }),
 	};
 
 	async run(): Promise<void> {
@@ -42,6 +43,7 @@ export default class Config extends Command {
 			value,
 			flags: {
 				json: flags.json,
+				showSecrets: flags["show-secrets"],
 			},
 		};
 

package/src/commands/deep-interview.ts

@@ -8,6 +8,7 @@ export default class DeepInterview extends Command {
 		quick: Flags.boolean({ description: "Seed a quick deep-interview run" }),
 		standard: Flags.boolean({ description: "Seed a standard deep-interview run" }),
 		deep: Flags.boolean({ description: "Seed a deep deep-interview run" }),
+		trace: Flags.boolean({ description: "Run a bounded trace evidence pre-step before interview questions" }),
 		threshold: Flags.string({ description: "Override ambiguity threshold for kickoff" }),
 		"threshold-source": Flags.string({ description: "Describe the threshold override source" }),
 		"session-id": Flags.string({
@@ -25,7 +26,7 @@ export default class DeepInterview extends Command {
 		json: Flags.boolean({ description: "Output JSON" }),
 	};
 	static examples = [
-		'$ gjc deep-interview --standard "<idea>"',
+		'$ gjc deep-interview --trace --standard "<idea>"',
 		"$ gjc deep-interview --write --stage final --slug my-feature --spec ./final-spec.md",
 		"$ gjc deep-interview --write --stage final --slug my-feature --spec ./final-spec.md --deliberate",
 	];

package/src/config/file-lock.ts

@@ -1,3 +1,4 @@
+import type { Stats } from "node:fs";
 import * as fs from "node:fs/promises";
 import { isEnoent } from "@gajae-code/utils/fs-error";
 
@@ -22,9 +23,10 @@ function getLockPath(filePath: string): string {
 	return `${filePath}.lock`;
 }
 
-async function writeLockInfo(lockPath: string): Promise<void> {
+async function writeLockInfo(lockPath: string): Promise<LockInfo> {
 	const info: LockInfo = { pid: process.pid, timestamp: Date.now() };
 	await Bun.write(`${lockPath}/info`, JSON.stringify(info));
+	return info;
 }
 
 async function readLockInfo(lockPath: string): Promise<LockInfo | null> {
@@ -51,17 +53,30 @@ export interface FileLockOwnerToken {
 	timestamp: number;
 }
 
-/** Outcome of a guarded GC removal attempt (`removeFileLockDirForGc`). */
+/** Outcome of a guarded lock-dir removal attempt (`removeFileLockDirForGc`). */
 export type FileLockGcRemoval = "removed" | "owner_changed" | "missing";
 
+interface LockDirStatToken {
+	dev: number;
+	ino: number;
+	mtimeMs: number;
+	ctimeMs: number;
+}
+
+type LockStaleSnapshot =
+	| { stale: false }
+	| { stale: true; owner: FileLockOwnerToken }
+	| { stale: true; owner: null; stat: LockDirStatToken };
+
 /**
  * @internal
- * Fail-closed removal of a dead lock dir for GC. Re-reads the on-disk owner
- * token as close to the unlink as possible and only deletes the dir when it
- * STILL holds the exact `{pid, timestamp}` identity the caller observed dead.
+ * Fail-closed removal of a lock dir whose owner is expected to be dead or
+ * finished. Re-reads the on-disk owner token as close to the unlink as possible
+ * and only deletes the dir when it STILL holds the exact `{pid, timestamp}`
+ * identity the caller observed.
  *
- * Closes the prune-time TOCTOU window (#606): between GC's dead re-read/probe
- * and the unlink, a live process can reclaim a stale lock at the same path
+ * Closes stale-cleanup TOCTOU windows (#606): between a dead/stale re-read and
+ * the unlink, a live process can reclaim a stale lock at the same path
  * (`acquireLock` rms the stale dir, then re-`mkdir`s and rewrites `info` with a
  * fresh pid+timestamp). Deleting by path alone would reap that LIVE lock. Any
  * mismatch (`owner_changed`) or absent/unreadable info (`missing` — e.g. a
@@ -99,14 +114,28 @@ function ownerLiveness(pid: number): OwnerLiveness {
 	}
 }
 
-async function isLockStale(lockPath: string, staleMs: number): Promise<boolean> {
+function statToken(stats: Stats): LockDirStatToken {
+	return {
+		dev: stats.dev,
+		ino: stats.ino,
+		mtimeMs: stats.mtimeMs,
+		ctimeMs: stats.ctimeMs,
+	};
+}
+
+function sameStatToken(a: LockDirStatToken, b: LockDirStatToken): boolean {
+	return a.dev === b.dev && a.ino === b.ino && a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs;
+}
+
+async function staleLockSnapshot(lockPath: string, staleMs: number): Promise<LockStaleSnapshot> {
 	const info = await readLockInfo(lockPath);
 	if (!info) {
 		try {
 			const stats = await fs.stat(lockPath);
-			return Date.now() - stats.mtimeMs > staleMs;
+			if (Date.now() - stats.mtimeMs <= staleMs) return { stale: false };
+			return { stale: true, owner: null, stat: statToken(stats) };
 		} catch (err) {
-			if (isEnoent(err)) return false;
+			if (isEnoent(err)) return { stale: false };
 			throw err;
 		}
 	}
@@ -115,53 +144,63 @@ async function isLockStale(lockPath: string, staleMs: number): Promise<boolean>
 	// not have its lock stolen (#652). Reclaim a dead owner immediately. Only when owner
 	// liveness is indeterminate do we fall back to the staleMs elapsed-time heuristic.
 	const liveness = ownerLiveness(info.pid);
-	if (liveness === "dead") return true;
-	if (liveness === "alive") return false;
-	return Date.now() - info.timestamp > staleMs;
+	if (liveness === "alive") return { stale: false };
+	if (liveness === "dead" || Date.now() - info.timestamp > staleMs) {
+		return { stale: true, owner: { pid: info.pid, timestamp: info.timestamp } };
+	}
+	return { stale: false };
 }
 
-async function tryAcquireLock(lockPath: string): Promise<boolean> {
+async function removeStaleLockForAcquire(lockPath: string, snapshot: LockStaleSnapshot): Promise<boolean> {
+	if (!snapshot.stale) return false;
+	if (snapshot.owner) {
+		return (await removeFileLockDirForGc(lockPath, snapshot.owner)) === "removed";
+	}
+
+	const currentInfo = await readLockInfo(lockPath);
+	if (currentInfo) return false;
 	try {
-		await fs.mkdir(lockPath);
-		await writeLockInfo(lockPath);
+		const currentStats = await fs.stat(lockPath);
+		if (!sameStatToken(statToken(currentStats), snapshot.stat)) return false;
+		await fs.rm(lockPath, { recursive: true, force: true });
 		return true;
+	} catch (err) {
+		if (isEnoent(err)) return false;
+		throw err;
+	}
+}
+
+async function tryAcquireLock(lockPath: string): Promise<LockInfo | null> {
+	try {
+		await fs.mkdir(lockPath);
+		return await writeLockInfo(lockPath);
 	} catch (error) {
 		if ((error as NodeJS.ErrnoException).code === "EEXIST") {
-			return false;
+			return null;
 		}
 		throw error;
 	}
 }
 
-async function releaseLock(lockPath: string): Promise<void> {
+async function releaseLock(lockPath: string, owner: FileLockOwnerToken): Promise<void> {
 	try {
-		await fs.rm(lockPath, { recursive: true });
+		await removeFileLockDirForGc(lockPath, owner);
 	} catch {
 		// Ignore errors on release
 	}
 }
-
-async function lockExists(lockPath: string): Promise<boolean> {
-	try {
-		await fs.stat(lockPath);
-		return true;
-	} catch (err) {
-		if (isEnoent(err)) return false;
-		throw err;
-	}
-}
-
 async function acquireLock(filePath: string, options: FileLockOptions = {}): Promise<() => Promise<void>> {
 	const opts = { ...DEFAULT_OPTIONS, ...options };
 	const lockPath = getLockPath(filePath);
 
 	for (let attempt = 0; attempt < opts.retries; attempt++) {
-		if (await tryAcquireLock(lockPath)) {
-			return () => releaseLock(lockPath);
+		const owner = await tryAcquireLock(lockPath);
+		if (owner) {
+			return () => releaseLock(lockPath, owner);
 		}
 
-		if ((await lockExists(lockPath)) && (await isLockStale(lockPath, opts.staleMs))) {
-			await releaseLock(lockPath);
+		const stale = await staleLockSnapshot(lockPath, opts.staleMs);
+		if (await removeStaleLockForAcquire(lockPath, stale)) {
 			continue;
 		}
 

package/src/config/keybindings.ts

@@ -134,8 +134,8 @@ export const KEYBINDINGS = {
 		description: "Queue message for next turn",
 	},
 	"app.message.dequeue": {
-		defaultKeys: "alt+up",
-		description: "Dequeue message",
+		defaultKeys: ["alt+up", "alt+down"],
+		description: "Select queued message to edit",
 	},
 	"app.clipboard.pasteImage": {
 		defaultKeys: process.platform === "win32" ? "alt+v" : "ctrl+v",

package/src/config/model-profile-activation.ts

@@ -76,6 +76,34 @@ export interface MaterializeModelProfileAssignmentOptions {
 	selector: string;
 }
 
+export interface MaterializeModelProfileAssignmentsOptions {
+	session: Pick<
+		ModelProfileActivationSession,
+		"model" | "thinkingLevel" | "setActiveModelProfile" | "getActiveModelProfile"
+	>;
+	settings: Pick<Settings, "clearOverride" | "get" | "override" | "set">;
+	assignments: ReadonlyMap<GjcModelAssignmentTargetId, string> | Partial<Record<GjcModelAssignmentTargetId, string>>;
+}
+
+function isReadonlyAssignmentMap(
+	assignments: ReadonlyMap<GjcModelAssignmentTargetId, string> | Partial<Record<GjcModelAssignmentTargetId, string>>,
+): assignments is ReadonlyMap<GjcModelAssignmentTargetId, string> {
+	return typeof (assignments as { entries?: unknown }).entries === "function";
+}
+
+function getMaterializedAssignments(
+	assignments: ReadonlyMap<GjcModelAssignmentTargetId, string> | Partial<Record<GjcModelAssignmentTargetId, string>>,
+): Array<[GjcModelAssignmentTargetId, string]> {
+	if (isReadonlyAssignmentMap(assignments)) return [...assignments.entries()];
+	const assignmentRecord: Partial<Record<GjcModelAssignmentTargetId, string>> = assignments;
+	const result: Array<[GjcModelAssignmentTargetId, string]> = [];
+	for (const role of Object.keys(assignmentRecord) as GjcModelAssignmentTargetId[]) {
+		const selector = assignmentRecord[role];
+		if (selector !== undefined) result.push([role, selector]);
+	}
+	return result;
+}
+
 export function materializeActiveModelProfileAssignment(options: MaterializeModelProfileAssignmentOptions): boolean {
 	const activeProfile = options.session.getActiveModelProfile?.() ?? options.settings.get("modelProfile.default");
 	if (!activeProfile) return false;
@@ -109,6 +137,43 @@ export function materializeActiveModelProfileAssignment(options: MaterializeMode
 	return true;
 }
 
+export function materializeActiveModelProfileAssignments(options: MaterializeModelProfileAssignmentsOptions): boolean {
+	const activeProfile = options.session.getActiveModelProfile?.() ?? options.settings.get("modelProfile.default");
+	if (!activeProfile) return false;
+
+	const materializedAssignments = getMaterializedAssignments(options.assignments);
+	if (materializedAssignments.length === 0) return true;
+
+	const nextModelRoles = { ...options.settings.get("modelRoles") };
+	const nextAgentModelOverrides = { ...options.settings.get("task.agentModelOverrides") };
+	const includesDefault = materializedAssignments.some(([role]) => role === "default");
+
+	if (!includesDefault && !nextModelRoles.default && options.session.model) {
+		nextModelRoles.default = formatModelSelectorValue(
+			`${options.session.model.provider}/${options.session.model.id}`,
+			options.session.thinkingLevel,
+		);
+	}
+
+	for (const [role, selector] of materializedAssignments) {
+		const target = GJC_MODEL_ASSIGNMENT_TARGETS[role];
+		if (target.settingsPath === "modelRoles") {
+			nextModelRoles[role] = selector;
+		} else {
+			nextAgentModelOverrides[role] = selector;
+		}
+	}
+
+	options.settings.set("modelRoles", nextModelRoles);
+	options.settings.set("task.agentModelOverrides", nextAgentModelOverrides);
+	options.settings.set("modelProfile.default", undefined);
+	options.settings.clearOverride("modelProfile.default");
+	options.settings.override("modelRoles", nextModelRoles);
+	options.settings.override("task.agentModelOverrides", nextAgentModelOverrides);
+	options.session.setActiveModelProfile?.(undefined);
+	return true;
+}
+
 export function formatModelProfileCredentialError(profileLabel: string, providers: readonly string[]): string {
 	return `Model profile "${profileLabel}" requires credentials for: ${providers.join(", ")}. Run /login and configure the missing provider(s), then retry.`;
 }