@gajae-code/coding-agent 0.18.12 → 0.19.0

package/src/migrate/executor.ts

@@ -76,7 +76,11 @@ async function writeSkillFileNoFollow(destination: string, content: string): Pro
 	}
 }
 
-async function ensureInstructionDirectory(directory: string, project: boolean): Promise<void> {
+async function ensureInstructionDirectory(
+	directory: string,
+	project: boolean,
+	label = "instruction destination",
+): Promise<void> {
 	let trustedBase = path.dirname(directory);
 	if (!project) {
 		const home = path.resolve(getTrustedHomeDir());
@@ -92,7 +96,7 @@ async function ensureInstructionDirectory(directory: string, project: boolean):
 				try {
 					const stat = await fs.lstat(current);
 					if (!stat.isDirectory() || stat.isSymbolicLink()) {
-						throw new Error(`user instruction destination ancestor is not a real directory: ${current}`);
+						throw new Error(`user ${label} ancestor is not a real directory: ${current}`);
 					}
 					trustedBase = current;
 					break;
@@ -105,7 +109,7 @@ async function ensureInstructionDirectory(directory: string, project: boolean):
 			}
 		}
 	}
-	await ensureRealDirectoryPathNoFollow(directory, trustedBase, "instruction destination", true, 0o700);
+	await ensureRealDirectoryPathNoFollow(directory, trustedBase, label, true, 0o700);
 }
 
 async function writeInstructionFileNoFollow(destination: string, content: string, project: boolean): Promise<void> {
@@ -122,6 +126,107 @@ async function writeInstructionFileNoFollow(destination: string, content: string
 	}
 }
 
