@gajae-code/coding-agent 0.4.5 → 0.5.0

package/src/config/model-profiles.ts

@@ -54,71 +54,270 @@ const profile = (
 });
 
 export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
-	profile("opencode-go-eco", ["opencode-go"], {
-		default: "opencode-go/deepseek-v4-flash",
-		executor: "opencode-go/qwen3.5-plus",
-		architect: "opencode-go/glm-5",
-		planner: "opencode-go/minimax-m2.5",
-		critic: "opencode-go/kimi-k2.5",
-	}),
-	profile("opencode-go-standard", ["opencode-go"], {
-		default: "opencode-go/kimi-k2.6",
-		executor: "opencode-go/qwen3.6-plus",
-		architect: "opencode-go/glm-5.1",
-		planner: "opencode-go/minimax-m2.7",
-		critic: "opencode-go/deepseek-v4-pro",
-	}),
-	profile("opencode-go-pro", ["opencode-go"], {
-		default: "opencode-go/qwen3.7-max",
-		executor: "opencode-go/kimi-k2.6",
-		architect: "opencode-go/deepseek-v4-pro:high",
-		planner: "opencode-go/glm-5.1:high",
-		critic: "opencode-go/minimax-m2.7:high",
-	}),
 	profile("codex-eco", ["openai-codex"], {
-		default: "openai-codex/gpt-5.4-mini",
-		executor: "openai-codex/gpt-5.4-nano",
-		architect: "openai-codex/gpt-5.4-mini",
-		planner: "openai-codex/gpt-5.4-mini",
-		critic: "openai-codex/gpt-5.4-mini",
-	}),
-	profile("codex-standard", ["openai-codex"], {
-		default: "openai-codex/gpt-5.4:medium",
-		executor: "openai-codex/gpt-5.4:low",
-		architect: "openai-codex/gpt-5.4:xhigh",
-		planner: "openai-codex/gpt-5.4:medium",
-		critic: "openai-codex/gpt-5.4:high",
+		default: "openai-codex/gpt-5.5:low",
+		executor: "openai-codex/gpt-5.5:minimal",
+		planner: "openai-codex/gpt-5.5:low",
+		critic: "openai-codex/gpt-5.5:medium",
+		architect: "openai-codex/gpt-5.5:high",
+	}),
+	profile("codex-medium", ["openai-codex"], {
+		default: "openai-codex/gpt-5.5:medium",
+		executor: "openai-codex/gpt-5.5:low",
+		planner: "openai-codex/gpt-5.5:medium",
+		critic: "openai-codex/gpt-5.5:high",
+		architect: "openai-codex/gpt-5.5:xhigh",
 	}),
 	profile("codex-pro", ["openai-codex"], {
-		default: "openai-codex/gpt-5.5",
-		executor: "openai-codex/gpt-5.2-codex",
-		architect: "openai-codex/gpt-5.1-codex-max:high",
+		default: "openai-codex/gpt-5.5:xhigh",
+		executor: "openai-codex/gpt-5.5:medium",
 		planner: "openai-codex/gpt-5.5:high",
-		critic: "openai-codex/gpt-5.3-codex-spark:high",
+		critic: "openai-codex/gpt-5.5:xhigh",
+		architect: "openai-codex/gpt-5.5:xhigh",
 	}),
