@gajae-code/coding-agent 0.12.11 → 0.12.13

package/src/config/file-lock-gc.ts

@@ -13,13 +13,15 @@ import type {
 	GcPruneOutcome,
 	GcRecord,
 	GcStoreAdapter,
+	GcWarning,
 } from "../gjc-runtime/gc-runtime";
 import { gcPidStatusLabel } from "../gjc-runtime/gc-runtime";
 import { resolveReceiptSpoolDir } from "../harness-control-plane/receipt-spool";
 import { readFileLockInfoForGc, removeFileLockDirForGc } from "./file-lock";
 
 const MAX_WALK_DEPTH = 6;
-const MAX_WALK_ENTRIES = 20_000;
+/** Default per-root walk budget. Truncation is a warning, not a hard error. */
+export const FILE_LOCK_GC_MAX_WALK_ENTRIES = 20_000;
 
 // High-cardinality, lock-free subtrees we never descend into. `.lock` dirs are
 // created next to config files, never inside these.
@@ -30,6 +32,11 @@ interface WalkState {
 	truncated: boolean;
 }
 
+export interface FileLocksGcCollectOptions {
+	/** Override per-root entry budget (tests). Defaults to {@link FILE_LOCK_GC_MAX_WALK_ENTRIES}. */
+	maxWalkEntries?: number;
+}
+
 // Global, env-aware GJC lock roots. Per the approved scope this covers the
 // user config root, the agent dir (honors GJC_CODING_AGENT_DIR), and the
 // configured receipt-spool dir — NOT the invocation cwd's project `.gjc`.
