@gajae-code/coding-agent 0.12.10 → 0.12.12

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"