-	profile("opencode-go-codex-eco", ["opencode-go", "openai-codex"], {
-		default: "opencode-go/deepseek-v4-flash",
-		executor: "opencode-go/qwen3.5-plus",
-		architect: "openai-codex/gpt-5.4-mini",
-		planner: "openai-codex/gpt-5.4-mini",
-		critic: "openai-codex/gpt-5.4-mini",
-	}),
-	profile("opencode-go-codex-standard", ["opencode-go", "openai-codex"], {
+	profile("opencodego", ["opencode-go"], {
 		default: "opencode-go/kimi-k2.6",
-		executor: "opencode-go/qwen3.6-plus",
-		architect: "openai-codex/gpt-5.4",
-		planner: "openai-codex/gpt-5.4",
-		critic: "openai-codex/gpt-5.4",
-	}),
-	profile("opencode-go-codex-pro", ["opencode-go", "openai-codex"], {
-		default: "opencode-go/qwen3.7-max",
-		executor: "opencode-go/kimi-k2.6",
-		architect: "openai-codex/gpt-5.1-codex-max:high",
-		planner: "openai-codex/gpt-5.5:high",
-		critic: "openai-codex/gpt-5.3-codex-spark:high",
+		executor: "opencode-go/deepseek-v4-flash",
+		planner: "opencode-go/qwen3.7-max",
+		critic: "opencode-go/mimo-v2.5-pro",
+		architect: "opencode-go/deepseek-v4-pro",
+	}),
+	profile("claude-opus", ["anthropic"], {
+		default: "anthropic/claude-opus-4-8:xhigh",
+		executor: "anthropic/claude-sonnet-4-6",
+		planner: "anthropic/claude-opus-4-8:low",
+		critic: "anthropic/claude-opus-4-8:high",
+		architect: "anthropic/claude-opus-4-8:xhigh",
+	}),
+	profile("glm-eco", ["zai"], {
+		default: "zai/glm-5.1:low",
+		executor: "zai/glm-5.1:minimal",
+		planner: "zai/glm-5.1:low",
+		critic: "zai/glm-5.1:medium",
+		architect: "zai/glm-5.1:high",
+	}),
+	profile("glm-medium", ["zai"], {
+		default: "zai/glm-5.1:medium",
+		executor: "zai/glm-5.1:low",
+		planner: "zai/glm-5.1:medium",
+		critic: "zai/glm-5.1:high",
+		architect: "zai/glm-5.1:xhigh",
+	}),
+	profile("glm-pro", ["zai"], {
+		default: "zai/glm-5.1:xhigh",
+		executor: "zai/glm-5.1:medium",
+		planner: "zai/glm-5.1:high",
+		critic: "zai/glm-5.1:xhigh",
+		architect: "zai/glm-5.1:xhigh",
+	}),
+	profile("kimi-coding-plan-eco", ["kimi-code"], {
+		default: "kimi-code/kimi-k2.7-code:low",
+		executor: "kimi-code/kimi-k2.7-code:minimal",
+		planner: "kimi-code/kimi-k2.7-code:low",
+		critic: "kimi-code/kimi-k2.7-code:medium",
+		architect: "kimi-code/kimi-k2.7-code:high",
+	}),
+	profile("kimi-coding-plan-medium", ["kimi-code"], {
+		default: "kimi-code/kimi-k2.7-code:medium",
+		executor: "kimi-code/kimi-k2.7-code:low",
+		planner: "kimi-code/kimi-k2.7-code:medium",
+		critic: "kimi-code/kimi-k2.7-code:high",
+		architect: "kimi-code/kimi-k2.7-code:xhigh",
+	}),
+	profile("kimi-coding-plan-pro", ["kimi-code"], {
+		default: "kimi-code/kimi-k2.7-code:xhigh",
+		executor: "kimi-code/kimi-k2.7-code:medium",
+		planner: "kimi-code/kimi-k2.7-code:high",
+		critic: "kimi-code/kimi-k2.7-code:xhigh",
+		architect: "kimi-code/kimi-k2.7-code:xhigh",
+	}),
+	profile("mimo-eco", ["xiaomi"], {
+		default: "xiaomi/mimo-v2.5-pro:low",
+		executor: "xiaomi/mimo-v2.5-pro:minimal",
+		planner: "xiaomi/mimo-v2.5-pro:low",
+		critic: "xiaomi/mimo-v2.5-pro:medium",
+		architect: "xiaomi/mimo-v2.5-pro:high",
+	}),
+	profile("mimo-medium", ["xiaomi"], {
+		default: "xiaomi/mimo-v2.5-pro:medium",
+		executor: "xiaomi/mimo-v2.5-pro:low",
+		planner: "xiaomi/mimo-v2.5-pro:medium",
+		critic: "xiaomi/mimo-v2.5-pro:high",
+		architect: "xiaomi/mimo-v2.5-pro:xhigh",
+	}),
+	profile("mimo-pro", ["xiaomi"], {
+		default: "xiaomi/mimo-v2.5-pro:xhigh",
+		executor: "xiaomi/mimo-v2.5-pro:medium",
+		planner: "xiaomi/mimo-v2.5-pro:high",
+		critic: "xiaomi/mimo-v2.5-pro:xhigh",
+		architect: "xiaomi/mimo-v2.5-pro:xhigh",
+	}),
+	profile("grok-eco", ["xai"], {
+		default: "xai/grok-4.3:low",
+		executor: "xai/grok-4.3:minimal",
+		planner: "xai/grok-4.3:low",
+		critic: "xai/grok-4.3:medium",
+		architect: "xai/grok-4.3:high",
+	}),
+	profile("grok-medium", ["xai"], {
+		default: "xai/grok-4.3:medium",
+		executor: "xai/grok-4.3:low",
+		planner: "xai/grok-4.3:medium",
+		critic: "xai/grok-4.3:high",
+		architect: "xai/grok-4.3:xhigh",
+	}),
+	profile("grok-pro", ["xai"], {
+		default: "xai/grok-4.3:xhigh",
+		executor: "xai/grok-4.3:medium",
+		planner: "xai/grok-4.3:high",
+		critic: "xai/grok-4.3:xhigh",
+		architect: "xai/grok-4.3:xhigh",
+	}),
+	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",
+	}),
+	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",
 	}),