@@ -61,6 +68,21 @@ function keptMalformedRecord(lockDir: string): GcRecord {
 async function collectLockRecord(lockDir: string, ctx: GcContext): Promise<GcRecord> {
 	const info = await readFileLockInfoForGc(lockDir);
 	if (!info) return keptMalformedRecord(lockDir);
+	if (info.owner_host_id !== undefined) {
+		return {
+			store: "file_locks",
+			id: lockDir,
+			path: lockDir,
+			pid: info.pid,
+			pid_status: "unknown",
+			status: "host_qualified",
+			stale: false,
+			removable: false,
+			action: "none",
+			reason: "host_qualified_lock_requires_owner_reclamation",
+			detail: `timestamp=${info.timestamp}`,
+		};
+	}
 
 	const probeResult = ctx.probe(info.pid);
 	const pidStatus = gcPidStatusLabel(probeResult);
@@ -87,8 +109,9 @@ async function walkForLockDirs(
 	state: WalkState,
 	lockDirs: Set<string>,
 	errors: GcError[],
+	maxWalkEntries: number,
 ): Promise<void> {
-	if (state.entries >= MAX_WALK_ENTRIES) {
+	if (state.entries >= maxWalkEntries) {
 		state.truncated = true;
 		return;
 	}
@@ -122,50 +145,66 @@ async function walkForLockDirs(
 	}
 
 	for (const entry of entries) {
-		if (state.entries >= MAX_WALK_ENTRIES) {
+		if (state.entries >= maxWalkEntries) {
 			state.truncated = true;
 			return;
 		}
 		if (PRUNED_DIR_NAMES.has(entry)) continue;
-		await walkForLockDirs(path.join(dir, entry), depth + 1, state, lockDirs, errors);
+		await walkForLockDirs(path.join(dir, entry), depth + 1, state, lockDirs, errors, maxWalkEntries);
 	}
 }
 
-export const fileLocksGcAdapter: GcStoreAdapter = {
-	store: "file_locks",
-	async collect(ctx: GcContext): Promise<GcCollectResult> {
-		const records: GcRecord[] = [];
-		const errors: GcError[] = [];
-		const lockDirs = new Set<string>();
+/**
+ * Discover + classify file-lock records. Each known lock root gets its own walk
+ * budget so truncating one root never skips the others. Caps surface as
+ * warnings (partial results), not hard discovery errors.
+ */
+export async function collectFileLocksForGc(
+	ctx: GcContext,
+	options: FileLocksGcCollectOptions = {},
+): Promise<GcCollectResult> {
+	const maxWalkEntries = options.maxWalkEntries ?? FILE_LOCK_GC_MAX_WALK_ENTRIES;
+	const records: GcRecord[] = [];
+	const errors: GcError[] = [];
+	const warnings: GcWarning[] = [];
+	const lockDirs = new Set<string>();
+
+	for (const root of knownFileLockRoots(ctx)) {
+		// Fresh budget per root so a huge agent dir cannot starve config/spool.
 		const state: WalkState = { entries: 0, truncated: false };
-
-		for (const root of knownFileLockRoots(ctx)) {
-			await walkForLockDirs(root, 0, state, lockDirs, errors);
-			if (state.truncated) break;
-		}
-
+		await walkForLockDirs(root, 0, state, lockDirs, errors, maxWalkEntries);
 		if (state.truncated) {
-			errors.push({
+			warnings.push({
 				store: "file_locks",
-				scope: "discovery",
-				message: `file lock discovery capped at ${MAX_WALK_ENTRIES} entries`,
+				scope: root,
+				message: `file lock discovery capped at ${maxWalkEntries} entries for root ${root} (scanned ${state.entries})`,
 			});
 		}
+	}
 
-		for (const lockDir of lockDirs) {
-			try {
-				records.push(await collectLockRecord(lockDir, ctx));
-			} catch (error) {
-				errors.push({ store: "file_locks", scope: lockDir, message: errorMessage(error) });
-			}
+	for (const lockDir of lockDirs) {
+		try {
+			records.push(await collectLockRecord(lockDir, ctx));
+		} catch (error) {
+			errors.push({ store: "file_locks", scope: lockDir, message: errorMessage(error) });
 		}
+	}
 
-		return { records, errors };
+	return { records, errors, warnings };
+}
+
+export const fileLocksGcAdapter: GcStoreAdapter = {
+	store: "file_locks",
+	async collect(ctx: GcContext): Promise<GcCollectResult> {
+		return collectFileLocksForGc(ctx);
 	},
 	async prune(record: GcRecord, ctx: GcContext): Promise<GcPruneOutcome> {
 		const lockDir = record.path ?? record.id;
 		const info = await readFileLockInfoForGc(lockDir);
 		if (!info) return { removed: false, skipped: "lock_no_longer_dead_or_missing" };
+		if (info.owner_host_id !== undefined) {
+			return { removed: false, skipped: "host_qualified_lock_requires_owner_reclamation" };
+		}
 
 		const probeResult = ctx.probe(info.pid);
 		if (probeResult.status !== "dead") {

package/src/config/file-lock.ts

@@ -1,3 +1,4 @@
+import * as crypto from "node:crypto";
 import type { Stats } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
@@ -7,9 +8,11 @@ export interface FileLockOptions {
 	staleMs?: number;
 	retries?: number;
 	retryDelayMs?: number;
+	/** Stable host identity required to safely reclaim locks on a shared volume. */
+	ownerHostId?: string;
 }
 
-const DEFAULT_OPTIONS: Required<FileLockOptions> = {
+const DEFAULT_OPTIONS: Required<Omit<FileLockOptions, "ownerHostId">> = {
 	staleMs: 10_000,
 	retries: 50,
 	retryDelayMs: 100,
@@ -61,8 +64,16 @@ function ownerIsAlive(owner: FileLockOwnerToken, startTimeCache?: Map<string, st
 	return currentStartTime === null || currentStartTime === owner.start_time;
 }
 
-function writeLockInfo(lockPath: string): Promise<LockInfo> {
-	const info: LockInfo = { pid: process.pid, start_time: currentProcessStartTime(), timestamp: Date.now() };
+function lockInfo(ownerHostId?: string): LockInfo {
+	return {
+		pid: process.pid,
+		start_time: currentProcessStartTime(),
+		timestamp: Date.now(),
+		...(ownerHostId === undefined ? {} : { owner_host_id: ownerHostId }),
+	};
+}
+
+function writeLockInfo(lockPath: string, info: LockInfo): Promise<LockInfo> {
 	return Bun.write(`${lockPath}/info`, JSON.stringify(info)).then(() => info);
 }
 
@@ -76,17 +87,18 @@ async function readLockInfo(lockPath: string): Promise<LockInfo | null> {
 	}
 
 	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
-	const { pid, start_time, timestamp } = parsed as Partial<LockInfo>;
+	const { pid, start_time, timestamp, owner_host_id } = parsed as Partial<LockInfo>;
 	if (
 		typeof pid !== "number" ||
 		!Number.isInteger(pid) ||
 		pid <= 0 ||
 		typeof timestamp !== "number" ||
 		!Number.isFinite(timestamp) ||
-		(start_time !== undefined && (typeof start_time !== "string" || !start_time))
+		(start_time !== undefined && (typeof start_time !== "string" || !start_time)) ||
+		(owner_host_id !== undefined && (typeof owner_host_id !== "string" || !owner_host_id))
 	)
 		return null;
-	return { pid, start_time, timestamp };
+	return { pid, start_time, timestamp, owner_host_id };
 }
 
 /** @internal */
@@ -98,7 +110,7 @@ export async function readFileLockInfoForGc(lockDir: string): Promise<FileLockOw
 export interface FileLockOwnerToken {
 	pid: number;
 	start_time?: string;
-
+	owner_host_id?: string;
 	timestamp: number;
 }
 
@@ -147,6 +159,7 @@ export async function removeFileLockDirForGc(
 	if (
 		current.pid !== expected.pid ||
 		(expected.start_time !== undefined && current.start_time !== expected.start_time) ||
+		current.owner_host_id !== expected.owner_host_id ||
 		current.timestamp !== expected.timestamp
 	) {
 		return "owner_changed";
@@ -187,6 +200,7 @@ function sameStatToken(a: LockDirStatToken, b: LockDirStatToken): boolean {
 async function staleLockSnapshot(
 	lockPath: string,
 	staleMs: number,
+	ownerHostId?: string,
 	startTimeCache?: Map<string, string | null>,
 ): Promise<LockStaleSnapshot> {
 	let info: LockInfo | null;
@@ -199,6 +213,7 @@ async function staleLockSnapshot(
 		if (hasFsCode(error, "EPERM")) return { stale: false };
 		throw error;
 	}
+	if (!info && ownerHostId !== undefined) return { stale: false };
 	if (!info) {
 		try {
 			const stats = await fs.stat(lockPath);
@@ -210,6 +225,10 @@ async function staleLockSnapshot(
 		}
 	}
 
+	// A host-qualified lock may only be reclaimed after proving that its owner is
+	// local. Foreign and malformed host-qualified records fail closed: PID values
+	// and clocks are not meaningful across hosts.
+	if (ownerHostId !== undefined && info.owner_host_id !== ownerHostId) return { stale: false };
 	// Never reap a live owner by elapsed time: a long legitimate critical section must
 	// not have its lock stolen (#652). Reclaim a dead owner immediately. Only when owner
 	// liveness is indeterminate do we fall back to the staleMs elapsed-time heuristic.
@@ -239,18 +258,43 @@ async function removeStaleLockForAcquire(lockPath: string, snapshot: LockStaleSn
 	}
 }
 
-async function tryAcquireLock(lockPath: string): Promise<LockInfo | null> {
+async function tryAcquireLock(lockPath: string, ownerHostId?: string): Promise<LockInfo | null> {
 	await fs.mkdir(path.dirname(lockPath), { recursive: true });
 	const afterParentMkdir = FileLockTestHooks.afterParentMkdir;
 	if (afterParentMkdir) await afterParentMkdir(lockPath);
+	if (ownerHostId === undefined) {
+		try {
+			await fs.mkdir(lockPath);
+			return await writeLockInfo(lockPath, lockInfo());
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code === "EEXIST") return null;
+			throw error;
+		}
+	}
+
+	const pendingPath = `${lockPath}.pending.${process.pid}.${crypto.randomUUID()}`;
+	const owner = lockInfo(ownerHostId);
 	try {
-		await fs.mkdir(lockPath);
-		return await writeLockInfo(lockPath);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "EEXIST") {
-			return null;
+		await fs.mkdir(pendingPath);
+		await writeLockInfo(pendingPath, owner);
+		try {
+			await fs.rename(pendingPath, lockPath);
+			return owner;
+		} catch (error) {
+			const code = (error as NodeJS.ErrnoException).code;
+			if (code === "EEXIST" || code === "ENOTEMPTY") return null;
+			if (code === "EPERM") {
+				try {
+					await fs.stat(lockPath);
+					return null;
+				} catch (statError) {
+					if (!isEnoent(statError)) throw statError;
+				}
+			}
+			throw error;
 		}
-		throw error;
+	} finally {
+		await fs.rm(pendingPath, { recursive: true, force: true }).catch(() => undefined);
 	}
 }
 
@@ -259,14 +303,15 @@ async function releaseLock(lockPath: string, owner: FileLockOwnerToken): Promise
 	if (outcome !== "removed") throw new Error(`Failed to release file lock: ${outcome}.`);
 }
 async function acquireLock(filePath: string, options: FileLockOptions = {}): Promise<() => Promise<void>> {
+	if (options.ownerHostId !== undefined && !options.ownerHostId) throw new Error("ownerHostId must be non-empty");
 	const opts = { ...DEFAULT_OPTIONS, ...options };
 	const lockPath = getLockPath(filePath);
 	const contentionStartTimes = new Map<string, string | null>();
 	for (let attempt = 0; attempt < opts.retries; attempt++) {
-		const owner = await tryAcquireLock(lockPath);
+		const owner = await tryAcquireLock(lockPath, opts.ownerHostId);
 		if (owner) return () => releaseLock(lockPath, owner);
 
-		const stale = await staleLockSnapshot(lockPath, opts.staleMs, contentionStartTimes);
+		const stale = await staleLockSnapshot(lockPath, opts.staleMs, opts.ownerHostId, contentionStartTimes);
 		if (await removeStaleLockForAcquire(lockPath, stale)) continue;
 		await Bun.sleep(opts.retryDelayMs);
 	}

package/src/config/model-profiles.ts

@@ -243,46 +243,46 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 		architect: "grok-build/grok-build",
 	}),
 	profile("cursor-eco", ["cursor"], {
-		default: "cursor/composer-1.5:low",
-		executor: "cursor/composer-1.5:minimal",
-		planner: "cursor/composer-1.5:low",
-		critic: "cursor/composer-1.5:medium",
-		architect: "cursor/composer-1.5:high",
+		default: "cursor/composer-2.5",
+		executor: "cursor/composer-2.5",
+		planner: "cursor/composer-2.5",
+		critic: "cursor/composer-2.5",
+		architect: "cursor/composer-2.5",
 	}),
 	profile("cursor-medium", ["cursor"], {
-		default: "cursor/composer-1.5:medium",
-		executor: "cursor/composer-1.5:low",
-		planner: "cursor/composer-1.5:medium",
-		critic: "cursor/composer-1.5:high",
-		architect: "cursor/composer-1.5:xhigh",
+		default: "cursor/composer-2.5",
+		executor: "cursor/composer-2.5-fast",
+		planner: "cursor/composer-2.5",
+		critic: "cursor/composer-2.5-fast",
+		architect: "cursor/composer-2.5-fast",
 	}),
 	profile("cursor-pro", ["cursor"], {
-		default: "cursor/composer-1.5:xhigh",
-		executor: "cursor/composer-1.5:medium",
-		planner: "cursor/composer-1.5:high",
-		critic: "cursor/composer-1.5:xhigh",
-		architect: "cursor/composer-1.5:xhigh",
+		default: "cursor/composer-2.5-fast",
+		executor: "cursor/composer-2.5-fast",
+		planner: "cursor/composer-2.5-fast",
+		critic: "cursor/composer-2.5-fast",
+		architect: "cursor/composer-2.5-fast",
 	}),
 	profile("minimax-eco", ["minimax-code"], {
-		default: "minimax-code/minimax-m3:low",
-		executor: "minimax-code/minimax-m3:minimal",
-		planner: "minimax-code/minimax-m3:low",
-		critic: "minimax-code/minimax-m3:medium",
-		architect: "minimax-code/minimax-m3:high",
+		default: "minimax-code/MiniMax-M3:low",
+		executor: "minimax-code/MiniMax-M3:minimal",
+		planner: "minimax-code/MiniMax-M3:low",
+		critic: "minimax-code/MiniMax-M3:medium",
+		architect: "minimax-code/MiniMax-M3:high",
 	}),
 	profile("minimax-medium", ["minimax-code"], {
-		default: "minimax-code/minimax-m3:medium",
-		executor: "minimax-code/minimax-m3:low",
-		planner: "minimax-code/minimax-m3:medium",
-		critic: "minimax-code/minimax-m3:high",
-		architect: "minimax-code/minimax-m3:xhigh",
+		default: "minimax-code/MiniMax-M3:medium",
+		executor: "minimax-code/MiniMax-M3:low",
+		planner: "minimax-code/MiniMax-M3:medium",
+		critic: "minimax-code/MiniMax-M3:high",
+		architect: "minimax-code/MiniMax-M3:xhigh",
 	}),
 	profile("minimax-pro", ["minimax-code"], {
-		default: "minimax-code/minimax-m3:xhigh",
-		executor: "minimax-code/minimax-m3:medium",
-		planner: "minimax-code/minimax-m3:high",
-		critic: "minimax-code/minimax-m3:xhigh",
-		architect: "minimax-code/minimax-m3:xhigh",
+		default: "minimax-code/MiniMax-M3:xhigh",
+		executor: "minimax-code/MiniMax-M3:medium",
+		planner: "minimax-code/MiniMax-M3:high",
+		critic: "minimax-code/MiniMax-M3:xhigh",
+		architect: "minimax-code/MiniMax-M3:xhigh",
 	}),
 	profile("alibaba-token-plan-balanced", ["alibaba-token-plan"], {
 		default: "alibaba-token-plan/qwen3.8-max-preview:medium",
@@ -305,6 +305,20 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 		architect: "alibaba-token-plan/qwen3.8-max-preview:xhigh",
 		critic: "alibaba-token-plan/qwen3.8-max-preview:xhigh",
 	}),
+	profile("alibaba-token-plan-qwen-deepseek", ["alibaba-token-plan"], {
+		default: "alibaba-token-plan/qwen3.8-max:high",
+		executor: "alibaba-token-plan/deepseek-v4-flash-0731:high",
+		planner: "alibaba-token-plan/deepseek-v4-flash-0731:max",
+		architect: "alibaba-token-plan/qwen3.8-max:xhigh",
+		critic: "alibaba-token-plan/qwen3.8-max:xhigh",
+	}),
+	profile("alibaba-token-plan-glm-deepseek", ["alibaba-token-plan"], {
+		default: "alibaba-token-plan/glm-5.2:high",
+		executor: "alibaba-token-plan/deepseek-v4-flash-0731:high",
+		planner: "alibaba-token-plan/deepseek-v4-flash-0731:max",
+		architect: "alibaba-token-plan/glm-5.2:xhigh",
+		critic: "alibaba-token-plan/glm-5.2:xhigh",
+	}),
 	profile("opus-codex", ["anthropic", "openai-codex"], {
 		default: "anthropic/claude-opus-5:xhigh",
 		executor: "openai-codex/gpt-5.6-terra:low",
@@ -370,6 +384,8 @@ const PROFILE_PRESENTATION: Record<string, ModelProfilePresentation> = {
 	"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" },
+	"alibaba-token-plan-qwen-deepseek": { displayName: "Qwen + DeepSeek", providerGroup: "ALIBABA TOKEN PLAN" },
+	"alibaba-token-plan-glm-deepseek": { displayName: "GLM + DeepSeek", providerGroup: "ALIBABA TOKEN PLAN" },
 	"opus-codex": { displayName: "Opus + Codex", providerGroup: "COMBOS" },
 	"codex-opencodego": { displayName: "Codex + OpenCodeGo", providerGroup: "COMBOS" },
 	"fable-opus-codex": { displayName: "Fable + Opus + Codex", providerGroup: "COMBOS" },

package/src/config/model-registry.ts

@@ -926,12 +926,24 @@ const customReferenceMap = buildCustomReferenceMap();
 
 function getCustomReferenceCandidateIds(modelId: string): string[] {
 	const candidates = new Set<string>();
-	const minimaxM = /^minimax-m(\d+(?:\.\d+)*)$/i.exec(modelId.trim());
-	const queue = minimaxM ? [`MiniMax-M${minimaxM[1]}`, modelId] : [modelId];
+	const trimmedId = modelId.trim();
+	const minimaxM = /^minimax-m(\d+(?:\.\d+)*)$/i.exec(trimmedId);
+	const queue = minimaxM ? [`MiniMax-M${minimaxM[1]}`, trimmedId] : [trimmedId];
 	if (minimaxM) {
-		// MiniMax catalogs include lowercase wire ids plus display-cased aliases.
-		// Custom providers should keep the lowercase wire id while inheriting the
-		// canonical display casing when the alias exists.
+		// First-class MiniMax catalogs expose canonical `MiniMax-M*` ids only,
+		// but custom providers may still use lowercase wire ids. Normalize to
+		// the canonical display casing so metadata inheritance keeps working.
+	}
+	// Namespaced wire IDs (e.g. `cline-pass/deepseek-v4-flash`) keep the full id for
+	// the API request, but should still try the leaf segment against bundled
+	// references so capability metadata is not silently replaced by 128K/16K defaults.
+	// Only an exact leaf match in the reference map inherits; unknown leaves stay defaulted.
+	const slashIndex = trimmedId.lastIndexOf("/");
+	if (slashIndex >= 0 && slashIndex < trimmedId.length - 1) {
+		const leafId = trimmedId.slice(slashIndex + 1).trim();
+		if (leafId && leafId !== trimmedId) {
+			queue.push(leafId);
+		}
 	}
 	for (let index = 0; index < queue.length; index += 1) {
 		const candidate = queue[index]?.trim();

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

@@ -20,7 +20,7 @@ const ReasoningEffortMapSchema = z.object({
 	max: z.string().optional(),
 });
 
-export const OpenAICompatSchema = z.object({
+export const ModelCompatSchema = z.object({
 	supportsStore: z.boolean().optional(),
 	supportsDeveloperRole: z.boolean().optional(),
 	sendSessionHeaders: z.boolean().optional(),
@@ -48,8 +48,13 @@ export const OpenAICompatSchema = z.object({
 	extraBody: z.record(z.string(), z.unknown()).optional(),
 	supportsStrictMode: z.boolean().optional(),
 	toolStrictMode: z.enum(["all_strict", "none"]).optional(),
+	supportsLongCacheRetention: z.boolean().optional(),
+	promptCacheMode: z.enum(["none", "explicit", "automatic"]).optional(),
 });
 
+// Backward-compatible export for callers that imported the original schema name.
+export const OpenAICompatSchema = ModelCompatSchema;
+
 export const GJC_MODEL_EFFORT_IDS = ["minimal", "low", "medium", "high", "xhigh", "max"] as const;
 export const GJC_MODEL_ASSIGNMENT_TARGET_IDS = ["default", "executor", "architect", "planner", "critic"] as const;
 export const EffortSchema = z.enum(GJC_MODEL_EFFORT_IDS);
@@ -146,7 +151,7 @@ const ModelDefinitionSchema = z
 		contextWindow: z.number().optional(),
 		maxTokens: z.number().optional(),
 		headers: z.record(z.string(), z.string()).optional(),
-		compat: OpenAICompatSchema.optional(),
+		compat: ModelCompatSchema.optional(),
 		contextPromotionTarget: z.string().min(1).optional(),
 		wireModelId: z.string().min(1).optional(),
 		requestTransform: RequestTransformSchema.optional(),
@@ -173,7 +178,7 @@ export const ModelOverrideSchema = z
 		contextWindow: z.number().optional(),
 		maxTokens: z.number().optional(),
 		headers: z.record(z.string(), z.string()).optional(),
-		compat: OpenAICompatSchema.optional(),
+		compat: ModelCompatSchema.optional(),
 		contextPromotionTarget: z.string().min(1).optional(),
 		wireModelId: z.string().min(1).optional(),
 		requestTransform: RequestTransformSchema.optional(),
@@ -221,7 +226,7 @@ const ProviderConfigSchema = z
 			])
 			.optional(),
 		headers: z.record(z.string(), z.string()).optional(),
-		compat: OpenAICompatSchema.optional(),
+		compat: ModelCompatSchema.optional(),
 		webSearch: z.enum(["on", "off", "auto"]).optional(),
 		authHeader: z.boolean().optional(),
 		auth: ProviderAuthSchema.optional(),

package/src/coordinator/contract.ts

@@ -12,6 +12,7 @@ export const COORDINATOR_MCP_TOOL_NAMES = [
 	"gjc_coordinator_watch_events",
 	"gjc_coordinator_register_session",
 	"gjc_coordinator_start_session",
+	"gjc_coordinator_activate_session",
 	"gjc_coordinator_stop_session",
 	"gjc_coordinator_send_prompt",
 	"gjc_coordinator_submit_question_answer",

package/src/coordinator-mcp/question-state.ts

@@ -6,6 +6,8 @@ import type { PrivateAskGateCodecV1, PublicReason } from "./question-gate-codec"
 
 export type CoordinatorSessionState =
 	| "booting"
+	/** Live and endpoint-addressable, but withholding readiness until activation. */
+	| "prepared"
 	| "ready_for_input"
 	| "running"
 	| "needs_user_input"