llm-cli-gateway 2.4.0 → 2.6.0

package/dist/index.js

@@ -2,11 +2,12 @@
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { randomUUID } from "crypto";
-import { existsSync, readFileSync, readdirSync, renameSync, unlinkSync } from "fs";
+import { createRequire } from "module";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync, chmodSync, } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { z } from "zod/v3";
-import { executeCli, killAllProcessGroups } from "./executor.js";
+import { executeCli, killAllProcessGroups, providerCommandName } from "./executor.js";
 import { parseStreamJson } from "./stream-json-parser.js";
 import { parseCodexJsonStream } from "./codex-json-parser.js";
 import { parseGeminiJson, parseGeminiStreamJson } from "./gemini-json-parser.js";
@@ -17,7 +18,7 @@ import { createWorktree, createWorktreeSessionCleanupHook, } from "./worktree-ma
 import { ResourceProvider } from "./resources.js";
 import { PerformanceMetrics } from "./metrics.js";
 import { estimateTokens, optimizePrompt as optimizePromptText, optimizeResponse as optimizeResponseText, } from "./optimizer.js";
-import { loadConfig, loadPersistenceConfig, loadCacheAwarenessConfig, loadProvidersConfig, isXaiProviderEnabled, minStableTokensForModel, } from "./config.js";
+import { loadConfig, loadPersistenceConfig, loadCacheAwarenessConfig, loadProvidersConfig, defaultGatewayConfigPath, isXaiProviderEnabled, minStableTokensForModel, } from "./config.js";
 import { createXaiResponse, XaiApiError, } from "./xai-api-provider.js";
 import { checkHealth } from "./health.js";
 import { clearModelRegistryCache, getAvailableCliInfo, getCliInfo, resolveModelAlias, } from "./model-registry.js";
@@ -26,15 +27,19 @@ import { createJobStore } from "./job-store.js";
 import { ApprovalManager } from "./approval-manager.js";
 import { checkReviewIntegrity } from "./review-integrity.js";
 import { buildClaudeMcpConfig, CLAUDE_MCP_SERVER_NAMES, } from "./claude-mcp-config.js";
-import { resolveGrokSessionArgs, resolveMistralSessionArgs, resolveCodexSessionArgs, sanitizeCliArgValues, prepareMistralRequest as buildMistralCliInvocation, MISTRAL_AGENT_MODES, GATEWAY_SESSION_PREFIX, resolveClaudePermissionFlags, resolveCodexSandboxFlags, CLAUDE_PERMISSION_MODES, GEMINI_APPROVAL_MODES, CODEX_SANDBOX_MODES, CODEX_ASK_FOR_APPROVAL_MODES, CLAUDE_EFFORT_LEVELS, prepareClaudeHighImpactFlags, validateClaudeAgentsMap, prepareCodexHighImpactFlags, prepareCodexForkRequest, CODEX_CONFIG_OVERRIDES_SCHEMA, prepareGeminiHighImpactFlags, prependGeminiAttachments, resolveGeminiSessionPlan, GEMINI_HIGH_IMPACT_PARAMS_SCHEMA, } from "./request-helpers.js";
+import { resolveGrokSessionArgs, resolveMistralSessionArgs, resolveCodexSessionArgs, sanitizeCliArgValues, prepareMistralRequest as buildMistralCliInvocation, MISTRAL_AGENT_MODES, GATEWAY_SESSION_PREFIX, resolveClaudePermissionFlags, resolveCodexSandboxFlags, CLAUDE_PERMISSION_MODES, GEMINI_APPROVAL_MODES, CODEX_SANDBOX_MODES, CODEX_ASK_FOR_APPROVAL_MODES, CLAUDE_EFFORT_LEVELS, prepareClaudeHighImpactFlags, validateClaudeAgentsMap, prepareCodexHighImpactFlags, prepareCodexForkRequest, CODEX_CONFIG_OVERRIDES_SCHEMA, resolveGeminiSessionPlan, GEMINI_HIGH_IMPACT_PARAMS_SCHEMA, } from "./request-helpers.js";
 import { createFlightRecorder } from "./flight-recorder.js";
 import { resolvePromptInput, PromptPartsSchema, assembleClaudeCacheBlocks, } from "./prompt-parts.js";
 import { computeSessionCacheStats, computeTtlRemaining, readPersistedRequest, PERSISTED_REQUEST_DEFAULT_MAX_CHARS, } from "./cache-stats.js";
 import { getCliVersions, runCliUpgrade } from "./cli-updater.js";
 import { startHttpGateway } from "./http-transport.js";
+import { getRequestContext } from "./request-context.js";
 import { printDoctorJson } from "./doctor.js";
+import { createWorkspace, describeWorkspace, getWorkspace, loadWorkspaceRegistry, registerExistingWorkspace, resolveWorkspaceForProvider, validatePathInsideWorkspace, } from "./workspace-registry.js";
+import { generateSecret, hashSecret } from "./oauth.js";
 import { registerValidationTools } from "./validation-tools.js";
