@gajae-code/coding-agent 0.16.0 → 0.16.3

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/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/update-cli.ts

@@ -1150,6 +1150,67 @@ function formatRegistryProvenance(version: string, registry: string | undefined)
 	return `Version ${version} was resolved from ${registry}; GitHub release assets may not exist for a version that was never published there.`;
 }
 
+interface ProcessReportWithLibc {
+	header?: {
+		glibcVersionRuntime?: unknown;
+	};
+}
+
+const GLIBC_VERSION_PATTERN = /^\d+\.\d+$/u;
+
+function reportedGlibcVersion(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const version = value.trim();
+	return GLIBC_VERSION_PATTERN.test(version) ? version : undefined;
+}
+
+function runtimeGlibcVersion(): string | undefined {
+	try {
+		const report = process.report?.getReport?.() as ProcessReportWithLibc | undefined;
+		return reportedGlibcVersion(report?.header?.glibcVersionRuntime);
+	} catch {
+		return undefined;
+	}
+}
+
+function hasMuslLoader(): boolean {
+	return (
+		fs.existsSync("/lib/ld-musl-x86_64.so.1") ||
+		fs.existsSync("/lib/ld-musl-aarch64.so.1") ||
+		fs.existsSync("/lib/ld-musl-armhf.so.1")
+	);
+}
+
+type LinuxLibc = "glibc" | "musl" | "unknown";
+
+function detectLinuxLibcFromSignals(glibcVersionRuntime: string | undefined, muslLoaderPresent: boolean): LinuxLibc {
+	if (reportedGlibcVersion(glibcVersionRuntime) !== undefined) return "glibc";
+	return muslLoaderPresent ? "musl" : "unknown";
+}
+
+function detectLinuxLibc(): LinuxLibc {
+	return detectLinuxLibcFromSignals(runtimeGlibcVersion(), hasMuslLoader());
+}
+
+function unsupportedLinuxLibcReason(libc: LinuxLibc): string | undefined {
+	if (libc === "glibc") return undefined;
+	return libc === "musl"
+		? "Unsupported libc: musl. Prebuilt Linux binaries are glibc-only. See docs/install.md"
+		: "Unable to verify an active glibc runtime. Prebuilt Linux binaries are glibc-only. See docs/install.md";
+}
+
+function assertSupportedLinuxLibc(libc: LinuxLibc): void {
+	const reason = unsupportedLinuxLibcReason(libc);
+	if (reason) throw new Error(formatUnsupportedTargetMessage(reason));
+}
+
+export function assertSupportedLinuxLibcForTest(
+	glibcVersionRuntime: string | undefined,
+	muslLoaderPresent: boolean,
+): void {
+	assertSupportedLinuxLibc(detectLinuxLibcFromSignals(glibcVersionRuntime, muslLoaderPresent));
+}
+
 /**
  * Download a release binary to a target path, replacing an existing file.
  */
