@gajae-code/coding-agent 0.18.11 → 0.18.12

package/src/cli/install-activation.ts

@@ -504,8 +504,12 @@ export interface ReconcileResult {
 	readonly record?: ActivationRecordV1;
 	readonly recordIdentity?: FileIdentity;
 	readonly reason?: string;
-	/** Present only for a pre-mutation Windows sharing violation on the destination open. */
+	/** Present only for a pre-mutation Windows exact-replacement failure. */
 	readonly windowsErrorCode?: string;
+	readonly detachedPath?: string;
+	readonly retainedSuccessorPath?: string;
+	readonly retainedPlaceholderPath?: string;
+	readonly retainedUnknownPath?: string;
 }
 
 /**
@@ -519,9 +523,11 @@ export interface ReconcileResult {
  * records are re-verified and advanced to `verified` once the target
  * digest/identity matches the candidate. `verified` records are read-only
  * re-confirmations. Anything else (target/parent drift, missing staged
- * candidate, an already-occupied backup name, a pre-mutation Windows
- * sharing violation) is reported as `conflict` with the exact reason and
- * never silently promoted.
+ * candidate, an already-occupied backup name) is reported as `conflict` with
+ * the exact reason and never silently promoted. A pre-mutation Windows
+ * sharing violation becomes `pending_activation`; an access-denied result is
+ * also recorded as pending for safe reuse but remains a `conflict` so the
+ * caller reports the publication failure.
  */
 export async function reconcileActivationRecord(
 	targetPath: string,
@@ -637,11 +643,48 @@ export async function reconcileActivationRecord(
 					};
 				}
 			}
+			if (
+				record.targetIdentity &&
+				record.stagingIdentity &&
+				result.code === "access_denied" &&
+				(process.platform === "win32" || result.windowsErrorCode === "0xC0000022") &&
+				!result.detachedPath &&
+				!result.retainedSuccessorPath &&
+				!result.retainedUnknownPath &&
+				!result.retainedPlaceholderPath
+			) {
+				const unchangedTarget = await snapshotRegularFile(targetPath);
+				const unchangedStaging = await snapshotRegularFile(record.stagingPath);
+				if (
+					unchangedTarget &&
+					unchangedStaging &&
+					sameFileIdentity(record.targetIdentity, unchangedTarget.identity) &&
+					sameFileIdentity(record.stagingIdentity, unchangedStaging.identity)
+				) {
+					const pending: ActivationRecordV1 = { ...record, phase: "pending_activation" };
+					const pendingIdentity = await updateActivationRecordFile(pending, recordIdentity);
+					return {
+						status: "conflict",
+						record: pending,
+						recordIdentity: pendingIdentity,
+						reason: "access_denied",
+						...(result.windowsErrorCode ? { windowsErrorCode: result.windowsErrorCode } : {}),
+					};
+				}
+			}
 			return {
 				status: "conflict",
 				record,
 				reason: result.code ?? "activation_promotion_failed",
 				...(result.windowsErrorCode ? { windowsErrorCode: result.windowsErrorCode } : {}),
+				...(result.detachedPath !== undefined ? { detachedPath: result.detachedPath } : {}),
+				...(result.retainedSuccessorPath !== undefined
+					? { retainedSuccessorPath: result.retainedSuccessorPath }
+					: {}),
+				...(result.retainedPlaceholderPath !== undefined
+					? { retainedPlaceholderPath: result.retainedPlaceholderPath }
+					: {}),
+				...(result.retainedUnknownPath !== undefined ? { retainedUnknownPath: result.retainedUnknownPath } : {}),
 			};
 		}
 		const promoted = await snapshotRegularFile(targetPath);

package/src/cli/migrate-cli.ts

@@ -1,5 +1,5 @@
 /**
- * `gjc migrate` — import MCP servers and skills from other coding agents.
+ * `gjc migrate` — import MCP servers, skills, and instruction files from other coding agents.
  */
 import * as os from "node:os";
 import * as path from "node:path";