+	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",
+	}),
+	profile("minimax-eco", ["minimax-code"], {
+		default: "minimax-code/minimax-v3:low",
+		executor: "minimax-code/minimax-v3:minimal",
+		planner: "minimax-code/minimax-v3:low",
+		critic: "minimax-code/minimax-v3:medium",
+		architect: "minimax-code/minimax-v3:high",
+	}),
+	profile("minimax-medium", ["minimax-code"], {
+		default: "minimax-code/minimax-v3:medium",
+		executor: "minimax-code/minimax-v3:low",
+		planner: "minimax-code/minimax-v3:medium",
+		critic: "minimax-code/minimax-v3:high",
+		architect: "minimax-code/minimax-v3:xhigh",
+	}),
+	profile("minimax-pro", ["minimax-code"], {
+		default: "minimax-code/minimax-v3:xhigh",
+		executor: "minimax-code/minimax-v3:medium",
+		planner: "minimax-code/minimax-v3:high",
+		critic: "minimax-code/minimax-v3:xhigh",
+		architect: "minimax-code/minimax-v3:xhigh",
+	}),
+	profile("opus-codex", ["anthropic", "openai-codex"], {
+		default: "anthropic/claude-opus-4-8:xhigh",
+		executor: "openai-codex/gpt-5.5:low",
+		planner: "openai-codex/gpt-5.5:medium",
+		critic: "openai-codex/gpt-5.5:high",
+		architect: "openai-codex/gpt-5.5:xhigh",
+	}),
+	profile("codex-opencodego", ["openai-codex", "opencode-go"], {
+		default: "openai-codex/gpt-5.5:medium",
+		executor: "opencode-go/deepseek-v4-pro",
+		planner: "opencode-go/kimi-k2.6",
+		critic: "opencode-go/mimo-v2.5-pro",
+		architect: "openai-codex/gpt-5.5:xhigh",
+	}),
+];
+
+export interface ModelProfilePresentation {
+	displayName: string;
+	providerGroup: string;
+}
+
+const PROFILE_PRESENTATION: Record<string, ModelProfilePresentation> = {
+	"codex-eco": { displayName: "Codex Eco", providerGroup: "CODEX" },
+	"codex-medium": { displayName: "Codex Medium", providerGroup: "CODEX" },
+	"codex-pro": { displayName: "Codex Pro", providerGroup: "CODEX" },
+	opencodego: { displayName: "OpenCodeGo", providerGroup: "OPENCODEGO" },
+	"claude-opus": { displayName: "Claude Opus", providerGroup: "CLAUDE" },
+	"glm-eco": { displayName: "GLM Eco", providerGroup: "GLM" },
+	"glm-medium": { displayName: "GLM Medium", providerGroup: "GLM" },
+	"glm-pro": { displayName: "GLM Pro", providerGroup: "GLM" },
+	"kimi-coding-plan-eco": { displayName: "Kimi Coding Plan Eco", providerGroup: "KIMI CODING PLAN" },
+	"kimi-coding-plan-medium": { displayName: "Kimi Coding Plan Medium", providerGroup: "KIMI CODING PLAN" },
+	"kimi-coding-plan-pro": { displayName: "Kimi Coding Plan Pro", providerGroup: "KIMI CODING PLAN" },
+	"mimo-eco": { displayName: "Mimo Eco", providerGroup: "MIMO" },
+	"mimo-medium": { displayName: "Mimo Medium", providerGroup: "MIMO" },
+	"mimo-pro": { displayName: "Mimo Pro", providerGroup: "MIMO" },
+	"grok-eco": { displayName: "Grok Eco", providerGroup: "GROK" },
+	"grok-medium": { displayName: "Grok Medium", providerGroup: "GROK" },
+	"grok-pro": { displayName: "Grok Pro", providerGroup: "GROK" },
+	"cursor-eco": { displayName: "Cursor Eco", providerGroup: "CURSOR" },
+	"cursor-medium": { displayName: "Cursor Medium", providerGroup: "CURSOR" },
+	"cursor-pro": { displayName: "Cursor Pro", providerGroup: "CURSOR" },
+	"minimax-eco": { displayName: "MiniMax Eco", providerGroup: "MINIMAX" },
+	"minimax-medium": { displayName: "MiniMax Medium", providerGroup: "MINIMAX" },
+	"minimax-pro": { displayName: "MiniMax Pro", providerGroup: "MINIMAX" },
+	"opus-codex": { displayName: "Opus + Codex", providerGroup: "COMBOS" },
+	"codex-opencodego": { displayName: "Codex + OpenCodeGo", providerGroup: "COMBOS" },
+};
+
+const PROFILE_GROUP_ORDER = [
+	"CODEX",
+	"OPENCODEGO",
+	"CLAUDE",
+	"GLM",
+	"KIMI CODING PLAN",
+	"MIMO",
+	"GROK",
+	"CURSOR",
+	"MINIMAX",
+	"COMBOS",
 ];
 
