@gajae-code/coding-agent 0.12.7 → 0.12.10

package/src/commands/sdk.ts

@@ -9,6 +9,7 @@ import { applyStartupModelProfiles, createSessionManager } from "../main";
 import { initializeExtensions } from "../modes/runtime-init";
 import { ACP_MCP_REQUEST_TIMEOUT_MS, ACP_MCP_STARTUP_HEADROOM_MS } from "../sdk/acp/mcp";
 import { Broker } from "../sdk/broker/broker";
+import { readBrokerDiscovery } from "../sdk/broker/discovery";
 import { completeBrokerProcess } from "../sdk/broker/internal";
 import {
 	type LifecycleTranscriptEvidence,
@@ -58,6 +59,54 @@ export async function lifecycleArgs(
 	};
 }
 
+/**
+ * How long a session host tolerates the complete absence of a live broker
+ * publication before treating itself as orphaned. Hosts intentionally survive
+ * broker restarts (a replacement broker republishes discovery within seconds),
+ * so this must comfortably exceed a restart window while still bounding the
+ * lifetime of hosts whose broker is gone for good — otherwise every crashed or
+ * torn-down broker leaks a detached multi-hundred-megabyte host forever.
+ */
+export const SESSION_HOST_BROKER_ABSENCE_GRACE_MS = 10 * 60_000;
+const SESSION_HOST_BROKER_POLL_MS = 15_000;
+
+/**
+ * Resolves only once no live broker publication has been observable in
+ * `agentDir` for the full grace window. A reappearing broker (including a
+ * replacement with a different pid) resets the window; an unreadable
+ * publication is not proof of orphanhood but accrues against the same bound.
+ */
+export async function watchSessionHostBrokerLiveness(deps: {
+	agentDir: string;
+	now?: () => number;
+	sleep?: (ms: number) => Promise<void>;
+	readDiscovery?: (agentDir: string) => Promise<unknown>;
+	graceMs?: number;
+	pollMs?: number;
+}): Promise<void> {
+	const now = deps.now ?? Date.now;
+	const sleep = deps.sleep ?? (async ms => await Bun.sleep(ms));
+	const readDiscovery = deps.readDiscovery ?? readBrokerDiscovery;
+	const graceMs = deps.graceMs ?? SESSION_HOST_BROKER_ABSENCE_GRACE_MS;
+	const pollMs = deps.pollMs ?? SESSION_HOST_BROKER_POLL_MS;
+	let absentSince: number | null = null;
+	for (;;) {
+		let live: unknown = null;
+		try {
+			live = await readDiscovery(deps.agentDir);
+		} catch {
+			// Transient read failures are ambiguity, not proof of orphanhood.
+		}
+		if (live) {
+			absentSince = null;
+		} else {
+			absentSince ??= now();
+			if (now() - absentSince >= graceMs) return;
+		}
+		await sleep(pollMs);
+	}
+}
+
 type LifecycleTranscriptSource = {
 	cwd: string;
 	path: string;
@@ -505,6 +554,11 @@ export async function runSessionHost(
 	}
 	process.once("SIGTERM", stop);
 	process.once("SIGINT", stop);
+	// A detached host whose broker is gone for good would otherwise live (and
+	// hold its session's memory) forever; reap it through the same graceful
+	// teardown a SIGTERM would take once the bounded absence grace elapses.
+	await watchSessionHostBrokerLiveness({ agentDir });
+	stop();
 	await new Promise<void>(() => {});
 }
 

package/src/config/file-lock.ts

