@gajae-code/coding-agent 0.13.3 → 0.14.0

package/src/cli/skills-cli.ts

@@ -1,19 +1,23 @@
 /**
- * Handles `gjc skills` for inspecting bundled workflow skill definitions.
+ * Handles `gjc skills` for inspecting bundled workflow skills and
+ * filesystem-discovered custom skills.
  */
+import { Settings } from "../config/settings";
 import {
 	DEFAULT_GJC_DEFINITION_NAMES,
 	type EmbeddedDefaultGjcSkill,
 	getEmbeddedDefaultGjcSkills,
 } from "../defaults/gjc-defaults";
+import { discoverRuntimeSkills, type RuntimeSkillDiscoveryCandidate } from "../extensibility/runtime-skill-discovery";
 
-export type SkillsAction = "list" | "read";
+export type SkillsAction = "list" | "read" | "discover";
 
 export interface SkillsCommandArgs {
 	action: SkillsAction;
 	name?: string;
 	flags?: {
 		json?: boolean;
+		source?: "all" | "project" | "user";
 	};
 }
 
@@ -45,6 +49,11 @@ function writeJson(value: unknown): void {
 	process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
 
+function formatCandidate(candidate: RuntimeSkillDiscoveryCandidate): string {
+	const useWhen = candidate.useWhen && candidate.useWhen.length > 0 ? ` [when: ${candidate.useWhen.join(", ")}]` : "";
+	return `${candidate.name}\t${candidate.source}\t${candidate.description}\t${candidate.path}${useWhen}`;
+}
+
 export async function runSkillsCommand(cmd: SkillsCommandArgs): Promise<void> {
 	if (cmd.action === "list") {
 		const skills = listEmbeddedSkills();
@@ -58,6 +67,33 @@ export async function runSkillsCommand(cmd: SkillsCommandArgs): Promise<void> {
 		return;
 	}
 
+	if (cmd.action === "discover") {
+		const source = cmd.flags?.source ?? "all";
+		const settings = await Settings.loadForScope({ cwd: process.cwd() });
+		const result = await discoverRuntimeSkills({
+			cwd: process.cwd(),
+			source,
+			policy: {
+				...settings.getGroup("skills"),
+				disabledExtensions: settings.get("disabledExtensions"),
+			},
+		});
+		if (cmd.flags?.json) {
+			writeJson({ candidates: result.candidates, diagnostics: result.diagnostics.messages });
+			return;
+		}
+		for (const candidate of result.candidates) {
+			process.stdout.write(`${formatCandidate(candidate)}\n`);
+		}
+		if (result.diagnostics.messages.length > 0) {
+			process.stdout.write("\nDiagnostics:\n");
+			for (const message of result.diagnostics.messages) {
+				process.stdout.write(`- ${message}\n`);
+			}
+		}
+		return;
+	}
+
 	const name = cmd.name?.trim();
 	if (!name) {
 		process.stderr.write(`error: skill name is required for read (${DEFAULT_GJC_DEFINITION_NAMES.join(", ")})\n`);

package/src/cli/update-cli.ts

@@ -10,15 +10,19 @@ import { pipeline } from "node:stream/promises";
 import { $which, APP_NAME, isEnoent, VERSION } from "@gajae-code/utils";
 import { $ } from "bun";
 import chalk from "chalk";
+import { Settings } from "../config/settings";
 import { distTagForChannel, isUpdateChannel, UPDATE_CHANNELS, type UpdateChannel } from "../config/update-channel";
 import { installDefaultGjcDefinitions } from "../defaults/gjc-defaults";
 import { theme } from "../modes/theme/theme";
+import { getNotificationConfig, type NotificationProvider, resolveNotificationProvider } from "../sdk/bus/config";
 import {
 	DEFAULT_NPM_REGISTRY,
 	fetchLatestPackageVersion,
 	type Installer,
 	type NpmRegistryLookupOptions,
 } from "../utils/npm-registry";
+import { runDaemonCommand } from "./daemon-cli";
+import { runNotifyCommand } from "./notify-cli";
 
 const RELEASE_REPO = "Yeachan-Heo/gajae-code";
 const PACKAGE = "@gajae-code/coding-agent";
@@ -602,9 +606,9 @@ async function updateViaPackageManager(options: PackageManagerUpdateOptions): Pr
 /**
  * Update via bun package manager.
  */
-async function updateViaBun(expectedVersion: string): Promise<void> {
+async function updateViaBun(expectedVersion: string): Promise<InstalledVersionVerification> {
 	console.log(chalk.dim("Updating via bun..."));
-	await updateViaPackageManager({
+	return await updateViaPackageManager({
 		managerName: "bun",
 		expectedVersion,
 		runInstall: async version => await $`bun install -g ${PACKAGE}@${version}`.nothrow(),
@@ -612,9 +616,9 @@ async function updateViaBun(expectedVersion: string): Promise<void> {
 	});
 }
 
-async function updateViaNpm(packageName: string, expectedVersion: string): Promise<void> {
+async function updateViaNpm(packageName: string, expectedVersion: string): Promise<InstalledVersionVerification> {
 	console.log(chalk.dim(`Updating npm-managed install via npm (${packageName})...`));
-	await updateViaPackageManager({
+	return await updateViaPackageManager({
 		managerName: "npm",
 		expectedVersion,
 		runInstall: async version => await $`npm install -g ${packageName}@${version}`.nothrow(),
@@ -735,7 +739,11 @@ function formatRegistryProvenance(version: string, registry: string | undefined)
 /**
  * Download a release binary to a target path, replacing an existing file.
  */
-async function updateViaBinaryAt(targetPath: string, expectedVersion: string, registry?: string): Promise<void> {
+async function updateViaBinaryAt(
+	targetPath: string,
+	expectedVersion: string,
+	registry?: string,
+): Promise<InstalledVersionVerification> {
 	const binaryName = getBinaryName();
 	const url = buildReleaseBinaryUrl(expectedVersion);
 	const registryNote = formatRegistryProvenance(expectedVersion, registry);
@@ -753,6 +761,7 @@ async function updateViaBinaryAt(targetPath: string, expectedVersion: string, re
 	printVerifiedVersion(expectedVersion);
 	if (verification.cleanupWarning) console.warn(chalk.yellow(verification.cleanupWarning));
 	printRestartGuidance();
+	return verification;
 }
 
 /**
@@ -761,18 +770,151 @@ async function updateViaBinaryAt(targetPath: string, expectedVersion: string, re
 export interface UpdateCommandDependencies {
 	getLatestRelease?: (options?: LatestReleaseLookupOptions) => Promise<ReleaseInfo>;
 	resolveUpdateTarget?: () => Promise<UpdateTarget>;
-	performUpdate?: (target: UpdateTarget, expectedVersion: string, registry?: string) => Promise<void>;
+	performUpdate?: (
+		target: UpdateTarget,
+		expectedVersion: string,
+		registry?: string,
+	) => Promise<InstalledVersionVerification | undefined>;
 	refreshInstalledDefaultSkills?: () => Promise<void>;
+	settings?: () => Promise<Settings>;
+	stopDaemon?: (settings: Settings) => Promise<void>;
+	restartDaemon?: (settings: Settings) => Promise<void>;
+	recoverNotifications?: (settings: Settings) => Promise<void>;
+	runPostUpdateRecovery?: (runtimePath: string) => Promise<void>;
 	exit?: (code: number) => never;
 }
 
-async function performUpdate(target: UpdateTarget, expectedVersion: string, registry?: string): Promise<void> {
+export type PostUpdateRecoverySpawn = (argv: string[]) => Promise<number>;
+export type PostUpdateRecoverySupportCheck = (runtimePath: string) => Promise<boolean>;
+export type LegacyRecoveryDaemonKinds = () => Promise<NotificationProvider[]>;
+
+/**
+ * A complete, non-quarantined provider with provider-level desired intent is a
+ * durable managed-notify setup. The global switch is deliberately excluded:
+ * disabling delivery must not leave credential-backed daemon locks unrecovered.
+ */
+export function hasManagedNotifySetup(settings: Settings): boolean {
+	return managedNotifyDaemonKinds(settings).length > 0;
+}
+
+function managedNotifyDaemonKinds(settings: Settings): NotificationProvider[] {
+	const config = getNotificationConfig(settings);
+	return (["telegram", "discord", "slack"] as const).filter(provider => {
+		const resolution = resolveNotificationProvider(config, provider);
+		return resolution.configured && !resolution.quarantined && resolution.desiredEnabled;
+	});
+}
+
+async function stopManagedDaemon(settings: Settings): Promise<void> {
+	const kinds = managedNotifyDaemonKinds(settings);
+	let failed = false;
+	await runDaemonCommand(
+		{ action: "stop", kinds, all: false, json: false, force: true },
+		{
+			settings,
+			setExitCode: code => {
+				if (code !== 0) failed = true;
+			},
+		},
+	);
+	if (failed) throw new Error("daemon stop reported failure");
+}
+
+async function restartManagedDaemon(settings: Settings): Promise<void> {
+	const kinds = managedNotifyDaemonKinds(settings);
+	let failed = false;
+	await runDaemonCommand(
+		{ action: "restart", kinds, all: false, json: false, force: false, allowDisabledNoop: true },
+		{
+			settings,
+			setExitCode: code => {
+				if (code !== 0) failed = true;
+			},
+		},
+	);
+	if (failed) throw new Error("daemon restart reported failure");
+}
+
+async function recoverManagedNotifications(settings: Settings): Promise<void> {
+	await runNotifyCommand({ action: "recovery", rawArgs: [], forceDaemonLock: false }, { settings });
+}
+
+async function spawnPostUpdateRecovery(argv: string[]): Promise<number> {
+	const child = Bun.spawn(argv, { stdin: "inherit", stdout: "inherit", stderr: "inherit" });
+	return await child.exited;
+}
+
+async function supportsUpdateRecovery(runtimePath: string): Promise<boolean> {
+	const child = Bun.spawn([runtimePath, "update", "--help"], { stdout: "pipe", stderr: "pipe" });
+	const [exitCode, stdout] = await Promise.all([child.exited, new Response(child.stdout).text()]);
+	return exitCode === 0 && stdout.includes("update-recovery");
+}
+
+async function runLegacyPostUpdateRecovery(
+	runtimePath: string,
+	spawn: PostUpdateRecoverySpawn,
+	managedKinds: LegacyRecoveryDaemonKinds,
+): Promise<void> {
+	const kinds = await managedKinds();
+	if (kinds.length === 0) return;
+	for (const [name, argv] of [
+		["daemon stop --force", [runtimePath, "daemon", "stop", ...kinds, "--force"]],
+		["daemon reload", [runtimePath, "daemon", "reload", ...kinds]],
+		["notify recovery", [runtimePath, "notify", "recovery"]],
+	] as const) {
+		const exitCode = await spawn([...argv]);
+		if (exitCode !== 0) throw new Error(`legacy post-update ${name} exited ${exitCode}`);
+	}
+}
+
+export async function runPostUpdateRecoveryForTest(
+	runtimePath: string,
+	spawn: PostUpdateRecoverySpawn = spawnPostUpdateRecovery,
+	supportsRecovery: PostUpdateRecoverySupportCheck = supportsUpdateRecovery,
+	managedKinds: LegacyRecoveryDaemonKinds = async () => managedNotifyDaemonKinds(await Settings.init()),
+): Promise<void> {
+	if (!(await supportsRecovery(runtimePath))) {
+		await runLegacyPostUpdateRecovery(runtimePath, spawn, managedKinds);
+		return;
+	}
+	const exitCode = await spawn([runtimePath, "update", "update-recovery"]);
+	if (exitCode !== 0) throw new Error(`the verified installed runtime exited ${exitCode}`);
+}
+
+async function runPostUpdateRecovery(runtimePath: string): Promise<void> {
+	await runPostUpdateRecoveryForTest(runtimePath);
+}
+
+export async function runManagedNotifyRecovery(
+	deps: Pick<UpdateCommandDependencies, "settings" | "stopDaemon" | "restartDaemon" | "recoverNotifications">,
+): Promise<void> {
+	const settings = await (deps.settings ?? (() => Settings.init()))();
+	if (!hasManagedNotifySetup(settings)) return;
+	const stages: readonly [string, (settings: Settings) => Promise<void>][] = [
+		["daemon stop --force", deps.stopDaemon ?? stopManagedDaemon],
+		["daemon restart", deps.restartDaemon ?? restartManagedDaemon],
+		["notify recovery", deps.recoverNotifications ?? recoverManagedNotifications],
+	];
+	for (const [name, run] of stages) {
+		try {
+			await run(settings);
+		} catch (error) {
+			throw new Error(`Post-update ${name} failed: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+}
+
+async function performUpdate(
+	target: UpdateTarget,
+	expectedVersion: string,
+	registry?: string,
+): Promise<InstalledVersionVerification> {
 	if (target.method === "bun") {
-		await updateViaBun(expectedVersion);
+		return await updateViaBun(expectedVersion);
 	} else if (target.method === "npm") {
-		await updateViaNpm(target.packageName, expectedVersion);
+		return await updateViaNpm(target.packageName, expectedVersion);
 	} else {
-		await updateViaBinaryAt(target.path, expectedVersion, registry);
+		return await updateViaBinaryAt(target.path, expectedVersion, registry);
 	}
 }
 
@@ -881,14 +1023,24 @@ export async function runUpdateCommand(
 
 	if (opts.check) return;
 
+	let installedVersion: string | undefined;
 	try {
 		const resolved = target ?? (await resolveTarget());
-		await update(resolved, release.version, release.registry);
+		const verification = await update(resolved, release.version, release.registry);
+		if (verification?.path) {
+			installedVersion = release.version;
+			await (deps.runPostUpdateRecovery ?? runPostUpdateRecovery)(verification.path);
+		} else if (!deps.performUpdate) throw new Error("verified installed runtime path is unavailable");
 	} catch (err) {
-		console.error(chalk.red(`Update failed: ${err}`));
+		const prefix = installedVersion
+			? `Updated to ${installedVersion}, but post-update recovery failed`
+			: "Update failed";
+		console.error(chalk.red(`${prefix}: ${err}`));
 		return exit(1);
 	}
 
+	// The installed runtime completes recovery before this old updater process
+	// refreshes opt-in local definitions, avoiding stale-module daemon control.
 	await refreshDefaults();
 }
 
@@ -927,6 +1079,9 @@ ${chalk.bold("Options:")}
   -f, --force               Force reinstall even if up to date
   --channel <stable|nightly>  Release channel to update from (default: stable or startup.updateChannel setting)
 
+${chalk.bold("After a verified update:")}
+  When a complete managed notification provider is configured, GJC serially stops the daemon with --force, restarts it, then runs notify recovery. Globally disabled delivery still receives this lock recovery.
+
 ${chalk.bold("Examples:")}
   ${APP_NAME} update                    Update to latest version
   ${APP_NAME} update --check            Check if updates are available

package/src/cli.ts

@@ -39,11 +39,13 @@ export const commands: CommandEntry[] = [
 	{ name: "auth-gateway", load: () => import("./commands/auth-gateway").then(m => m.default) },
 	{ name: "skills", load: () => import("./commands/skills").then(m => m.default) },
 	{ name: "session", load: () => import("./commands/session").then(m => m.default) },
+	{ name: "accounts", load: () => import("./commands/accounts").then(m => m.default) },
 	{ name: "harness", load: () => import("./commands/harness").then(m => m.default) },
 	{ name: "coordinator", load: () => import("./commands/coordinator").then(m => m.default) },
 	{ name: "team", load: () => import("./commands/team").then(m => m.default) },
 	{ name: "ultragoal", load: () => import("./commands/ultragoal").then(m => m.default) },
 	{ name: "gc", load: () => import("./commands/gc").then(m => m.default) },
+	{ name: "crash", load: () => import("./commands/crash").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) },
@@ -64,6 +66,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: "read", load: () => import("./commands/read").then(m => m.default) },
+	{ name: "customize", load: () => import("./commands/customize").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) },
@@ -302,6 +305,7 @@ export class RootHelpCommand extends Command {
 		`# Use different model (fuzzy matching)\n  ${APP_NAME} --model opus "Help me refactor this code"`,
 		`# Limit model cycling to specific models\n  ${APP_NAME} --models claude-sonnet,claude-haiku,gpt-4o`,
 		`# Pin a stored credential for this session\n  ${APP_NAME} --credential email:me@example.com`,
+		`# Prefer a stored credential, falling back on quota limits\n  ${APP_NAME} --prefer-credential id:15`,
 		`# Activate a model profile for this session\n  ${APP_NAME} --mpreset codex-medium`,
 		`# Persist a model profile as the default\n  ${APP_NAME} --mpreset opencodego --default`,
 		`# Export a session file to HTML\n  ${APP_NAME} --export ~/.gjc/agent/sessions/--path--/session.jsonl`,

package/src/commands/accounts.ts

@@ -0,0 +1,71 @@
+/** Manage stored OAuth accounts without exposing credential payloads. */
+import { Args, Command, Flags, renderCommandHelp } from "@gajae-code/utils/cli";
+import {
+	ACCOUNTS_ACTIONS,
+	type AccountsAction,
+	type AccountsCommandArgs,
+	runAccountsCommand,
+} from "../cli/accounts-cli";
+
+export default class Accounts extends Command {
+	static description = "List, check, pin, and remove stored OAuth accounts";
+	static strict = true;
+
+	static args = {
+		action: Args.string({
+			description: "Account action",
+			required: false,
+			options: [...ACCOUNTS_ACTIONS],
+		}),
+		provider: Args.string({
+			description: "Provider id",
+			required: false,
+		}),
+		selector: Args.string({
+			description: "Account selector (bare email, id:, email:, or account:)",
+			required: false,
+		}),
+	};
+
+	static flags = {
+		json: Flags.boolean({ description: "Output safe machine-readable JSON" }),
+		persistent: Flags.boolean({ description: "Required for persistent pin changes" }),
+		clear: Flags.boolean({ description: "Clear the persistent pin" }),
+		account: Flags.string({ description: "Logout one account by row id or email" }),
+		all: Flags.boolean({ description: "Logout every OAuth account for the provider" }),
+	};
+
+	static examples = [
+		"gjc accounts list",
+		"gjc accounts list --json",
+		"gjc accounts check",
+		"gjc accounts check anthropic --json",
+		"gjc accounts pin anthropic me@example.com --persistent",
+		"gjc accounts pin anthropic id:42 --persistent",
+		"gjc accounts pin anthropic --clear --persistent",
+		"gjc accounts logout anthropic --account me@example.com",
+		"gjc accounts logout anthropic --all",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Accounts);
+		if (!args.action) {
+			renderCommandHelp("gjc", "accounts", Accounts);
+			return;
+		}
+		const action = args.action as AccountsAction;
+		const cmd: AccountsCommandArgs = {
+			action,
+			provider: args.provider,
+			selector: args.selector,
+			flags: {
+				json: flags.json,
+				persistent: flags.persistent,
+				clear: flags.clear,
+				account: flags.account,
+				all: flags.all,
+			},
+		};
+		await runAccountsCommand(cmd);
+	}
+}

package/src/commands/crash.ts

@@ -0,0 +1,35 @@
+/**
+ * `gjc crash` — inspect local crash signatures and file an assisted, fully
+ * consented bug report. Nothing leaves the machine without an explicit,
+ * digest-confirmed confirmation for that exact invocation.
+ */
+import { Args, Command, Flags } from "@gajae-code/utils/cli";
+import { runCrashListCommand, runCrashReportCommand } from "../cli/crash-cli";
+
+export default class Crash extends Command {
+	static description = "Inspect crash signatures and file an assisted bug report";
+	static args = {
+		action: Args.string({ description: "list | report", required: false }),
+	};
+	static flags = {
+		json: Flags.boolean({ char: "j", description: "Emit machine-readable JSON (list only)", default: false }),
+	};
+
+	static examples = ["gjc crash list", "gjc crash list --json", "gjc crash report"];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Crash);
+		const action = args.action ?? "list";
+		if (action === "list") {
+			await runCrashListCommand(flags.json === true);
+			return;
+		}
+		if (action !== "report") {
+			process.stderr.write(`Unknown action "${action}". Expected: list, report.\n`);
+			process.exitCode = 1;
+			return;
+		}
+		const outcome = await runCrashReportCommand();
+		if (outcome.status === "refused" || outcome.status === "unmatchable") process.exitCode = 1;
+	}
+}

package/src/commands/customize.ts

@@ -0,0 +1,84 @@
+/**
+ * `gjc customize` — customization inspection commands.
+ *
+ * Currently exposes a single subcommand: `doctor`, a read-only provenance and
+ * status report over everything GJC discovers (MCP servers, skills, hooks,
+ * tools, extensions, slash commands, plugin bundles).
+ */
+import { getProjectDir } from "@gajae-code/utils";
+import { Args, Command, Flags, renderCommandHelp } from "@gajae-code/utils/cli";
+import { runCustomizeDoctorCommand } from "../cli/customize-doctor";
+
+const ACTIONS = ["doctor"] as const;
+
+export default class Customize extends Command {
+	static description = "Inspect discovered customizations (MCP, skills, hooks, tools, extensions, commands, plugins)";
+	static delegateHelp = true;
+
+	static examples = ["gjc customize doctor", "gjc customize doctor --json"];
+
+	static args = {
+		action: Args.string({
+			description: "Customize action",
+			required: false,
+			options: ACTIONS,
+		}),
+	};
+
+	static flags = {
+		json: Flags.boolean({
+			char: "j",
+			description: "Emit machine-readable JSON with secrets redacted",
+			default: false,
+		}),
+	};
+
+	async run(): Promise<void> {
+		if (this.argv.includes("--help") || this.argv.includes("-h")) {
+			this.#printHelp();
+			return;
+		}
+
+		const { args, flags } = await this.parse(Customize);
+		const action = (args.action ?? "doctor") as (typeof ACTIONS)[number];
+		if (action !== "doctor") {
+			renderCommandHelp("gjc", "customize", Customize);
+			return;
+		}
+
+		await runCustomizeDoctorCommand({ json: flags.json, cwd: getProjectDir() });
+	}
+
+	#printHelp(): void {
+		process.stdout.write(`Inspect discovered customizations and their runtime status
+
+USAGE
+  $ gjc customize doctor [FLAGS]
+
+COMMANDS
+  doctor  Provenance and status report for MCP servers, skills, hooks, tools,
+          extensions, slash commands, and plugin bundles
+
+FLAGS
+  -j, --json  Emit machine-readable JSON with secrets redacted
+
+EXAMPLES
+  $ gjc customize doctor
+  $ gjc customize doctor --json
+
+WHAT IT REPORTS
+  For every discovered item: source convention and scope (gjc, Claude project,
+  Codex project, plugin, explicit config), effective precedence and shadowing,
+  runtime status (loaded/disabled/shadowed/rejected/quarantined/stored-only),
+  a bounded reason code, remediation commands, trust requirements, and whether
+  a new session is required for changes to take effect.
+
+SAFETY
+  This command is read-only. It never executes hooks, never connects MCP
+  servers, and never prints credentials, endpoint tokens, auth headers, env
+  values, or raw config dumps. MCP env variable names (not values) and
+  redacted endpoints may appear; everything secret-shaped is replaced with
+  <redacted>.
+`);
+	}
+}

package/src/commands/daemon.ts

@@ -1,5 +1,5 @@
 /**
- * Manage GJC background daemons (status/list/stop/reload).
+ * Manage GJC background daemons (status/list/stop/restart).
  */
 import { Args, CliParseError, Command, Flags } from "@gajae-code/utils/cli";
 import {
@@ -54,7 +54,7 @@ export default class Daemon extends Command {
 		force: Flags.boolean({ description: "Allow hard-kill escalation when graceful stop times out" }),
 		"graceful-timeout-ms": Flags.string({ description: "Cooperative stop timeout before escalation" }),
 		"kill-timeout-ms": Flags.string({ description: "Wait for old pid death after SIGKILL" }),
-		"spawn-if-stopped": Flags.boolean({ description: "On reload, spawn even when no daemon is running" }),
+		"spawn-if-stopped": Flags.boolean({ description: "On restart, spawn even when no daemon is running" }),
 		smoke: Flags.boolean({ description: "Internal: run worker smoke without configuration or network" }),
 		"owner-id": Flags.string({ description: "Internal: daemon owner id" }),
 		"agent-dir": Flags.string({ description: "Internal: daemon state directory" }),

package/src/commands/deep-interview.ts

@@ -1,4 +1,5 @@
 import { Command, Flags } from "@gajae-code/utils/cli";
+import { ensureWorkflowSettingsMigrated } from "../config/settings";
 import { runNativeDeepInterviewCommand } from "../gjc-runtime/deep-interview-runtime";
 
 export default class DeepInterview extends Command {
@@ -57,6 +58,7 @@ session_id, or GJC_SESSION_ID.`;
 	];
 
 	async run(): Promise<void> {
+		await ensureWorkflowSettingsMigrated(process.cwd());
 		const result = await runNativeDeepInterviewCommand(this.argv, process.cwd());
 		if (result.stdout) process.stdout.write(result.stdout);
 		if (result.stderr) process.stderr.write(result.stderr);

package/src/commands/launch.ts

@@ -82,6 +82,7 @@ export default class Index extends Command {
 		`# Use different model (fuzzy matching)\n  ${APP_NAME} --model opus "Help me refactor this code"`,
 		`# Limit model cycling to specific models\n  ${APP_NAME} --models claude-sonnet,claude-haiku,gpt-4o`,
 		`# Pin a stored credential for this session\n  ${APP_NAME} --credential email:me@example.com`,
+		`# Prefer a stored credential, falling back on quota limits\n  ${APP_NAME} --prefer-credential id:15`,
 		`# Activate a model profile for this session\n  ${APP_NAME} --mpreset codex-medium`,
 		`# Persist a model profile as the default\n  ${APP_NAME} --mpreset opencodego --default`,
 		`# Export a session file to HTML\n  ${APP_NAME} --export ~/.gjc/agent/sessions/v2-<scope>/session.jsonl`,

package/src/commands/mcp.ts

@@ -7,7 +7,7 @@ import { type MCPAction, type MCPCommandArgs, runMCPCommand } from "../cli/mcp-c
 const ACTIONS: MCPAction[] = ["add", "list", "remove"];
 
 export default class MCP extends Command {
-	static description = "Store standalone MCP server definitions without loading them at runtime";
+	static description = "Register MCP servers that ordinary standalone sessions load at startup";
 	static delegateHelp = true;
 
 	static examples = [
@@ -87,15 +87,15 @@ export default class MCP extends Command {
 	}
 
 	#printHelp(): void {
-		process.stdout.write(`Store standalone MCP server definitions in GJC config without loading them at runtime
+		process.stdout.write(`Register MCP servers that ordinary standalone sessions load at startup
 
 USAGE
   $ gjc mcp [add|list|remove] [NAME] [COMMAND_OR_URL] [ARGS...] [FLAGS]
 
 COMMANDS
-  add     Store an explicit user-provided MCP server definition
-  list    List stored servers with env/header/auth values redacted
-  remove  Remove a stored server and print the removed definition redacted
+  add     Register an explicit user-provided MCP server definition
+  list    List registered servers with source, status, and env/header/auth values redacted
+  remove  Remove a registered server and print the removed definition redacted
 
 FLAGS
       --project          Use project scope (./.gjc/mcp.json) instead of user scope
@@ -117,8 +117,13 @@ EXAMPLES
   $ gjc mcp list --json
   $ gjc mcp remove context7
 
-STORAGE/RUNTIME
-  This command stores only the server definition supplied on this invocation. It does not import or inherit Claude Code, Codex, OpenCode, or other live MCP configs. Normal standalone gjc sessions do not load stored MCP registrations today. Public output redacts env, header, auth, and OAuth credential values.
+RUNTIME
+  Registrations are consumed by ordinary standalone gjc sessions at startup
+  (conventional autoload) unless disabled (enabled: false or the disabledServers
+  list), marked autoload: false, or the session opts out with --no-mcp. This
+  command stores only the definition supplied on this invocation; it does not
+  import or inherit Claude Code, Codex, OpenCode, or other live MCP configs.
+  Public output redacts env, header, auth, and OAuth credential values.
 `);
 	}
 }

package/src/commands/ralplan.ts

@@ -1,4 +1,5 @@
 import { Command } from "@gajae-code/utils/cli";
+import { ensureWorkflowSettingsMigrated } from "../config/settings";
 import { runNativeRalplanCommand } from "../gjc-runtime/ralplan-runtime";
 
 export default class Ralplan extends Command {
@@ -12,6 +13,7 @@ export default class Ralplan extends Command {
 	];
 
 	async run(): Promise<void> {
+		await ensureWorkflowSettingsMigrated(process.cwd());
 		const result = await runNativeRalplanCommand(this.argv, process.cwd());
 		if (result.stdout) process.stdout.write(result.stdout);
 		if (result.stderr) process.stderr.write(result.stderr);