@gajae-code/coding-agent 0.6.4 → 0.7.0

package/src/migrate/skill-normalizer.ts

@@ -0,0 +1,80 @@
+/**
+ * Normalize a skill from another agent into a native GJC `SKILL.md`.
+ *
+ * GJC derives a skill's loaded name from its directory (`<slug>/SKILL.md`) when no
+ * frontmatter `name` is present, and requires a `description`. To guarantee the
+ * effective loaded name equals the lowercase-hyphen slug, we drop any frontmatter
+ * `name` and place the file at `<slug>/SKILL.md`, synthesizing a `description`
+ * when the source lacks one.
+ */
+
+import { parseFrontmatter } from "@gajae-code/utils";
+import { YAML } from "bun";
+
+export interface NormalizeSkillInput {
+	/** Raw name from the source (filename stem, frontmatter name, etc.). */
+	rawName: string;
+	/** Full source markdown (may or may not have frontmatter). */
+	content: string;
+}
+
+export interface NormalizedSkill {
+	slug: string;
+	content: string;
+	warnings: string[];
+}
+
+/** Convert an arbitrary name into a lowercase-hyphen slug. */
+export function slugify(name: string): string {
+	const slug = name
+		.normalize("NFKD")
+		.replace(/[^\w\s-]/g, "")
+		.trim()
+		.toLowerCase()
+		.replace(/[\s_]+/g, "-")
+		.replace(/-+/g, "-")
+		.replace(/^-+|-+$/g, "");
+	return slug;
+}
+
+function firstNonEmptyLine(body: string): string | undefined {
+	for (const raw of body.split("\n")) {
+		const line = raw.replace(/^#+\s*/, "").trim();
+		if (line) return line;
+	}
+	return undefined;
+}
+
+/**
+ * Produce a `{ slug, content }` pair whose effective GJC-loaded name equals `slug`.
+ * Throws only on an unusable name (cannot produce a slug).
+ */
+export function normalizeSkill(input: NormalizeSkillInput): NormalizedSkill {
+	const warnings: string[] = [];
+	const { frontmatter, body } = parseFrontmatter(input.content, { level: "off" });
+
+	const sourceName =
+		typeof frontmatter.name === "string" && frontmatter.name.trim() ? frontmatter.name : input.rawName;
+	const slug = slugify(sourceName);
+	if (!slug) {
+		throw new Error(`cannot derive a valid slug from skill name "${input.rawName}"`);
+	}
+	if (slugify(input.rawName) !== slug && typeof frontmatter.name === "string") {
+		warnings.push(`renamed skill "${input.rawName}" to slug "${slug}"`);
+	}
+
+	// Build the destination frontmatter: drop `name` (loaded name comes from the dir),
+	// keep other fields, and ensure a non-empty description.
+	const { name: _droppedName, description: rawDescription, ...rest } = frontmatter;
+	let description = typeof rawDescription === "string" ? rawDescription.trim() : "";
+	if (!description) {
+		description = firstNonEmptyLine(body) ?? `Imported ${slug} skill.`;
+		warnings.push(`synthesized description for skill "${slug}"`);
+	}
+
+	const fm: Record<string, unknown> = { description, ...rest };
+	const yaml = YAML.stringify(fm).trimEnd();
+	const content = `---\n${yaml}\n---\n\n${body.trim()}\n`;
+
+	return { slug, content, warnings };
+}

package/src/migrate/types.ts

@@ -0,0 +1,163 @@
+/**
+ * Shared types for `gjc migrate`.
+ *
+ * Imports MCP servers and skills 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.
+ */
+import type { MCPServerConfig } from "../runtime-mcp/types";
+
+/** Supported migration sources. */
+export type MigrateSource = "claude-code" | "codex" | "opencode";
+
+export const MIGRATE_SOURCES: readonly MigrateSource[] = ["claude-code", "codex", "opencode"];
+
+/** Canonical, deterministic ordering used when expanding `--from all` / repeated `--from`. */
+export const CANONICAL_SOURCE_ORDER: readonly MigrateSource[] = MIGRATE_SOURCES;
+
+/** What kind of thing an action/coverage row is about. */
+export type MigrateItemType = "mcp" | "skill" | "source";
+
+/**
+ * Per-item outcome taxonomy.
+ *
+ * `skipped_*` outcomes are non-fatal (exit 0). Any `failed_*` outcome sets
+ * `ok=false` and a non-zero process exit code.
+ */
+export type MigrationStatus =
+	| "imported"
+	| "updated"
+	| "skipped_exists"
+	| "skipped_absent_source"
+	| "skipped_unmappable"
+	| "failed_invalid_source"
+	| "failed_invalid_destination"
+	| "failed_io";
+
+export const MIGRATION_STATUSES: readonly MigrationStatus[] = [
+	"imported",
+	"updated",
+	"skipped_exists",
+	"skipped_absent_source",
+	"skipped_unmappable",
+	"failed_invalid_source",
+	"failed_invalid_destination",
+	"failed_io",
+];
+
+/** Statuses that represent a hard failure (drive `ok=false` + non-zero exit). */
+export const FAILURE_STATUSES: ReadonlySet<MigrationStatus> = new Set<MigrationStatus>([
+	"failed_invalid_source",
+	"failed_invalid_destination",
+	"failed_io",
+]);
+
+export function isFailureStatus(status: MigrationStatus): boolean {
+	return FAILURE_STATUSES.has(status);
+}
+
+/** Operation the planner decided for an item. */
+export type MigrateOperation = "create" | "update" | "skip" | "fail";
+
+/** A raw MCP server candidate parsed from a source, before mapping/destination planning. */
+export interface McpCandidate {
+	source: MigrateSource;
+	name: string;
+	/** The raw, unmapped server entry from the source config (mapped by the planner). */
+	raw: unknown;
+}
+
+/** A raw skill candidate parsed from a source, before normalization/destination planning. */
+export interface SkillCandidate {
+	source: MigrateSource;
+	/** Slug used as the destination directory and effective loaded name. */
+	slug: string;
+	/** Full SKILL.md content (frontmatter already normalized so loaded name == slug). */
+	content: string;
+	warnings: 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
+ * are reported once instead of per item.
+ */
+export interface SourceDiagnostic {
+	source: MigrateSource;
+	type: Exclude<MigrateItemType, "source"> | "source";
+	status: Extract<MigrationStatus, "skipped_absent_source" | "failed_invalid_source" | "failed_io">;
+	message: string;
+}
+
+/** Normalized candidates + diagnostics returned by an adapter. */
+export interface AdapterResult {
+	mcpCandidates: McpCandidate[];
+	skillCandidates: SkillCandidate[];
+	diagnostics: SourceDiagnostic[];
+}
+
+/** A single planned action consumed identically by dry-run and live execution. */
+export interface MigrateAction {
+	source: MigrateSource;
+	type: MigrateItemType;
+	name?: string;
+	/** For skills: the effective GJC-loaded name (== slug). */
+	effectiveName?: string;
+	/** Absolute destination path (mcp.json for MCP, <skillsDir>/<slug>/SKILL.md for skills). */
+	destination?: string;
+	operation: MigrateOperation;
+	status: MigrationStatus;
+	reason?: string;
+	warnings?: string[];
+	/** Resolved payload the executor needs; never serialized to the report. */
+	mcp?: { config: MCPServerConfig; force: boolean };
+	skill?: { content: string };
+}
+
+export interface MigrateWarning {
+	source: MigrateSource;
+	type: string;
+	name?: string;
+	message: string;
+}
+
+export type StatusCounts = Record<MigrationStatus, number>;
+
+export interface MigrateDestinations {
+	mcpConfigPath: string;
+	skillsDir: string;
+}
+
+/** The full machine-readable report emitted with `--json`. */
+export interface MigrateReport {
+	ok: boolean;
+	dryRun: boolean;
+	project: boolean;
+	force: boolean;
+	sources: MigrateSource[];
+	destinations: MigrateDestinations;
+	summary: {
+		total: StatusCounts;
+		byType: { mcp: StatusCounts; skill: StatusCounts; source: StatusCounts };
+		bySource: Record<MigrateSource, StatusCounts>;
+	};
+	actions: Array<{
+		source: MigrateSource;
+		type: MigrateItemType;
+		name?: string;
+		effectiveName?: string;
+		destination?: string;
+		operation: MigrateOperation;
+		status: MigrationStatus;
+		reason?: string;
+		warnings?: string[];
+	}>;
+	warnings: MigrateWarning[];
+}
+
+/** Create a zeroed status-count record. */
+export function emptyStatusCounts(): StatusCounts {
+	const counts = {} as StatusCounts;
+	for (const status of MIGRATION_STATUSES) counts[status] = 0;
+	return counts;
+}

package/src/modes/acp/acp-event-mapper.ts

@@ -244,6 +244,7 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 		case "retry_fallback_succeeded":
 		case "ttsr_triggered":
 		case "irc_message":
+		case "subagent_steer_message":
 		case "notice":
 		case "thinking_level_changed":
 		case "goal_updated":

package/src/modes/bridge/bridge-mode.ts

@@ -1,5 +1,5 @@
-import * as path from "node:path";
 import type { ExtensionUIContext } from "../../extensibility/extensions";
+import { workflowGatePath } from "../../gjc-runtime/session-layout";
 import type { AgentSession } from "../../session/agent-session";
 import type { ClientBridgePermissionOutcome } from "../../session/client-bridge";
 import type { RpcCommand, RpcResponse, RpcWorkflowGateResponse } from "../rpc/rpc-types";
@@ -611,7 +611,7 @@ export async function runBridgeMode(
 		});
 	};
 	const gateStore = new FileGateStore(
-		path.join(session.sessionManager.getCwd(), ".gjc", "state", "workflow-gates", `${session.sessionId}.json`),
+		workflowGatePath(session.sessionManager.getCwd(), session.sessionId, session.sessionId),
 	);
 	const unattendedControlPlane = new UnattendedSessionControlPlane({
 		runId: session.sessionId,

package/src/modes/components/custom-editor.ts

@@ -1,6 +1,6 @@
 import { Editor, type KeyId, matchesKey, parseKittySequence } from "@gajae-code/tui";
 import { BracketedPasteHandler } from "@gajae-code/tui/bracketed-paste";
-import type { AppKeybinding } from "../../config/keybindings";
+import { type AppKeybinding, KEYBINDINGS } from "../../config/keybindings";
 
 type ConfigurableEditorAction = Extract<
 	AppKeybinding,
@@ -23,25 +23,35 @@ type ConfigurableEditorAction = Extract<
 	| "app.clipboard.copyPrompt"
 >;
 
-const DEFAULT_ACTION_KEYS: Record<ConfigurableEditorAction, KeyId[]> = {
-	"app.interrupt": ["escape"],
-	"app.clear": ["ctrl+c"],
-	"app.exit": ["ctrl+d"],
-	"app.suspend": ["ctrl+z"],
-	"app.thinking.cycle": ["shift+tab"],
-	"app.model.cycleForward": ["ctrl+p"],
-	"app.model.cycleBackward": ["shift+ctrl+p"],
-	"app.model.select": ["ctrl+l"],
-	"app.model.selectTemporary": ["alt+p"],
-	"app.tools.expand": ["ctrl+o"],
-	"app.thinking.toggle": ["ctrl+t"],
-	"app.editor.external": ["ctrl+g"],
-	"app.history.search": ["ctrl+r"],
-	"app.message.queue": ["alt+enter"],
-	"app.message.dequeue": ["alt+up"],
-	"app.clipboard.pasteImage": ["ctrl+v"],
-	"app.clipboard.copyPrompt": ["alt+shift+c"],
-};
+// Editor-configurable app actions. Defaults are derived from the central
+// KEYBINDINGS registry so there is a single source of truth (e.g. the
+// platform-aware app.clipboard.pasteImage default is not duplicated here).
+const CONFIGURABLE_EDITOR_ACTIONS = [
+	"app.interrupt",
+	"app.clear",
+	"app.exit",
+	"app.suspend",
+	"app.thinking.cycle",
+	"app.model.cycleForward",
+	"app.model.cycleBackward",
+	"app.model.select",
+	"app.model.selectTemporary",
+	"app.tools.expand",
+	"app.thinking.toggle",
+	"app.editor.external",
+	"app.history.search",
+	"app.message.queue",
+	"app.message.dequeue",
+	"app.clipboard.pasteImage",
+	"app.clipboard.copyPrompt",
+] as const satisfies readonly ConfigurableEditorAction[];
+
+const DEFAULT_ACTION_KEYS = Object.fromEntries(
+	CONFIGURABLE_EDITOR_ACTIONS.map(action => {
+		const defaultKeys = KEYBINDINGS[action].defaultKeys;
+		return [action, Array.isArray(defaultKeys) ? [...defaultKeys] : [defaultKeys]];
+	}),
+) as Record<ConfigurableEditorAction, KeyId[]>;
 
 const PASTE_DECISION_TIMEOUT_MS = 5_000;
 const PENDING_PASTE_INPUT_MAX = 64;

package/src/modes/components/hook-editor.ts

@@ -17,6 +17,10 @@ export interface HookEditorOptions {
 	promptStyle?: boolean;
 }
 
+function isWindowsRawLfNewlineInput(keyData: string): boolean {
+	return process.platform === "win32" && keyData === "\n";
+}
+
 export class HookEditorComponent extends Container {
 	#editor: Editor;
 	#onSubmitCallback: (value: string) => void;
@@ -92,8 +96,9 @@ export class HookEditorComponent extends Container {
 			return;
 		}
 
-		// Submit on any plain Enter encoding, including terminals that report unmodified Enter as LF.
-		if (matchesKey(keyData, "enter") || matchesKey(keyData, "return")) {
+		// Submit on plain Enter encodings. On Windows, raw LF is reserved for terminal
+		// newline mappings (Shift+Enter/Ctrl+J/Ctrl+Enter); plain Enter reports CR.
+		if (!isWindowsRawLfNewlineInput(keyData) && (matchesKey(keyData, "enter") || matchesKey(keyData, "return"))) {
 			this.#onSubmitCallback(this.#editor.getText());
 			return;
 		}

package/src/modes/components/oauth-selector.ts

@@ -4,6 +4,7 @@ import { Container, matchesKey, Spacer, TruncatedText } from "@gajae-code/tui";
 import { theme } from "../../modes/theme/theme";
 import { matchesSelectCancel } from "../../modes/utils/keybinding-matchers";
 import type { AuthStorage } from "../../session/auth-storage";
+import type { ImportableCredential } from "../../setup/credential-import";
 import { DynamicBorder } from "./dynamic-border";
 
 const OAUTH_SELECTOR_MAX_VISIBLE = 10;
@@ -22,6 +23,7 @@ export class OAuthSelectorComponent extends Container {
 	#validateAuthCallback?: (providerId: string) => Promise<boolean>;
 	#requestRenderCallback?: () => void;
 	#authState: Map<string, "checking" | "valid" | "invalid"> = new Map();
+	#externalCredentialCandidates: ImportableCredential[] = [];
 	#spinnerFrame: number = 0;
 	#spinnerInterval?: NodeJS.Timeout;
 	#validationGeneration: number = 0;
@@ -33,6 +35,7 @@ export class OAuthSelectorComponent extends Container {
 		options?: {
 			validateAuth?: (providerId: string) => Promise<boolean>;
 			requestRender?: () => void;
+			externalCredentialCandidates?: ImportableCredential[];
 		},
 	) {
 		super();
@@ -42,6 +45,7 @@ export class OAuthSelectorComponent extends Container {
 		this.#onCancelCallback = onCancel;
 		this.#validateAuthCallback = options?.validateAuth;
 		this.#requestRenderCallback = options?.requestRender;
+		this.#externalCredentialCandidates = options?.externalCredentialCandidates ?? [];
 		// Load all OAuth providers
 		this.#loadProviders();
 		this.addChild(new DynamicBorder());
@@ -195,6 +199,21 @@ export class OAuthSelectorComponent extends Container {
 			this.#listContainer.addChild(new Spacer(1));
 			this.#listContainer.addChild(new TruncatedText(theme.fg("warning", `  ${this.#statusMessage}`), 0, 0));
 		}
+		if (this.#mode === "login" && this.#externalCredentialCandidates.length > 0) {
+			this.#listContainer.addChild(new Spacer(1));
+			for (const credential of this.#externalCredentialCandidates) {
+				this.#listContainer.addChild(
+					new TruncatedText(
+						theme.fg(
+							"success",
+							`  ${theme.status.success} Imported ${credential.provider} from ${credential.source}`,
+						),
+						0,
+						0,
+					),
+				);
+			}
+		}
 	}
 	handleInput(keyData: string): void {
 		// Up arrow

package/src/modes/controllers/event-controller.ts

@@ -83,6 +83,7 @@ export class EventController {
 			todo_reminder: e => this.#handleTodoReminder(e),
 			todo_auto_clear: e => this.#handleTodoAutoClear(e),
 			irc_message: e => this.#handleIrcMessage(e),
+			subagent_steer_message: e => this.#handleSubagentSteerMessage(e),
 			notice: e => this.#handleNotice(e),
 			thinking_level_changed: async () => {},
 			goal_updated: async () => {},
@@ -284,6 +285,25 @@ export class EventController {
 		this.ctx.ui.requestRender();
 	}
 
+	async #handleSubagentSteerMessage(
+		event: Extract<AgentSessionEvent, { type: "subagent_steer_message" }>,
+	): Promise<void> {
+		const details = event.message.details as
+			| { observationId?: string; from?: string; to?: string; body?: string; state?: string }
+			| undefined;
+		const obsId = details?.observationId;
+		const signature = obsId
+			? `steer:${obsId}`
+			: `${event.message.role}:${event.message.customType}:${event.message.timestamp}:${details?.from}:${details?.to}:${details?.state}:${details?.body}`;
+		if (this.#renderedCustomMessages.has(signature)) {
+			return;
+		}
+		this.#renderedCustomMessages.add(signature);
+		this.#resetReadGroup();
+		this.ctx.addMessageToChat(event.message);
+		this.ctx.ui.requestRender();
+	}
+
 	#scheduleIrcExpiry(signature: string, components: Component[]): void {
 		if (components.length === 0 || this.#ircExpiryTimers.has(signature)) return;
 		const timer = setTimeout(() => {

package/src/modes/controllers/selector-controller.ts

@@ -29,10 +29,14 @@ import {
 	setTheme,
 	theme,
 } from "../../modes/theme/theme";
-import type { InteractiveModeContext } from "../../modes/types";
+import type { InteractiveModeContext, OAuthSelectorOptions } from "../../modes/types";
 import { type SessionInfo, SessionManager } from "../../session/session-manager";
 import { FileSessionStorage } from "../../session/session-storage";
-import { discoverExternalCredentials, formatDiscoverySummary, importCredentials } from "../../setup/credential-import";
+import {
+	CREDENTIAL_AUTO_IMPORT_ROTATION_WARNING,
+	runExternalCredentialAutoImport,
+} from "../../setup/credential-auto-import";
+import { filterAutoImportOAuthCredentials, formatDiscoverySummary } from "../../setup/credential-import";
 import {
 	MODEL_ONBOARDING_API_PROVIDER_COMMAND,
 	MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND,
@@ -156,10 +160,22 @@ export class SelectorController {
 
 	async #handleCredentialImport(): Promise<void> {
 		this.ctx.showStatus("Scanning for existing Claude Code / Codex CLI credentials…");
-		const result = await discoverExternalCredentials();
-		const summaryLines = formatDiscoverySummary(result);
+		const preview = await runExternalCredentialAutoImport({
+			authStorage: {
+				importCredentialIfAbsent: async () => ({
+					inserted: false,
+					reason: "skipped-existing",
+					provider: "",
+					entries: [],
+				}),
+			},
+			trigger: "bare-login",
+		});
+		const result = preview.discovery ?? { importable: [], skipped: [], environment: [] };
+		const candidates = filterAutoImportOAuthCredentials(result.importable);
+		const summaryLines = formatDiscoverySummary({ ...result, importable: candidates });
 
-		if (result.importable.length === 0) {
+		if (candidates.length === 0) {
 			this.ctx.chatContainer.addChild(new Spacer(1));
 			for (const line of summaryLines) {
 				this.ctx.chatContainer.addChild(new Text(theme.fg("dim", line), 1, 0));
@@ -168,7 +184,7 @@ export class SelectorController {
 				new Text(
 					theme.fg(
 						"warning",
-						"No importable Claude/Codex credentials found. Use /login or add a custom provider.",
+						"No importable Claude/Codex OAuth credentials found. Use /login or add a custom provider.",
 					),
 					1,
 					0,
@@ -179,7 +195,7 @@ export class SelectorController {
 		}
 
 		const confirmed = await this.ctx.showHookConfirm(
-			`Import ${result.importable.length} credential(s)?`,
+			`Import ${candidates.length} credential(s)?`,
 			summaryLines.join("\n"),
 		);
 		if (!confirmed) {
@@ -187,9 +203,10 @@ export class SelectorController {
 			return;
 		}
 
-		const summary = await importCredentials(result.importable, (provider, credential) =>
-			this.ctx.session.modelRegistry.authStorage.upsertCredential(provider, credential),
-		);
+		const summary = await runExternalCredentialAutoImport({
+			authStorage: this.ctx.session.modelRegistry.authStorage,
+			trigger: "bare-login",
+		});
 		await this.ctx.session.modelRegistry.refresh();
 
 		this.ctx.chatContainer.addChild(new Spacer(1));
@@ -202,13 +219,15 @@ export class SelectorController {
 				),
 			);
 		}
-		for (const failure of summary.failed) {
+		for (const skip of summary.skipped) {
 			this.ctx.chatContainer.addChild(
-				new Text(
-					theme.fg("error", `${theme.status.error} Failed ${failure.credential.provider}: ${failure.error}`),
-					1,
-					0,
-				),
+				new Text(theme.fg("dim", `${theme.status.info} Skipped ${skip.credential.provider}: ${skip.reason}`), 1, 0),
+			);
+		}
+		for (const failure of summary.failures) {
+			const provider = failure.credential?.provider ?? failure.origin ?? "credential discovery";
+			this.ctx.chatContainer.addChild(
+				new Text(theme.fg("error", `${theme.status.error} Failed ${provider}: ${failure.failureClass}`), 1, 0),
 			);
 		}
 		if (summary.imported.length > 0) {
@@ -1232,7 +1251,11 @@ export class SelectorController {
 		}
 	}
 
-	async showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void> {
+	async showOAuthSelector(
+		mode: "login" | "logout",
+		providerId?: string,
+		options?: OAuthSelectorOptions,
+	): Promise<void> {
 		if (providerId) {
 			const oauthProvider = getOAuthProviders().find(provider => provider.id === providerId);
 			if (!oauthProvider && !this.ctx.session.modelRegistry.getModelProfiles().has(providerId)) {
@@ -1259,6 +1282,45 @@ export class SelectorController {
 			}
 		}
 
+		let externalCredentialCandidates: ReturnType<typeof filterAutoImportOAuthCredentials> = [];
+		if (
+			mode === "login" &&
+			providerId === undefined &&
+			options?.allowExternalCredentialDiscovery === true &&
+			options.trigger === "bare-login"
+		) {
+			const preview = await runExternalCredentialAutoImport({
+				authStorage: {
+					importCredentialIfAbsent: async () => ({
+						inserted: false,
+						reason: "skipped-existing",
+						provider: "",
+						entries: [],
+					}),
+				},
+				trigger: "bare-login",
+				discover: options.externalCredentialDiscover,
+			});
+			const result = preview.discovery ?? { importable: [], skipped: [], environment: [] };
+			const candidates = filterAutoImportOAuthCredentials(result.importable);
+			if (candidates.length > 0) {
+				const confirmed = await this.ctx.showHookConfirm(
+					`Import ${candidates.length} external credential(s)?`,
+					`${formatDiscoverySummary({ ...result, importable: candidates }).join("\n")}\n\n${CREDENTIAL_AUTO_IMPORT_ROTATION_WARNING}`,
+				);
+				if (confirmed) {
+					const summary = await runExternalCredentialAutoImport({
+						authStorage: this.ctx.session.modelRegistry.authStorage,
+						trigger: "bare-login",
+						discover: options.externalCredentialDiscover,
+					});
+					externalCredentialCandidates = summary.imported;
+					if (externalCredentialCandidates.length > 0) {
+						await this.ctx.session.modelRegistry.refresh("offline");
+					}
+				}
+			}
+		}
 		this.showSelector(done => {
 			let selector: OAuthSelectorComponent;
 			selector = new OAuthSelectorComponent(
@@ -1289,6 +1351,7 @@ export class SelectorController {
 					requestRender: () => {
 						this.ctx.ui.requestRender();
 					},
+					externalCredentialCandidates,
 				},
 			);
 			return { component: selector, focus: selector };

package/src/modes/interactive-mode.ts

@@ -2502,8 +2502,12 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#selectorController.handleSessionDeleteCommand();
 	}
 
-	showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void> {
-		return this.#selectorController.showOAuthSelector(mode, providerId);
+	showOAuthSelector(
+		mode: "login" | "logout",
+		providerId?: string,
+		options?: import("./types").OAuthSelectorOptions,
+	): Promise<void> {
+		return this.#selectorController.showOAuthSelector(mode, providerId, options);
 	}
 
 	showHookConfirm(title: string, message: string): Promise<boolean> {

package/src/modes/rpc/rpc-mode.ts

@@ -11,13 +11,13 @@
  * - Extension UI: Extension UI requests are emitted, client responds with extension_ui_response
  */
 
-import * as path from "node:path";
 import { $pickenv, logger, readLines, Snowflake } from "@gajae-code/utils";
 import type {
 	ExtensionUIContext,
 	ExtensionUIDialogOptions,
 	ExtensionWidgetOptions,
 } from "../../extensibility/extensions";
+import { workflowGatePath } from "../../gjc-runtime/session-layout";
 import { type Theme, theme } from "../../modes/theme/theme";
 import type { AgentSession } from "../../session/agent-session";
 import { initializeExtensions } from "../runtime-init";
@@ -336,7 +336,7 @@ export async function runRpcMode(
 	// Unattended control plane (#318/#319/#323/G011): routes negotiate_unattended +
 	// workflow_gate_response and lets skill runtimes emit gates over RPC.
 	const gateStore = new FileGateStore(
-		path.join(session.sessionManager.getCwd(), ".gjc", "state", "workflow-gates", `${session.sessionId}.json`),
+		workflowGatePath(session.sessionManager.getCwd(), session.sessionId, session.sessionId),
 	);
 	const unattendedControlPlane = new UnattendedSessionControlPlane({
 		runId: session.sessionId,

package/src/modes/runtime-init.ts

@@ -78,6 +78,7 @@ export async function initializeExtensions(session: AgentSession, options: Initi
 			shutdown,
 			getContextUsage: () => session.getContextUsage(),
 			getSystemPrompt: () => session.systemPrompt,
+			getWorkflowGate: () => session.getWorkflowGateEmitter(),
 			compact: instructionsOrOptions => runExtensionCompact(session, instructionsOrOptions),
 		},
 		// ExtensionCommandContextActions — commands invokable via prompt("/command")

package/src/modes/shared/agent-wire/event-contract.ts

@@ -49,6 +49,7 @@ const AGENT_SESSION_EVENT_TYPE_REGISTRY: Record<AgentWireEventType, true> = {
 	todo_reminder: true,
 	todo_auto_clear: true,
 	irc_message: true,
+	subagent_steer_message: true,
 	notice: true,
 	thinking_level_changed: true,
 	goal_updated: true,

package/src/modes/shared/agent-wire/event-envelope.ts

@@ -50,6 +50,7 @@ export function agentSessionEventType(event: AgentSessionEvent): AgentWireEventT
 		case "todo_reminder":
 		case "todo_auto_clear":
 		case "irc_message":
+		case "subagent_steer_message":
 		case "notice":
 		case "thinking_level_changed":
 		case "goal_updated":