@gajae-code/coding-agent 0.12.11 → 0.12.12

package/src/cli/update-cli.ts

@@ -12,6 +12,12 @@ import { $ } from "bun";
 import chalk from "chalk";
 import { installDefaultGjcDefinitions } from "../defaults/gjc-defaults";
 import { theme } from "../modes/theme/theme";
+import {
+	DEFAULT_NPM_REGISTRY,
+	fetchLatestPackageVersion,
+	type Installer,
+	type NpmRegistryLookupOptions,
+} from "../utils/npm-registry";
 
 const RELEASE_REPO = "Yeachan-Heo/gajae-code";
 const PACKAGE = "@gajae-code/coding-agent";
@@ -21,6 +27,10 @@ const NPM_MANAGED_PACKAGES = [NPM_WRAPPER_PACKAGE, PACKAGE] as const;
 interface ReleaseInfo {
 	tag: string;
 	version: string;
+	/** Registry the version came from. Release binaries still come from GitHub. */
+	registry: string;
+	/** Config problems that did not stop the lookup but changed its outcome. */
+	warnings: string[];
 }
 
 /** Result from running the installed binary and parsing its reported version. */
@@ -205,23 +215,31 @@ async function resolveUpdateTarget(): Promise<UpdateTarget> {
 /**
  * Get the latest release info from the npm registry.
  * Uses npm instead of GitHub API to avoid unauthenticated rate limiting.
+ *
+ * The registry comes from npm config (`npm_config_registry`, `.npmrc`,
+ * `BUN_CONFIG_REGISTRY`) so the check reaches the same place the install does.
+ * Hardcoding the public registry broke every mirrored or firewalled network.
  */
-async function getLatestRelease(): Promise<ReleaseInfo> {
-	const response = await fetch(`https://registry.npmjs.org/${PACKAGE}/latest`);
-	if (!response.ok) {
-		throw new Error(`Failed to fetch release info: ${response.statusText}`);
-	}
-
-	const data = (await response.json()) as { version: string };
-	const version = data.version;
-	const tag = `v${version}`;
+async function getLatestRelease(options?: Installer | NpmRegistryLookupOptions): Promise<ReleaseInfo> {
+	const overrides: NpmRegistryLookupOptions = typeof options === "string" ? { installer: options } : (options ?? {});
+	// The user is deliberately waiting on this command, unlike the startup check.
+	const { version, registry, warnings } = await fetchLatestPackageVersion(PACKAGE, {
+		timeoutMs: 20_000,
+		...overrides,
+	});
 
 	return {
-		tag,
+		tag: `v${version}`,
 		version,
+		registry,
+		warnings,
 	};
 }
 
+export function getLatestReleaseForTest(options: NpmRegistryLookupOptions): Promise<ReleaseInfo> {
+	return getLatestRelease(options);
+}
+
 /**
  * Compare semver versions. Returns:
  * - negative if a < b
@@ -376,8 +394,10 @@ function formatBinaryDownloadFailureMessage(
 	url: string,
 	status: string | number,
 	platform: NodeJS.Platform = process.platform,
+	registryNote?: string,
 ): string {
-	return `Download failed for ${binaryName} from ${url}: ${status}.\n${formatManualUpdateInstructions(platform)}`;
+	const note = registryNote ? `\n${registryNote}` : "";
+	return `Download failed for ${binaryName} from ${url}: ${status}.${note}\n${formatManualUpdateInstructions(platform)}`;
 }
 
 export function formatBinaryDownloadFailureMessageForTest(
@@ -385,8 +405,9 @@ export function formatBinaryDownloadFailureMessageForTest(
 	url: string,
 	status: string | number,
 	platform: NodeJS.Platform = process.platform,
+	registryNote?: string,
 ): string {
-	return formatBinaryDownloadFailureMessage(binaryName, url, status, platform);
+	return formatBinaryDownloadFailureMessage(binaryName, url, status, platform, registryNote);
 }
 
 export function buildReleaseBinaryUrlForTest(
@@ -582,10 +603,23 @@ export async function fsyncFileForTest(filePath: string): Promise<void> {
  * Download a release binary to a temp path, throwing a friendly error when the
  * release asset cannot be fetched.
  */
-async function downloadBinaryTo(url: string, tempPath: string, binaryName: string): Promise<void> {
+async function downloadBinaryTo(
+	url: string,
+	tempPath: string,
+	binaryName: string,
+	registryNote?: string,
+): Promise<void> {
 	const response = await fetch(url, { redirect: "follow" });
 	if (!response.ok || !response.body) {
-		throw new Error(formatBinaryDownloadFailureMessage(binaryName, url, response.statusText || response.status));
+		throw new Error(
+			formatBinaryDownloadFailureMessage(
+				binaryName,
+				url,
+				response.statusText || response.status,
+				process.platform,
+				registryNote,
+			),
+		);
 	}
 	const fileStream = fs.createWriteStream(tempPath, { mode: 0o755 });
 	await pipeline(response.body, fileStream);
@@ -639,16 +673,29 @@ export async function runBinaryUpdateFlow(
 	});
 }
 
+/**
+ * Describe the registry a version came from, when it is not the public one.
+ *
+ * The binary update path downloads from GitHub release tags, so a version that
+ * only exists on a private mirror produces a bare 404 with nothing linking it
+ * back to the registry that named it.
+ */
+function formatRegistryProvenance(version: string, registry: string | undefined): string | undefined {
+	if (!registry || registry === DEFAULT_NPM_REGISTRY) return undefined;
+	return `Version ${version} was resolved from ${registry}, not ${DEFAULT_NPM_REGISTRY}; a version published only to that registry has no matching GitHub release asset.`;
+}
+
 /**
  * Download a release binary to a target path, replacing an existing file.
  */
-async function updateViaBinaryAt(targetPath: string, expectedVersion: string): Promise<void> {
+async function updateViaBinaryAt(targetPath: string, expectedVersion: string, registry?: string): Promise<void> {
 	const binaryName = getBinaryName();
 	const url = buildReleaseBinaryUrl(expectedVersion);
+	const registryNote = formatRegistryProvenance(expectedVersion, registry);
 	console.log(chalk.dim(`Downloading ${binaryName}…`));
 
 	const verification = await runBinaryUpdateFlow(targetPath, url, expectedVersion, {
-		download: (downloadUrl, tempPath) => downloadBinaryTo(downloadUrl, tempPath, binaryName),
+		download: (downloadUrl, tempPath) => downloadBinaryTo(downloadUrl, tempPath, binaryName, registryNote),
 		fsync: fsyncFile,
 		replace: replaceBinaryForUpdate,
 		verifyInstalledVersion: verifyInstalledRuntime,
@@ -665,20 +712,20 @@ async function updateViaBinaryAt(targetPath: string, expectedVersion: string): P
  * Run the update command.
  */
 export interface UpdateCommandDependencies {
-	getLatestRelease?: () => Promise<ReleaseInfo>;
+	getLatestRelease?: (installer?: Installer) => Promise<ReleaseInfo>;
 	resolveUpdateTarget?: () => Promise<UpdateTarget>;
-	performUpdate?: (target: UpdateTarget, expectedVersion: string) => Promise<void>;
+	performUpdate?: (target: UpdateTarget, expectedVersion: string, registry?: string) => Promise<void>;
 	refreshInstalledDefaultSkills?: () => Promise<void>;
 	exit?: (code: number) => never;
 }
 
-async function performUpdate(target: UpdateTarget, expectedVersion: string): Promise<void> {
+async function performUpdate(target: UpdateTarget, expectedVersion: string, registry?: string): Promise<void> {
 	if (target.method === "bun") {
 		await updateViaBun(expectedVersion);
 	} else if (target.method === "npm") {
 		await updateViaNpm(target.packageName, expectedVersion);
 	} else {
-		await updateViaBinaryAt(target.path, expectedVersion);
+		await updateViaBinaryAt(target.path, expectedVersion, registry);
 	}
 }
 
@@ -694,14 +741,34 @@ export async function runUpdateCommand(
 
 	console.log(chalk.dim(`Current version: ${VERSION}`));
 
+	// Resolve the install target first so the registry lookup can match the
+	// manager that will actually run: the npm-managed path ignores
+	// BUN_CONFIG_REGISTRY, so preferring it there would make the version check
+	// disagree with the install this command is gating. Failure is not fatal
+	// here — the later resolveTarget() call reports it.
+	let installer: Installer | undefined;
+	let target: UpdateTarget | undefined;
+	try {
+		target = await resolveTarget();
+		installer = target.method === "bun" ? "bun" : target.method === "npm" ? "npm" : undefined;
+	} catch {
+		installer = undefined;
+	}
+
 	let release: ReleaseInfo;
 	try {
-		release = await lookupRelease();
+		release = await lookupRelease(installer);
 	} catch (err) {
 		console.error(chalk.red(`Failed to check for updates: ${err}`));
 		return exit(1);
 	}
 
+	// A config file that exists but could not be read changes which registry
+	// answered; saying so beats a version that quietly came from somewhere else.
+	// `?? []` because UpdateCommandDependencies is a public seam an untyped
+	// consumer can satisfy without the field.
+	for (const warning of release.warnings ?? []) console.warn(chalk.yellow(`Warning: ${warning}`));
+
 	const comparison = compareVersions(release.version, VERSION);
 
 	if (comparison <= 0 && !opts.force) {
@@ -718,8 +785,8 @@ export async function runUpdateCommand(
 	if (opts.check) return;
 
 	try {
-		const target = await resolveTarget();
-		await update(target, release.version);
+		const resolved = target ?? (await resolveTarget());
+		await update(resolved, release.version, release.registry);
 	} catch (err) {
 		console.error(chalk.red(`Update failed: ${err}`));
 		return exit(1);

package/src/commands/notify.ts

@@ -2,17 +2,32 @@
  * Configure Telegram, Discord, or Slack notifications.
  */
 import { Args, Command, Flags } from "@gajae-code/utils/cli";
-import { type NotifyAction, type NotifyCommandArgs, runNotifyCliCommand } from "../cli/notify-cli";
+import {
+	assertStrictActivateThreadInvocation,
+	assertStrictBindThreadInvocation,
+	type NotifyAction,
+	type NotifyCommandArgs,
+	runNotifyCliCommand,
+} from "../cli/notify-cli";
 import { initTheme } from "../modes/theme/theme";
 
-const ACTIONS: NotifyAction[] = ["setup", "status", "health", "test", "recovery", "daemon-internal"];
+const ACTIONS: NotifyAction[] = [
+	"setup",
+	"status",
+	"health",
+	"test",
+	"recovery",
+	"bind-thread",
+	"activate-thread",
+	"daemon-internal",
+];
 
 export default class Notify extends Command {
 	static description = "Configure Telegram, Discord, or Slack notifications";
 
 	static args = {
 		action: Args.string({
-			description: "Notify action (setup|status|health|test|recovery|daemon-internal)",
+			description: "Notify action (setup|status|health|test|recovery|bind-thread|activate-thread|daemon-internal)",
 			required: false,
 		}),
 		extra: Args.string({
@@ -46,6 +61,8 @@ export default class Notify extends Command {
 		}),
 		probe: Flags.boolean({ description: "notify health: run the selected provider's REST diagnostic" }),
 		message: Flags.string({ description: "notify test: custom message body" }),
+		"session-id": Flags.string({ description: "Live GJC session to bind to an existing Slack thread" }),
+		"thread-ts": Flags.string({ description: "Existing Slack root thread timestamp" }),
 		"owner-id": Flags.string({ description: "Internal: daemon owner id" }),
 		"agent-dir": Flags.string({ description: "Internal: agent dir for the daemon" }),
 	};
@@ -105,8 +122,15 @@ export default class Notify extends Command {
 			redact: Boolean(flags.redact),
 			probe: Boolean(flags.probe),
 			message: flags.message as string | undefined,
+			sessionId: flagRec["session-id"] as string | undefined,
+			threadTs: flagRec["thread-ts"] as string | undefined,
 		};
 
+		// `bind-thread` and `activate-thread` have no positional or internal form:
+		// any extra argument or unrelated notify flag is rejected here rather than
+		// silently ignored.
+		if (action === "bind-thread") assertStrictBindThreadInvocation(cmd);
+		if (action === "activate-thread") assertStrictActivateThreadInvocation(cmd);
 		if (action !== "daemon-internal") await initTheme();
 		await runNotifyCliCommand(cmd);
 	}

package/src/commands/sdk.ts

@@ -423,6 +423,7 @@ export async function runSessionHost(
 				sessionManager: opened.sessionManager,
 				...(mcpConfigPath ? { mcpConfigPath } : {}),
 				...(mcpStartupTimeoutMs !== undefined ? { mcpStartupTimeoutMs } : {}),
+				...(request.readiness ? { readiness: request.readiness } : {}),
 			});
 		} catch (error) {
 			throw await registrationFailure(error);

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

@@ -61,6 +61,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);
@@ -166,6 +181,9 @@ export const fileLocksGcAdapter: GcStoreAdapter = {
 		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,25 +243,25 @@ 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",
@@ -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/qwen-3.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/qwen-3.8-max:xhigh",
+		critic: "alibaba-token-plan/qwen-3.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/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"