-import { assertUpstreamCliArgs, assertUpstreamCliEnv, buildProviderSubcommandsCompactCatalog, buildUpstreamContractReport, getCliSubcommandContract, probeInstalledCliContract, serializeCliSubcommandContract, } from "./upstream-contracts.js";
+import { assertUpstreamCliArgs, assertUpstreamCliEnv, buildProviderSubcommandsCompactCatalog, buildUpstreamContractReport, getCliSubcommandContract, probeInstalledCliContract, serializeCliSubcommandContract, UPSTREAM_CLI_CONTRACTS, } from "./upstream-contracts.js";
+import { buildArgvFromGeneration, deriveZodShapeFromGeneration, GROK_FLAG_GENERATION, GROK_GEN_OUTPUT_FORMAT, GROK_GEN_MAIN, GROK_GEN_PROMPT_FILE, GROK_GEN_SINGLE, GROK_GEN_TAIL, } from "./provider-codegen.js";
 import { entrypointFileURL } from "./entrypoint-url.js";
 const logger = {
     info: (message, ...args) => {
@@ -158,7 +163,7 @@ Other: list_models, cli_versions, upstream_contracts, provider_subcommands_* (re
 
 Key behaviors:
 ${deferralLine}
-- Sessions: Claude --continue, Gemini --resume, Grok --resume/--continue, Mistral --resume/--continue (current Vibe defaults session logging on; doctor flags explicit session_logging.enabled=false), Codex \`exec resume <ID>\` / \`exec resume --last\` (all real CLI continuity). For Codex, sessionId must be a real Codex UUID (from ~/.codex/sessions/); gateway-generated gw-* IDs are rejected.
+- Sessions: Claude --continue, Gemini (Antigravity) --conversation <id>/--continue, Grok --resume/--continue, Mistral --resume/--continue (current Vibe defaults session logging on; doctor flags explicit session_logging.enabled=false), Codex \`exec resume <ID>\` / \`exec resume --last\` (all real CLI continuity). For Codex, sessionId must be a real Codex UUID (from ~/.codex/sessions/); gateway-generated gw-* IDs are rejected.
 - Approval gates: opt-in via approvalStrategy:"mcp_managed".
 - Upstream drift detection: After upgrading any provider CLI (especially grok), use upstream_contracts with probeInstalled:true and provider_subcommand_drift for declared subcommand help surfaces. Probes are safe, read-only --help checks.
 - Idle timeout kills stuck processes (default 10min, configurable via idleTimeoutMs).
@@ -226,6 +231,7 @@ function getApprovalManager(runtimeLogger = logger) {
 const MCP_SERVER_ENUM = z.enum(CLAUDE_MCP_SERVER_NAMES);
 const CLI_TYPE_ENUM = z.enum(CLI_TYPES);
 export const MAX_TURNS_SCHEMA = z.number().int().positive().safe().max(10_000);
+const GROK_GENERATED_SHAPE = deriveZodShapeFromGeneration(UPSTREAM_CLI_CONTRACTS.grok, GROK_FLAG_GENERATION);
 export const MAX_TOKENS_SCHEMA = z.number().int().positive().safe().max(100_000_000);
 export const MAX_PRICE_SCHEMA = z.number().positive().finite().min(1e-6).max(10_000);
 export const WORKTREE_SCHEMA = z
@@ -252,6 +258,12 @@ export const WORKTREE_SCHEMA = z
     "path. NOTE: callers should `.gitignore` the `.worktrees/` " +
     "directory in their repo (the gateway does NOT auto-gitignore — " +
     "see slice λ spec Q4).");
+export const WORKSPACE_ALIAS_SCHEMA = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[A-Za-z][A-Za-z0-9._-]{0,63}$/)
+    .describe("Registered workspace alias. Remote clients use aliases, not absolute paths.");
 export const SESSION_PROVIDER_VALUES = PROVIDER_TYPES;
 export const SESSION_PROVIDER_ENUM = z.enum(SESSION_PROVIDER_VALUES);
 let activeServer = null;
@@ -286,6 +298,7 @@ export function resolveGatewayServerRuntime(deps = {}, options = {}) {
         persistence: deps.persistence ?? getPersistenceConfig(runtimeLogger),
         cacheAwareness: deps.cacheAwareness ?? getCacheAwarenessConfig(runtimeLogger),
         providers: deps.providers ?? getProvidersConfig(runtimeLogger),
+        workspaces: deps.workspaces ?? loadWorkspaceRegistry(runtimeLogger),
     };
 }
 export function shouldRegisterGrokApiTools(providers) {
@@ -329,7 +342,7 @@ async function awaitJobOrDefer(cli, args, corrId, idleTimeoutMs, outputFormat, f
         runtime.persistence.asyncJobsEnabled &&
         runtime.asyncJobManager.hasStore();
     if (SYNC_DEADLINE_MS === 0 || !deferralAvailable) {
-        const command = cli === "mistral" ? "vibe" : cli;
+        const command = providerCommandName(cli);
         try {
             return await executeCli(command, args, {
                 idleTimeout: idleTimeoutMs,
@@ -415,7 +428,7 @@ function buildDeferredToolResponse(deferred, sessionId) {
         ],
     };
 }
-export async function resolveWorktreeForRequest(worktreeOpt, sessionId, runtime) {
+export async function resolveWorktreeForRequest(worktreeOpt, sessionId, runtime, options = {}) {
     if (!worktreeOpt)
         return {};
     const sessionManager = runtime.sessionManager;
@@ -423,12 +436,21 @@ export async function resolveWorktreeForRequest(worktreeOpt, sessionId, runtime)
         const session = await Promise.resolve(sessionManager.getSession(sessionId));
         const existingPath = session?.metadata?.worktreePath;
         if (typeof existingPath === "string" && existingPath.length > 0) {
-            return { cwd: existingPath, worktreePath: existingPath };
+            return {
+                cwd: existingPath,
+                worktreePath: existingPath,
+                workspaceAlias: typeof session?.metadata?.workspaceAlias === "string"
+                    ? session.metadata.workspaceAlias
+                    : options.workspaceAlias,
+                workspaceRoot: typeof session?.metadata?.workspaceRoot === "string"
+                    ? session.metadata.workspaceRoot
+                    : options.workspaceRoot,
+            };
         }
     }
     const name = worktreeOpt === true ? undefined : worktreeOpt.name;
     const ref = worktreeOpt === true ? undefined : worktreeOpt.ref;
-    const repoRoot = process.cwd();
+    const repoRoot = options.repoRoot ?? process.cwd();
     const handle = await createWorktree({
         repoRoot,
         name,
@@ -439,13 +461,204 @@ export async function resolveWorktreeForRequest(worktreeOpt, sessionId, runtime)
         await Promise.resolve(sessionManager.updateSessionMetadata(sessionId, {
             worktreePath: handle.path,
             worktreeName: handle.name,
+            ...(options.workspaceAlias ? { workspaceAlias: options.workspaceAlias } : {}),
+            ...(options.workspaceRoot ? { workspaceRoot: options.workspaceRoot } : {}),
+        }));
+    }
+    return {
+        cwd: handle.path,
+        worktreePath: handle.path,
+        workspaceAlias: options.workspaceAlias,
+        workspaceRoot: options.workspaceRoot,
+    };
+}
+function isGatewayAppDirCwd() {
+    return process.cwd() === join(homedir(), ".llm-cli-gateway");
+}
+async function resolveWorkspaceAndWorktreeForRequest(args) {
+    const session = args.sessionId
+        ? await Promise.resolve(args.runtime.sessionManager.getSession(args.sessionId))
+        : null;
+    let workspace;
+    if (args.workspace ||
+        args.runtime.workspaces.defaultAlias ||
+        typeof session?.metadata?.workspaceAlias === "string") {
+        workspace = resolveWorkspaceForProvider(args.runtime.workspaces, args.provider, args.workspace, session?.metadata);
+    }
+    else if (isGatewayAppDirCwd()) {
+        throw new Error("No workspace selected. Configure [workspaces].default or pass a registered workspace alias.");
+    }
+    if (!workspace && getRequestContext()?.authKind === "oauth") {
+        throw new Error("Remote OAuth provider requests require a registered workspace alias or [workspaces].default.");
+    }
+    if (!workspace &&
+        (args.workingDir || (args.addDir?.length ?? 0) > 0) &&
+        !args.runtime.workspaces.allowUnregisteredWorkingDir) {
+        throw new Error("workingDir/addDir require a registered workspace alias unless [workspaces].allow_unregistered_working_dir is explicitly enabled.");
+    }
+    if (workspace) {
+        if (args.workingDir) {
+            validatePathInsideWorkspace(workspace, args.workingDir, "workingDir");
+        }
+        for (const dir of args.addDir ?? []) {
+            validatePathInsideWorkspace(workspace, dir, "addDir");
+        }
+    }
+    if (args.worktree) {
+        if (workspace && !workspace.repo.allowWorktree) {
+            throw new Error(`Workspace "${workspace.alias}" does not allow worktree requests`);
+        }
+        const resolved = await resolveWorktreeForRequest(args.worktree, args.sessionId, args.runtime, {
+            repoRoot: workspace?.root,
+            workspaceAlias: workspace?.alias,
+            workspaceRoot: workspace?.root,
+        });
+        return { cwd: resolved.cwd, worktreePath: resolved.worktreePath, workspace };
+    }
+    if (workspace && args.sessionId) {
+        await Promise.resolve(args.runtime.sessionManager.updateSessionMetadata(args.sessionId, {
+            workspaceAlias: workspace.alias,
+            workspaceRoot: workspace.root,
         }));
     }
-    return { cwd: handle.path, worktreePath: handle.path };
+    return { cwd: workspace?.cwd, workspace };
 }
 export function formatWorktreePrefix(worktreePath) {
     return worktreePath ? `[gateway] worktree=${worktreePath}\n` : "";
 }
+function workspaceAdminEnabled() {
+    const scopes = getRequestContext()?.authScopes ?? [];
+    return process.env.LLM_GATEWAY_WORKSPACE_ADMIN === "1" && scopes.includes("workspace:admin");
+}
+function registerWorkspaceTools(server, runtime) {
+    server.tool("workspace_list", "List registered workspace aliases and summary metadata. Does not browse files.", {}, {
+        title: "List workspaces",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    }, async () => {
+        const registry = loadWorkspaceRegistry(runtime.logger);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        enabled: registry.enabled,
+                        default: registry.defaultAlias,
+                        workspaces: registry.repos.map(describeWorkspace),
+                        allowed_roots: registry.allowedRoots.map(root => ({
+                            alias: root.alias,
+                            path: root.path,
+                            allow_register_existing_git_repos: root.allowRegisterExistingGitRepos,
+                            allow_create_directories: root.allowCreateDirectories,
+                            allow_init_git_repos: root.allowInitGitRepos,
+                            max_create_depth: root.maxCreateDepth,
+                        })),
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("workspace_get", "Inspect a registered workspace alias. Does not list files.", { alias: WORKSPACE_ALIAS_SCHEMA }, {
+        title: "Get workspace",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    }, async ({ alias }) => {
+        try {
+            const registry = loadWorkspaceRegistry(runtime.logger);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ success: true, workspace: describeWorkspace(getWorkspace(registry, alias)) }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return createErrorResponse("workspace_get", 1, "", undefined, error);
+        }
+    });
+    server.tool("workspace_create", "Create a new local folder or git repo under a configured allowed root. Requires LLM_GATEWAY_WORKSPACE_ADMIN=1 and OAuth scope workspace:admin.", {
+        alias: WORKSPACE_ALIAS_SCHEMA,
+        root: WORKSPACE_ALIAS_SCHEMA.describe("Allowed-root alias from workspace_list."),
+        slug: z.string().min(1).max(255).describe("Safe relative path under the allowed root."),
+        kind: z.enum(["folder", "git"]).default("git"),
+        setDefault: z.boolean().default(false),
+    }, {
+        title: "Create workspace",
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false,
+    }, async ({ alias, root, slug, kind, setDefault }) => {
+        try {
+            if (!workspaceAdminEnabled()) {
+                throw new Error("workspace_create requires LLM_GATEWAY_WORKSPACE_ADMIN=1 and OAuth scope workspace:admin");
+            }
+            const repo = createWorkspace({
+                alias,
+                rootAlias: root,
+                slug,
+                kind,
+                setDefault,
+                logger: runtime.logger,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ success: true, workspace: describeWorkspace(repo) }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return createErrorResponse("workspace_create", 1, "", undefined, error);
+        }
+    });
+    server.tool("workspace_register_existing_repo", "Register an existing local Git repo under an allowed root. Requires LLM_GATEWAY_WORKSPACE_ADMIN=1 and OAuth scope workspace:admin.", {
+        alias: WORKSPACE_ALIAS_SCHEMA,
+        path: z
+            .string()
+            .min(1)
+            .describe("Absolute path to an existing Git repo under an allowed root."),
+        setDefault: z.boolean().default(false),
+    }, {
+        title: "Register workspace",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+    }, async ({ alias, path, setDefault }) => {
+        try {
+            if (!workspaceAdminEnabled()) {
+                throw new Error("workspace_register_existing_repo requires LLM_GATEWAY_WORKSPACE_ADMIN=1 and OAuth scope workspace:admin");
+            }
+            const repo = registerExistingWorkspace({
+                alias,
+                repoPath: path,
+                setDefault,
+                logger: runtime.logger,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ success: true, workspace: describeWorkspace(repo) }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return createErrorResponse("workspace_register_existing_repo", 1, "", undefined, error);
+        }
+    });
+}
 function createErrorResponse(cli, code, stderr, correlationId, error) {
     let errorMessage = `Error executing ${cli} CLI`;
     const isLaunchExit = code === 127 || code === -4058;
@@ -476,6 +689,7 @@ function createErrorResponse(cli, code, stderr, correlationId, error) {
         content: [{ type: "text", text: errorMessage }],
         isError: true,
         structuredContent: {
+            response: errorMessage,
             correlationId: correlationId || null,
             cli,
             exitCode: code,
@@ -900,7 +1114,7 @@ export function prepareClaudeRequest(params, runtime = resolveGatewayServerRunti
         logOptimizationTokens("prompt", corrId, effectivePrompt, optimized);
         effectivePrompt = optimized;
     }
-    const requestedMcpServers = normalizeMcpServers(params.mcpServers);
+    const requestedMcpServers = params.mcpServers ? [...new Set(params.mcpServers)] : [];
     const mcpConfigResolution = resolveClaudeMcpConfig(params.operation, corrId, requestedMcpServers, params.strictMcpConfig);
     if ("errorResponse" in mcpConfigResolution) {
         return mcpConfigResolution.errorResponse;
@@ -1109,7 +1323,7 @@ export function prepareCodexRequest(params, runtime = resolveGatewayServerRuntim
         logOptimizationTokens("prompt", corrId, effectivePrompt, optimized);
         effectivePrompt = optimized;
     }
-    const requestedMcpServers = normalizeMcpServers(params.mcpServers);
+    const requestedMcpServers = params.mcpServers ? [...new Set(params.mcpServers)] : [];
     let approvalDecision = null;
     if (params.approvalStrategy === "mcp_managed") {
         approvalDecision = runtime.approvalManager.decide({
@@ -1267,7 +1481,7 @@ export function prepareGeminiRequest(params, runtime = resolveGatewayServerRunti
         logOptimizationTokens("prompt", corrId, effectivePrompt, optimized);
         effectivePrompt = optimized;
     }
-    const requestedMcpServers = normalizeMcpServers(params.mcpServers);
+    const requestedMcpServers = params.mcpServers ? [...new Set(params.mcpServers)] : [];
     let approvalDecision = null;
     if (params.approvalStrategy === "mcp_managed") {
         approvalDecision = runtime.approvalManager.decide({
@@ -1287,51 +1501,45 @@ export function prepareGeminiRequest(params, runtime = resolveGatewayServerRunti
         }
     }
     const effectiveApprovalMode = params.approvalStrategy === "mcp_managed" ? "yolo" : params.approvalMode;
-    const highImpact = prepareGeminiHighImpactFlags({
-        sandbox: params.sandbox,
-        policyFiles: params.policyFiles,
-        adminPolicyFiles: params.adminPolicyFiles,
-    });
-    if (highImpact.missingPolicyPath) {
-        return createErrorResponse(params.operation, 1, "", corrId, new Error(`${highImpact.missingPolicyField}: path does not exist: ${highImpact.missingPolicyPath}`));
-    }
-    if (params.attachments && params.attachments.length > 0) {
-        try {
-            effectivePrompt = prependGeminiAttachments(effectivePrompt, params.attachments);
-        }
-        catch (err) {
-            return createErrorResponse(params.operation, 1, "", corrId, err instanceof Error ? err : new Error(String(err)));
-        }
-    }
-    const args = ["-p", effectivePrompt];
-    if (resolvedModel)
-        args.push("--model", resolvedModel);
-    if (effectiveApprovalMode)
-        args.push("--approval-mode", effectiveApprovalMode);
-    if (params.yolo && effectiveApprovalMode !== "yolo") {
-        args.push("--yolo");
+    const unsupported = (field, detail) => createErrorResponse(params.operation, 1, "", corrId, new Error(`${field} is not supported by Antigravity CLI (agy): ${detail}`));
+    if (effectiveApprovalMode &&
+        effectiveApprovalMode !== "default" &&
+        effectiveApprovalMode !== "yolo") {
+        return unsupported("approvalMode", "use 'default' for prompted execution or 'yolo'/yolo=true for --dangerously-skip-permissions");
     }
     if (params.allowedTools && params.allowedTools.length > 0) {
-        sanitizeCliArgValues(params.allowedTools, "allowedTools");
-        params.allowedTools.forEach(tool => args.push("--allowed-tools", tool));
+        return unsupported("allowedTools", "agy has no non-interactive allowed-tools flag");
     }
     if (requestedMcpServers.length > 0) {
-        sanitizeCliArgValues(requestedMcpServers, "mcpServers");
-        requestedMcpServers.forEach(serverName => args.push("--allowed-mcp-server-names", serverName));
+        return unsupported("mcpServers", "agy has no non-interactive allowed MCP server allowlist flag");
     }
-    if (params.includeDirs && params.includeDirs.length > 0) {
-        sanitizeCliArgValues(params.includeDirs, "includeDirs");
-        params.includeDirs.forEach(dir => args.push("--include-directories", dir));
+    if (params.outputFormat && params.outputFormat !== "text") {
+        return unsupported("outputFormat", "agy print mode currently emits text only");
     }
-    args.push(...highImpact.args);
-    if (params.outputFormat === "json") {
-        args.push("-o", "json");
+    if (params.policyFiles && params.policyFiles.length > 0) {
+        return unsupported("policyFiles", "agy has no --policy flag");
     }
-    else if (params.outputFormat === "stream-json") {
-        args.push("-o", "stream-json");
+    if (params.adminPolicyFiles && params.adminPolicyFiles.length > 0) {
+        return unsupported("adminPolicyFiles", "agy has no --admin-policy flag");
+    }
+    if (params.attachments && params.attachments.length > 0) {
+        return unsupported("attachments", "agy has no documented @path attachment-token contract");
     }
     if (params.skipTrust) {
-        args.push("--skip-trust");
+        return unsupported("skipTrust", "agy has no --skip-trust flag");
+    }
+    const args = ["--print", effectivePrompt];
+    if (resolvedModel)
+        args.push("--model", resolvedModel);
+    if (params.includeDirs && params.includeDirs.length > 0) {
+        sanitizeCliArgValues(params.includeDirs, "includeDirs");
+        params.includeDirs.forEach(dir => args.push("--add-dir", dir));
+    }
+    if (params.sandbox) {
+        args.push("--sandbox");
+    }
+    if (params.yolo || effectiveApprovalMode === "yolo") {
+        args.push("--dangerously-skip-permissions");
     }
     return {
         corrId,
@@ -1400,76 +1608,19 @@ export function prepareGrokRequest(params, runtime = resolveGatewayServerRuntime
         }
     }
     const effectiveAlwaysApprove = params.approvalStrategy === "mcp_managed" ? true : Boolean(params.alwaysApprove);
+    const grokContract = UPSTREAM_CLI_CONTRACTS.grok;
+    const genParams = params;
     const args = ["-p", effectivePrompt];
     if (resolvedModel)
         args.push("--model", resolvedModel);
-    if (params.outputFormat)
-        args.push("--output-format", params.outputFormat);
+    args.push(...buildArgvFromGeneration(grokContract, GROK_GEN_OUTPUT_FORMAT, genParams));
     if (effectiveAlwaysApprove) {
         args.push("--always-approve");
     }
     else if (params.permissionMode) {
         args.push("--permission-mode", params.permissionMode);
     }
-    if (params.effort)
-        args.push("--effort", params.effort);
-    if (params.reasoningEffort)
-        args.push("--reasoning-effort", params.reasoningEffort);
-    if (params.allowedTools && params.allowedTools.length > 0) {
-        args.push("--tools", params.allowedTools.join(","));
-    }
-    if (params.disallowedTools && params.disallowedTools.length > 0) {
-        args.push("--disallowed-tools", params.disallowedTools.join(","));
-    }
-    if (params.maxTurns !== undefined) {
-        args.push("--max-turns", String(params.maxTurns));
-    }
-    if (params.workingDir) {
-        args.push("--cwd", params.workingDir);
-    }
-    if (params.sandbox) {
-        args.push("--sandbox", params.sandbox);
-    }
-    if (params.rules) {
-        args.push("--rules", params.rules);
-    }
-    if (params.systemPromptOverride) {
-        args.push("--system-prompt-override", params.systemPromptOverride);
-    }
-    if (params.allow && params.allow.length > 0) {
-        for (const rule of params.allow) {
-            args.push("--allow", rule);
-        }
-    }
-    if (params.deny && params.deny.length > 0) {
-        for (const rule of params.deny) {
-            args.push("--deny", rule);
-        }
-    }
-    if (params.compactionMode) {
-        args.push("--compaction-mode", params.compactionMode);
-    }
-    if (params.compactionDetail) {
-        args.push("--compaction-detail", params.compactionDetail);
-    }
-    if (params.agent) {
-        args.push("--agent", params.agent);
-    }
-    if (params.bestOfN !== undefined) {
-        args.push("--best-of-n", String(params.bestOfN));
-    }
-    if (params.check) {
-        args.push("--check");
-    }
-    if (params.disableWebSearch) {
-        args.push("--disable-web-search");
-    }
-    if (params.todoGate) {
-        args.push("--todo-gate");
-    }
-    if (params.verbatim) {
-        args.push("--verbatim");
-    }
+    args.push(...buildArgvFromGeneration(grokContract, GROK_GEN_MAIN, genParams));
     if (params.agents !== undefined) {
         if (typeof params.agents === "string") {
             if (!params.agents.trim()) {
@@ -1485,9 +1636,7 @@ export function prepareGrokRequest(params, runtime = resolveGatewayServerRuntime
             args.push("--agents", JSON.stringify(agentsResult.value));
         }
     }
-    if (params.promptFile) {
-        args.push("--prompt-file", params.promptFile);
-    }
+    args.push(...buildArgvFromGeneration(grokContract, GROK_GEN_PROMPT_FILE, genParams));
     if (params.promptJson !== undefined) {
         const promptJsonValue = typeof params.promptJson === "string" ? params.promptJson : JSON.stringify(params.promptJson);
         if (!promptJsonValue.trim()) {
@@ -1495,33 +1644,8 @@ export function prepareGrokRequest(params, runtime = resolveGatewayServerRuntime
         }
         args.push("--prompt-json", promptJsonValue);
     }
-    if (params.single) {
-        args.push("--single", params.single);
-    }
-    if (params.experimentalMemory) {
-        args.push("--experimental-memory");
-    }
-    if (params.noAltScreen) {
-        args.push("--no-alt-screen");
-    }
-    if (params.noMemory) {
-        args.push("--no-memory");
-    }
-    if (params.noPlan) {
-        args.push("--no-plan");
-    }
-    if (params.noSubagents) {
-        args.push("--no-subagents");
-    }
-    if (params.oauth) {
-        args.push("--oauth");
-    }
-    if (params.restoreCode) {
-        args.push("--restore-code");
-    }
-    if (params.leaderSocket) {
-        args.push("--leader-socket", params.leaderSocket);
-    }
+    args.push(...buildArgvFromGeneration(grokContract, GROK_GEN_SINGLE, genParams));
+    args.push(...buildArgvFromGeneration(grokContract, GROK_GEN_TAIL, genParams));
     if (params.nativeWorktree === true) {
         args.push("--worktree");
     }
@@ -1678,6 +1802,7 @@ function buildCliResponse(cli, stdout, optimizeResponse, corrId, sessionId, prep
     const response = {
         content: [{ type: "text", text: finalStdout }],
         structuredContent: {
+            response: finalStdout,
             model: prep.resolvedModel || "default",
             cli,
             correlationId: corrId,
@@ -1813,6 +1938,7 @@ function buildGrokApiToolResponse(args) {
     const response = {
         content: [{ type: "text", text }],
         structuredContent: {
+            response: text,
             provider: "grok-api",
             cli: "grok-api",
             model: args.result.model || args.prep.resolvedModel,
@@ -2016,6 +2142,7 @@ function resolveHandlerRuntime(deps) {
         sessionManager: deps.sessionManager,
         logger: normalizedLogger,
         asyncJobManager: asyncDeps.asyncJobManager,
+        workspaces: deps.workspaces,
     });
 }
 export async function handleGeminiRequest(deps, params) {
@@ -2071,13 +2198,20 @@ export async function handleGeminiRequest(deps, params) {
         args.push(...sessionPlan.args);
         let worktreeResolution = {};
         try {
-            worktreeResolution = await resolveWorktreeForRequest(params.worktree, effectiveSessionIdHint, runtime);
+            worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "gemini",
+                workspace: params.workspace,
+                worktree: params.worktree,
+                sessionId: effectiveSessionIdHint,
+                runtime,
+                addDir: params.includeDirs,
+            });
         }
         catch (err) {
             return createErrorResponse("gemini_request", 1, "", corrId, err);
         }
         const geminiFrHandoff = buildAsyncFlightRecorderHandoff("gemini", prep, params.sessionId, params.outputFormat);
-        const result = await awaitJobOrDefer("gemini", args, corrId, resolveIdleTimeout("gemini", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, runtime, undefined, undefined, geminiFrHandoff.flightRecorderEntry, geminiFrHandoff.extractUsage, worktreeResolution.cwd);
+        const result = await awaitJobOrDefer("gemini", args, corrId, resolveIdleTimeout("gemini", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, runtime, undefined, undefined, geminiFrHandoff.flightRecorderEntry, geminiFrHandoff.extractUsage, undefined, worktreeResolution.cwd);
         if (isDeferredResponse(result)) {
             return buildDeferredToolResponse(result, effectiveSessionIdHint);
         }
@@ -2209,7 +2343,14 @@ export async function handleGeminiRequestAsync(deps, params) {
         }
         let worktreeResolution = {};
         try {
-            worktreeResolution = await resolveWorktreeForRequest(params.worktree, effectiveSessionId, runtime);
+            worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "gemini",
+                workspace: params.workspace,
+                worktree: params.worktree,
+                sessionId: effectiveSessionId,
+                runtime,
+                addDir: params.includeDirs,
+            });
         }
         catch (err) {
             return createErrorResponse("gemini_request_async", 1, "", corrId, err);
@@ -2322,7 +2463,14 @@ export async function handleGrokRequest(deps, params) {
         args.push(...sessionResult.resumeArgs);
         let worktreeResolution = {};
         try {
-            worktreeResolution = await resolveWorktreeForRequest(params.worktree, sessionResult.effectiveSessionId, runtime);
+            worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "grok",
+                workspace: params.workspace,
+                worktree: params.worktree,
+                sessionId: sessionResult.effectiveSessionId,
+                runtime,
+                workingDir: params.workingDir,
+            });
         }
         catch (err) {
             return createErrorResponse("grok_request", 1, "", corrId, err);
@@ -2490,7 +2638,14 @@ export async function handleGrokRequestAsync(deps, params) {
         }
         let worktreeResolution = {};
         try {
-            worktreeResolution = await resolveWorktreeForRequest(params.worktree, effectiveSessionId, runtime);
+            worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "grok",
+                workspace: params.workspace,
+                worktree: params.worktree,
+                sessionId: effectiveSessionId,
+                runtime,
+                workingDir: params.workingDir,
+            });
         }
         catch (err) {
             return createErrorResponse("grok_request_async", 1, "", corrId, err);
@@ -2578,7 +2733,15 @@ export async function handleMistralRequest(deps, params) {
         args.push(...sessionResult.resumeArgs);
         let worktreeResolution = {};
         try {
-            worktreeResolution = await resolveWorktreeForRequest(params.worktree, sessionResult.effectiveSessionId, runtime);
+            worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "mistral",
+                workspace: params.workspace,
+                worktree: params.worktree,
+                sessionId: sessionResult.effectiveSessionId,
+                runtime,
+                workingDir: params.workingDir,
+                addDir: params.addDir,
+            });
         }
         catch (err) {
             return createErrorResponse("mistral_request", 1, "", corrId, err);
@@ -2732,7 +2895,15 @@ export async function handleMistralRequestAsync(deps, params) {
         }
         let worktreeResolution = {};
         try {
-            worktreeResolution = await resolveWorktreeForRequest(params.worktree, effectiveSessionId, runtime);
+            worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "mistral",
+                workspace: params.workspace,
+                worktree: params.worktree,
+                sessionId: effectiveSessionId,
+                runtime,
+                workingDir: params.workingDir,
+                addDir: params.addDir,
+            });
         }
         catch (err) {
             return createErrorResponse("mistral_request_async", 1, "", corrId, err);
@@ -2844,7 +3015,15 @@ export async function handleCodexRequestAsync(deps, params) {
         }
         let worktreeResolution = {};
         try {
-            worktreeResolution = await resolveWorktreeForRequest(params.worktree, effectiveSessionId, runtime);
+            worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "codex",
+                workspace: params.workspace,
+                worktree: params.worktree,
+                sessionId: effectiveSessionId,
+                runtime,
+                workingDir: params.workingDir,
+                addDir: params.addDir,
+            });
         }
         catch (err) {
             runPrepCleanupLocally();
@@ -2899,6 +3078,7 @@ export function createGatewayServer(deps = {}) {
     const server = newGatewayMcpServer(asyncJobsEnabled, grokApiToolsEnabled);
     registerBaseResources(server, runtime);
     registerValidationTools(server, { asyncJobManager });
+    registerWorkspaceTools(server, runtime);
     if (grokApiToolsEnabled) {
         server.tool("grok_api_request", "Run an xAI Grok API request synchronously through the Responses API. Requires exactly one of prompt or promptParts. Registered only when [providers.xai] is configured and its API-key env var is present.", {
             prompt: z
@@ -3082,6 +3262,7 @@ export function createGatewayServer(deps = {}) {
             .array(z.string())
             .optional()
             .describe('Claude --tools: restrict the available built-in tool set (distinct from allowedTools permission gating). Pass [""] to disable all tools.'),
+        workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
         worktree: WORKTREE_SCHEMA.optional(),
         approvalStrategy: z
             .enum(["legacy", "mcp_managed"])
@@ -3119,7 +3300,7 @@ export function createGatewayServer(deps = {}) {
         destructiveHint: true,
         idempotentHint: false,
         openWorldHint: true,
-    }, async ({ prompt, promptParts, model, outputFormat, sessionId, continueSession, createNewSession, allowedTools, disallowedTools, dangerouslySkipPermissions, permissionMode, agent, agents, forkSession, systemPrompt, appendSystemPrompt, maxBudgetUsd, maxTurns, effort, excludeDynamicSystemPromptSections, fallbackModel, jsonSchema, addDir, noSessionPersistence, settingSources, settings, tools, worktree, approvalStrategy, approvalPolicy, mcpServers, strictMcpConfig, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, }) => {
+    }, async ({ prompt, promptParts, model, outputFormat, sessionId, continueSession, createNewSession, allowedTools, disallowedTools, dangerouslySkipPermissions, permissionMode, agent, agents, forkSession, systemPrompt, appendSystemPrompt, maxBudgetUsd, maxTurns, effort, excludeDynamicSystemPromptSections, fallbackModel, jsonSchema, addDir, noSessionPersistence, settingSources, settings, tools, workspace, worktree, approvalStrategy, approvalPolicy, mcpServers, strictMcpConfig, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, }) => {
         const startTime = Date.now();
         if (systemPrompt !== undefined && appendSystemPrompt !== undefined) {
             return createErrorResponse("claude", 1, "", correlationId, new Error("systemPrompt and appendSystemPrompt are mutually exclusive; use one or the other (not both)."));
@@ -3214,7 +3395,14 @@ export function createGatewayServer(deps = {}) {
             }
             let worktreeResolution = {};
             try {
-                worktreeResolution = await resolveWorktreeForRequest(worktree, effectiveSessionId, runtime);
+                worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                    provider: "claude",
+                    workspace,
+                    worktree,
+                    sessionId: effectiveSessionId,
+                    runtime,
+                    addDir,
+                });
             }
             catch (err) {
                 return createErrorResponse("claude_request", 1, "", corrId, err);
@@ -3425,6 +3613,7 @@ export function createGatewayServer(deps = {}) {
             .array(z.string())
             .optional()
             .describe("Codex --add-dir <DIR>: additional writable workspace directories. Emitted once per entry on new sessions only; resume inherits the original session's writable-dir policy."),
+        workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
         worktree: WORKTREE_SCHEMA.optional(),
     }, {
         title: "Codex request",
@@ -3432,7 +3621,7 @@ export function createGatewayServer(deps = {}) {
         destructiveHint: true,
         idempotentHint: false,
         openWorldHint: true,
-    }, async ({ prompt, promptParts, model, fullAuto, sandboxMode, askForApproval, useLegacyFullAutoFlag, dangerouslyBypassApprovalsAndSandbox, approvalStrategy, approvalPolicy, mcpServers, sessionId, resumeLatest, createNewSession, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, outputFormat, outputSchema, search, profile, configOverrides, ephemeral, images, ignoreUserConfig, ignoreRules, workingDir, addDir, worktree, }) => {
+    }, async ({ prompt, promptParts, model, fullAuto, sandboxMode, askForApproval, useLegacyFullAutoFlag, dangerouslyBypassApprovalsAndSandbox, approvalStrategy, approvalPolicy, mcpServers, sessionId, resumeLatest, createNewSession, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, outputFormat, outputSchema, search, profile, configOverrides, ephemeral, images, ignoreUserConfig, ignoreRules, workingDir, addDir, workspace, worktree, }) => {
         const startTime = Date.now();
         const prep = prepareCodexRequest({
             prompt,
@@ -3488,7 +3677,15 @@ export function createGatewayServer(deps = {}) {
         const prepCleanup = "cleanup" in prep && typeof prep.cleanup === "function" ? prep.cleanup : undefined;
         let worktreeResolution = {};
         try {
-            worktreeResolution = await resolveWorktreeForRequest(worktree, sessionId, runtime);
+            worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "codex",
+                workspace,
+                worktree,
+                sessionId,
+                runtime,
+                workingDir,
+                addDir,
+            });
         }
         catch (err) {
             return createErrorResponse("codex_request", 1, "", corrId, err);
@@ -3610,13 +3807,14 @@ export function createGatewayServer(deps = {}) {
             .max(3_600_000)
             .optional()
             .describe("Idle timeout in ms (min 30s, max 1h, omit=CLI default)"),
+        workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
     }, {
         title: "Fork Codex session",
         readOnlyHint: false,
         destructiveHint: true,
         idempotentHint: false,
         openWorldHint: true,
-    }, async ({ prompt, sessionId, forkLast, model, sandboxMode, askForApproval, correlationId, idleTimeoutMs, }) => {
+    }, async ({ prompt, sessionId, forkLast, model, sandboxMode, askForApproval, correlationId, idleTimeoutMs, workspace, }) => {
         const corrId = correlationId || randomUUID();
         const startTime = Date.now();
         let durationMs = 0;
@@ -3656,7 +3854,13 @@ export function createGatewayServer(deps = {}) {
         const finalArgs = [forkArgs[0], ...flagSegment, ...forkArgs.slice(1)];
         logger.info(`[${corrId}] codex_fork_session invoked (forkLast=${Boolean(forkLast)}, sessionId=${sessionId ? "set" : "unset"})`);
         try {
-            const result = await awaitJobOrDefer("codex", finalArgs, corrId, resolveIdleTimeout("codex", idleTimeoutMs), undefined, false, runtime);
+            const worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "codex",
+                workspace,
+                sessionId,
+                runtime,
+            });
+            const result = await awaitJobOrDefer("codex", finalArgs, corrId, resolveIdleTimeout("codex", idleTimeoutMs), undefined, false, runtime, undefined, undefined, undefined, undefined, undefined, worktreeResolution.cwd);
             if (isDeferredResponse(result)) {
                 return buildDeferredToolResponse(result, sessionId);
             }
@@ -3678,23 +3882,23 @@ export function createGatewayServer(deps = {}) {
             performanceMetrics.recordRequest("codex", finalizedDurationMs, wasSuccessful);
         }
     });
-    server.tool("gemini_request", "Run a Google Gemini CLI request synchronously (when async jobs are enabled, auto-defers to a pollable job past the sync deadline; otherwise runs to completion). Requires exactly one of prompt or promptParts.", {
+    server.tool("gemini_request", "Run a Google Antigravity CLI (`agy`) request through the Gemini-compatible gateway tool synchronously (when async jobs are enabled, auto-defers to a pollable job past the sync deadline; otherwise runs to completion). Requires exactly one of prompt or promptParts.", {
         prompt: z
             .string()
             .min(1, "Prompt cannot be empty")
             .max(100000, "Prompt too long (max 100k chars)")
             .optional()
-            .describe("Prompt text for Gemini (mutually exclusive with promptParts)"),
+            .describe("Prompt text for Antigravity CLI (mutually exclusive with promptParts)"),
         promptParts: PromptPartsSchema.optional().describe("Cache-aware structured prompt: { system?, tools?, context?, task }. Mutually exclusive with prompt. Stable parts hash into cache_state for prefix-discipline tracking."),
         model: z
             .string()
             .optional()
-            .describe("Model name or alias (e.g. gemini-3-pro-preview, gemini-2.5-flash, pro, flash, latest)"),
+            .describe("Model name or alias passed to agy --model (e.g. gemini-3-pro-preview, gemini-2.5-flash, pro, flash, latest)"),
         sessionId: z
             .string()
             .optional()
-            .describe("Gemini session ID to resume (emits --resume <id>), or 'latest' for the most recent session in this cwd"),
-        resumeLatest: z.boolean().default(false).describe("Resume latest session"),
+            .describe("Antigravity conversation ID to resume (emits --conversation <id>)"),
+        resumeLatest: z.boolean().default(false).describe("Continue the most recent conversation"),
         createNewSession: z.boolean().default(false).describe("Force new session"),
         approvalMode: z
             .enum(GEMINI_APPROVAL_MODES)
@@ -3710,13 +3914,16 @@ export function createGatewayServer(deps = {}) {
             .describe("Approval policy override"),
         mcpServers: z
             .array(MCP_SERVER_ENUM)
-            .default(["sqry"])
-            .describe("MCP server names passed to Gemini as --allowed-mcp-server-names"),
+            .default([])
+            .describe("Unsupported for Antigravity CLI; non-empty values are rejected"),
         allowedTools: z
             .array(z.string())
             .optional()
-            .describe("Allowed tools (['Write','Edit','Bash'])"),
-        includeDirs: z.array(z.string()).optional().describe("Additional workspace directories"),
+            .describe("Unsupported for Antigravity CLI; non-empty values are rejected"),
+        includeDirs: z
+            .array(z.string())
+            .optional()
+            .describe("Additional workspace directories passed as --add-dir"),
         correlationId: z.string().optional().describe("Request trace ID (auto if omitted)"),
         optimizePrompt: z.boolean().default(false).describe("Optimize prompt before execution"),
         optimizeResponse: z.boolean().default(false).describe("Optimize response output"),
@@ -3734,19 +3941,20 @@ export function createGatewayServer(deps = {}) {
         outputFormat: z
             .enum(["text", "json", "stream-json"])
             .default("text")
-            .describe("Gemini output format. `json` emits `-o json` (single JSON with usageMetadata). `stream-json` emits `-o stream-json` (NDJSON event stream — `init`/`message`/`result` lines, usage extracted from the terminal `result.stats` event). Both report usage to the flight recorder."),
-        sandbox: GEMINI_HIGH_IMPACT_PARAMS_SCHEMA.shape.sandbox.describe("Run Gemini in sandbox mode (-s)"),
-        policyFiles: GEMINI_HIGH_IMPACT_PARAMS_SCHEMA.shape.policyFiles.describe("Policy file paths (--policy <path>, one per file). Paths must exist."),
-        adminPolicyFiles: GEMINI_HIGH_IMPACT_PARAMS_SCHEMA.shape.adminPolicyFiles.describe("Admin policy file paths (--admin-policy <path>, one per file). Paths must exist."),
-        attachments: GEMINI_HIGH_IMPACT_PARAMS_SCHEMA.shape.attachments.describe("Absolute file paths prepended as @<path> tokens to the prompt"),
+            .describe("Antigravity CLI currently supports text output only through the gateway; json and stream-json are rejected."),
+        sandbox: GEMINI_HIGH_IMPACT_PARAMS_SCHEMA.shape.sandbox.describe("Run Antigravity in sandbox mode (--sandbox)"),
+        policyFiles: GEMINI_HIGH_IMPACT_PARAMS_SCHEMA.shape.policyFiles.describe("Unsupported for Antigravity CLI; non-empty values are rejected."),
+        adminPolicyFiles: GEMINI_HIGH_IMPACT_PARAMS_SCHEMA.shape.adminPolicyFiles.describe("Unsupported for Antigravity CLI; non-empty values are rejected."),
+        attachments: GEMINI_HIGH_IMPACT_PARAMS_SCHEMA.shape.attachments.describe("Unsupported for Antigravity CLI; non-empty values are rejected."),
         skipTrust: z
             .boolean()
             .default(false)
-            .describe("Emit `--skip-trust` so Gemini trusts the workspace for this session and skips the interactive trust prompt (Phase 4 slice γ). Required for headless runs in fresh workspaces."),
+            .describe("Unsupported for Antigravity CLI; true is rejected."),
         yolo: z
             .boolean()
             .optional()
-            .describe("Emit `--yolo` to auto-approve all actions. Equivalent to approvalMode 'yolo'; routed through the same approval gate. Under mcp_managed the gate still decides."),
+            .describe("Emit `--dangerously-skip-permissions` to auto-approve all actions. Routed through the same approval gate. Under mcp_managed the gate still decides."),
+        workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
         worktree: WORKTREE_SCHEMA.optional(),
     }, {
         title: "Gemini request",
@@ -3754,7 +3962,7 @@ export function createGatewayServer(deps = {}) {
         destructiveHint: true,
         idempotentHint: false,
         openWorldHint: true,
-    }, async ({ prompt, promptParts, model, sessionId, resumeLatest, createNewSession, approvalMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, includeDirs, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, outputFormat, sandbox, policyFiles, adminPolicyFiles, attachments, skipTrust, yolo, worktree, }) => {
+    }, async ({ prompt, promptParts, model, sessionId, resumeLatest, createNewSession, approvalMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, includeDirs, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, outputFormat, sandbox, policyFiles, adminPolicyFiles, attachments, skipTrust, yolo, workspace, worktree, }) => {
         return handleGeminiRequest({ sessionManager, logger, runtime }, {
             prompt,
             promptParts,
@@ -3780,6 +3988,7 @@ export function createGatewayServer(deps = {}) {
             attachments,
             skipTrust,
             yolo,
+            workspace,
             worktree,
         });
     });
@@ -3792,10 +4001,7 @@ export function createGatewayServer(deps = {}) {
             .describe("Prompt text for Grok (mutually exclusive with promptParts)"),
         promptParts: PromptPartsSchema.optional().describe("Cache-aware structured prompt: { system?, tools?, context?, task }. Mutually exclusive with prompt. Stable parts hash into cache_state for prefix-discipline tracking."),
         model: z.string().optional().describe("Model name or alias (e.g. grok-build, latest)"),
-        outputFormat: z
-            .enum(["plain", "json", "streaming-json"])
-            .optional()
-            .describe("Output format (plain|json|streaming-json). Grok default is plain."),
+        ...GROK_GENERATED_SHAPE,
         sessionId: z
             .string()
             .optional()
@@ -3813,11 +4019,6 @@ export function createGatewayServer(deps = {}) {
             .enum(["default", "acceptEdits", "auto", "dontAsk", "bypassPermissions", "plan"])
             .optional()
             .describe("Grok permission mode"),
-        effort: z
-            .enum(["low", "medium", "high", "xhigh", "max"])
-            .optional()
-            .describe("Grok effort level"),
-        reasoningEffort: z.string().optional().describe("Reasoning effort for reasoning models"),
         approvalStrategy: z
             .enum(["legacy", "mcp_managed"])
             .default("legacy")
@@ -3830,14 +4031,6 @@ export function createGatewayServer(deps = {}) {
             .array(MCP_SERVER_ENUM)
             .default(["sqry"])
             .describe("MCP server names for approval tracking (Grok manages its own MCP config via `grok mcp`)"),
-        allowedTools: z
-            .array(z.string())
-            .optional()
-            .describe("Allowed built-in tools (passed as --tools comma list)"),
-        disallowedTools: z
-            .array(z.string())
-            .optional()
-            .describe("Disallowed built-in tools (passed as --disallowed-tools comma list)"),
         correlationId: z.string().optional().describe("Request trace ID (auto if omitted)"),
         optimizePrompt: z.boolean().default(false).describe("Optimize prompt before execution"),
         optimizeResponse: z.boolean().default(false).describe("Optimize response output"),
@@ -3852,111 +4045,19 @@ export function createGatewayServer(deps = {}) {
             .boolean()
             .default(false)
             .describe("Bypass dedup and force a fresh CLI run even if a recent identical request exists"),
-        maxTurns: MAX_TURNS_SCHEMA.optional().describe("Grok `--max-turns N`: cap on agent-loop iterations for cost / latency control (Phase 4 slice δ). Bounded to safe integers ≤ 10000."),
-        workingDir: z
-            .string()
-            .min(1)
-            .optional()
-            .describe("Grok --cwd <DIR>: working directory for this invocation. Lets headless callers run Grok against a directory other than the gateway process's cwd."),
-        sandbox: z
-            .string()
-            .min(1)
-            .optional()
-            .describe("Grok --sandbox <PROFILE>: sandbox profile for filesystem and network access. Freeform per `grok --help` (no enum constraint on Grok 0.1.210); also settable via GROK_SANDBOX env var. Caller responsibility to pass a valid profile name."),
-        rules: z
-            .string()
-            .min(1)
-            .optional()
-            .describe("Grok --rules <RULES>: extra rules to append to the system prompt. Supports `@file` prefix per `grok --help` to load from a file; gateway passes the value verbatim and lets Grok parse the prefix."),
-        systemPromptOverride: z
-            .string()
-            .min(1)
-            .optional()
-            .describe("Grok --system-prompt-override <PROMPT>: replace the agent's system prompt entirely. Distinct from Claude's --system-prompt / --append-system-prompt (Grok has only one override flag, not a pair)."),
-        allow: z
-            .array(z.string())
-            .optional()
-            .describe('Grok --allow <RULE>: permission allow rules. Each entry is emitted as its own --allow instance (per `grok --help`: "Repeat to add multiple rules").'),
-        deny: z
-            .array(z.string())
-            .optional()
-            .describe('Grok --deny <RULE>: permission deny rules. Each entry is emitted as its own --deny instance (per `grok --help`: "Repeat to add multiple rules").'),
-        compactionMode: z
-            .enum(["summary", "transcript", "segments"])
-            .optional()
-            .describe("Grok --compaction-mode: summary (default; no pointer) | transcript (points at the raw transcript) | segments (persists per-segment markdown to grep). Sets GROK_COMPACTION_MODE."),
-        compactionDetail: z
-            .enum(["none", "minimal", "balanced", "verbose"])
-            .optional()
-            .describe("Grok --compaction-detail: verbatim segment detail (none|minimal|balanced|verbose, default verbose). Only affects `--compaction-mode segments`. Sets GROK_COMPACTION_DETAIL."),
-        agent: z
-            .string()
-            .min(1)
-            .optional()
-            .describe("Grok --agent <NAME>: agent name or definition file path."),
-        bestOfN: MAX_TURNS_SCHEMA.optional().describe("Grok --best-of-n <N>: run the task N ways in parallel and pick the best (headless only)."),
-        check: z
-            .boolean()
-            .optional()
-            .describe("Grok --check: append a self-verification loop to the prompt (headless only)."),
-        disableWebSearch: z
-            .boolean()
-            .optional()
-            .describe("Grok --disable-web-search: disable web search and remote retrieval tools."),
-        todoGate: z
-            .boolean()
-            .optional()
-            .describe("Grok --todo-gate: enable runtime turn-end TodoGate for this session (session-scoped, not persisted)."),
-        verbatim: z
-            .boolean()
-            .optional()
-            .describe("Grok --verbatim: send the prompt exactly as given. Also skips gateway optimizePrompt when true."),
         agents: z
             .union([z.string().min(1), z.record(z.string(), z.record(z.string(), z.unknown()))])
             .optional()
             .describe("Grok --agents <JSON>: inline subagent definitions (JSON string or name → { description, prompt, … } map)."),
-        promptFile: z
-            .string()
-            .min(1)
-            .optional()
-            .describe("Grok --prompt-file <PATH>: single-turn prompt loaded from a file."),
         promptJson: z
             .union([z.string(), z.array(z.unknown()), z.record(z.string(), z.unknown())])
             .optional()
             .describe("Grok --prompt-json <JSON>: single-turn prompt JSON blocks (string or serializable value)."),
-        single: z
-            .string()
-            .min(1)
-            .optional()
-            .describe("Grok --single <PROMPT>: single-turn prompt (in addition to gateway -p)."),
-        experimentalMemory: z
-            .boolean()
-            .optional()
-            .describe("Grok --experimental-memory: enable cross-session memory."),
-        noAltScreen: z
-            .boolean()
-            .optional()
-            .describe("Grok --no-alt-screen: run inline without alt screen."),
-        noMemory: z.boolean().optional().describe("Grok --no-memory: disable cross-session memory."),
-        noPlan: z.boolean().optional().describe("Grok --no-plan: disable plan mode."),
-        noSubagents: z
-            .boolean()
-            .optional()
-            .describe("Grok --no-subagents: disable subagent spawning."),
-        oauth: z.boolean().optional().describe("Grok --oauth: use OAuth during authentication."),
-        restoreCode: z
-            .boolean()
-            .optional()
-            .describe("Grok --restore-code: check out the original session commit when resuming."),
-        leaderSocket: z
-            .string()
-            .min(1)
-            .optional()
-            .describe("Grok 0.2.32+ --leader-socket <PATH>: custom leader socket path (default ~/.grok/leader.sock). Targets an isolated leader process, e.g. a local/branch Grok build; name it ~/.grok/leader-*.sock to keep `grok leader list/kill` discovery working."),
         nativeWorktree: z
             .union([z.boolean(), z.string().min(1)])
             .optional()
             .describe("Grok -w/--worktree: native CLI worktree flag (`true` → bare `--worktree`, string → named). NOT gateway slice λ `worktree`."),
+        workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
         worktree: WORKTREE_SCHEMA.optional(),
     }, {
         title: "Grok request",
@@ -3964,7 +4065,7 @@ export function createGatewayServer(deps = {}) {
         destructiveHint: true,
         idempotentHint: false,
         openWorldHint: true,
-    }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, alwaysApprove, permissionMode, effort, reasoningEffort, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, maxTurns, workingDir, sandbox, rules, systemPromptOverride, allow, deny, compactionMode, compactionDetail, agent, bestOfN, check, disableWebSearch, todoGate, verbatim, agents, promptFile, promptJson, single, experimentalMemory, noAltScreen, noMemory, noPlan, noSubagents, oauth, restoreCode, leaderSocket, nativeWorktree, worktree, }) => {
+    }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, alwaysApprove, permissionMode, effort, reasoningEffort, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, maxTurns, workingDir, sandbox, rules, systemPromptOverride, allow, deny, compactionMode, compactionDetail, agent, bestOfN, check, disableWebSearch, todoGate, verbatim, agents, promptFile, promptJson, single, experimentalMemory, noAltScreen, noMemory, noPlan, noSubagents, oauth, restoreCode, leaderSocket, nativeWorktree, workspace, worktree, }) => {
         return handleGrokRequest({ sessionManager, logger, runtime }, {
             prompt,
             promptParts,
@@ -4015,6 +4116,7 @@ export function createGatewayServer(deps = {}) {
             restoreCode,
             leaderSocket,
             nativeWorktree,
+            workspace,
             worktree,
         });
     });
@@ -4097,6 +4199,7 @@ export function createGatewayServer(deps = {}) {
             .array(z.string())
             .optional()
             .describe("Vibe --add-dir <DIR>: additional writable workspace directories. Each entry is emitted as its own --add-dir instance (Vibe states this flag may be specified multiple times)."),
+        workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
         worktree: WORKTREE_SCHEMA.optional(),
     }, {
         title: "Mistral Vibe request",
@@ -4104,7 +4207,7 @@ export function createGatewayServer(deps = {}) {
         destructiveHint: true,
         idempotentHint: false,
         openWorldHint: true,
-    }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, permissionMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, trust, maxTurns, maxPrice, maxTokens, workingDir, addDir, worktree, }) => {
+    }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, permissionMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, trust, maxTurns, maxPrice, maxTokens, workingDir, addDir, workspace, worktree, }) => {
         return handleMistralRequest({ sessionManager, logger, runtime }, {
             prompt,
             promptParts,
@@ -4130,6 +4233,7 @@ export function createGatewayServer(deps = {}) {
             maxTokens,
             workingDir,
             addDir,
+            workspace,
             worktree,
         });
     });
@@ -4242,6 +4346,7 @@ export function createGatewayServer(deps = {}) {
                 .array(z.string())
                 .optional()
                 .describe('Claude --tools: restrict the available built-in tool set (distinct from allowedTools permission gating). Pass [""] to disable all tools.'),
+            workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
             worktree: WORKTREE_SCHEMA.optional(),
             approvalStrategy: z
                 .enum(["legacy", "mcp_managed"])
@@ -4278,7 +4383,7 @@ export function createGatewayServer(deps = {}) {
             destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
-        }, async ({ prompt, promptParts, model, outputFormat, sessionId, continueSession, createNewSession, allowedTools, disallowedTools, dangerouslySkipPermissions, permissionMode, agent, agents, forkSession, systemPrompt, appendSystemPrompt, maxBudgetUsd, maxTurns, effort, excludeDynamicSystemPromptSections, fallbackModel, jsonSchema, addDir, noSessionPersistence, settingSources, settings, tools, worktree, approvalStrategy, approvalPolicy, mcpServers, strictMcpConfig, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, }) => {
+        }, async ({ prompt, promptParts, model, outputFormat, sessionId, continueSession, createNewSession, allowedTools, disallowedTools, dangerouslySkipPermissions, permissionMode, agent, agents, forkSession, systemPrompt, appendSystemPrompt, maxBudgetUsd, maxTurns, effort, excludeDynamicSystemPromptSections, fallbackModel, jsonSchema, addDir, noSessionPersistence, settingSources, settings, tools, workspace, worktree, approvalStrategy, approvalPolicy, mcpServers, strictMcpConfig, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, }) => {
             if (systemPrompt !== undefined && appendSystemPrompt !== undefined) {
                 return createErrorResponse("claude", 1, "", correlationId, new Error("systemPrompt and appendSystemPrompt are mutually exclusive; use one or the other (not both)."));
             }
@@ -4349,7 +4454,14 @@ export function createGatewayServer(deps = {}) {
                 });
                 let worktreeResolution = {};
                 try {
-                    worktreeResolution = await resolveWorktreeForRequest(worktree, effectiveSessionId, runtime);
+                    worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                        provider: "claude",
+                        workspace,
+                        worktree,
+                        sessionId: effectiveSessionId,
+                        runtime,
+                        addDir,
+                    });
                 }
                 catch (err) {
                     return createErrorResponse("claude_request_async", 1, "", corrId, err);
@@ -4489,6 +4601,7 @@ export function createGatewayServer(deps = {}) {
                 .array(z.string())
                 .optional()
                 .describe("Codex --add-dir <DIR>: additional writable workspace directories (repeat per entry). New sessions only."),
+            workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
             worktree: WORKTREE_SCHEMA.optional(),
         }, {
             title: "Codex request (async job)",
@@ -4496,7 +4609,7 @@ export function createGatewayServer(deps = {}) {
             destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
-        }, async ({ prompt, promptParts, model, fullAuto, sandboxMode, askForApproval, useLegacyFullAutoFlag, dangerouslyBypassApprovalsAndSandbox, approvalStrategy, approvalPolicy, mcpServers, sessionId, resumeLatest, createNewSession, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, outputFormat, outputSchema, search, profile, configOverrides, ephemeral, images, ignoreUserConfig, ignoreRules, workingDir, addDir, worktree, }) => {
+        }, async ({ prompt, promptParts, model, fullAuto, sandboxMode, askForApproval, useLegacyFullAutoFlag, dangerouslyBypassApprovalsAndSandbox, approvalStrategy, approvalPolicy, mcpServers, sessionId, resumeLatest, createNewSession, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, outputFormat, outputSchema, search, profile, configOverrides, ephemeral, images, ignoreUserConfig, ignoreRules, workingDir, addDir, workspace, worktree, }) => {
             return handleCodexRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
                 promptParts,
@@ -4527,26 +4640,27 @@ export function createGatewayServer(deps = {}) {
                 ignoreRules,
                 workingDir,
                 addDir,
+                workspace,
                 worktree,
             });
         });
-        server.tool("gemini_request_async", "Start a Google Gemini CLI request as a durable background job. Poll with llm_job_status, collect with llm_job_result.", {
+        server.tool("gemini_request_async", "Start a Google Antigravity CLI (`agy`) request as a durable background job through the Gemini-compatible gateway tool. Poll with llm_job_status, collect with llm_job_result.", {
             prompt: z
                 .string()
                 .min(1, "Prompt cannot be empty")
                 .max(100000, "Prompt too long (max 100k chars)")
                 .optional()
-                .describe("Prompt text for Gemini (mutually exclusive with promptParts)"),
+                .describe("Prompt text for Antigravity CLI (mutually exclusive with promptParts)"),
             promptParts: PromptPartsSchema.optional().describe("Cache-aware structured prompt: { system?, tools?, context?, task }. Mutually exclusive with prompt. Stable parts hash into cache_state for prefix-discipline tracking."),
             model: z
                 .string()
                 .optional()
-                .describe("Model name or alias (e.g. gemini-3-pro-preview, gemini-2.5-flash, pro, flash, latest)"),
+                .describe("Model name or alias passed to agy --model (e.g. gemini-3-pro-preview, gemini-2.5-flash, pro, flash, latest)"),
             sessionId: z
                 .string()
                 .optional()
-                .describe("Gemini session ID to resume (emits --resume <id>), or 'latest' for the most recent session in this cwd"),
-            resumeLatest: z.boolean().default(false).describe("Resume latest session"),
+                .describe("Antigravity conversation ID to resume (emits --conversation <id>)"),
+            resumeLatest: z.boolean().default(false).describe("Continue the most recent conversation"),
             createNewSession: z.boolean().default(false).describe("Force new session"),
             approvalMode: z
                 .enum(GEMINI_APPROVAL_MODES)
@@ -4562,13 +4676,16 @@ export function createGatewayServer(deps = {}) {
                 .describe("Approval policy override"),
             mcpServers: z
                 .array(MCP_SERVER_ENUM)
-                .default(["sqry"])
-                .describe("MCP server names passed to Gemini as --allowed-mcp-server-names"),
+                .default([])
+                .describe("Unsupported for Antigravity CLI; non-empty values are rejected"),
             allowedTools: z
                 .array(z.string())
                 .optional()
-                .describe("Allowed tools (['Write','Edit','Bash'])"),
-            includeDirs: z.array(z.string()).optional().describe("Additional workspace directories"),
+                .describe("Unsupported for Antigravity CLI; non-empty values are rejected"),
+            includeDirs: z
+                .array(z.string())
+                .optional()
+                .describe("Additional workspace directories passed as --add-dir"),
             correlationId: z.string().optional().describe("Request trace ID (auto if omitted)"),
             optimizePrompt: z.boolean().default(false).describe("Optimize prompt before execution"),
             idleTimeoutMs: z
@@ -4585,19 +4702,20 @@ export function createGatewayServer(deps = {}) {
             outputFormat: z
                 .enum(["text", "json", "stream-json"])
                 .default("text")
-                .describe("Gemini output format. `json` emits `-o json` (single JSON with usageMetadata). `stream-json` emits `-o stream-json` (NDJSON event stream — `init`/`message`/`result` lines, usage extracted from the terminal `result.stats` event). Both report usage to the flight recorder."),
-            sandbox: GEMINI_HIGH_IMPACT_PARAMS_SCHEMA.shape.sandbox.describe("Run Gemini in sandbox mode (-s)"),
-            policyFiles: GEMINI_HIGH_IMPACT_PARAMS_SCHEMA.shape.policyFiles.describe("Policy file paths (--policy <path>, one per file). Paths must exist."),
-            adminPolicyFiles: GEMINI_HIGH_IMPACT_PARAMS_SCHEMA.shape.adminPolicyFiles.describe("Admin policy file paths (--admin-policy <path>, one per file). Paths must exist."),
-            attachments: GEMINI_HIGH_IMPACT_PARAMS_SCHEMA.shape.attachments.describe("Absolute file paths prepended as @<path> tokens to the prompt"),
+                .describe("Antigravity CLI currently supports text output only through the gateway; json and stream-json are rejected."),
+            sandbox: GEMINI_HIGH_IMPACT_PARAMS_SCHEMA.shape.sandbox.describe("Run Antigravity in sandbox mode (--sandbox)"),
+            policyFiles: GEMINI_HIGH_IMPACT_PARAMS_SCHEMA.shape.policyFiles.describe("Unsupported for Antigravity CLI; non-empty values are rejected."),
+            adminPolicyFiles: GEMINI_HIGH_IMPACT_PARAMS_SCHEMA.shape.adminPolicyFiles.describe("Unsupported for Antigravity CLI; non-empty values are rejected."),
+            attachments: GEMINI_HIGH_IMPACT_PARAMS_SCHEMA.shape.attachments.describe("Unsupported for Antigravity CLI; non-empty values are rejected."),
             skipTrust: z
                 .boolean()
                 .default(false)
-                .describe("Emit `--skip-trust` so Gemini trusts the workspace for this session and skips the interactive trust prompt (Phase 4 slice γ). Required for headless runs in fresh workspaces."),
+                .describe("Unsupported for Antigravity CLI; true is rejected."),
             yolo: z
                 .boolean()
                 .optional()
-                .describe("Emit `--yolo` to auto-approve all actions. Equivalent to approvalMode 'yolo'; routed through the same approval gate. Under mcp_managed the gate still decides."),
+                .describe("Emit `--dangerously-skip-permissions` to auto-approve all actions. Routed through the same approval gate. Under mcp_managed the gate still decides."),
+            workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
             worktree: WORKTREE_SCHEMA.optional(),
         }, {
             title: "Gemini request (async job)",
@@ -4605,7 +4723,7 @@ export function createGatewayServer(deps = {}) {
             destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
-        }, async ({ prompt, promptParts, model, sessionId, resumeLatest, createNewSession, approvalMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, includeDirs, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, outputFormat, sandbox, policyFiles, adminPolicyFiles, attachments, skipTrust, yolo, worktree, }) => {
+        }, async ({ prompt, promptParts, model, sessionId, resumeLatest, createNewSession, approvalMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, includeDirs, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, outputFormat, sandbox, policyFiles, adminPolicyFiles, attachments, skipTrust, yolo, workspace, worktree, }) => {
             return handleGeminiRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
                 promptParts,
@@ -4630,6 +4748,7 @@ export function createGatewayServer(deps = {}) {
                 attachments,
                 skipTrust,
                 yolo,
+                workspace,
                 worktree,
             });
         });
@@ -4809,6 +4928,7 @@ export function createGatewayServer(deps = {}) {
                 .union([z.boolean(), z.string().min(1)])
                 .optional()
                 .describe("Grok -w/--worktree: native CLI worktree flag (`true` → bare `--worktree`, string → named). NOT gateway slice λ `worktree`."),
+            workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
             worktree: WORKTREE_SCHEMA.optional(),
         }, {
             title: "Grok request (async job)",
@@ -4816,7 +4936,7 @@ export function createGatewayServer(deps = {}) {
             destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
-        }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, alwaysApprove, permissionMode, effort, reasoningEffort, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, maxTurns, workingDir, sandbox, rules, systemPromptOverride, allow, deny, compactionMode, compactionDetail, agent, bestOfN, check, disableWebSearch, todoGate, verbatim, agents, promptFile, promptJson, single, experimentalMemory, noAltScreen, noMemory, noPlan, noSubagents, oauth, restoreCode, leaderSocket, nativeWorktree, worktree, }) => {
+        }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, alwaysApprove, permissionMode, effort, reasoningEffort, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, maxTurns, workingDir, sandbox, rules, systemPromptOverride, allow, deny, compactionMode, compactionDetail, agent, bestOfN, check, disableWebSearch, todoGate, verbatim, agents, promptFile, promptJson, single, experimentalMemory, noAltScreen, noMemory, noPlan, noSubagents, oauth, restoreCode, leaderSocket, nativeWorktree, workspace, worktree, }) => {
             return handleGrokRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
                 promptParts,
@@ -4866,6 +4986,7 @@ export function createGatewayServer(deps = {}) {
                 restoreCode,
                 leaderSocket,
                 nativeWorktree,
+                workspace,
                 worktree,
             });
         });
@@ -4947,6 +5068,7 @@ export function createGatewayServer(deps = {}) {
                 .array(z.string())
                 .optional()
                 .describe("Vibe --add-dir <DIR>: additional writable workspace directories. Each entry is emitted as its own --add-dir instance."),
+            workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
             worktree: WORKTREE_SCHEMA.optional(),
         }, {
             title: "Mistral Vibe request (async job)",
@@ -4954,7 +5076,7 @@ export function createGatewayServer(deps = {}) {
             destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
-        }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, permissionMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, trust, maxTurns, maxPrice, maxTokens, workingDir, addDir, worktree, }) => {
+        }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, permissionMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, trust, maxTurns, maxPrice, maxTokens, workingDir, addDir, workspace, worktree, }) => {
             return handleMistralRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
                 promptParts,
@@ -4979,6 +5101,7 @@ export function createGatewayServer(deps = {}) {
                 maxTokens,
                 workingDir,
                 addDir,
+                workspace,
                 worktree,
             });
         });
@@ -5845,6 +5968,210 @@ async function shutdown(signal) {
 }
 process.on("SIGTERM", () => shutdown("SIGTERM"));
 process.on("SIGINT", () => shutdown("SIGINT"));
+function readMutableGatewayConfig(configPath = defaultGatewayConfigPath()) {
+    if (!existsSync(configPath))
+        return {};
+    const require = createRequire(import.meta.url);
+    const TOML = require("smol-toml");
+    return TOML.parse(readFileSync(configPath, "utf8"));
+}
+function writeMutableGatewayConfig(data, configPath = defaultGatewayConfigPath()) {
+    const require = createRequire(import.meta.url);
+    const TOML = require("smol-toml");
+    mkdirSync(dirname(configPath), { recursive: true, mode: 0o700 });
+    writeFileSync(configPath, TOML.stringify(data), { mode: 0o600 });
+    chmodSync(configPath, 0o600);
+}
+function ensureOAuthTable(config) {
+    config.http ??= {};
+    config.http.oauth ??= {};
+    const oauth = config.http.oauth;
+    oauth.enabled ??= true;
+    oauth.issuer ??= "auto";
+    oauth.require_pkce ??= true;
+    oauth.registration_policy ??= "static_clients";
+    oauth.allow_public_clients ??= false;
+    oauth.token_ttl_seconds ??= 3600;
+    oauth.clients ??= [];
+    return oauth;
+}
+function argValue(args, name) {
+    const idx = args.indexOf(name);
+    return idx >= 0 ? args[idx + 1] : undefined;
+}
+function requireArg(args, name) {
+    const value = argValue(args, name);
+    if (!value)
+        throw new Error(`Missing ${name}`);
+    return value;
+}
+function localBaseUrlForPrint() {
+    const publicUrl = process.env.LLM_GATEWAY_PUBLIC_URL;
+    if (publicUrl) {
+        try {
+            return new URL(publicUrl).origin;
+        }
+        catch {
+        }
+    }
+    return `http://${process.env.LLM_GATEWAY_HTTP_HOST ?? "127.0.0.1"}:${process.env.LLM_GATEWAY_HTTP_PORT ?? "3333"}`;
+}
+function printJsonLine(value) {
+    process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+}
+function runOAuthCommand(args) {
+    const [scope, action] = args;
+    const config = readMutableGatewayConfig();
+    const oauth = ensureOAuthTable(config);
+    if (scope === "client") {
+        const clients = (Array.isArray(oauth.clients) ? oauth.clients : []);
+        oauth.clients = clients;
+        if (action === "add") {
+            const clientId = args[2];
+            if (!clientId)
+                throw new Error("Usage: llm-cli-gateway oauth client add <client-id> --redirect-uri <uri> [--print-once]");
+            const redirectUri = requireArg(args, "--redirect-uri");
+            const secret = generateSecret();
+            clients.push({
+                client_id: clientId,
+                client_secret_hash: hashSecret(secret),
+                allowed_redirect_uris: [redirectUri],
+                scopes: ["mcp"],
+            });
+            writeMutableGatewayConfig(config);
+            printJsonLine({
+                ok: true,
+                client_id: clientId,
+                ...(args.includes("--print-once") ? { client_secret: secret } : {}),
+                oauth: {
+                    issuer: localBaseUrlForPrint(),
+                    authorization_url: `${localBaseUrlForPrint()}/oauth/authorize`,
+                    token_url: `${localBaseUrlForPrint()}/oauth/token`,
+                },
+                note: args.includes("--print-once")
+                    ? "client_secret is shown once; it is stored only as a hash."
+                    : "client secret generated and stored only as a hash; rerun rotate --print-once if needed.",
+            });
+            return;
+        }
+        if (action === "list") {
+            printJsonLine({
+                ok: true,
+                clients: clients.map(client => ({
+                    client_id: client.client_id,
+                    redirect_uris: client.allowed_redirect_uris ?? [],
+                    secret_configured: Boolean(client.client_secret_hash),
+                })),
+            });
+            return;
+        }
+        if (action === "rotate") {
+            const clientId = args[2];
+            const client = clients.find(candidate => candidate.client_id === clientId);
+            if (!client)
+                throw new Error(`Unknown OAuth client ${clientId}`);
+            const secret = generateSecret();
+            client.client_secret_hash = hashSecret(secret);
+            writeMutableGatewayConfig(config);
+            printJsonLine({
+                ok: true,
+                client_id: clientId,
+                ...(args.includes("--print-once") ? { client_secret: secret } : {}),
+                note: "Future OAuth exchanges use the rotated secret; already-issued opaque access tokens expire by token TTL or server restart.",
+            });
+            return;
+        }
+        if (action === "revoke") {
+            const clientId = args[2];
+            oauth.clients = clients.filter(client => client.client_id !== clientId);
+            writeMutableGatewayConfig(config);
+            printJsonLine({
+                ok: true,
+                client_id: clientId,
+                note: "Future OAuth exchanges are revoked; already-issued opaque access tokens expire by token TTL or server restart.",
+            });
+            return;
+        }
+    }
+    if (scope === "shared-secret") {
+        if (action === "set" || action === "rotate") {
+            const secret = generateSecret();
+            oauth.registration_policy = "shared_secret";
+            oauth.shared_secret = {
+                enabled: true,
+                secret_hash: hashSecret(secret),
+                prompt_label: "Gateway access code",
+            };
+            writeMutableGatewayConfig(config);
+            printJsonLine({
+                ok: true,
+                shared_secret_enabled: true,
+                ...(args.includes("--print-once") ? { shared_secret: secret } : {}),
+                note: args.includes("--print-once")
+                    ? "shared_secret is shown once; it is stored only as a hash."
+                    : "shared secret generated and stored only as a hash.",
+            });
+            return;
+        }
+        if (action === "disable") {
+            oauth.shared_secret = { enabled: false, prompt_label: "Gateway access code" };
+            if (oauth.registration_policy === "shared_secret")
+                oauth.registration_policy = "static_clients";
+            writeMutableGatewayConfig(config);
+            printJsonLine({ ok: true, shared_secret_enabled: false });
+            return;
+        }
+    }
+    throw new Error("Usage: llm-cli-gateway oauth client|shared-secret ...");
+}
+function runWorkspaceCommand(args) {
+    const [action] = args;
+    if (action === "list") {
+        const registry = loadWorkspaceRegistry(logger);
+        printJsonLine({
+            ok: true,
+            default: registry.defaultAlias,
+            workspaces: registry.repos.map(describeWorkspace),
+            allowed_roots: registry.allowedRoots.map(root => ({
+                alias: root.alias,
+                path: root.path,
+                allow_create_directories: root.allowCreateDirectories,
+                allow_init_git_repos: root.allowInitGitRepos,
+            })),
+        });
+        return;
+    }
+    if (action === "create") {
+        const alias = args[1];
+        if (!alias)
+            throw new Error("Usage: llm-cli-gateway workspace create <alias> --root <root> --slug <slug> --kind folder|git [--default]");
+        const repo = createWorkspace({
+            alias,
+            rootAlias: requireArg(args, "--root"),
+            slug: requireArg(args, "--slug"),
+            kind: (argValue(args, "--kind") ?? "git"),
+            setDefault: args.includes("--default"),
+            logger,
+        });
+        printJsonLine({ ok: true, workspace: describeWorkspace(repo) });
+        return;
+    }
+    if (action === "add") {
+        const alias = args[1];
+        const repoPath = args[2];
+        if (!alias || !repoPath)
+            throw new Error("Usage: llm-cli-gateway workspace add <alias> <path> [--default]");
+        const repo = registerExistingWorkspace({
+            alias,
+            repoPath,
+            setDefault: args.includes("--default"),
+            logger,
+        });
+        printJsonLine({ ok: true, workspace: describeWorkspace(repo) });
+        return;
+    }
+    throw new Error("Usage: llm-cli-gateway workspace list|add|create ...");
+}
 async function main() {
     startWindowsBootstrapperSelfHeal();
     const args = process.argv.slice(2);
@@ -5858,6 +6185,8 @@ async function main() {
             "",
             "Usage:",
             "  llm-cli-gateway [doctor --json|contracts --json|--transport=http|--version]",
+            "  llm-cli-gateway oauth client add <id> --redirect-uri <uri> [--print-once]",
+            "  llm-cli-gateway workspace list|add|create",
             "",
             "Doctor:",
             "  doctor --json                     # environment, providers, declared contracts",
@@ -5879,6 +6208,14 @@ async function main() {
         process.stderr.write("Only doctor --json is supported in this layer.\n");
         process.exit(2);
     }
+    if (args[0] === "oauth") {
+        runOAuthCommand(args.slice(1));
+        return;
+    }
+    if (args[0] === "workspace") {
+        runWorkspaceCommand(args.slice(1));
+        return;
+    }
     if (args[0] === "contracts") {
         if (args.includes("--json")) {
             const cliArg = args.find(arg => arg.startsWith("--cli="))?.split("=")[1];