@@ -53,8 +53,10 @@ export function resolveSources(from: string[]): MigrateSource[] {
 
 function resolveDestinations(project: boolean, cwd: string): MigrateDestinations {
 	const scope = project ? "project" : "user";
-	const skillsDir = project ? path.join(getProjectAgentDir(cwd), "skills") : path.join(getAgentDir(), "skills");
-	return { mcpConfigPath: getMCPConfigPath(scope, cwd), skillsDir };
+	const agentDir = project ? getProjectAgentDir(cwd) : getAgentDir();
+	const skillsDir = path.join(agentDir, "skills");
+	const instructionsPath = path.join(agentDir, "AGENTS.md");
+	return { mcpConfigPath: getMCPConfigPath(scope, cwd), skillsDir, instructionsPath };
 }
 
 /** Run the migration and return the report (does not set process.exitCode). */
@@ -66,11 +68,11 @@ export async function runMigrate(args: MigrateCommandArgs): Promise<MigrateRepor
 
 	const results: AdapterResult[] = [];
 	for (const source of sources) {
-		results.push(await getAdapter(source).collect({ homeDir }));
+		results.push(await getAdapter(source).collect({ homeDir, cwd, scope: args.project ? "project" : "user" }));
 	}
 
 	const { actions, warnings } = await planMigration({ results, destinations, force: args.force });
-	const finalActions = args.dryRun ? actions : await executeActions(actions);
+	const finalActions = args.dryRun ? actions : await executeActions(actions, { project: args.project });
 
 	return buildReport({
 		actions: finalActions,

package/src/cli/public-command-errors.ts

@@ -111,6 +111,10 @@ export const PUBLIC_COMMAND_DIAGNOSTICS = {
 	// of them and never implies that another key would be safe.
 	lifecycle_idempotency_conflict:
 		"The broker reported an idempotency conflict. Reconcile existing lifecycle state before deciding whether another request is safe.",
+	// Refusals of the request payload itself: the broker's own text names the missing field
+	// (a required `sessionPath`, for one), and it is never rendered, so the class is named here.
+	lifecycle_input_refused:
+		"The broker refused the request as invalid input. Correct the request payload and reconcile existing lifecycle state before deciding whether another request is safe.",
 	usage_transport_exclusive: "Specify exactly one of --stdio or --socket <path>.",
 	usage_duplicate_option: "Each option on this command may occur at most once.",
 	usage_unknown_argument: "An unrecognized argument was supplied; re-read the command help for its accepted grammar.",

package/src/cli/root-flags.ts

@@ -19,11 +19,11 @@ export const ROOT_LAUNCH_FLAGS = {
 	"api-key": Flags.string({ description: "API key (defaults to env vars)" }),
 	credential: Flags.string({
 		description:
-			"Stored credential selector: email:<addr>, id:<n>, account:<id>, project:<id>, or provider/email:<addr>",
+			"Stored credential selector: email:<addr>, id:<n>, account:<id>, project:<id>, org:<id|name>, or provider/email:<addr>",
 	}),
 	"prefer-credential": Flags.string({
 		description:
-			"Preferred stored credential with quota fallback: email:<addr>, id:<n>, account:<id>, project:<id>, or provider/id:<n>",
+			"Preferred stored credential with quota fallback: email:<addr>, id:<n>, account:<id>, project:<id>, org:<id|name>, or provider/id:<n>",
 	}),
 	"system-prompt": Flags.string({ description: "System prompt (default: coding assistant prompt)" }),
 	"append-system-prompt": Flags.string({ description: "Append text or file contents to the system prompt" }),

package/src/cli/stats-cli.ts

@@ -4,7 +4,7 @@
  * Handles `gjc stats` subcommand for viewing AI usage statistics.
  */
 
-import { APP_NAME, formatDuration, formatNumber, formatPercent } from "@gajae-code/utils";
+import { APP_NAME, formatDuration, formatNumber, formatPercent, sanitizeDisplayLine } from "@gajae-code/utils";
 import chalk from "chalk";
 import { openPath } from "../utils/open";
 
@@ -168,7 +168,7 @@ async function printStatsSummary(): Promise<void> {
 		console.log(chalk.bold("\nBy Model:"));
 		for (const m of byModel.slice(0, 10)) {
 			console.log(
-				`  ${m.model}: ${formatNumber(m.totalRequests)} reqs, ${formatCost(m.totalCost)}, ${formatPercent(m.cacheRate)} cache`,
+				`  ${sanitizeDisplayLine(m.model)}: ${formatNumber(m.totalRequests)} reqs, ${formatCost(m.totalCost)}, ${formatPercent(m.cacheRate)} cache`,
 			);
 		}
 	}
@@ -177,7 +177,7 @@ async function printStatsSummary(): Promise<void> {
 		console.log(chalk.bold("\nBy Agent Role:"));
 		for (const agent of byAgent) {
 			console.log(
-				`  ${agent.agent}: ${formatNumber(agent.totalRequests)} reqs, ${formatNumber(agent.totalInputTokens)} input / ${formatNumber(agent.totalOutputTokens)} output, ${formatPercent(agent.cacheRate)} cache, ${formatCost(agent.totalCost)}`,
+				`  ${sanitizeDisplayLine(agent.agent)}: ${formatNumber(agent.totalRequests)} reqs, ${formatNumber(agent.totalInputTokens)} input / ${formatNumber(agent.totalOutputTokens)} output, ${formatPercent(agent.cacheRate)} cache, ${formatCost(agent.totalCost)}`,
 			);
 		}
 	}
@@ -185,7 +185,9 @@ async function printStatsSummary(): Promise<void> {
 	if (byFolder.length > 0) {
 		console.log(chalk.bold("\nBy Folder:"));
 		for (const f of byFolder.slice(0, 10)) {
-			console.log(`  ${f.folder}: ${formatNumber(f.totalRequests)} reqs, ${formatCost(f.totalCost)}`);
+			console.log(
+				`  ${sanitizeDisplayLine(f.folder)}: ${formatNumber(f.totalRequests)} reqs, ${formatCost(f.totalCost)}`,
+			);
 		}
 	}
 
@@ -201,7 +203,9 @@ async function printStatsSummary(): Promise<void> {
 		console.log(`  Provider-side (prefix intact): ${formatNumber(misses.providerSideMisses)}`);
 		console.log(`  Model switch: ${formatNumber(misses.modelSwitchMisses)}`);
 		for (const cause of misses.byCause) {
-			const label = cause.divergedRole ? `${cause.change} (${cause.divergedRole})` : cause.change;
+			const label = sanitizeDisplayLine(
+				cause.divergedRole ? `${cause.change} (${cause.divergedRole})` : cause.change,
+			);
 			console.log(`    ${label}: ${formatNumber(cause.misses)}`);
 		}
 	}

package/src/cli/update-cli.ts

@@ -11,7 +11,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { exactReplaceRetained, exactUnlink } from "@gajae-code/natives";
-import { $which, APP_NAME, isCompiledBinary, isEnoent, redactCrashSecrets, VERSION } from "@gajae-code/utils";
+import { $which, APP_NAME, isCompiledBinary, isEnoent, logger, redactCrashSecrets, VERSION } from "@gajae-code/utils";
 import { $ } from "bun";
 import chalk from "chalk";
 import { acquireFileLock } from "../config/file-lock";
@@ -38,6 +38,7 @@ import {
 	createActivationRecordFile,
 	type DirectoryIdentity,
 	type FileIdentity,
+	type ReconcileResult,
 	readActivationRecord,
 	reconcileActivationRecord,
 	sameDirectoryIdentity,
@@ -108,6 +109,60 @@ export interface BinaryReplacementOptions {
 	verifyInstalledVersion: (expectedVersion: string) => Promise<InstalledVersionVerification>;
 }
 
+function formatRetainedActivationPaths(
+	paths:
+		| Pick<
+				ReconcileResult,
+				"detachedPath" | "retainedSuccessorPath" | "retainedPlaceholderPath" | "retainedUnknownPath"
+		  >
+		| undefined,
+): string {
+	if (!paths) return "";
+	const entries = [
+		paths.detachedPath !== undefined ? `detached=${paths.detachedPath}` : undefined,
+		paths.retainedSuccessorPath !== undefined ? `successor=${paths.retainedSuccessorPath}` : undefined,
+		paths.retainedPlaceholderPath !== undefined ? `placeholder=${paths.retainedPlaceholderPath}` : undefined,
+		paths.retainedUnknownPath !== undefined ? `unknown=${paths.retainedUnknownPath}` : undefined,
+	].filter((entry): entry is string => entry !== undefined);
+	return entries.length > 0 ? `; retained paths: ${entries.join("|")}` : "";
+}
+
+export class InstallationAccessDeniedError extends Error {
+	readonly code = "access_denied";
+
+	constructor(
+		readonly targetPath: string,
+		readonly windowsErrorCode?: string,
+		readonly stagingCleanupWarning?: string,
+		readonly retainedPaths?: Pick<
+			ReconcileResult,
+			"detachedPath" | "retainedSuccessorPath" | "retainedPlaceholderPath" | "retainedUnknownPath"
+		>,
+	) {
+		super(
+			`access_denied during exact replacement of ${targetPath}${windowsErrorCode ? ` (${windowsErrorCode})` : ""}${stagingCleanupWarning ? `; ${stagingCleanupWarning}` : ""}${formatRetainedActivationPaths(retainedPaths)}`,
+		);
+		this.name = "InstallationAccessDeniedError";
+	}
+}
+
+export class ActivationRetryCandidateRepointError extends Error {
+	readonly reasonCode: string;
+
+	constructor(
+		readonly candidatePath: string,
+		cause: unknown,
+	) {
+		const reasonCode =
+			cause instanceof Error && /^[a-z][a-z0-9_]{0,63}$/.test(cause.message)
+				? cause.message
+				: "activation_record_repoint_failed";
+		super(`${reasonCode}; retained retry candidate: ${candidatePath}`, { cause });
+		this.name = "ActivationRetryCandidateRepointError";
+		this.reasonCode = reasonCode;
+	}
+}
+
 /**
  * Parse update subcommand arguments.
  * Returns undefined if not an update command.
@@ -782,6 +837,60 @@ export async function recoverWindowsUpdateJournal(journalPath: string): Promise<
 	throw new Error("legacy_update_journal_requires_manual_review");
 }
 
+async function removeExactStagingFile(filePath: string, identity: FileIdentity): Promise<void> {
+	const quarantineName = `.${path.basename(filePath)}.cleanup.${randomUUID()}`;
+	const removed = exactUnlink(filePath, toNativeIdentity(identity, quarantineName));
+	let pathStillExists = false;
+	let snapshotFailure: string | undefined;
+	try {
+		pathStillExists = (await snapshotRegularFile(filePath)) !== undefined;
+	} catch (error) {
+		snapshotFailure = error instanceof Error ? error.message : String(error);
+	}
+	const recoveryPaths = [
+		removed.detachedPath ? `detached=${removed.detachedPath}` : undefined,
+		removed.retainedPlaceholderPath ? `placeholder=${removed.retainedPlaceholderPath}` : undefined,
+		removed.retainedUnknownPath ? `unknown=${removed.retainedUnknownPath}` : undefined,
+		removed.retainedSuccessorPath ? `successor=${removed.retainedSuccessorPath}` : undefined,
+	].filter((value): value is string => value !== undefined);
+	if (
+		(!removed.ok && removed.code !== "not_found") ||
+		pathStillExists ||
+		snapshotFailure !== undefined ||
+		recoveryPaths.length > 0
+	) {
+		const reason =
+			removed.code ?? (pathStillExists ? "path_still_exists" : snapshotFailure ? "snapshot_failed" : "unverified");
+		const details = [
+			`path=${filePath}`,
+			...recoveryPaths,
+			...(snapshotFailure !== undefined ? [`snapshot=${snapshotFailure}`] : []),
+		].join("|");
+		throw new Error(`activation_retry_staging_cleanup_failed:${reason}:${details}`);
+	}
+}
+
+async function tryRemoveExactStagingFile(filePath: string, identity: FileIdentity): Promise<string | undefined> {
+	try {
+		await removeExactStagingFile(filePath, identity);
+		return undefined;
+	} catch (error) {
+		return error instanceof Error ? error.message : String(error);
+	}
+}
+
+async function repointActivationRecordToRetryCandidate(
+	record: ActivationRecordV1,
+	recordIdentity: FileIdentity,
+	candidatePath: string,
+): Promise<FileIdentity> {
+	try {
+		return await updateActivationRecordFile(record, recordIdentity);
+	} catch (error) {
+		throw new ActivationRetryCandidateRepointError(candidatePath, error);
+	}
+}
+
 /**
  * Atomically replace the installed binary and roll back if version verification fails.
  */
@@ -830,6 +939,7 @@ export async function replaceBinaryForUpdate(options: BinaryReplacementOptions):
 	}
 	let record: ActivationRecordV1;
 	let recordIdentity: FileIdentity;
+	let redundantStage: { readonly path: string; readonly identity: FileIdentity } | undefined;
 	if (existing.status === "valid" && existing.record.phase !== "verified" && existing.record.phase !== "rolled_back") {
 		if (
 			existing.record.candidate.digest !== (options.candidate?.sha256.toLowerCase() ?? staged?.identity.sha256) ||
@@ -839,8 +949,43 @@ export async function replaceBinaryForUpdate(options: BinaryReplacementOptions):
 					existing.record.candidate.channel !== options.candidate.channel))
 		)
 			throw new Error("activation_transaction_requires_reconciliation");
-		record = existing.record;
-		recordIdentity = existing.identity;
+		const currentStagingPath = path.resolve(options.tempPath);
+		const recordedStagingPath = path.resolve(existing.record.stagingPath);
+		if (currentStagingPath !== recordedStagingPath) {
+			const retryCandidate = staged ?? (await snapshotRegularFile(currentStagingPath));
+			if (retryCandidate && retryCandidate.identity.sha256 !== existing.record.candidate.digest)
+				throw new Error("activation_retry_candidate_digest_mismatch");
+			const activationNeedsStagedCandidate =
+				existing.record.phase === "staged" || existing.record.phase === "pending_activation";
+			const recordedStage = activationNeedsStagedCandidate
+				? await snapshotRegularFile(recordedStagingPath)
+				: undefined;
+			const recordedStageIsValid =
+				recordedStage &&
+				existing.record.stagingIdentity &&
+				sameFileIdentity(existing.record.stagingIdentity, recordedStage.identity) &&
+				recordedStage.identity.sha256 === existing.record.candidate.digest;
+			if (activationNeedsStagedCandidate && !recordedStageIsValid) {
+				if (!retryCandidate) throw new Error("activation_retry_candidate_missing");
+				record = {
+					...existing.record,
+					stagingPath: currentStagingPath,
+					stagingIdentity: retryCandidate.identity,
+				};
+				recordIdentity = await repointActivationRecordToRetryCandidate(
+					record,
+					existing.identity,
+					currentStagingPath,
+				);
+			} else {
+				if (retryCandidate) redundantStage = { path: currentStagingPath, identity: retryCandidate.identity };
+				record = existing.record;
+				recordIdentity = existing.identity;
+			}
+		} else {
+			record = existing.record;
+			recordIdentity = existing.identity;
+		}
 	} else {
 		if (!staged) throw new Error("installation_staging_unavailable");
 		record = {
@@ -873,26 +1018,97 @@ export async function replaceBinaryForUpdate(options: BinaryReplacementOptions):
 		allowPromotion: true,
 		expectedRecordIdentity: recordIdentity,
 	});
-	if (promoted.status === "pending_activation") throw new Error("installation_pending_activation");
+	if (promoted.reason === "candidate_changed" && redundantStage) {
+		logger.warn("Activation staging path changed during reconciliation; leaving it untouched", {
+			changedStagingPath: record.stagingPath,
+			retryCandidatePath: redundantStage.path,
+		});
+		await repointActivationRecordToRetryCandidate(
+			{
+				...record,
+				phase: "pending_activation",
+				stagingPath: redundantStage.path,
+				stagingIdentity: redundantStage.identity,
+			},
+			recordIdentity,
+			redundantStage.path,
+		);
+		throw new Error("installation_pending_activation");
+	}
+	if (promoted.status === "pending_activation") {
+		if (promoted.reason === "candidate_missing" && redundantStage) {
+			await repointActivationRecordToRetryCandidate(
+				{
+					...record,
+					phase: "pending_activation",
+					stagingPath: redundantStage.path,
+					stagingIdentity: redundantStage.identity,
+				},
+				recordIdentity,
+				redundantStage.path,
+			);
+		} else {
+			const stagingCleanupWarning = redundantStage
+				? await tryRemoveExactStagingFile(redundantStage.path, redundantStage.identity)
+				: undefined;
+			if (stagingCleanupWarning)
+				logger.warn("Update staging cleanup failed while activation is pending", {
+					warning: stagingCleanupWarning,
+				});
+		}
+		throw new Error("installation_pending_activation");
+	}
 	if (
 		(promoted.status !== "reconciled" &&
 			promoted.status !== "applied_unverified" &&
 			promoted.status !== "verified") ||
 		!promoted.record ||
 		!promoted.recordIdentity
-	)
+	) {
+		const stagingCleanupWarning = redundantStage
+			? await tryRemoveExactStagingFile(redundantStage.path, redundantStage.identity)
+			: undefined;
+		if (promoted.reason === "access_denied")
+			throw new InstallationAccessDeniedError(targetPath, promoted.windowsErrorCode, stagingCleanupWarning, {
+				detachedPath: promoted.detachedPath,
+				retainedSuccessorPath: promoted.retainedSuccessorPath,
+				retainedPlaceholderPath: promoted.retainedPlaceholderPath,
+				retainedUnknownPath: promoted.retainedUnknownPath,
+			});
+		if (stagingCleanupWarning)
+			logger.warn("Update staging cleanup failed after activation reconciliation failed", {
+				reason: promoted.reason ?? promoted.status,
+				warning: stagingCleanupWarning,
+			});
 		throw new Error(promoted.reason ?? "installation_publication_unverified");
+	}
 	record = promoted.record;
 	recordIdentity = promoted.recordIdentity;
+	const cleanupWarnings: string[] = [];
 	try {
-		const verification = await options.verifyInstalledVersion(options.expectedVersion);
+		let verification = await options.verifyInstalledVersion(options.expectedVersion);
 		if (!verification.ok) throw new Error(formatVerificationFailure(verification, options.expectedVersion));
 		const after = await snapshotRegularFile(targetPath);
 		if (!after || !record.targetIdentity || !sameFileIdentity(record.targetIdentity, after.identity))
 			throw new Error("installation_postcheck_identity_changed");
+		if (redundantStage) {
+			const cleanupWarning = await tryRemoveExactStagingFile(redundantStage.path, redundantStage.identity);
+			if (cleanupWarning) {
+				cleanupWarnings.push(cleanupWarning);
+				verification = { ...verification, cleanupWarning };
+			}
+		}
 		await updateActivationRecordFile({ ...record, phase: "verified" }, recordIdentity);
 		return verification;
 	} catch (primary) {
+		const rollbackCleanupWarning = redundantStage
+			? await tryRemoveExactStagingFile(redundantStage.path, redundantStage.identity)
+			: undefined;
+		if (rollbackCleanupWarning) cleanupWarnings.push(rollbackCleanupWarning);
+		if (cleanupWarnings.length > 0)
+			logger.warn("Update staging cleanup failed before activation rollback", {
+				warning: cleanupWarnings.join("\n"),
+			});
 		try {
 			const after = await snapshotRegularFile(targetPath);
 			if (!after || !record.targetIdentity || !sameFileIdentity(record.targetIdentity, after.identity))
@@ -1286,7 +1502,8 @@ async function updateViaBinaryAt(
 		beforeReplace: () => console.log(chalk.dim("Installing update...")),
 	});
 
-	if (verification.cleanupWarning) console.warn(chalk.yellow(verification.cleanupWarning));
+	if (verification.cleanupWarning)
+		logger.warn("Update staging cleanup failed", { warning: verification.cleanupWarning });
 	return verification;
 }
 

package/src/cli-ordinary.ts

@@ -3,8 +3,8 @@
  * This module owns the effectful bootstrap (startup timing, stderr drainer,
  * bash-shell worker protocol) plus the unchanged ordinary routing order:
  * bash-shell workers -> darwin malloc re-exec -> internal smoke -> tmux owner
- * isolation -> managed-owner supervisor/admission/recovery -> private sdk
- * stderr drainer -> public family dispatch -> community app -> doctor worker /
+ * isolation -> managed-owner supervisor/admission/recovery -> broker hop ->
+ * private sdk stderr drainer -> public family dispatch -> community app -> doctor worker /
  * probe / cli -> full registry. `cli.ts` imports it lazily, only after argv has
  * been proven not to be a `sdk diagnostics` observation. */
 
@@ -16,6 +16,7 @@ import {
 	BASH_SHELL_SUPERVISOR_ARG,
 	BASH_SHELL_WORKER_ARG,
 } from "./exec/bash-shell-worker-protocol";
+import { runBrokerHopFromArgv } from "./sdk/broker/hop";
 import { runSdkStderrDrainerFromArgv } from "./sdk/broker/stderr-drainer";
 
 export { commands };
@@ -128,6 +129,10 @@ export async function runOrdinaryCli(argv: string[]): Promise<void> {
 			return;
 		}
 	}
+	if (argv.length >= 2 && argv[0] === "internal" && argv[1] === "broker-hop") {
+		await runBrokerHopFromArgv(argv.slice(2));
+		return;
+	}
 	if (argv[0] === "sdk" && argv[1] === "stderr-drain-internal") {
 		// Private lifecycle stderr drainer: must stay ahead of the public sdk family
 		// dispatcher, which would otherwise reject the private argv as a usage error.

package/src/commands/accounts.ts

@@ -8,7 +8,7 @@ import {
 } from "../cli/accounts-cli";
 
 export default class Accounts extends Command {
-	static description = "List, check, pin, and remove stored OAuth accounts";
+	static description = "List, check, pin, prefer, and remove stored OAuth accounts";
 	static strict = true;
 
 	static args = {
@@ -22,16 +22,18 @@ export default class Accounts extends Command {
 			required: false,
 		}),
 		selector: Args.string({
-			description: "Account selector (bare email, id:, email:, or account:)",
+			description:
+				"Account selector (bare email, id:, email:, or account:); prefer takes several in order, each optionally =<max used percent>",
 			required: false,
+			multiple: true,
 		}),
 	};
 
 	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" }),
+		clear: Flags.boolean({ description: "Clear the persistent pin or preferred accounts" }),
+		account: Flags.string({ description: "Logout one account by row id, email, or org:<organization id or name>" }),
 		all: Flags.boolean({ description: "Logout every OAuth account for the provider" }),
 	};
 
@@ -42,7 +44,10 @@ export default class Accounts extends Command {
 		"gjc accounts check anthropic --json",
 		"gjc accounts pin anthropic me@example.com --persistent",
 		"gjc accounts pin anthropic id:42 --persistent",
+		"gjc accounts pin anthropic 'org:Acme Team' --persistent",
 		"gjc accounts pin anthropic --clear --persistent",
+		"gjc accounts prefer anthropic cheap@example.com shared@example.com=75",
+		"gjc accounts prefer anthropic --clear",
 		"gjc accounts logout anthropic --account me@example.com",
 		"gjc accounts logout anthropic --all",
 	];
@@ -57,7 +62,7 @@ export default class Accounts extends Command {
 		const cmd: AccountsCommandArgs = {
 			action,
 			provider: args.provider,
-			selector: args.selector,
+			selectors: Array.isArray(args.selector) ? args.selector : args.selector ? [args.selector] : undefined,
 			flags: {
 				json: flags.json,
 				persistent: flags.persistent,

package/src/commands/migrate.ts

@@ -1,11 +1,11 @@
 /**
- * Import MCP servers and skills from other coding agents into GJC.
+ * Import MCP servers, skills, and instructions from other coding agents into GJC.
  */
 import { Command, Flags } from "@gajae-code/utils/cli";
 import { type MigrateCommandArgs, runMigrateCommand } from "../cli/migrate-cli";
 
 export default class Migrate extends Command {
-	static description = "Import MCP servers and skills from Claude Code, Codex, or OpenCode";
+	static description = "Import MCP servers and skills, plus Claude Code/Codex instructions";
 
 	static examples = [
 		"gjc migrate --from claude-code",
@@ -25,7 +25,7 @@ export default class Migrate extends Command {
 			default: false,
 		}),
 		force: Flags.boolean({
-			description: "Overwrite existing skills/MCP servers instead of skipping them",
+			description: "Overwrite existing skills, MCP servers, or instruction files instead of skipping them",
 			default: false,
 		}),
 		"dry-run": Flags.boolean({ description: "Preview the migration without writing anything", default: false }),