@gajae-code/coding-agent 0.4.2 → 0.4.4

package/src/commands/setup.ts

@@ -5,7 +5,7 @@ import { Args, Command, Flags } from "@gajae-code/utils/cli";
 import { runSetupCommand, type SetupCommandArgs, type SetupComponent } from "../cli/setup-cli";
 import { initTheme } from "../modes/theme/theme";
 
-const COMPONENTS: SetupComponent[] = ["defaults", "hooks", "provider", "python", "stt"];
+const COMPONENTS: SetupComponent[] = ["defaults", "hermes", "hooks", "provider", "python", "stt"];
 
 export default class Setup extends Command {
 	static description = "Install GJC defaults or optional feature dependencies";
@@ -22,6 +22,22 @@ export default class Setup extends Command {
 		check: Flags.boolean({ char: "c", description: "Check if dependencies are installed" }),
 		force: Flags.boolean({ char: "f", description: "Overwrite existing default workflow skill files" }),
 		json: Flags.boolean({ description: "Output status as JSON" }),
+		smoke: Flags.boolean({ description: "Run Hermes MCP setup smoke checks" }),
+		install: Flags.boolean({ description: "Install generated Hermes setup files" }),
+		root: Flags.string({ description: "Allowed Hermes MCP workdir/artifact root (repeatable)", multiple: true }),
+		repo: Flags.string({ description: "Hermes MCP repo namespace" }),
+		profile: Flags.string({ description: "Hermes MCP profile namespace" }),
+		"session-command": Flags.string({ description: "Explicit GJC session command for Hermes to launch" }),
+		"state-root": Flags.string({ description: "Hermes MCP coordination state root" }),
+		mutation: Flags.string({
+			description: "Hermes MCP mutation classes: sessions,questions,reports,all",
+			multiple: true,
+		}),
+		"artifact-byte-cap": Flags.string({ description: "Hermes MCP artifact read byte cap" }),
+		"server-key": Flags.string({ description: "Hermes MCP server key in coordinator config" }),
+		"gjc-command": Flags.string({ description: "Command used to start `gjc mcp-serve coordinator`" }),
+		target: Flags.string({ description: "Hermes config file target for config-only install" }),
+		"profile-dir": Flags.string({ description: "Hermes profile directory for full setup install" }),
 		preset: Flags.string({ description: "Provider preset: minimax, minimax-cn, or glm" }),
 		compat: Flags.string({ description: "Provider compatibility: openai or anthropic" }),
 		provider: Flags.string({ description: "Provider id to add to models.yml" }),
@@ -46,6 +62,19 @@ export default class Setup extends Command {
 				apiKeyEnv: flags["api-key-env"],
 				model: flags.model,
 				modelsPath: flags["models-path"],
+				smoke: flags.smoke,
+				install: flags.install,
+				root: flags.root,
+				repo: flags.repo,
+				profile: flags.profile,
+				sessionCommand: flags["session-command"],
+				stateRoot: flags["state-root"],
+				mutation: flags.mutation,
+				artifactByteCap: flags["artifact-byte-cap"],
+				serverKey: flags["server-key"],
+				gjcCommand: flags["gjc-command"],
+				target: flags.target,
+				profileDir: flags["profile-dir"],
 			},
 		};
 		await initTheme();

package/src/commands/ultragoal.ts

@@ -1,6 +1,7 @@
 import { Command } from "@gajae-code/utils/cli";
 import {
 	GJC_SESSION_FILE_ENV,
+	GJC_SESSION_ID_ENV,
 	isUltragoalCreateGoalsInvocation,
 	readUltragoalGjcObjective,
 	writeCurrentSessionGoalModeState,
@@ -28,6 +29,11 @@ export default class Ultragoal extends Command {
 			sessionFile: process.env[GJC_SESSION_FILE_ENV],
 			objective,
 		});
-		await writePendingGoalModeRequest({ cwd, objective, goalsPath });
+		await writePendingGoalModeRequest({
+			cwd,
+			objective,
+			goalsPath,
+			sessionId: process.env[GJC_SESSION_ID_ENV],
+		});
 	}
 }

package/src/commit/agentic/index.ts