+const PROFILE_RECOMMENDATIONS: Record<string, string> = {
+	"openai-codex": "codex-medium",
+	anthropic: "claude-opus",
+	"opencode-go": "opencodego",
+	zai: "glm-medium",
+	"kimi-code": "kimi-coding-plan-medium",
+	xiaomi: "mimo-medium",
+	xai: "grok-medium",
+	cursor: "cursor-medium",
+	"minimax-code": "minimax-medium",
+};
+
+export function getModelProfilePresentation(name: string): ModelProfilePresentation {
+	return PROFILE_PRESENTATION[name] ?? { displayName: name, providerGroup: "COMBOS" };
+}
+
+export function groupModelProfilesForPresetLanding(
+	profiles: ReadonlyMap<string, ModelProfileDefinition>,
+): Map<string, ModelProfileDefinition[]> {
+	const groups = new Map<string, ModelProfileDefinition[]>();
+	for (const group of PROFILE_GROUP_ORDER) groups.set(group, []);
+	for (const profile of profiles.values()) {
+		const group = getModelProfilePresentation(profile.name).providerGroup;
+		if (!groups.has(group)) groups.set(group, []);
+		groups.get(group)?.push(profile);
+	}
+	for (const [group, entries] of groups) {
+		if (entries.length === 0) groups.delete(group);
+		else entries.sort((a, b) => a.name.localeCompare(b.name));
+	}
+	return groups;
+}
+
+export function recommendModelProfileForProvider(
+	providerId: string,
+	profiles: ReadonlyMap<string, ModelProfileDefinition>,
+): ModelProfileDefinition | undefined {
+	const recommended = PROFILE_RECOMMENDATIONS[providerId];
+	return recommended ? profiles.get(recommended) : undefined;
+}
+
 export function mergeModelProfiles(userProfiles?: ModelsConfig["profiles"]): Map<string, ModelProfileDefinition> {
 	const profiles = new Map<string, ModelProfileDefinition>();
 	for (const definition of BUILTIN_MODEL_PROFILES) {

package/src/config/model-resolver.ts

@@ -776,30 +776,33 @@ export async function resolveModelOverrideWithAuthFallback(
 	thinkingLevel?: ThinkingLevel;
 	explicitThinkingLevel: boolean;
 	authFallbackUsed: boolean;
+	requestedModel?: Model<Api>;
+	fallbackReason?: "auth_unavailable";
 }> {
 	const primary = resolveModelOverride(modelPatterns, modelRegistry, settings);
+	const unchanged = { ...primary, requestedModel: primary.model, authFallbackUsed: false };
 	if (!primary.model || !parentActiveModelPattern) {
-		return { ...primary, authFallbackUsed: false };
+		return unchanged;
 	}
 
 	const primaryKey = await modelRegistry.getApiKey(primary.model, sessionId);
 	if (primaryKey === kNoAuth || isAuthenticated(primaryKey)) {
-		return { ...primary, authFallbackUsed: false };
+		return unchanged;
 	}
 
 	const fallback = resolveModelOverride([parentActiveModelPattern], modelRegistry, settings);
 	if (!fallback.model) {
-		return { ...primary, authFallbackUsed: false };
+		return unchanged;
 	}
 	if (modelsAreEqual(fallback.model, primary.model)) {
-		return { ...primary, authFallbackUsed: false };
+		return unchanged;
 	}
 	const fallbackKey = await modelRegistry.getApiKey(fallback.model, sessionId);
 	if (!isAuthenticated(fallbackKey)) {
-		return { ...primary, authFallbackUsed: false };
+		return unchanged;
 	}
 
-	return { ...fallback, authFallbackUsed: true };
+	return { ...fallback, requestedModel: primary.model, authFallbackUsed: true, fallbackReason: "auth_unavailable" };
 }
 
 /**

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

@@ -37,6 +37,7 @@ export const OpenAICompatSchema = z.object({
 	requiresAssistantContentForToolCalls: z.boolean().optional(),
 	supportsToolChoice: z.boolean().optional(),
 	supportsForcedToolChoice: z.boolean().optional(),
+	toolChoiceSupport: z.enum(["none", "auto", "required", "named"]).optional(),
 	disableReasoningOnForcedToolChoice: z.boolean().optional(),
 	disableReasoningOnToolChoice: z.boolean().optional(),
 	thinkingFormat: z.enum(["openai", "openrouter", "zai", "qwen", "qwen-chat-template"]).optional(),

package/src/config/settings-schema.ts

@@ -1,7 +1,10 @@
-import { THINKING_EFFORTS } from "@gajae-code/ai/model-thinking";
+import type { Effort } from "@gajae-code/ai/model-thinking";
 import { TASK_SIMPLE_MODES } from "../task/simple-mode";
-import { getThinkingLevelMetadata } from "../thinking";
+import { getThinkingLevelMetadata } from "../thinking-metadata";
 import { EDIT_MODES } from "../utils/edit-mode";
+
+const THINKING_EFFORTS = ["minimal", "low", "medium", "high", "xhigh", "max"] as readonly Effort[];
+
 import {
 	DEFAULT_DISABLED_EXTENSIONS,
 	DEFAULT_SKILL_DISCOVERY_SETTINGS,
@@ -665,7 +668,7 @@ export const SETTINGS_SCHEMA = {
 	defaultThinkingLevel: {
 		type: "enum",
 		values: THINKING_EFFORTS,
-		default: "high",
+		default: THINKING_EFFORTS[3],
 		ui: {
 			tab: "model",
 			label: "Thinking Level",

package/src/coordinator-mcp/server.ts

@@ -742,6 +742,7 @@ async function startTmuxSession(
 	config: CoordinatorMcpConfig,
 	input: SessionStartInput,
 	namespaceDir: string,
+	runner: CommandRunner = runCommand,
 ): Promise<Record<string, unknown>> {
 	if (!config.sessionCommand) throw new Error("coordinator_session_command_required");
 	const sessionName = `gjc-coordinator-${randomUUID().slice(0, 8)}`;
@@ -752,7 +753,7 @@ async function startTmuxSession(
 		`${GJC_COORDINATOR_SESSION_ID_ENV}=${shellQuote(sessionName)}`,
 		config.sessionCommand,
 	].join(" ");
-	const started = await runCommand([
+	const started = await runner([
 		"tmux",
 		"new-session",
 		"-d",
@@ -767,9 +768,6 @@ async function startTmuxSession(
 	]);
 	if (started.exitCode !== 0) throw new Error(`coordinator_tmux_start_failed:${started.stderr || started.stdout}`);
 	const [tmuxTarget, paneId] = started.stdout.trim().split(/\s+/, 2);
-	const initialPromptTmuxKeysSent = input.prompt
-		? await sendTmuxPromptKeys(tmuxTarget || sessionName, input.prompt)
-		: false;
 	return {
 		sessionId: sessionName,
 		tmuxSession: sessionName,
@@ -779,7 +777,6 @@ async function startTmuxSession(
 		createdAt: new Date().toISOString(),
 		sessionCommand: config.sessionCommand,
 		runtimeStateFile,
-		initialPromptTmuxKeysSent,
 	};
 }
 
@@ -964,27 +961,26 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 	}
 
 	async function activateTurn(session: Record<string, unknown>, turn: TurnRecord): Promise<TurnRecord> {
-		const tmuxKeysSent = await sendTmuxPrompt(session, turn.prompt.text, commandRunner);
 		const timestamp = new Date().toISOString();
 		const target = typeof session.tmux_target === "string" ? session.tmux_target : session.tmuxTarget;
 		const live = hasTmuxIdentity(session) ? await hasTmuxSession(session, commandRunner) : null;
-		const activeTurn: TurnRecord = {
+		const pendingTurn: TurnRecord = {
 			...turn,
 			status: "active",
 			delivery: {
 				delivered: false,
-				queued: !tmuxKeysSent,
+				queued: true,
 				target: typeof target === "string" ? target : null,
-				tmux_keys_sent: tmuxKeysSent,
+				tmux_keys_sent: false,
 				prompt_acknowledged: false,
-				state: tmuxKeysSent ? "tmux_keys_sent" : "unavailable",
+				state: "queued",
 				attempts: [
 					{
 						delivered: false,
-						tmux_keys_sent: tmuxKeysSent,
+						tmux_keys_sent: false,
 						channel: "tmux_keys",
 						created_at: timestamp,
-						reason: tmuxKeysSent ? "awaiting_runtime_ack" : "tmux_delivery_unavailable",
+						reason: "awaiting_tmux_delivery",
 					},
 				],
 			},
@@ -992,13 +988,50 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 			started_at: turn.started_at ?? timestamp,
 			updated_at: timestamp,
 		};
-		await writeActiveTurn(namespaceDir, activeTurn);
-		await writeSessionState(namespaceDir, activeTurn.session_id, tmuxKeysSent ? "running" : "stale", {
-			currentTurnId: activeTurn.turn_id,
+		await writeTurnRecord(namespaceDir, pendingTurn);
+		await writeActiveTurn(namespaceDir, pendingTurn);
+		await writeSessionState(namespaceDir, pendingTurn.session_id, "running", {
+			currentTurnId: pendingTurn.turn_id,
 			live,
-			reason: tmuxKeysSent ? null : "tmux_delivery_unavailable",
+			reason: null,
 		});
+
+		const tmuxKeysSent = await sendTmuxPrompt(session, turn.prompt.text, commandRunner);
+		const deliveredAt = new Date().toISOString();
+		const activeTurn: TurnRecord = {
+			...pendingTurn,
+			delivery: {
+				delivered: false,
+				queued: !tmuxKeysSent,
+				target: typeof target === "string" ? target : null,
+				tmux_keys_sent: tmuxKeysSent,
+				prompt_acknowledged: false,
+				state: tmuxKeysSent ? "tmux_keys_sent" : "unavailable",
+				attempts: [
+					{
+						delivered: false,
+						tmux_keys_sent: tmuxKeysSent,
+						channel: "tmux_keys",
+						created_at: deliveredAt,
+						reason: tmuxKeysSent ? "awaiting_runtime_ack" : "tmux_delivery_unavailable",
+					},
+				],
+			},
+			updated_at: deliveredAt,
+		};
 		await writeTurnRecord(namespaceDir, activeTurn);
+		await writeActiveTurn(namespaceDir, activeTurn);
+		const sessionState = await readSessionState(namespaceDir, activeTurn.session_id);
+		const runtimeStateAlreadySettled =
+			sessionState?.current_turn_id === activeTurn.turn_id &&
+			(sessionState.state === "completed" || sessionState.state === "errored");
+		if (!runtimeStateAlreadySettled) {
+			await writeSessionState(namespaceDir, activeTurn.session_id, tmuxKeysSent ? "running" : "stale", {
+				currentTurnId: activeTurn.turn_id,
+				live,
+				reason: tmuxKeysSent ? null : "tmux_delivery_unavailable",
+			});
+		}
 		return activeTurn;
 	}
 
@@ -1149,18 +1182,16 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 				};
 				const started = services.startSession
 					? await services.startSession(input)
-					: await startTmuxSession(config, input, namespaceDir);
+					: await startTmuxSession(config, input, namespaceDir, commandRunner);
 				const startedRecord = asRecord(started);
 				if (!startedRecord) throw new Error("coordinator_session_command_required");
 				const session = normalizeSession(startedRecord);
 				await writeJsonFile(sessionFile(session.session_id), session);
 				const live = hasTmuxIdentity(session) ? await hasTmuxSession(session, commandRunner) : null;
-				let sessionState = await writeSessionState(
-					namespaceDir,
-					String(session.session_id),
-					input.prompt ? "running" : "ready_for_input",
-					{ live, reason: null },
-				);
+				let sessionState = await writeSessionState(namespaceDir, String(session.session_id), "ready_for_input", {
+					live,
+					reason: null,
+				});
 				if (typeof args.prompt === "string" && args.prompt.length > 0) {
 					const turn = await activateTurn(
 						session,

package/src/cursor.ts

@@ -160,6 +160,20 @@ function formatMcpToolErrorMessage(toolName: string, availableTools: string[]):
 	return `MCP tool "${toolName}" not found. Available tools: ${list}`;
 }
 
+/**
+ * Cursor's wire protocol carries shell timeouts in milliseconds — the
+ * model-facing parameter is `block_until_ms`, and `ShellArgs.hard_timeout` is
+ * likewise documented in ms — while the bash tool's `timeout` is seconds.
+ * Passing the raw value through made a requested 30 s wait (30000 ms) arrive
+ * as 30000 s and clamp to the 3600 s ceiling, i.e. an accidental 1-hour
+ * timeout on a blocking command. Convert, rounding sub-second values up to 1 s
+ * so a tiny requested wait does not collapse to "no timeout".
+ */
+function shellTimeoutSeconds(timeout: number | undefined): number | undefined {
+	if (!timeout || timeout <= 0) return undefined;
+	return Math.max(1, Math.ceil(timeout / 1000));
+}
+
 export class CursorExecHandlers implements ICursorExecHandlers {
 	constructor(private options: CursorExecBridgeOptions) {
 		// Bind every native handler so methods stay instance-safe when invoked
@@ -240,7 +254,7 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 
 	async shell(args: Parameters<NonNullable<ICursorExecHandlers["shell"]>>[0]) {
 		const toolCallId = decodeToolCallId(args.toolCallId);
-		const timeoutSeconds = args.timeout && args.timeout > 0 ? args.timeout : undefined;
+		const timeoutSeconds = shellTimeoutSeconds(args.timeout);
 		const toolResultMessage = await executeTool(this.#optionsForCall(), "bash", toolCallId, {
 			command: args.command,
 			cwd: args.workingDirectory || undefined,
@@ -262,7 +276,7 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 			return createToolResultMessage(toolCallId, toolName, result, true);
 		}
 
-		const timeoutSeconds = args.timeout && args.timeout > 0 ? args.timeout : undefined;
+		const timeoutSeconds = shellTimeoutSeconds(args.timeout);
 		const toolArgs: Record<string, unknown> = {
 			command: args.command,
 			cwd: args.workingDirectory || undefined,

package/src/defaults/gjc/skills/team/SKILL.md

@@ -306,8 +306,9 @@ Worker protocol:
 
 Useful runtime env vars:
 
-- `GJC_TEAM_TMUX_COMMAND`
-  - tmux binary/command override (default `tmux`)
+- `GJC_TMUX_COMMAND` / `GJC_TEAM_TMUX_COMMAND`
+  - tmux binary/command override (default `tmux`). `GJC_TMUX_COMMAND` applies to every GJC tmux flow; `GJC_TEAM_TMUX_COMMAND` is honored as an alias by the team path. Both resolve through the same resolver, so the team leader and `gjc session ...` always target the same multiplexer.
+  - Multiplexer support boundary: GJC-managed sessions and the team leader are detected via tmux user options (`@gjc-profile`, written with `set-option` and read back with `show-options` / `list-sessions -F`). A provider must round-trip those user options to be supported. Real tmux works. Alternative multiplexers such as psmux on Windows do not reliably persist tmux user options yet, so `gjc session status` reports `gjc_tmux_session_untagged` (the session exists in the multiplexer but is not GJC-tagged) and team startup rejects the leader as `unmanaged_tmux_session`. The Windows-native psmux path is therefore not fully supported; use real tmux for GJC-managed session and team flows.
 - `GJC_TEAM_WORKER_COMMAND`
   - worker command override (default resolves to active GJC entrypoint or `gjc`)
 - `GJC_TEAM_STATE_ROOT`

package/src/defaults/gjc/skills/ultragoal/SKILL.md

@@ -120,9 +120,15 @@ Examples:
 
 ```sh
 gjc ultragoal steer --kind add_subgoal --title "Investigate blocker" --objective "Validate the blocker and report evidence." --evidence "log/test output" --rationale "The blocker changes the safe execution order." --json
-gjc ultragoal steer --directive-json ./steering.json --json
+gjc ultragoal steer --kind split_subgoal --goal-id G002 --replacements-json '[{"title":"Fix parser","objective":"Resolve parser blocker."},{"title":"Verify parser","objective":"Run focused parser verification."}]' --evidence "Implementation split found two separable risks" --rationale "Splitting keeps each sub-goal independently verifiable." --json
+gjc ultragoal steer --kind reorder_pending --order-json '["G003","G002"]' --evidence "Dependency order changed after investigation" --rationale "G003 must land before G002 can proceed safely." --json
+gjc ultragoal steer --kind revise_pending_wording --goal-id G002 --title "Clarify blocker story" --evidence "The current title hides the actual blocker" --rationale "Clear wording keeps the ledger auditable." --json
+gjc ultragoal steer --kind annotate_ledger --evidence "User changed release ordering at runtime" --rationale "The aggregate objective is unchanged, but the execution history needs an audit note." --json
+gjc ultragoal steer --kind mark_blocked_superseded --goal-id G004 --evidence "The blocked work is no longer required because replacement evidence covers it" --rationale "No replacement sub-goal is needed; superseding only the blocked sub-goal unblocks final completion without changing the aggregate objective." --json
 ```
 
+`--directive-json` and UserPromptSubmit structured steering are planned/deferred routing surfaces, not part of the native typed `--kind` CLI path described above.
+
 Steering invariants:
 
 - Do not edit the aggregate goal objective, original brief constraints, quality gates, or completion status. The aggregate objective is a stable pointer to `.gjc/ultragoal/goals.json` and `.gjc/ultragoal/ledger.jsonl`, not an enumeration of initial goal ids.
@@ -131,7 +137,7 @@ Steering invariants:
 - Superseded goals remain in `goals.json` with steering metadata and are skipped for scheduling.
 - Blocked goals without replacements are skipped for scheduling but still block final completion until later explicit steering replaces or supersedes them.
 
-UserPromptSubmit uses the same steering API only for structured directives such as `GJC_ULTRAGOAL_STEER: { ... }`, `gjc.ultragoal.steer: { ... }`, or `gjc ultragoal steer: { ... }`. Normal prose does not mutate state, and repeated prompt-submit directives dedupe by prompt signature or idempotency key.
+UserPromptSubmit structured steering directives are a planned/deferred routing surface. Normal prose does not mutate state.
 
 ## Role-agent delegation guidance
 

package/src/export/html/index.ts

@@ -150,15 +150,19 @@ export async function exportFromFile(inputPath: string, options?: ExportOptions
 		throw err;
 	}
 
-	const sessionData: SessionData = {
-		header: sm.getHeader(),
-		entries: sm.getEntries(),
-		leafId: sm.getLeafId(),
-	};
+	try {
+		const sessionData: SessionData = {
+			header: sm.getHeader(),
+			entries: sm.getEntries(),
+			leafId: sm.getLeafId(),
+		};
 
-	const html = await generateHtml(sessionData, opts.themeName);
-	const outputPath = opts.outputPath || `${APP_NAME}-session-${path.basename(inputPath, ".jsonl")}.html`;
+		const html = await generateHtml(sessionData, opts.themeName);
+		const outputPath = opts.outputPath || `${APP_NAME}-session-${path.basename(inputPath, ".jsonl")}.html`;
 
-	await Bun.write(outputPath, html);
-	return outputPath;
+		await Bun.write(outputPath, html);
+		return outputPath;
+	} finally {
+		await sm.close();
+	}
 }