@gajae-code/coding-agent 0.15.6 → 0.16.1

package/scripts/generate-sdk-operation-inventory.ts

@@ -52,6 +52,10 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 	"slash_command:tutorial": "visual/local-only onboarding selector, not a user-facing SDK control seam",
 	"slash_command:transcript": "visual/local-only transcript viewer, not a user-facing SDK control seam",
 	"slash_command:sessions": "visual/local-only sessions dashboard, not a user-facing SDK control seam",
+	"slash_command:star":
+		"local transcript-discovery metadata command; no SDK operation counterpart or runtime/retention authority",
+	"slash_command:unstar":
+		"local transcript-discovery metadata command; no SDK operation counterpart or runtime/retention authority",
 	"agent_session:constructor": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:getSessionAgentDir":
 		"internal session-scoped agent-directory accessor, not a user-facing SDK control seam",
@@ -107,6 +111,12 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 	"agent_session:activeMidRunBarrierCountForTests": "read-only test seam, not a user-facing SDK control seam",
 	"agent_session:activeMidRunMaintenanceCountForTests": "read-only test seam, not a user-facing SDK control seam",
 	"agent_session:getPendingNextTurnMessagesForTests": "read-only test seam, not a user-facing SDK control seam",
+	"agent_session:queueCoordinatorRuntimeStatePersistForTests":
+		"test-only coordinator persistence ordering seam, not a user-facing SDK control seam",
+	"agent_session:parkAgentEndForCoordinatorPersistForTests":
+		"test-only parked terminal persistence seam, not a user-facing SDK control seam",
+	"agent_session:flushParkedAgentEndForCoordinatorPersistForTests":
+		"test-only parked terminal flush seam, not a user-facing SDK control seam",
 	"agent_session:setCancelAndSubmitAbortOutcomeProviderForTests":
 		"test-only cancellation seam, not a user-facing SDK control seam",
 	"agent_session:getAgentId": "internal accessor/plumbing, not a user-facing control seam",
@@ -131,6 +141,7 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 	"agent_session:hasForegroundBashBackgroundRequestHandler":
 		"internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:requestForegroundBashBackground": "internal accessor/plumbing, not a user-facing SDK control seam",
+	"agent_session:onJobFold": "internal fold-event plumbing feeding the bash_folded event frame, not a control seam",
 
 	"agent_session:getSelectedMCPToolNames": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:isToolDiscoveryEnabled": "internal accessor/plumbing, not a user-facing control seam",