+async function writeAgentFileNoFollow(
+	destination: string,
+	content: string,
+	project: boolean,
+	createOnly: boolean,
+): Promise<void> {
+	const destinationDirectory = path.dirname(destination);
+	if (project) {
+		const agentsRoot = path.dirname(destinationDirectory);
+		const agentRoot = path.dirname(agentsRoot);
+		await ensureRealDirectoryPathNoFollow(agentRoot, path.dirname(agentRoot), "agent destination", true, 0o700);
+		await ensureRealDirectoryPathNoFollow(agentsRoot, agentRoot, "agent destination", true, 0o700);
+		await ensureRealDirectoryPathNoFollow(destinationDirectory, agentsRoot, "agent destination", true, 0o700);
+	} else {
+		await ensureInstructionDirectory(destinationDirectory, false, "agent destination");
+	}
+	const handle = await fs.open(
+		destination,
+		createOnly
+			? fsSync.constants.O_WRONLY | fsSync.constants.O_CREAT | fsSync.constants.O_EXCL | fsSync.constants.O_NOFOLLOW
+			: fsSync.constants.O_WRONLY |
+					fsSync.constants.O_CREAT |
+					fsSync.constants.O_TRUNC |
+					fsSync.constants.O_NOFOLLOW,
+		0o666,
+	);
+	try {
+		await handle.writeFile(content, "utf-8");
+	} finally {
+		await handle.close();
+	}
+}
+
+/** Generated hook modules live beside the agent's own hooks, so they use the same no-follow rules. */
+async function writeHookModuleNoFollow(destination: string, content: string, createOnly: boolean): Promise<void> {
+	await ensureInstructionDirectory(path.dirname(destination), false, "hook destination");
+	const handle = await fs.open(
+		destination,
+		createOnly
+			? fsSync.constants.O_WRONLY | fsSync.constants.O_CREAT | fsSync.constants.O_EXCL | fsSync.constants.O_NOFOLLOW
+			: fsSync.constants.O_WRONLY |
+					fsSync.constants.O_CREAT |
+					fsSync.constants.O_TRUNC |
+					fsSync.constants.O_NOFOLLOW,
+		0o666,
+	);
+	try {
+		await handle.writeFile(content, "utf-8");
+	} finally {
+		await handle.close();
+	}
+}
+
+async function writeCommandFileNoFollow(
+	destination: string,
+	content: string,
+	name: string,
+	project: boolean,
+	createOnly: boolean,
+): Promise<void> {
+	const destinationDirectory = path.dirname(destination);
+	if (project) {
+		const nameParts = name.split(":");
+		let commandsRoot = destinationDirectory;
+		for (let index = 1; index < nameParts.length; index++) commandsRoot = path.dirname(commandsRoot);
+		const agentRoot = path.dirname(commandsRoot);
+		await ensureRealDirectoryPathNoFollow(
+			agentRoot,
+			path.dirname(agentRoot),
+			"slash command destination",
+			true,
+			0o700,
+		);
+		await ensureRealDirectoryPathNoFollow(commandsRoot, agentRoot, "slash command destination", true, 0o700);
+		await ensureRealDirectoryPathNoFollow(
+			destinationDirectory,
+			commandsRoot,
+			"slash command destination",
+			true,
+			0o700,
+		);
+	} else {
+		await ensureInstructionDirectory(destinationDirectory, false, "slash command destination");
+	}
+
+	const handle = await fs.open(
+		destination,
+		fsSync.constants.O_WRONLY |
+			fsSync.constants.O_CREAT |
+			fsSync.constants.O_TRUNC |
+			fsSync.constants.O_NOFOLLOW |
+			(createOnly ? fsSync.constants.O_EXCL : 0),
+		0o666,
+	);
+	try {
+		await handle.writeFile(content, "utf-8");
+	} finally {
+		await handle.close();
+	}
+}
+
 export async function executeActions(
 	actions: MigrateAction[],
 	options?: { project?: boolean },
@@ -159,10 +264,43 @@ export async function executeActions(
 					options?.project ?? false,
 				);
 				out.push(action);
+			} else if (action.type === "hook" && action.hook && action.destination) {
+				await writeHookModuleNoFollow(action.destination, action.hook.content, action.operation === "create");
+				out.push(action);
+			} else if (action.type === "agent" && action.agent && action.destination) {
+				await writeAgentFileNoFollow(
+					action.destination,
+					action.agent.content,
+					options?.project ?? false,
+					action.operation === "create",
+				);
+				out.push(action);
+			} else if (action.type === "command" && action.command && action.destination && action.name) {
+				await writeCommandFileNoFollow(
+					action.destination,
+					action.command.content,
+					action.name,
+					options?.project ?? false,
+					action.operation === "create",
+				);
+				out.push(action);
 			} else {
 				out.push(action);
 			}
 		} catch (error) {
+			if (
+				(action.type === "command" || action.type === "agent") &&
+				action.operation === "create" &&
+				(error as NodeJS.ErrnoException).code === "EEXIST"
+			) {
+				out.push({
+					...action,
+					operation: "skip",
+					status: "skipped_exists",
+					reason: "destination appeared after planning; refusing to overwrite it",
+				});
+				continue;
+			}
 			out.push({
 				...action,
 				operation: "fail",

package/src/migrate/hook-module.ts

@@ -0,0 +1,193 @@
+/**
+ * Render a gjc hook module from imported foreign hook commands.
+ *
+ * Claude Code hooks are shell commands: the runtime writes a JSON payload to
+ * stdin and reads the exit code. `PreToolUse` blocks on exit 2 with stderr as the
+ * reason; every other event is observational. gjc hooks are TypeScript modules
+ * that subscribe to events in-process, so the importer reproduces the foreign
+ * contract rather than rewriting the commands.
+ *
+ * Only events whose semantics are unambiguous are translated. The payload keeps
+ * the foreign field names so an existing script that reads its JSON keeps working;
+ * fields this host cannot supply are omitted instead of guessed, which the module
+ * header states.
+ */
+import type { HookCandidate, MigrateSource } from "./types";
+
+/** Foreign event -> gjc hook event. Blocking events are marked separately. */
+const EVENT_MAP: Record<string, { event: string; blocking: boolean }> = {
+	PreToolUse: { event: "tool_call", blocking: true },
+	PostToolUse: { event: "tool_result", blocking: false },
+	SessionStart: { event: "session_start", blocking: false },
+	Stop: { event: "turn_end", blocking: false },
+};
+
+export function isSupportedHookEvent(event: string): boolean {
+	return event in EVENT_MAP;
+}
+
+/** Foreign events this importer translates, for user-facing messages. */
+export const SUPPORTED_HOOK_EVENTS: readonly string[] = Object.keys(EVENT_MAP);
+
+interface RenderedHook {
+	event: string;
+	blocking: boolean;
+	matcher?: string;
+	command: string;
+	sourceEvent: string;
+}
+
+function constantName(event: string): string {
+	return event.replace(/[^a-z_]/g, "_").toUpperCase();
+}
+
+function renderHookLiteral(hook: RenderedHook): string {
+	const parts = [`event: ${JSON.stringify(hook.sourceEvent)}`, `command: ${JSON.stringify(hook.command)}`];
+	if (hook.matcher) parts.push(`matcher: ${JSON.stringify(hook.matcher)}`);
+	return `\t{ ${parts.join(", ")} },`;
+}
+
+/**
+ * Build the module source. The result is deterministic for a given candidate
+ * list, so a dry-run report and a live write describe the same file.
+ */
+export function renderHookModule(source: MigrateSource, candidates: readonly HookCandidate[]): string {
+	const hooks: RenderedHook[] = [];
+	for (const candidate of candidates) {
+		const mapped = EVENT_MAP[candidate.event];
+		if (!mapped) continue;
+		hooks.push({
+			event: mapped.event,
+			blocking: mapped.blocking,
+			matcher: candidate.matcher,
+			command: candidate.command,
+			sourceEvent: candidate.event,
+		});
+	}
+	const byEvent = new Map<string, RenderedHook[]>();
+	for (const hook of hooks) {
+		const list = byEvent.get(hook.event) ?? [];
+		list.push(hook);
+		byEvent.set(hook.event, list);
+	}
+	const eventNames = [...byEvent.keys()].sort();
+	const blocks = eventNames
+		.map(event => {
+			const entries = (byEvent.get(event) ?? []).map(renderHookLiteral).join("\n");
+			return `const ${constantName(event)}_HOOKS: readonly ImportedHook[] = [\n${entries}\n];`;
+		})
+		.join("\n\n");
+	const registrations = eventNames
+		.map(event => {
+			const blocking = byEvent.get(event)?.some(hook => hook.blocking) ?? false;
+			const register = blocking ? "registerBlocking" : "registerObservational";
+			return `\t${register}(api, ${JSON.stringify(event)}, ${constantName(event)}_HOOKS);`;
+		})
+		.join("\n");
+
+	return `/**
+ * Generated by \`gjc migrate --from ${source}\`. Re-run with --force to regenerate.
+ *
+ * These hooks were shell commands in ${source}. Each command receives a JSON
+ * payload on stdin under the origin's field names; fields this runtime cannot
+ * supply (session id, transcript path) are omitted rather than invented.
+ * \`PreToolUse\` blocks the tool when the command exits 2 and uses its stderr as
+ * the reason, which is the origin contract; the other events only run the
+ * command.
+ */
+import { spawn } from "node:child_process";
+
+interface ImportedHook {
+	event: string;
+	command: string;
+	matcher?: string;
+}
+
+interface HookCommandResult {
+	code: number;
+	stdout: string;
+	stderr: string;
+}
+
+interface HookApi {
+	on(event: string, handler: (payload: unknown, context: { cwd?: string }) => unknown): void;
+}
+
+${blocks}
+
+function matches(matcher: string | undefined, toolName: string | undefined): boolean {
+	if (!matcher || !matcher.trim()) return true;
+	if (!toolName) return false;
+	try {
+		return new RegExp(\`^(?:\${matcher})$\`).test(toolName);
+	} catch {
+		return matcher === toolName;
+	}
+}
+
+function shellCommand(command: string): string[] {
+	return process.platform === "win32"
+		? [process.env.ComSpec ?? "cmd.exe", "/d", "/s", "/c", command]
+		: ["/bin/bash", "-lc", command];
+}
+
+async function runHook(hook: ImportedHook, payload: unknown): Promise<HookCommandResult> {
+	const [file, ...args] = shellCommand(hook.command);
+	const child = spawn(file, args, { stdio: ["pipe", "pipe", "pipe"] });
+	child.stdin?.end(JSON.stringify(payload));
+	let stdout = "";
+	let stderr = "";
+	child.stdout?.on("data", chunk => {
+		stdout += String(chunk);
+	});
+	child.stderr?.on("data", chunk => {
+		stderr += String(chunk);
+	});
+	const code = await new Promise<number>(resolve => {
+		child.on("error", () => resolve(1));
+		child.on("close", value => resolve(value ?? 1));
+	});
+	return { code, stdout, stderr };
+}
+
+function registerBlocking(api: HookApi, event: string, hooks: readonly ImportedHook[]): void {
+	api.on(event, async (payload, context) => {
+		const record = payload as { toolName?: string; input?: unknown };
+		for (const hook of hooks) {
+			if (!matches(hook.matcher, record?.toolName)) continue;
+			const result = await runHook(hook, {
+				hook_event_name: hook.event,
+				tool_name: record?.toolName,
+				tool_input: record?.input,
+				cwd: context?.cwd,
+			});
+			if (result.code === 2) {
+				return { block: true, reason: result.stderr.trim() || \`blocked by imported \${hook.event} hook\` };
+			}
+		}
+		return undefined;
+	});
+}
+
+function registerObservational(api: HookApi, event: string, hooks: readonly ImportedHook[]): void {
+	api.on(event, async (payload, context) => {
+		const record = payload as { toolName?: string; input?: unknown; turnIndex?: number };
+		for (const hook of hooks) {
+			if (event === "tool_result" && !matches(hook.matcher, record?.toolName)) continue;
+			await runHook(hook, {
+				hook_event_name: hook.event,
+				tool_name: record?.toolName,
+				tool_input: record?.input,
+				turn_index: record?.turnIndex,
+				cwd: context?.cwd,
+			});
+		}
+		return undefined;
+	});
+}
+
+export default (api: HookApi): void => {
+${registrations}
+};
+`;
+}

package/src/migrate/report.ts

@@ -7,6 +7,7 @@
 import {
 	emptyStatusCounts,
 	isFailureStatus,
+	type ManualAction,
 	type MigrateAction,
 	type MigrateDestinations,
 	type MigrateReport,
@@ -20,6 +21,7 @@ export interface BuildReportInput {
 	warnings: MigrateWarning[];
 	sources: MigrateSource[];
 	destinations: MigrateDestinations;
+	manualActions: ManualAction[];
 	dryRun: boolean;
 	project: boolean;
 	force: boolean;
@@ -30,6 +32,9 @@ export function buildReport(input: BuildReportInput): MigrateReport {
 	const byType = {
 		mcp: emptyStatusCounts(),
 		skill: emptyStatusCounts(),
+		command: emptyStatusCounts(),
+		agent: emptyStatusCounts(),
+		hook: emptyStatusCounts(),
 		instruction: emptyStatusCounts(),
 		source: emptyStatusCounts(),
 	};
@@ -52,6 +57,7 @@ export function buildReport(input: BuildReportInput): MigrateReport {
 		sources: input.sources,
 		destinations: input.destinations,
 		summary: { total, byType, bySource },
+		manualActions: input.manualActions,
 		actions: input.actions.map(action => ({
 			source: action.source,
 			type: action.type,
@@ -81,12 +87,42 @@ export function renderHuman(report: MigrateReport): string {
 	lines.push(`gjc migrate${mode}: ${report.ok ? "ok" : "completed with failures"}`);
 	lines.push(`Sources: ${report.sources.join(", ") || "none"}`);
 	lines.push(
-		`Destination: mcp=${report.destinations.mcpConfigPath} skills=${report.destinations.skillsDir} instructions=${report.destinations.instructionsPath}`,
+		`Destination: mcp=${report.destinations.mcpConfigPath} skills=${report.destinations.skillsDir} commands=${report.destinations.commandsDir} agents=${report.destinations.agentsDir} hooks=${report.destinations.hooksDir} instructions=${report.destinations.instructionsPath}`,
 	);
 	lines.push("");
 	lines.push(`MCP:    ${summarizeCounts(report.summary.byType.mcp)}`);
 	lines.push(`Skills: ${summarizeCounts(report.summary.byType.skill)}`);
+	lines.push(`Commands: ${summarizeCounts(report.summary.byType.command)}`);
+	lines.push(`Agents: ${summarizeCounts(report.summary.byType.agent)}`);
+	lines.push(`Hooks:  ${summarizeCounts(report.summary.byType.hook)}`);
 	lines.push(`Instructions: ${summarizeCounts(report.summary.byType.instruction)}`);
+	const commandActions = report.actions.filter(action => action.type === "command");
+	if (commandActions.length > 0) {
+		lines.push("Slash commands:");
+		for (const action of commandActions) {
+			lines.push(
+				`  - [${action.source}] /${action.name ?? ""}: ${action.status}${action.reason ? ` (${action.reason})` : ""}`,
+			);
+		}
+	}
+	const agentActions = report.actions.filter(action => action.type === "agent");
+	if (agentActions.length > 0) {
+		lines.push("Subagents:");
+		for (const action of agentActions) {
+			lines.push(
+				`  - [${action.source}] ${action.name ?? ""}: ${action.status}${action.reason ? ` (${action.reason})` : ""}`,
+			);
+		}
+	}
+	const hookActions = report.actions.filter(action => action.type === "hook");
+	if (hookActions.length > 0) {
+		lines.push("Hooks:");
+		for (const action of hookActions) {
+			lines.push(
+				`  - [${action.source}] ${action.name ?? ""}: ${action.status}${action.reason ? ` (${action.reason})` : ""}`,
+			);
+		}
+	}
 	const instructionActions = report.actions.filter(action => action.type === "instruction");
 	if (instructionActions.length > 0) {
 		lines.push("Instruction files:");
@@ -109,6 +145,14 @@ export function renderHuman(report: MigrateReport): string {
 		}
 	}
 
+	if (report.manualActions.length > 0) {
+		lines.push("");
+		lines.push("Manual actions:");
+		for (const m of report.manualActions) {
+			lines.push(`  - [${m.source}] ${m.area}: ${m.detail}`);
+		}
+	}
+
 	if (report.warnings.length > 0) {
 		lines.push("");
 		lines.push("Warnings:");

package/src/migrate/types.ts

@@ -1,7 +1,7 @@
 /**
  * Shared types for `gjc migrate`.
  *
- * Imports MCP servers, skills, and instruction files from other coding agents
+ * Imports MCP servers, skills, slash commands, and instruction files from other coding agents
  * (Claude Code, Codex, OpenCode) into native GJC config. See the consensus plan under
  * `.gjc/plans/ralplan/` for the full taxonomy and force/collision semantics.
  */
@@ -16,7 +16,7 @@ export const MIGRATE_SOURCES: readonly MigrateSource[] = ["claude-code", "codex"
 export const CANONICAL_SOURCE_ORDER: readonly MigrateSource[] = MIGRATE_SOURCES;
 
 /** What kind of thing an action/coverage row is about. */
-export type MigrateItemType = "mcp" | "skill" | "instruction" | "source";
+export type MigrateItemType = "mcp" | "skill" | "command" | "agent" | "hook" | "instruction" | "source";
 
 /**
  * Per-item outcome taxonomy.
@@ -84,6 +84,24 @@ export interface InstructionCandidate {
 	content: string;
 }
 
+/** A Markdown subagent collected from a foreign coding-agent setup. */
+export interface AgentCandidate {
+	source: MigrateSource;
+	/** Agent name exactly as it will be loaded from `<agentsDir>/<name>.md`. */
+	name: string;
+	/** Full Markdown content with normalized GJC frontmatter. */
+	content: string;
+	warnings: string[];
+}
+
+/** A Markdown slash command collected from a foreign coding-agent setup. */
+export interface SlashCommandCandidate {
+	source: MigrateSource;
+	/** Name without the leading slash; nested path components use `:`. */
+	name: string;
+	content: string;
+}
+
 /**
  * Source-level diagnostic for a single source/type pair (e.g. "codex mcp config
  * was malformed"). Distinct from per-item actions so absent/unreadable sources
@@ -96,12 +114,48 @@ export interface SourceDiagnostic {
 	message: string;
 }
 
+/**
+ * A foreign hook command that maps onto a gjc hook event.
+ *
+ * Claude Code hooks are shell commands that receive a JSON payload on stdin and
+ * signal a block with exit code 2; gjc hooks are TypeScript modules. The
+ * importer generates a module that reproduces that contract for the events whose
+ * semantics are unambiguous.
+ */
+export interface HookCandidate {
+	source: MigrateSource;
+	/** Foreign event name, e.g. `PreToolUse`. */
+	event: string;
+	/** Tool-name matcher; empty or absent means every tool. */
+	matcher?: string;
+	/** Shell command exactly as the source declared it. */
+	command: string;
+}
+
+/**
+ * A source setting the migration cannot express in gjc. Reported instead of
+ * guessed at: silently translating an approval or hook policy would change what
+ * the agent is allowed to do. Secret values are never read, so detail may name
+ * keys but never their contents.
+ */
+export interface ManualAction {
+	source: MigrateSource;
+	/** Setting area, e.g. `hooks`, `settings.model`, `env`. */
+	area: string;
+	/** One-line instruction naming the concrete follow-up. */
+	detail: string;
+}
+
 /** Normalized candidates + diagnostics returned by an adapter. */
 export interface AdapterResult {
 	mcpCandidates: McpCandidate[];
 	skillCandidates: SkillCandidate[];
+	slashCommandCandidates: SlashCommandCandidate[];
+	agentCandidates: AgentCandidate[];
+	hookCandidates: HookCandidate[];
 	instructionCandidates: InstructionCandidate[];
 	diagnostics: SourceDiagnostic[];
+	manualActions: ManualAction[];
 }
 
 /** A single planned action consumed identically by dry-run and live execution. */
@@ -120,6 +174,9 @@ export interface MigrateAction {
 	/** Resolved payload the executor needs; never serialized to the report. */
 	mcp?: { config: MCPServerConfig; force: boolean };
 	skill?: { content: string };
+	command?: { content: string };
+	agent?: { content: string };
+	hook?: { content: string };
 	instruction?: { content: string };
 }
 
@@ -135,6 +192,10 @@ export type StatusCounts = Record<MigrationStatus, number>;
 export interface MigrateDestinations {
 	mcpConfigPath: string;
 	skillsDir: string;
+	commandsDir: string;
+	agentsDir: string;
+	/** Directory that receives generated hook modules. */
+	hooksDir: string;
 	instructionsPath: string;
 }
 
@@ -148,7 +209,15 @@ export interface MigrateReport {
 	destinations: MigrateDestinations;
 	summary: {
 		total: StatusCounts;
-		byType: { mcp: StatusCounts; skill: StatusCounts; instruction: StatusCounts; source: StatusCounts };
+		byType: {
+			mcp: StatusCounts;
+			skill: StatusCounts;
+			command: StatusCounts;
+			agent: StatusCounts;
+			hook: StatusCounts;
+			instruction: StatusCounts;
+			source: StatusCounts;
+		};
 		bySource: Record<MigrateSource, StatusCounts>;
 	};
 	actions: Array<{
@@ -163,6 +232,7 @@ export interface MigrateReport {
 		warnings?: string[];
 	}>;
 	warnings: MigrateWarning[];
+	manualActions: ManualAction[];
 }
 
 /** Create a zeroed status-count record. */

package/src/modes/acp/acp-agent.ts

@@ -631,6 +631,11 @@ function isAbortNoEffect(value: unknown): boolean {
 	const result = object(candidate?.result) ?? candidate;
 	return result?.turn === "no_active_turn" || result?.turn === "no_effect" || result?.turn === "no_store";
 }
+function isAbortUncertain(value: unknown): boolean {
+	const candidate = object(value);
+	const result = object(candidate?.result) ?? candidate;
+	return result?.turn === "uncertain";
+}
 
 function strictCorrelationFrom(...values: unknown[]): PromptCorrelation | undefined {
 	const correlation: PromptCorrelation = {};
@@ -3064,12 +3069,16 @@ export class AcpAgent implements Agent {
 			let acknowledgementScope = scope;
 			if (
 				!isAbortAcknowledged(acknowledgement, scope) &&
-				isAbortNoEffect(acknowledgement) &&
+				(isAbortNoEffect(acknowledgement) || isAbortUncertain(acknowledgement)) &&
 				(waiterWasUnacknowledged || waiterWasBeforeActivity) &&
 				waiter &&
 				record.activePrompt === waiter &&
 				!waiter.settled
 			) {
+				// An uncertain replay result is not proof that the worker stopped, but it
+				// also must not erase a cancellation that arrived before prompt admission.
+				// Retain the intent and retry once the prompt acknowledgement/start gives
+				// the abort a concrete active turn to target.
 				waiter.cancelBeforeAdmission = true;
 				waiter.cancelBeforeAdmissionScope =
 					waiter.cancelBeforeAdmissionScope === "owned" || scope === "owned" ? "owned" : "turn";

package/src/modes/components/agent-dashboard.ts

@@ -90,14 +90,22 @@ export function resolveAgentCreationModel(
 	modelPatterns: string[],
 	modelRegistry: ModelRegistry,
 	settings: Settings | undefined,
+	credentialSessionId?: string,
 ) {
-	const { model } = resolveModelOverride(modelPatterns, modelRegistry, settings);
+	const { model } = resolveModelOverride(
+		modelPatterns,
+		modelRegistry,
+		settings,
+		undefined,
+		undefined,
+		credentialSessionId,
+	);
 	if (model) return model;
 	if (modelPatterns.length > 0) {
 		throw new Error(`Configured model selector(s) did not resolve: ${modelPatterns.join(", ")}.`);
 	}
 
-	const fallbackModel = modelRegistry.getAvailable()[0];
+	const fallbackModel = modelRegistry.getAvailable(credentialSessionId)[0];
 	if (!fallbackModel) {
 		throw new Error("No available model to generate agent specification.");
 	}
@@ -612,7 +620,12 @@ export class AgentDashboard extends Container {
 				settings?.getModelRole("default"),
 			settings,
 		);
-		const selectedModel = resolveAgentCreationModel(modelPatterns, modelRegistry, settings);
+		const selectedModel = resolveAgentCreationModel(
+			modelPatterns,
+			modelRegistry,
+			settings,
+			this.modelContext.credentialSessionId,
+		);
 
 		const systemPrompt = prompt.render(agentCreationArchitectPrompt, { TASK_TOOL_NAME: "task" });
 		const userPrompt = prompt.render(agentCreationUserPrompt, { request: description });
@@ -701,7 +714,7 @@ export class AgentDashboard extends Container {
 		if (!modelRegistry) return [];
 		const query = input.trim().toLowerCase();
 		if (!query) return [];
-		const available = modelRegistry.getAvailable();
+		const available = modelRegistry.getAvailable(this.modelContext.credentialSessionId);
 		const seen = new Set<string>();
 		const matches: string[] = [];
 		for (const model of available) {
@@ -757,6 +770,9 @@ export class AgentDashboard extends Container {
 			patterns,
 			modelRegistry,
 			this.#settingsManager ?? undefined,
+			undefined,
+			undefined,
+			this.modelContext.credentialSessionId,
 		);
 		if (!model) return undefined;
 		return {