@@ -17,6 +17,10 @@ const DEFAULT_OPTIONS: Required<FileLockOptions> = {
 
 type LockInfo = FileLockOwnerToken;
 
+export const FileLockTestHooks: {
+	afterParentMkdir?: (lockPath: string) => void | Promise<void>;
+} = {};
+
 /**
  * Returns the OS-provided process start timestamp for PID-reuse detection.
  * `ps` is available on the supported Unix hosts (macOS and Linux), unlike
@@ -237,6 +241,8 @@ async function removeStaleLockForAcquire(lockPath: string, snapshot: LockStaleSn
 
 async function tryAcquireLock(lockPath: string): Promise<LockInfo | null> {
 	await fs.mkdir(path.dirname(lockPath), { recursive: true });
+	const afterParentMkdir = FileLockTestHooks.afterParentMkdir;
+	if (afterParentMkdir) await afterParentMkdir(lockPath);
 	try {
 		await fs.mkdir(lockPath);
 		return await writeLockInfo(lockPath);

package/src/config/model-discovery-manager.ts

@@ -37,6 +37,8 @@ export interface DiscoveryMergeInput {
 	models: readonly Model<Api>[];
 	state: ProviderDiscoveryState;
 	warning?: string;
+	authGeneration?: string;
+	fetched?: boolean;
 }
 
 export interface ProviderDiscoveryCallbacks<TProvider extends DiscoveryProvider> {
@@ -44,7 +46,9 @@ export interface ProviderDiscoveryCallbacks<TProvider extends DiscoveryProvider>
 	requiresAuth: (provider: TProvider) => boolean;
 	peekApiKey: (provider: TProvider) => Promise<string | undefined>;
 	isAuthenticated: (apiKey: string | undefined) => boolean;
-	fetchModels: (provider: TProvider) => Promise<Model<Api>[]>;
+	fetchModels: (provider: TProvider, apiKey: string | undefined) => Promise<Model<Api>[]>;
+	getEvidenceGeneration?: (provider: TProvider) => string;
+	canPublishCache?: (provider: TProvider) => boolean;
 }
 
 /** Owns configured discovery inputs, status, cache lifecycle, and refresh generations. */
@@ -89,6 +93,11 @@ export class ModelDiscoveryManager<TProvider extends DiscoveryProvider> {
 		const state = this.#states.get(provider);
 		return state === undefined ? undefined : this.#snapshot(state);
 	}
+	invalidate(provider: string): void {
+		this.#invalidate(provider);
+		this.#states.delete(provider);
+		this.#lastWarnings.delete(provider);
+	}
 
 	loadCached(provider: TProvider, cacheDbPath?: string): readonly Model<Api>[] {
 		const cache = readModelCache<Api>(provider.provider, 24 * 60 * 60 * 1000, Date.now, cacheDbPath);
@@ -133,9 +142,21 @@ export class ModelDiscoveryManager<TProvider extends DiscoveryProvider> {
 				models: models.map(model => model.id),
 			});
 
+		let authGeneration = callbacks.getEvidenceGeneration?.(provider);
+		let apiKey: string | undefined;
 		if (callbacks.requiresAuth(provider)) {
-			const apiKey = await callbacks.peekApiKey(provider);
+			apiKey = await callbacks.peekApiKey(provider);
+			const resolvedGeneration = callbacks.getEvidenceGeneration?.(provider);
 			if (!this.isCurrent(token)) return this.#stale(token);
+			if (authGeneration !== resolvedGeneration) {
+				authGeneration = resolvedGeneration;
+				// Resolving a command-backed key can update the evidence generation. Keep
+				// the key resolved for this refresh so round-robin selection cannot switch
+				// credentials between the request and its published evidence.
+				if (!this.isCurrent(token) || authGeneration !== callbacks.getEvidenceGeneration?.(provider)) {
+					return this.#stale(token);
+				}
+			}
 			if (!callbacks.isAuthenticated(apiKey)) return unauthenticated(cachedModels);
 		}
 
@@ -145,10 +166,14 @@ export class ModelDiscoveryManager<TProvider extends DiscoveryProvider> {
 			staticModels: [],
 			cacheDbPath: callbacks.cacheDbPath,
 			cacheTtlMs: 24 * 60 * 60 * 1000,
-			canPublishCache: () => this.isCurrent(token),
+			canPublishCache: () =>
+				this.isCurrent(token) &&
+				(callbacks.getEvidenceGeneration === undefined ||
+					callbacks.getEvidenceGeneration(provider) === authGeneration) &&
+				(callbacks.canPublishCache?.(provider) ?? true),
 			fetchDynamicModels: async () => {
 				try {
-					return await callbacks.fetchModels(provider);
+					return await callbacks.fetchModels(provider, apiKey);
 				} catch (cause) {
 					error = cause instanceof Error ? cause.message : String(cause);
 					return null;
@@ -156,7 +181,11 @@ export class ModelDiscoveryManager<TProvider extends DiscoveryProvider> {
 			},
 		});
 		const result = await manager.refresh(strategy);
-		if (!this.isCurrent(token)) return this.#stale(token);
+		if (
+			!this.isCurrent(token) ||
+			(callbacks.getEvidenceGeneration !== undefined && callbacks.getEvidenceGeneration(provider) !== authGeneration)
+		)
+			return this.#stale(token);
 		const status: ProviderDiscoveryStatus = error
 			? result.models.length > 0
 				? "cached"
@@ -166,7 +195,9 @@ export class ModelDiscoveryManager<TProvider extends DiscoveryProvider> {
 					? "cached"
 					: "idle"
 				: result.models.length > 0
-					? "ok"
+					? result.stale
+						? "cached"
+						: "ok"
 					: "empty";
 		const state: ProviderDiscoveryState = {
 			provider: provider.provider,
@@ -177,7 +208,7 @@ export class ModelDiscoveryManager<TProvider extends DiscoveryProvider> {
 			models: result.models.map(model => model.id),
 			error,
 		};
-		return this.#complete(token, result.models, state, error);
+		return this.#complete(token, result.models, state, error, authGeneration, result.fetched);
 	}
 
 	#complete(
@@ -185,6 +216,8 @@ export class ModelDiscoveryManager<TProvider extends DiscoveryProvider> {
 		models: readonly Model<Api>[],
 		state: ProviderDiscoveryState,
 		error?: string,
+		authGeneration?: string,
+		fetched?: boolean,
 	): DiscoveryMergeInput {
 		const current = this.isCurrent(token);
 		if (current) this.#states.set(token.provider, this.#snapshot(state));
@@ -193,7 +226,16 @@ export class ModelDiscoveryManager<TProvider extends DiscoveryProvider> {
 			if (error) this.#lastWarnings.set(token.provider, error);
 			else this.#lastWarnings.delete(token.provider);
 		}
-		return this.#snapshot({ provider: token.provider, token, current, models, state, warning });
+		return this.#snapshot({
+			provider: token.provider,
+			token,
+			current,
+			models,
+			state,
+			warning,
+			authGeneration,
+			fetched,
+		});
 	}
 
 	#stale(token: DiscoveryRefreshToken): DiscoveryMergeInput {

package/src/config/model-profiles.ts

@@ -291,6 +291,13 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 		architect: "alibaba-token-plan/qwen3.8-max-preview:xhigh",
 		critic: "alibaba-token-plan/glm-5.2:high",
 	}),