@@ -284,7 +295,7 @@ const SEAM_TO_SDK: Readonly<Record<string, string>> = {
 	"agent_session:cycleThinkingLevel": "thinking.cycle",
 	"agent_session:setSteeringMode": "queue.steering_mode.set",
 	"agent_session:setFollowUpMode": "queue.follow_up_mode.set",
-	"agent_session:setInterruptMode": "queue.interrupt_mode.set",
+	"agent_session:setToolInterruptPolicy": "queue.tool_interrupt_policy.set",
 	"agent_session:compact": "compaction.run",
 	"agent_session:setAutoCompactionEnabled": "compaction.auto.set",
 	"agent_session:setAutoRetryEnabled": "retry.auto.set",
@@ -296,6 +307,7 @@ const SEAM_TO_SDK: Readonly<Record<string, string>> = {
 	"agent_session:moveQueuedMessageForEditing": "queue.message.move",
 	"agent_session:executeBash": "bash.execute",
 	"agent_session:abortBash": "bash.abort",
+	"agent_session:requestForegroundBashBackgroundOutcome": "bash.background",
 	"agent_session:switchSession": "session.switch",
 	"agent_session:branch": "session.branch",
 	"agent_session:handoff": "session.handoff",

package/scripts/verify-gjc-sdk-canonicalization.ts

@@ -1567,6 +1567,24 @@ function isTypeOnlyTmuxPrimitiveOccurrence(contents: string, occurrence: TmuxPri
 	return /^\s*(?:export\s+)?type\b/.test(contents.slice(lineStart, lineEnd === -1 ? contents.length : lineEnd));
 }
 
+function isExactTmuxSelfInjectionGuardVerb(
+	file: string,
+	contents: string,
+	occurrence: TmuxPrimitiveOccurrence,
+): boolean {
+	if (file !== "packages/coding-agent/src/tools/tmux-self-injection-guard.ts") return false;
+	const declaration = 'const INPUT_VERBS = new Set(["send-keys", "paste-buffer", "send-prefix"]);';
+	const declarationStart = contents.indexOf(declaration);
+	if (declarationStart === -1 || contents.indexOf(declaration, declarationStart + 1) !== -1) return false;
+	const references = [...contents.matchAll(/\bINPUT_VERBS\b/g)];
+	if (references.length !== 2) return false;
+	const guardUse = "INPUT_VERBS.has(invocation.verb)";
+	const guardUseStart = contents.indexOf(guardUse);
+	if (guardUseStart === -1 || contents.indexOf(guardUse, guardUseStart + 1) !== -1) return false;
+	if (!references.some(reference => reference.index === guardUseStart)) return false;
+	return occurrence.start >= declarationStart && occurrence.end <= declarationStart + declaration.length;
+}
+
 function tmuxMachineBusViolations(file: string, contents: string): string[] {
 	if (isGeneratedDocumentationIndex(file)) return [];
 	const allowedTeamFallbackRanges =
@@ -1581,7 +1599,8 @@ function tmuxMachineBusViolations(file: string, contents: string): string[] {
 		if (
 			isExactTeamFallback ||
 			isExactTmuxScrollCopyModeSendKeys(file, contents, occurrence) ||
-			isTypeOnlyTmuxPrimitiveOccurrence(contents, occurrence)
+			isTypeOnlyTmuxPrimitiveOccurrence(contents, occurrence) ||
+			isExactTmuxSelfInjectionGuardVerb(file, contents, occurrence)
 		)
 			continue;
 		const detail =
@@ -3147,6 +3166,21 @@ fi
 		1,
 		"tmux send-keys content injection is outside sanctioned process lifecycle",
 	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/tools/tmux-self-injection-guard.ts":
+				'const INPUT_VERBS = new Set(["send-keys", "paste-buffer", "send-prefix"]);\nfunction guarded(invocation: { verb: string }): void { if (!INPUT_VERBS.has(invocation.verb)) return; }\n',
+		},
+		0,
+	);
+	await runSelfTestFixture(
+		{
+			"packages/coding-agent/src/tools/tmux-self-injection-guard.ts":
+				'const INPUT_VERBS = new Set(["send-keys", "paste-buffer", "send-prefix"]);\nfunction guarded(invocation: { verb: string }): void { if (!INPUT_VERBS.has(invocation.verb)) return; }\nfor (const verb of INPUT_VERBS) Bun.spawnSync(["tmux", verb, "-t", pane, prompt]);\n',
+		},
+		1,
+		"tmux send-keys content injection is outside sanctioned process lifecycle",
+	);
 	await runSelfTestFixture(
 		{
 			"packages/coding-agent/src/gjc-runtime/team-runtime.ts":

package/src/async/job-manager.ts

@@ -68,9 +68,25 @@ export function jobElapsedMs(job: Pick<AsyncJob, "startTime" | "endTime">, now:
 	return Math.max(0, (job.endTime ?? now) - job.startTime);
 }
 
+/**
+ * Why a foreground wait left the foreground. Every fold path names its
+ * trigger so job snapshots and SDK clients can tell a user steer from the
+ * chord, the auto-background timer, or the explicit `bash.background` control.
+ */
+export type FoldReason = "steer" | "chord" | "timer" | "sdk_control";
+
+/** A fold observed by the manager; published to SDK clients as `bash_folded`. */
+export interface JobFoldEvent {
+	jobId: string;
+	generation: string;
+	reason: FoldReason;
+}
+
 export interface AsyncJobMetadata {
 	/** Set once a foreground wait has been folded, so surfacing can show folded work. */
 	backgrounded?: boolean;
+	/** Why a foreground wait was folded; absent for jobs started directly in the background (`async: true`). */
+	foldReason?: FoldReason;
 	subagent?: {
 		id: string;
 		agent: string;
@@ -271,6 +287,7 @@ interface AsyncJobDelivery {
 	label: string;
 	status: AsyncJob["status"];
 	backgrounded: boolean;
+	foldReason?: FoldReason;
 	text: string;
 	originalBytes?: number;
 	truncated?: boolean;
@@ -290,6 +307,7 @@ interface AsyncJobReceiptClaim {
 	label: string;
 	status: AsyncJob["status"];
 	backgrounded: boolean;
+	foldReason?: FoldReason;
 	ownerId?: string;
 }
 
@@ -331,6 +349,8 @@ export interface AsyncJobSnapshotEntry {
 	status: AsyncJob["status"];
 	generation: string;
 	backgrounded: boolean;
+	/** Present when `backgrounded` was set by a fold; absent for direct background starts. */
+	foldReason?: FoldReason;
 	deliveryState: JobDeliveryState;
 }
 
@@ -630,6 +650,7 @@ export class AsyncJobManager {
 	}
 
 	readonly #jobs = new Map<string, AsyncJob>();
+	#retainedDisposalCompletion: Promise<void> = Promise.resolve();
 	readonly #deliveries: AsyncJobDelivery[] = [];
 	readonly #inFlightDeliveries: AsyncJobDelivery[] = [];
 	readonly #suppressedDeliveries = new Set<string>();
@@ -653,7 +674,6 @@ export class AsyncJobManager {
 	readonly #maxDeadLetterOverflowOwners: number;
 	#deliveryLoop: Promise<void> | undefined;
 	#disposed = false;
-	#disposing = false;
 	#runningOwnerCleanups = false;
 	readonly #subagentRecords = new Map<string, SubagentRecord>();
 	readonly #terminalEvents = new Map<string, TerminalEvent>();
@@ -996,6 +1016,8 @@ export class AsyncJobManager {
 		};
 	}
 
+	readonly #foldListeners = new Set<(event: JobFoldEvent) => void>();
+
 	#notifyChange(): void {
 		for (const cb of this.#changeListeners) {
 			try {
@@ -2307,6 +2329,7 @@ export class AsyncJobManager {
 				status: job.status,
 				generation: job.generation,
 				backgrounded: job.metadata?.backgrounded === true,
+				foldReason: job.metadata?.foldReason,
 				deliveryState,
 			};
 		});
@@ -2329,6 +2352,7 @@ export class AsyncJobManager {
 				status: delivery.status,
 				generation: delivery.generation,
 				backgrounded: delivery.backgrounded,
+				foldReason: delivery.foldReason,
 				deliveryState: "pending",
 			});
 		}
@@ -2344,6 +2368,7 @@ export class AsyncJobManager {
 				status: delivery.status,
 				generation: delivery.generation,
 				backgrounded: delivery.backgrounded,
+				foldReason: delivery.foldReason,
 				deliveryState: "pending",
 			});
 		}
@@ -2359,6 +2384,7 @@ export class AsyncJobManager {
 				status: claim.status,
 				generation: claim.generation,
 				backgrounded: claim.backgrounded,
+				foldReason: claim.foldReason,
 				deliveryState: "pending",
 			});
 		}
@@ -2408,6 +2434,7 @@ export class AsyncJobManager {
 			label: job.label,
 			status: job.status,
 			backgrounded: job.metadata?.backgrounded === true,
+			foldReason: job.metadata?.foldReason,
 			text,
 			attempt: 0,
 			nextAttemptAt: Date.now(),
@@ -2426,6 +2453,7 @@ export class AsyncJobManager {
 			label: job.label,
 			status: job.status,
 			backgrounded: job.metadata?.backgrounded === true,
+			foldReason: job.metadata?.foldReason,
 			ownerId: job.ownerId,
 		});
 		this.#notifyChange();
@@ -2632,12 +2660,26 @@ export class AsyncJobManager {
 	}
 
 	/**
-	 * Mark a running job as backgrounded (folded out of its foreground call).
-	 * Read by getJobsSnapshot so folded work stays visible; safe to call twice.
+	 * Subscribe to fold events. Fires once per successful `markBackgrounded`
+	 * transition (never on the idempotent repeat), so a subscriber can publish
+	 * exactly one `bash_folded` frame per fold. Listener errors are isolated.
 	 */
-	markBackgrounded(jobId: string, generation: string): boolean {
+	onFold(cb: (event: JobFoldEvent) => void): () => void {
+		this.#foldListeners.add(cb);
+		return () => {
+			this.#foldListeners.delete(cb);
+		};
+	}
+
+	/**
+	 * Mark a job that was launched directly in the background (`bash` with
+	 * `async: true`). It never had a foreground wait, so this is not a fold: no
+	 * `foldReason` is recorded and no fold listener fires.
+	 */
+	markStartedInBackground(jobId: string, generation: string): boolean {
 		const job = this.#jobs.get(jobId);
 		if (!job || job.generation !== generation) return false;
+		if (job.metadata?.backgrounded === true) return true;
 		job.metadata = { ...job.metadata, backgrounded: true };
 		for (const delivery of [...this.#deliveries, ...this.#inFlightDeliveries]) {
 			if (delivery.jobId === jobId && delivery.generation === generation) delivery.backgrounded = true;
@@ -2646,6 +2688,37 @@ export class AsyncJobManager {
 		return true;
 	}
 
+	/**
+	 * Mark a running job as backgrounded (folded out of its foreground call).
+	 * Read by getJobsSnapshot so folded work stays visible; safe to call twice.
+	 * The first transition records `reason` and notifies fold listeners; a
+	 * repeat keeps the original reason and emits nothing.
+	 */
+	markBackgrounded(jobId: string, generation: string, reason: FoldReason): boolean {
+		const job = this.#jobs.get(jobId);
+		if (!job || job.generation !== generation) return false;
+		if (job.metadata?.backgrounded === true) return true;
+		job.metadata = { ...job.metadata, backgrounded: true, foldReason: reason };
+		for (const delivery of [...this.#deliveries, ...this.#inFlightDeliveries]) {
+			if (delivery.jobId === jobId && delivery.generation === generation) {
+				delivery.backgrounded = true;
+				delivery.foldReason = reason;
+			}
+		}
+		this.#notifyChange();
+		const event: JobFoldEvent = { jobId, generation, reason };
+		for (const cb of this.#foldListeners) {
+			try {
+				cb(event);
+			} catch (error) {
+				logger.warn("Async job fold listener failed", {
+					error: error instanceof Error ? error.message : String(error),
+				});
+			}
+		}
+		return true;
+	}
+
 	async waitForAll(): Promise<void> {
 		await Promise.all(Array.from(this.#jobs.values()).map(job => job.promise));
 	}
@@ -2707,6 +2780,17 @@ export class AsyncJobManager {
 		// registration keeps the original protection (cleanups cannot register fresh
 		// work) without disabling delivery. Errors in cleanups are logged, never
 		// escalated.
+		const unsettledJobPromises = new Set<Promise<void>>();
+		const jobIdsByPromise = new Map<Promise<void>, string>();
+		for (const job of this.#jobs.values()) {
+			const promise = job.promise;
+			unsettledJobPromises.add(promise);
+			jobIdsByPromise.set(promise, job.id);
+			void promise.then(
+				() => unsettledJobPromises.delete(promise),
+				() => unsettledJobPromises.delete(promise),
+			);
+		}
 		this.#registrationClosed = true;
 		this.#clearEvictionTimers();
 		this.#runningOwnerCleanups = true;
@@ -2715,7 +2799,6 @@ export class AsyncJobManager {
 		} finally {
 			this.#runningOwnerCleanups = false;
 		}
-		this.#disposing = true;
 		this.cancelAll();
 		for (const tombstone of this.#monitorTombstones.values()) {
 			try {
@@ -2734,13 +2817,22 @@ export class AsyncJobManager {
 		const remainingDeliveryMs = Math.max(0, disposalDeadline - Date.now());
 		const drained = await this.drainDeliveries({ timeoutMs: remainingDeliveryMs });
 		if (!drained) this.#projectUndeliveredDisposalFailures();
-		const disposalCompleted = waitResult.completed && drained;
+		const retainedAuthority = new Set<Promise<void>>(unsettledJobPromises);
+		for (const delivery of this.#inFlightDeliveries) {
+			if (delivery.promise) retainedAuthority.add(delivery.promise);
+		}
+		this.#retainedDisposalCompletion = Promise.allSettled(retainedAuthority).then(() => {});
+		const physicalStuckJobIds = [...unsettledJobPromises]
+			.map(promise => jobIdsByPromise.get(promise))
+			.filter((id): id is string => id !== undefined);
+		const stuckJobIds = [...new Set([...waitResult.stuckJobIds, ...physicalStuckJobIds])];
+		const disposalCompleted = waitResult.completed && drained && retainedAuthority.size === 0;
 		this.#lastDisposeDiagnostics = {
-			stuckJobIds: waitResult.stuckJobIds,
+			stuckJobIds,
 			deliveriesDrained: disposalCompleted,
 		};
-		if (waitResult.stuckJobIds.length > 0) {
-			logger.warn("Async job manager dispose timed out waiting for jobs", { stuckJobIds: waitResult.stuckJobIds });
+		if (stuckJobIds.length > 0) {
+			logger.warn("Async job manager dispose timed out waiting for jobs", { stuckJobIds });
 		}
 		this.#clearEvictionTimers();
 		this.#disposed = true;
@@ -2772,9 +2864,14 @@ export class AsyncJobManager {
 		this.#ownerSubagentShutdownLeases.clear();
 		this.#notifyChange();
 		this.#changeListeners.clear();
+		this.#foldListeners.clear();
 		return disposalCompleted;
 	}
 
+	awaitRetainedDisposalCompletion(): Promise<void> {
+		return this.#retainedDisposalCompletion;
+	}
+
 	#projectUndeliveredDisposalFailures(): void {
 		const retained = [...this.#deliveries, ...this.#inFlightDeliveries];
 		for (const delivery of retained) {
@@ -3145,6 +3242,7 @@ export class AsyncJobManager {
 			label: job.label,
 			status: job.status,
 			backgrounded: job.metadata?.backgrounded === true,
+			foldReason: job.metadata?.foldReason,
 			text: deliveryText.text,
 			originalBytes: deliveryText.originalBytes,
 			truncated: deliveryText.truncated,

package/src/browser-backend.ts

@@ -0,0 +1,29 @@
+import browserAsidePrompt from "./prompts/agent-fragments/browser-aside.md" with { type: "text" };
+
+export type BrowserBackendId = "native" | "aside";
+
+export interface BrowserBackend {
+	readonly id: BrowserBackendId;
+	readonly exposesBuiltinTool: boolean;
+	readonly developerInstructions?: string;
+}
+
+interface BrowserBackendSettingsSource {
+	get(key: string): unknown;
+}
+
+const nativeBrowserBackend: BrowserBackend = {
+	id: "native",
+	exposesBuiltinTool: true,
+};
+
+const asideBrowserBackend: BrowserBackend = {
+	id: "aside",
+	exposesBuiltinTool: false,
+	developerInstructions: browserAsidePrompt.trim(),
+};
+
+/** Resolve the configured browser backend. Aside is strictly opt-in. */
+export function resolveBrowserBackend(settings: BrowserBackendSettingsSource): BrowserBackend {
+	return settings.get("browser.backend") === "aside" ? asideBrowserBackend : nativeBrowserBackend;
+}

package/src/cli/accounts-cli.ts

@@ -10,6 +10,7 @@ import {
 	type AuthStorage,
 	type CredentialInventoryRecord,
 	type CredentialRemovalTarget,
+	isSqliteCorruptionError,
 	OAuthCredentialSelectorError,
 	type OAuthPinTarget,
 	resolveOAuthStorageProvider,
@@ -23,6 +24,7 @@ import {
 	checkAccountInventory,
 	clearPersistentPinForRemovedRows,
 } from "../session/account-inventory";
+import { CREDENTIAL_STORE_UNREADABLE_MESSAGE } from "../session/credential-store-errors";
 import { resolveStartupAuthConfig, type StartupAuthConfigSnapshot } from "../session/startup-auth-config";
 
 export const ACCOUNTS_ACTIONS = ["list", "check", "pin", "logout"] as const;
@@ -48,6 +50,7 @@ class AccountsCommandError extends Error {
 	}
 }
 export function toAccountsCommandError(error: unknown): AccountsCommandError | undefined {
+	if (isSqliteCorruptionError(error)) return new AccountsCommandError(CREDENTIAL_STORE_UNREADABLE_MESSAGE);
 	if (error instanceof OAuthCredentialSelectorError) return new AccountsCommandError(error.message);
 	return undefined;
 }
@@ -391,16 +394,17 @@ export async function runAccountsCommand(cmd: AccountsCommandArgs): Promise<void
 			}
 		}
 	} catch (error) {
+		const normalizedError = toAccountsCommandError(error) ?? error;
 		if (cmd.flags.json) {
-			if (!(error instanceof AccountsCommandError)) {
-				process.stderr.write(`accounts command failed: ${cleanReason(error) ?? "Command failed."}\n`);
+			if (!(normalizedError instanceof AccountsCommandError)) {
+				process.stderr.write(`accounts command failed: ${cleanReason(normalizedError) ?? "Command failed."}\n`);
 			}
 			process.exitCode = 1;
-			writeJsonFailure(error);
+			writeJsonFailure(normalizedError);
 			return;
 		}
-		if (error instanceof AccountsCommandError) {
-			process.stderr.write(`${error.message}\n`);
+		if (normalizedError instanceof AccountsCommandError) {
+			process.stderr.write(`${normalizedError.message}\n`);
 			process.exitCode = 1;
 			return;
 		}

package/src/cli/args.ts

@@ -84,6 +84,8 @@ export interface Args {
 	noRules?: boolean;
 	listModels?: string | true;
 	noTitle?: boolean;
+	master?: true;
+	masterScope?: "repo" | "pwd" | "global";
 	messages: string[];
 	fileArgs: string[];
 	/** Flags unknown to every launch parser; their consumer supplies the diagnostic. */
@@ -178,6 +180,17 @@ export function parseArgs(args: string[], authority: ParseArgsAuthority = "local
 			result.help = true;
 		} else if (arg === "--version" || arg === "-v") {
 			result.version = true;
+		} else if (arg === "--master") {
+			result.master = true;
+		} else if (arg === "--scope") {
+			const scope = takeFlagValue(args, i++, "--scope");
+			if (scope !== "repo" && scope !== "pwd" && scope !== "global") {
+				throw new CliParseError("invalid --scope value (expected repo, pwd, or global)");
+			}
+			if (result.masterScope !== undefined && result.masterScope !== scope) {
+				throw new CliParseError("--scope cannot be specified with conflicting values");
+			}
+			result.masterScope = scope;
 		} else if (arg === "--allow-home") {
 			result.allowHome = true;
 		} else if (arg === "--mode") {
@@ -371,6 +384,10 @@ export function parseArgs(args: string[], authority: ParseArgsAuthority = "local
 		}
 	}
 
+	if (result.masterScope !== undefined && result.master !== true) {
+		throw new CliParseError("--scope requires --master");
+	}
+	if (result.master === true && result.masterScope === undefined) result.masterScope = "repo";
 	if (result.default && !result.mpreset) {
 		throw new CliParseError("--default requires --mpreset <name>");
 	}

package/src/cli/fast-help.ts

@@ -79,6 +79,7 @@ Environment Variables:
 
   # Configuration
   GJC_CODING_AGENT_DIR       - Session storage directory (default: ~/${CONFIG_DIR_NAME}/agent)
+  GJC_UI_LANGUAGE            - Explicit first-use onboarding language (en, ko, zh, or ja); invalid values use English without prompting
   GJC_PACKAGE_DIR            - Override package directory (for Nix/Guix store paths)
   GJC_SMOL_MODEL              - Override smol/fast model (see --smol)
   GJC_SLOW_MODEL              - Override slow/reasoning model (see --slow)

package/src/cli/plugin-cli.ts

@@ -886,11 +886,40 @@ async function handleLink(manager: PluginManager, paths: string[], flags: { json
 	}
 }
 
+async function collectMarketplaceDoctorChecks(): Promise<
+	Array<{ name: string; status: "ok" | "warning" | "error"; message: string }>
+> {
+	const extra: Array<{ name: string; status: "ok" | "warning" | "error"; message: string }> = [];
+	try {
+		const mktMgr = await makeMarketplaceManager();
+		const installed = await mktMgr.listInstalledPlugins();
+		for (const summary of installed) {
+			for (const entry of summary.entries) {
+				let exists = false;
+				try {
+					const { statSync } = await import("node:fs");
+					statSync(entry.installPath);
+					exists = true;
+				} catch {}
+				if (!exists) {
+					extra.push({
+						name: `marketplace:${summary.id}:${entry.scope}`,
+						status: "error",
+						message: `Marketplace plugin "${summary.id}" (${entry.scope}) references missing cache dir "${entry.installPath}" (v${entry.version}); reinstall or upgrade the plugin`,
+					});
+				}
+			}
+		}
+	} catch {}
+	return extra;
+}
+
 async function handleDoctor(
 	manager: PluginManager,
 	flags: { json?: boolean; fix?: boolean; migratePlugins?: boolean },
 ): Promise<void> {
 	const checks = await manager.doctor({ fix: flags.fix });
+	checks.push(...(await collectMarketplaceDoctorChecks()));
 	try {
 		const statuses = flags.migratePlugins
 			? await runGjcPluginMigrationPreflight(getProjectDir())

package/src/cli/root-flags.ts

@@ -73,6 +73,11 @@ export const ROOT_LAUNCH_FLAGS = {
 		optionalValue: true,
 	}),
 	"no-title": Flags.boolean({ description: "Disable title auto-generation" }),
+	master: Flags.boolean({ description: "Launch an interactive master session" }),
+	scope: Flags.string({
+		description: "Master scope: repo (default), pwd, or global",
+		options: ["repo", "pwd", "global"],
+	}),
 };
 
 export type ConsumerLaunchFlagName = "hook" | "extension" | "no-extensions" | "no-skills" | "skills";