@@ -1158,18 +1219,8 @@ async function updateViaBinaryAt(
 	expectedVersion: string,
 	registry?: string,
 ): Promise<InstalledVersionVerification> {
-	if (
-		process.platform === "linux" &&
-		(fs.existsSync("/lib/ld-musl-x86_64.so.1") ||
-			fs.existsSync("/lib/ld-musl-aarch64.so.1") ||
-			fs.existsSync("/lib/ld-musl-armhf.so.1"))
-	) {
-		throw new Error(
-			formatUnsupportedTargetMessage(
-				"Unsupported libc: musl. Prebuilt Linux binaries are glibc-only. See docs/install.md",
-			),
-		);
-	}
+	const linuxLibc = process.platform === "linux" ? detectLinuxLibc() : undefined;
+	if (linuxLibc !== undefined) assertSupportedLinuxLibc(linuxLibc);
 	const binaryName = getBinaryName();
 	const url = buildReleaseBinaryUrl(expectedVersion);
 	const registryNote = formatRegistryProvenance(expectedVersion, registry);

package/src/commands/sdk.ts

@@ -39,6 +39,7 @@ import {
 	SdkStartupRollbackTracker,
 } from "../sdk/startup-capability";
 import { runSdkServe } from "../sdk/transport/serve-cli";
+import { isSessionDisposalIncompleteError } from "../session/agent-session";
 import {
 	type CapturedSessionTranscriptSnapshot,
 	type ResumeSessionIdentity,
@@ -405,11 +406,13 @@ export async function runSessionHost(
 		sleep?: (ms: number) => Promise<void>;
 		cwd?: string;
 		processIncarnation?: (pid: number) => string | undefined;
+		applyStartupModelProfiles?: typeof applyStartupModelProfiles;
 	} = {},
 ): Promise<void> {
 	const now = timing.now ?? Date.now;
 	const sleep = timing.sleep ?? (async ms => await Bun.sleep(ms));
 	const readIncarnation = timing.processIncarnation ?? processIncarnation;
+	const applyModelProfiles = timing.applyStartupModelProfiles ?? applyStartupModelProfiles;
 	const request = readSessionLifecycleLaunchRequest(process.env.GJC_SDK_LIFECYCLE_REQUEST, now());
 	const agentDir = process.env.GJC_AGENT_DIR;
 	if (!agentDir) throw new Error("GJC_AGENT_DIR is required for sdk session-host-internal.");
@@ -599,22 +602,32 @@ export async function runSessionHost(
 		throw created.failure;
 	}
 	const { session, capability, rollback, startDeferredMemoryBackend } = created;
+	let lifecycleTranscriptPath: string | undefined;
+	session.registerToolSessionTransitionCleanup(async () => {
+		await session.sessionManager.ensureOnDisk();
+		lifecycleTranscriptPath = session.sessionManager.getSessionFile();
+	});
 	let sessionDisposal: Promise<void> | undefined;
 	const disposeSession = (): Promise<void> => {
-		sessionDisposal ??= session.dispose().catch(() => {});
+		sessionDisposal ??= (async () => {
+			try {
+				await session.dispose();
+			} catch (error) {
+				if (!isSessionDisposalIncompleteError(error)) throw error;
+				await session.awaitDisposeCompletion();
+			}
+		})();
 		return sessionDisposal;
 	};
 	let disposal: Promise<LifecycleTranscriptEvidence | undefined> | undefined;
 	const disposeAndCapture = (): Promise<LifecycleTranscriptEvidence | undefined> => {
 		disposal ??= (async () => {
 			await disposeSession();
+			if (!lifecycleTranscriptPath) return undefined;
 			try {
-				await session.sessionManager.ensureOnDisk();
-				const transcriptPath = session.sessionManager.getSessionFile();
-				if (!transcriptPath) return undefined;
 				const [bytes, stat] = await Promise.all([
-					fs.readFile(transcriptPath),
-					fs.stat(transcriptPath, { bigint: true }),
+					fs.readFile(lifecycleTranscriptPath),
+					fs.stat(lifecycleTranscriptPath, { bigint: true }),
 				]);
 				const digest = createHash("sha256").update(bytes).digest("hex");
 				return {
@@ -708,12 +721,14 @@ export async function runSessionHost(
 		const modelProfileStartup =
 			process.env.GJC_SDK_TEST_HANG_MODEL_PROFILE === cwd
 				? new Promise<void>(() => {})
-				: applyStartupModelProfiles({
+				: applyModelProfiles({
 						session,
 						settings: session.settings,
 						modelRegistry: session.modelRegistry,
 						parsedArgs: parsed,
 						startupThinkingLevel,
+						preferCachedModels: true,
+						preferCachedDefaultProfile: true,
 					});
 		await beforeCutoff(modelProfileStartup);
 		throwIfCutoff();

package/src/config/billing-path.ts

@@ -0,0 +1,42 @@
+/**
+ * Billing path for a resolved binding's credential source — audit-reversible.
+ * Derived from (model.api, credential-provenance) where the binding actually
+ * resolves credentials, not from a provider-name allowlist.
+ */
+import type { Api } from "@gajae-code/ai/core";
+import type { EffectiveProviderAuth } from "./provider-selection-policy";
+
+/**
+ * Label shown in the selector row + active-model line. Only the category is
+ * disclosed (never the key material or project id).
+ */
+export type BillingPathKind = "metered-api" | "cloud-project" | "bundled";
+
+export interface BillingPath {
+	kind: BillingPathKind;
+	/** Stable per-credential-source key for one-time notice dismissal. */
+	dismissKey: string;
+	label: string;
+}
+
+/**
+ * Derive from the concrete binding (api + credential provenance).
+ * - oauth/keyless/unknown => bundled (plan/proxied/kNoAuth-like)
+ * - key + cloud-project api (google-vertex / bedrock) => cloud-project
+ * - key + any other api (including custom OpenAI-compatible) => metered-api
+ */
+export function deriveBillingPath(
+	provider: string,
+	api: Api | string | undefined,
+	effectiveAuth: EffectiveProviderAuth,
+): BillingPath | undefined {
+	if (effectiveAuth === "oauth" || effectiveAuth === "keyless" || effectiveAuth === "unknown") return undefined;
+	if (effectiveAuth !== "key") return undefined;
+	const apiKind = typeof api === "string" ? api : undefined;
+	const cloudApis = new Set(["google-vertex", "bedrock-converse-stream"]);
+	const isCloud = apiKind ? cloudApis.has(apiKind) : false;
+	const kind: BillingPathKind = isCloud ? "cloud-project" : "metered-api";
+	const label = kind === "cloud-project" ? "cloud-project billing" : "metered API";
+	const dismissKey = `${kind}:${provider.trim().toLowerCase()}`;
+	return { kind, dismissKey, label };
+}

package/src/config/config-schema-version.ts

@@ -7,4 +7,21 @@
  * this dependency-light module so the resolver can import it without pulling in
  * the TUI/AI-heavy settings schema.
  */
-export const CONFIG_SCHEMA_VERSION = 1;
+export const CONFIG_SCHEMA_VERSION = 2;
+
+/**
+ * Normalize a durable `configSchemaVersion` marker into a comparable version.
+ *
+ * Every version decision (future-schema detection, migration-pending state, and
+ * the ordered migration registry) must read the SAME normalized value: a
+ * malformed marker read as a future schema by one guard and as unmigrated by
+ * the next would skip legacy migrations while still re-running v0 transforms.
+ * A finite malformed value floors to the nearest completed version; a
+ * non-finite or non-numeric one carries no version information and normalizes
+ * to 0 (fully unmigrated). `undefined` stays `undefined` (no marker written).
+ */
+export function normalizeConfigSchemaVersion(value: unknown): number | undefined {
+	if (value === undefined) return undefined;
+	if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+	return Math.max(0, Math.floor(value));
+}