+	profile("alibaba-token-plan-pro", ["alibaba-token-plan"], {
+		default: "alibaba-token-plan/qwen3.8-max-preview:medium",
+		executor: "alibaba-token-plan/deepseek-v4-flash-0731:max",
+		planner: "alibaba-token-plan/glm-5.2:high",
+		architect: "alibaba-token-plan/qwen3.8-max-preview:xhigh",
+		critic: "alibaba-token-plan/glm-5.2:xhigh",
+	}),
 	profile("alibaba-token-plan-qwenmaxxing", ["alibaba-token-plan"], {
 		default: "alibaba-token-plan/qwen3.8-max-preview:medium",
 		executor: "alibaba-token-plan/qwen3.8-max-preview:low",
@@ -361,6 +368,7 @@ const PROFILE_PRESENTATION: Record<string, ModelProfilePresentation> = {
 	"minimax-medium": { displayName: "MiniMax Medium", providerGroup: "MINIMAX" },
 	"minimax-pro": { displayName: "MiniMax Pro", providerGroup: "MINIMAX" },
 	"alibaba-token-plan-balanced": { displayName: "Balanced", providerGroup: "ALIBABA TOKEN PLAN" },
+	"alibaba-token-plan-pro": { displayName: "Pro", providerGroup: "ALIBABA TOKEN PLAN" },
 	"alibaba-token-plan-qwenmaxxing": { displayName: "QwenMaxxing", providerGroup: "ALIBABA TOKEN PLAN" },
 	"opus-codex": { displayName: "Opus + Codex", providerGroup: "COMBOS" },
 	"codex-opencodego": { displayName: "Codex + OpenCodeGo", providerGroup: "COMBOS" },