@@ -5,7 +5,7 @@ import { applyChangelogProposals } from "../../commit/changelog";
 import { detectChangelogBoundaries } from "../../commit/changelog/detect";
 import { parseUnreleasedSection } from "../../commit/changelog/parse";
 import { formatCommitMessage } from "../../commit/message";
-import { resolvePrimaryModel, resolveSmolModel } from "../../commit/model-selection";
+import { resolvePrimaryModel, resolveSecondaryCommitModel } from "../../commit/model-selection";
 import type { CommitCommandArgs, ConventionalAnalysis } from "../../commit/types";
 import { ModelRegistry } from "../../config/model-registry";
 import { Settings } from "../../config/settings";
@@ -47,7 +47,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	const { model: primaryModel, apiKey: primaryApiKey } = primaryModelResult;
 	process.stdout.write(`  └─ ${primaryModel.name}\n`);
 
-	const { model: agentModel, thinkingLevel: agentThinkingLevel } = await resolveSmolModel(
+	const { model: agentModel, thinkingLevel: agentThinkingLevel } = await resolveSecondaryCommitModel(
 		settings,
 		modelRegistry,
 		primaryModel,

package/src/commit/model-selection.ts

@@ -1,14 +1,7 @@
 import type { ThinkingLevel } from "@gajae-code/agent-core";
 import type { Api, Model } from "@gajae-code/ai";
-import { MODEL_ROLE_IDS } from "../config/model-registry";
-import {
-	type ModelLookupRegistry,
-	parseModelPattern,
-	resolveModelRoleValue,
-	resolveRoleSelection,
-} from "../config/model-resolver";
+import { type ModelLookupRegistry, resolveModelRoleValue, resolveRoleSelection } from "../config/model-resolver";
 import type { Settings } from "../config/settings";
-import MODEL_PRIO from "../priority.json" with { type: "json" };
 
 export interface ResolvedCommitModel {
 	model: Model<Api>;
@@ -29,7 +22,7 @@ export async function resolvePrimaryModel(
 	const matchPreferences = { usageOrder: settings.getStorage()?.getModelUsageOrder() };
 	const resolved = override
 		? resolveModelRoleValue(override, available, { settings, matchPreferences, modelRegistry })
-		: resolveRoleSelection(["commit", "smol", ...MODEL_ROLE_IDS], settings, available, modelRegistry);
+		: resolveRoleSelection(["default"], settings, available, modelRegistry);
 	const model = resolved?.model;
 	if (!model) {
 		throw new Error("No model available for commit generation");
@@ -41,25 +34,17 @@ export async function resolvePrimaryModel(
 	return { model, apiKey, thinkingLevel: resolved?.thinkingLevel };
 }
 
-export async function resolveSmolModel(
+export async function resolveSecondaryCommitModel(
 	settings: Settings,
 	modelRegistry: CommitModelRegistry,
 	fallbackModel: Model<Api>,
 	fallbackApiKey: string,
 ): Promise<ResolvedCommitModel> {
 	const available = modelRegistry.getAvailable();
-	const resolvedSmol = resolveRoleSelection(["smol"], settings, available, modelRegistry);
-	if (resolvedSmol?.model) {
-		const apiKey = await modelRegistry.getApiKey(resolvedSmol.model);
-		if (apiKey) return { model: resolvedSmol.model, apiKey, thinkingLevel: resolvedSmol.thinkingLevel };
-	}
-
-	const matchPreferences = { usageOrder: settings.getStorage()?.getModelUsageOrder() };
-	for (const pattern of MODEL_PRIO.smol) {
-		const candidate = parseModelPattern(pattern, available, matchPreferences, { modelRegistry }).model;
-		if (!candidate) continue;
-		const apiKey = await modelRegistry.getApiKey(candidate);
-		if (apiKey) return { model: candidate, apiKey };
+	const resolved = resolveRoleSelection(["default"], settings, available, modelRegistry);
+	if (resolved?.model) {
+		const apiKey = await modelRegistry.getApiKey(resolved.model);
+		if (apiKey) return { model: resolved.model, apiKey, thinkingLevel: resolved.thinkingLevel };
 	}
 
 	return { model: fallbackModel, apiKey: fallbackApiKey };

package/src/commit/pipeline.ts

@@ -18,7 +18,7 @@ import {
 import { runChangelogFlow } from "./changelog";
 import { runMapReduceAnalysis, shouldUseMapReduce } from "./map-reduce";
 import { formatCommitMessage } from "./message";
-import { resolvePrimaryModel, resolveSmolModel } from "./model-selection";
+import { resolvePrimaryModel, resolveSecondaryCommitModel } from "./model-selection";
 import summaryRetryPrompt from "./prompts/summary-retry.md" with { type: "text" };
 import typesDescriptionPrompt from "./prompts/types-description.md" with { type: "text" };
 import type { CommitCommandArgs, ConventionalAnalysis } from "./types";
@@ -56,7 +56,7 @@ async function runLegacyCommitCommand(args: CommitCommandArgs): Promise<void> {
 		model: smolModel,
 		apiKey: smolApiKey,
 		thinkingLevel: smolThinkingLevel,
-	} = await resolveSmolModel(settings, modelRegistry, primaryModel, primaryApiKey);
+	} = await resolveSecondaryCommitModel(settings, modelRegistry, primaryModel, primaryApiKey);
 
 	let stagedFiles = await git.diff.changedFiles(cwd, { cached: true });
 	if (stagedFiles.length === 0) {

package/src/config/model-registry.ts

@@ -62,7 +62,7 @@ export function isAuthenticated(apiKey: string | undefined | null): apiKey is st
 	return Boolean(apiKey) && apiKey !== kNoAuth;
 }
 
-export type ModelRole = "default" | "smol" | "slow" | "vision" | "plan" | "designer" | "commit" | "task";
+export type ModelRole = "default";
 
 export interface ModelRoleInfo {
 	tag?: string;
@@ -72,16 +72,9 @@ export interface ModelRoleInfo {
 
 export const MODEL_ROLES: Record<ModelRole, ModelRoleInfo> = {
 	default: { tag: "DEFAULT", name: "Default", color: "success" },
-	smol: { tag: "SMOL", name: "Fast", color: "warning" },
-	slow: { tag: "SLOW", name: "Thinking", color: "accent" },
-	vision: { tag: "VISION", name: "Vision", color: "error" },
-	plan: { tag: "PLAN", name: "Architect", color: "muted" },
-	designer: { tag: "DESIGNER", name: "Designer", color: "muted" },
-	commit: { tag: "COMMIT", name: "Commit", color: "dim" },
-	task: { tag: "TASK", name: "Subtask", color: "muted" },
 };
 
-export const MODEL_ROLE_IDS: ModelRole[] = ["default", "smol", "slow", "vision", "plan", "designer", "commit", "task"];
+export const MODEL_ROLE_IDS: ModelRole[] = ["default"];
 
 export type GjcModelAssignmentTargetId = "default" | "executor" | "architect" | "planner" | "critic";
 
@@ -688,6 +681,7 @@ function applyModelOverride(model: Model<Api>, override: ModelOverride): Model<A
 	if (override.reasoning !== undefined) result.reasoning = override.reasoning;
 	if (override.thinking !== undefined) result.thinking = override.thinking as ThinkingConfig;
 	if (override.input !== undefined) result.input = override.input as ("text" | "image")[];
+	if (override.output !== undefined) result.output = override.output as ("text" | "image")[];
 	if (override.cacheRetention !== undefined) result.cacheRetention = override.cacheRetention;
 	if (override.contextWindow !== undefined) result.contextWindow = override.contextWindow;
 	if (override.maxTokens !== undefined) result.maxTokens = override.maxTokens;
@@ -718,6 +712,7 @@ interface CustomModelDefinitionLike {
 	reasoning?: boolean;
 	thinking?: ThinkingConfig;
 	input?: ("text" | "image")[];
+	output?: ("text" | "image")[];
 	cost?: { input: number; output: number; cacheRead: number; cacheWrite: number };
 	contextWindow?: number;
 	maxTokens?: number;
@@ -743,6 +738,7 @@ type CustomModelOverlay = {
 	reasoning?: boolean;
 	thinking?: ThinkingConfig;
 	input?: ("text" | "image")[];
+	output?: ("text" | "image")[];
 	cost?: { input: number; output: number; cacheRead: number; cacheWrite: number };
 	contextWindow?: number;
 	maxTokens?: number;
@@ -818,6 +814,7 @@ function buildCustomModelOverlay(
 		reasoning: modelDef.reasoning,
 		thinking: modelDef.thinking as ThinkingConfig | undefined,
 		input: modelDef.input as ("text" | "image")[] | undefined,
+		output: modelDef.output as ("text" | "image")[] | undefined,
 		cost: modelDef.cost,
 		contextWindow: modelDef.contextWindow,
 		maxTokens: modelDef.maxTokens,
@@ -910,6 +907,7 @@ function finalizeCustomModel(model: CustomModelOverlay, options: CustomModelBuil
 		reference?.cost ??
 		(options.useDefaults ? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } : undefined);
 	const input = resolvedModel.input ?? reference?.input ?? (options.useDefaults ? ["text"] : undefined);
+	const output = resolvedModel.output ?? reference?.output;
 	return enrichModelThinking({
 		id: resolvedModel.id,
 		name: resolvedModel.name ?? (options.useDefaults ? resolvedModel.id : undefined),
@@ -919,6 +917,7 @@ function finalizeCustomModel(model: CustomModelOverlay, options: CustomModelBuil
 		reasoning: resolvedModel.reasoning ?? reference?.reasoning ?? (options.useDefaults ? false : undefined),
 		thinking: resolvedModel.thinking ?? reference?.thinking,
 		input: input as ("text" | "image")[],
+		output: output as ("text" | "image")[] | undefined,
 		cost,
 		contextWindow:
 			resolvedModel.contextWindow ?? reference?.contextWindow ?? (options.useDefaults ? 128000 : undefined),
@@ -1213,6 +1212,7 @@ export class ModelRegistry {
 					reasoning: customModel.reasoning ?? existingModel.reasoning,
 					thinking: customModel.thinking ?? existingModel.thinking,
 					input: customModel.input ?? existingModel.input,
+					output: customModel.output ?? existingModel.output,
 					cost: customModel.cost ?? existingModel.cost,
 					contextWindow: customModel.contextWindow ?? existingModel.contextWindow,
 					maxTokens: customModel.maxTokens ?? existingModel.maxTokens,
@@ -2325,6 +2325,14 @@ export class ModelRegistry {
 			fallback: 3,
 		};
 		return [...variants].sort((left, right) => {
+			// Prefer vision-capable variants over configured provider order so an
+			// ambiguous canonical id never resolves to a text-only namesake when a
+			// vision-capable variant of the same id is available.
+			const leftVision = left.model.input.includes("image") ? 0 : 1;
+			const rightVision = right.model.input.includes("image") ? 0 : 1;
+			if (leftVision !== rightVision) {
+				return leftVision - rightVision;
+			}
 			const leftProviderRank = providerRank.get(left.model.provider.toLowerCase()) ?? Number.MAX_SAFE_INTEGER;
 			const rightProviderRank = providerRank.get(right.model.provider.toLowerCase()) ?? Number.MAX_SAFE_INTEGER;
 			if (leftProviderRank !== rightProviderRank) {

package/src/config/model-resolver.ts

@@ -15,7 +15,6 @@ import {
 import { fuzzyMatch } from "@gajae-code/tui";
 import { logger } from "@gajae-code/utils";
 import chalk from "chalk";
-import MODEL_PRIO from "../priority.json" with { type: "json" };
 import { parseThinkingLevel, resolveThinkingLevelForModel } from "../thinking";
 import { isAuthenticated, kNoAuth, MODEL_ROLE_IDS, type ModelRegistry, type ModelRole } from "./model-registry";
 import type { Settings } from "./settings";
@@ -246,6 +245,15 @@ function pickPreferredModel(candidates: Model<Api>[], context: ModelPreferenceCo
 			return (aProviderUsage ?? Number.POSITIVE_INFINITY) - (bProviderUsage ?? Number.POSITIVE_INFINITY);
 		}
 
+		// Prefer vision-capable variants over configured provider/registration order
+		// so an ambiguous id never resolves to a text-only namesake when a
+		// vision-capable variant of the same id is available.
+		const aVision = a.input.includes("image") ? 0 : 1;
+		const bVision = b.input.includes("image") ? 0 : 1;
+		if (aVision !== bVision) {
+			return aVision - bVision;
+		}
+
 		const aDeprioritized = context.deprioritizedProviders.has(a.provider);
 		const bDeprioritized = context.deprioritizedProviders.has(b.provider);
 		if (aDeprioritized !== bDeprioritized) {
@@ -520,7 +528,7 @@ function normalizeModelPatternList(value: string | string[] | undefined): string
 }
 
 function isSessionInheritedAgentPattern(value: string): boolean {
-	return value === DEFAULT_MODEL_ROLE || value === `${PREFIX_MODEL_ROLE}${DEFAULT_MODEL_ROLE}` || value === "pi/task";
+	return value === DEFAULT_MODEL_ROLE || value === `${PREFIX_MODEL_ROLE}${DEFAULT_MODEL_ROLE}`;
 }
 
 function resolveConfiguredRolePattern(value: string, settings?: Settings): string[] | undefined {
@@ -535,8 +543,7 @@ function resolveConfiguredRolePattern(value: string, settings?: Settings): strin
 	if (!role) return [normalized];
 
 	const configured = settings?.getModelRole(role)?.trim();
-	const roleDefaults = normalizeModelPatternList(MODEL_PRIO[role as keyof typeof MODEL_PRIO]);
-	const resolved = configured ? normalizeModelPatternList(configured) : roleDefaults;
+	const resolved = configured ? normalizeModelPatternList(configured) : undefined;
 	if (!resolved || resolved.length === 0) {
 		return undefined;
 	}
@@ -545,7 +552,7 @@ function resolveConfiguredRolePattern(value: string, settings?: Settings): strin
 }
 
 /**
- * Expand a role alias like "pi/smol" to the configured model string.
+ * Expand a role alias like "pi/default" to the configured model string.
  */
 export function expandRoleAlias(value: string, settings?: Settings): string {
 	const normalized = value.trim();
@@ -582,9 +589,8 @@ export function resolveAgentModelPatterns(options: AgentModelPatternResolutionOp
 	const configuredAgentPatterns = resolveConfiguredModelPatterns(agentModel, settings);
 	const singleAgentPattern = normalizedAgentPatterns.length === 1 ? normalizedAgentPatterns[0] : undefined;
 	const agentInheritsSessionModel = singleAgentPattern ? isSessionInheritedAgentPattern(singleAgentPattern) : false;
-	if (configuredAgentPatterns.length > 0) {
-		if (!agentInheritsSessionModel) return configuredAgentPatterns;
-		if (singleAgentPattern === "pi/task") return configuredAgentPatterns;
+	if (configuredAgentPatterns.length > 0 && !agentInheritsSessionModel) {
+		return configuredAgentPatterns;
 	}
 
 	const fallback =
@@ -1325,79 +1331,3 @@ export async function restoreModelFromSession(
 	// No models available
 	return { model: undefined, fallbackMessage: undefined };
 }
-
-/**
- * Find a smol/fast model using the priority chain.
- * Tries exact matches first, then fuzzy matches.
- *
- * @param modelRegistry The model registry to search
- * @param savedModel Optional saved model string from settings (provider/modelId)
- * @returns The best available smol model, or undefined if none found
- */
-export async function findSmolModel(
-	modelRegistry: ModelLookupRegistry,
-	savedModel?: string,
-): Promise<Model<Api> | undefined> {
-	const availableModels = modelRegistry.getAvailable();
-	if (availableModels.length === 0) return undefined;
-
-	// 1. Try saved model from settings
-	if (savedModel) {
-		const match = resolveModelFromString(savedModel, availableModels, undefined, modelRegistry);
-		if (match) return match;
-	}
-
-	// 2. Try priority chain
-	for (const pattern of MODEL_PRIO.smol) {
-		// Try exact match with provider prefix
-		const providerMatch = availableModels.find(m => `${m.provider}/${m.id}`.toLowerCase() === pattern);
-		if (providerMatch) return providerMatch;
-
-		// Try exact match first
-		const exactMatch = parseModelPattern(pattern, availableModels, undefined, { modelRegistry }).model;
-		if (exactMatch) return exactMatch;
-
-		// Try fuzzy match (substring)
-		const fuzzyMatch = availableModels.find(m => m.id.toLowerCase().includes(pattern));
-		if (fuzzyMatch) return fuzzyMatch;
-	}
-
-	// 3. Fallback to first available (same as default)
-	return availableModels[0];
-}
-
-/**
- * Find a slow/comprehensive model using the priority chain.
- * Prioritizes reasoning and OpenAI code backend models for thorough analysis.
- *
- * @param modelRegistry The model registry to search
- * @param savedModel Optional saved model string from settings (provider/modelId)
- * @returns The best available slow model, or undefined if none found
- */
-export async function findSlowModel(
-	modelRegistry: ModelLookupRegistry,
-	savedModel?: string,
-): Promise<Model<Api> | undefined> {
-	const availableModels = modelRegistry.getAvailable();
-	if (availableModels.length === 0) return undefined;
-
-	// 1. Try saved model from settings
-	if (savedModel) {
-		const match = resolveModelFromString(savedModel, availableModels, undefined, modelRegistry);
-		if (match) return match;
-	}
-
-	// 2. Try priority chain
-	for (const pattern of MODEL_PRIO.slow) {
-		// Try exact match first
-		const exactMatch = parseModelPattern(pattern, availableModels, undefined, { modelRegistry }).model;
-		if (exactMatch) return exactMatch;
-
-		// Try fuzzy match (substring)
-		const fuzzyMatch = availableModels.find(m => m.id.toLowerCase().includes(pattern.toLowerCase()));
-		if (fuzzyMatch) return fuzzyMatch;
-	}
-
-	// 3. Fallback to first available (same as default)
-	return availableModels[0];
-}

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

@@ -135,6 +135,7 @@ const ModelDefinitionSchema = z
 		reasoning: z.boolean().optional(),
 		thinking: ModelThinkingSchema.optional(),
 		input: z.array(z.enum(["text", "image"])).optional(),
+		output: z.array(z.enum(["text", "image"])).optional(),
 		cost: z
 			.object({
 				input: z.number(),
@@ -161,6 +162,7 @@ export const ModelOverrideSchema = z
 		reasoning: z.boolean().optional(),
 		thinking: ModelThinkingSchema.optional(),
 		input: z.array(z.enum(["text", "image"])).optional(),
+		output: z.array(z.enum(["text", "image"])).optional(),
 		cost: z
 			.object({
 				input: z.number().optional(),

package/src/config/settings-schema.ts

@@ -938,6 +938,18 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	busyPromptMode: {
+		type: "enum",
+		values: ["steer", "queue"] as const,
+		default: "steer",
+		ui: {
+			tab: "interaction",
+			label: "Busy Prompt Mode",
+			description:
+				"What a submitted prompt does while the agent is busy: steer (interrupt the active turn) or queue (run after the active turn completes)",
+		},
+	},
+
 	// Input and startup
 	doubleEscapeAction: {
 		type: "enum",
@@ -2627,7 +2639,7 @@ export const SETTINGS_SCHEMA = {
 	},
 	"providers.image": {
 		type: "enum",
-		values: ["auto", "openai", "gemini", "openrouter"] as const,
+		values: ["auto", "openai", "gemini", "openrouter", "antigravity"] as const,
 		default: "auto",
 		ui: {
 			tab: "providers",
@@ -2642,6 +2654,7 @@ export const SETTINGS_SCHEMA = {
 				{ value: "openai", label: "OpenAI", description: "Uses the active GPT Responses/Codex model" },
 				{ value: "gemini", label: "Gemini", description: "Requires GEMINI_API_KEY" },
 				{ value: "openrouter", label: "OpenRouter", description: "Requires OPENROUTER_API_KEY" },
+				{ value: "antigravity", label: "Antigravity", description: "Requires login with google-antigravity" },
 			],
 		},
 	},

package/src/coordinator/contract.ts

@@ -0,0 +1,20 @@
+export const COORDINATOR_MCP_PROTOCOL_VERSION = "2024-11-05";
+export const COORDINATOR_MCP_SERVER_NAME = "gjc-coordinator-mcp";
+
+export const COORDINATOR_MCP_TOOL_NAMES = [
+	"gjc_coordinator_list_sessions",
+	"gjc_coordinator_read_status",
+	"gjc_coordinator_read_tail",
+	"gjc_coordinator_list_questions",
+	"gjc_coordinator_list_artifacts",
+	"gjc_coordinator_read_artifact",
+	"gjc_coordinator_read_coordination_status",
+	"gjc_coordinator_start_session",
+	"gjc_coordinator_send_prompt",
+	"gjc_coordinator_submit_question_answer",
+	"gjc_coordinator_read_turn",
+	"gjc_coordinator_await_turn",
+	"gjc_coordinator_report_status",
+] as const;
+
+export type CoordinatorToolName = (typeof COORDINATOR_MCP_TOOL_NAMES)[number];

package/src/coordinator-mcp/policy.ts

@@ -0,0 +1,160 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+export type CoordinatorMutationClass = "sessions" | "questions" | "reports";
+
+export interface CoordinatorNamespace {
+	profile: string | null;
+	repo: string | null;
+}
+
+export interface CoordinatorMcpConfig {
+	allowedRoots: string[];
+	mutationClasses: Set<CoordinatorMutationClass>;
+	artifactByteCap: number;
+	namespace: CoordinatorNamespace;
+	stateRoot: string;
+	sessionCommand: string | null;
+}
+
+export interface CoordinatorMutationRequest {
+	allow_mutation?: boolean;
+}
+
+const DEFAULT_ARTIFACT_BYTE_CAP = 64 * 1024;
+const MAX_ARTIFACT_BYTE_CAP = 1024 * 1024;
+const MUTATION_CLASSES = new Set<CoordinatorMutationClass>(["sessions", "questions", "reports"]);
+const LEGACY_MUTATION_CLASS_ALIASES = new Map<string, CoordinatorMutationClass>([
+	["session", "sessions"],
+	["prompt", "sessions"],
+	["question", "questions"],
+	["report", "reports"],
+]);
+
+function parseList(value: string | undefined): string[] {
+	return (value ?? "")
+		.split(/[\n,;:]+/)
+		.map(part => part.trim())
+		.filter(Boolean);
+}
+
+function parseRootList(value: string | undefined): string[] {
+	const normalized = (value ?? "").replace(/[\n,;]+/g, path.delimiter);
+	return normalized
+		.split(path.delimiter)
+		.map(part => part.trim())
+		.filter(Boolean);
+}
+
+function parseMutationClasses(value: string | undefined): Set<CoordinatorMutationClass> {
+	const classes = new Set<CoordinatorMutationClass>();
+	for (const raw of parseList(value)) {
+		const normalized = raw.toLowerCase();
+		if (normalized === "all") {
+			for (const mutationClass of MUTATION_CLASSES) classes.add(mutationClass);
+			continue;
+		}
+		const mutationClass = LEGACY_MUTATION_CLASS_ALIASES.get(normalized) ?? normalized;
+		if (MUTATION_CLASSES.has(mutationClass as CoordinatorMutationClass))
+			classes.add(mutationClass as CoordinatorMutationClass);
+	}
+	return classes;
+}
+
+function parseByteCap(value: string | undefined): number {
+	const parsed = Number.parseInt(value ?? "", 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_ARTIFACT_BYTE_CAP;
+	return Math.min(parsed, MAX_ARTIFACT_BYTE_CAP);
+}
+
+function cleanScope(value: string | undefined): string | null {
+	const trimmed = value?.trim();
+	if (!trimmed) return null;
+	return trimmed.replace(/[^a-zA-Z0-9_.-]+/g, "-").slice(0, 100) || null;
+}
+
+export function buildCoordinatorMcpConfig(env: NodeJS.ProcessEnv = process.env): CoordinatorMcpConfig {
+	const stateRoot =
+		env.GJC_COORDINATOR_MCP_STATE_ROOT?.trim() || path.join(process.cwd(), ".gjc", "state", "coordinator-mcp");
+	return {
+		allowedRoots: parseRootList(env.GJC_COORDINATOR_MCP_WORKDIR_ROOTS).map(root => path.resolve(root)),
+		mutationClasses: parseMutationClasses(
+			env.GJC_COORDINATOR_MCP_MUTATIONS ?? env.GJC_COORDINATOR_MCP_ENABLE_MUTATION_CLASSES,
+		),
+		artifactByteCap: parseByteCap(
+			env.GJC_COORDINATOR_MCP_ARTIFACT_BYTE_CAP ?? env.GJC_COORDINATOR_MCP_ARTIFACT_MAX_BYTES,
+		),
+		namespace: {
+			profile: cleanScope(env.GJC_COORDINATOR_MCP_PROFILE),
+			repo: cleanScope(env.GJC_COORDINATOR_MCP_REPO),
+		},
+		stateRoot: path.resolve(stateRoot),
+		sessionCommand: env.GJC_COORDINATOR_MCP_SESSION_COMMAND?.trim() || null,
+	};
+}
+
+async function realpathIfExists(value: string): Promise<string> {
+	try {
+		return await fs.realpath(value);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+		const parent = await fs.realpath(path.dirname(value));
+		return path.join(parent, path.basename(value));
+	}
+}
+
+function isInside(candidate: string, root: string): boolean {
+	const relative = path.relative(root, candidate);
+	return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+async function canonicalAllowedRoots(config: CoordinatorMcpConfig): Promise<string[]> {
+	const roots = await Promise.all(config.allowedRoots.map(root => realpathIfExists(root)));
+	return roots.map(root => path.resolve(root));
+}
+
+export async function assertCoordinatorWorkdir(config: CoordinatorMcpConfig, cwd: unknown): Promise<string> {
+	if (typeof cwd !== "string" || cwd.trim().length === 0) throw new Error("coordinator_workdir_required");
+	if (config.allowedRoots.length === 0) throw new Error("coordinator_workdir_roots_required");
+	const requested = path.resolve(cwd);
+	const canonicalRequested = await realpathIfExists(requested);
+	const roots = await canonicalAllowedRoots(config);
+	if (!roots.some(root => isInside(canonicalRequested, root))) {
+		throw new Error(`coordinator_workdir_outside_allowed_roots:${requested}`);
+	}
+	return requested;
+}
+
+export async function assertCoordinatorArtifactPath(
+	config: CoordinatorMcpConfig,
+	artifactPath: unknown,
+): Promise<{ path: string; byteCap: number }> {
+	if (typeof artifactPath !== "string" || artifactPath.trim().length === 0)
+		throw new Error("coordinator_artifact_path_required");
+	if (config.allowedRoots.length === 0) throw new Error("coordinator_artifact_roots_required");
+	const requested = path.resolve(artifactPath);
+	const canonicalRequested = await realpathIfExists(requested);
+	const roots = await canonicalAllowedRoots(config);
+	if (!roots.some(root => isInside(canonicalRequested, root))) {
+		throw new Error(`coordinator_artifact_outside_allowed_roots:${requested}`);
+	}
+	return { path: requested, byteCap: config.artifactByteCap };
+}
+
+export function requireCoordinatorMutation(
+	config: CoordinatorMcpConfig,
+	mutationClass: CoordinatorMutationClass,
+	request: CoordinatorMutationRequest,
+): void {
+	if (!config.mutationClasses.has(mutationClass))
+		throw new Error(`coordinator_mutation_class_disabled:${mutationClass}`);
+	if (request.allow_mutation !== true) throw new Error(`coordinator_mutation_call_not_allowed:${mutationClass}`);
+}
+
+export function coordinatorNamespacePath(config: CoordinatorMcpConfig): string {
+	return path.join(
+		config.stateRoot,
+		config.namespace.profile ?? "unscoped-profile",
+		config.namespace.repo ?? "unscoped-repo",
+	);
+}