llm-cli-gateway 2.1.0 → 2.3.0

package/CHANGELOG.md

@@ -4,6 +4,47 @@ All notable changes to the llm-cli-gateway project.
 
 ## Unreleased
 
+## [2.3.0] - 2026-06-08: MCP tool annotations and client safety hints
+
+### Added
+
+- MCP tool annotations for all 37 tools (per MCP spec + tool-design best
+  practice): display `title` plus `readOnlyHint`/`destructiveHint`/
+  `idempotentHint`/`openWorldHint` on every registration. 14 pure-read tools
+  marked read-only/closed-world; `cli_upgrade`, `session_delete`,
+  `session_clear_all`, `llm_job_cancel` marked destructive; every
+  provider-spawning tool (requests, fork, validation) marked open-world with
+  destructive potential (spawned agentic CLIs can modify the environment).
+  Clients can use the hints for confirmation UX and safe auto-approval. New
+  invariant test pins titles, the exact destructive/read-only/open-world
+  sets, and the readOnly+destructive contradiction ban.
+
+## [2.2.0] - 2026-06-07: MCP tool-surface usability — self-describing tools
+
+### Added
+
+- MCP tool-surface usability (4-seat cross-LLM review): all 37 tools now carry
+  action descriptions (previously none had tool-level descriptions — clients
+  that rank, search, or defer tools by description saw bare names); sync
+  `*_request` descriptions state the prompt/promptParts exactly-one rule and
+  conditional deferral; `job_status`/`job_result` vs `llm_job_*` and the
+  local-only `compare_answers` are disambiguated; session/`sessionId`
+  describes gain per-provider resume semantics parity.
+
+### Fixed
+
+- Codex gateway-bookkeeping sessions are now created with the reserved `gw-`
+  prefix (4 sites), so resuming a gateway ID fails fast with an actionable
+  error instead of reaching `codex exec resume` and dying with "no rollout
+  found" (root cause of real-world resume failures).
+- Server instructions are now built per-server from the same derived gate as
+  tool registration (backend, asyncJobsEnabled, hasStore()), so a
+  `backend = "none"` gateway no longer advertises unregistered
+  `*_request_async`/`llm_job_*` tools.
+- Sync auto-deferral is disabled when async jobs are unavailable — previously
+  a request could defer into an in-memory job whose polling tools were not
+  registered (dead-end jobId).
+
 ## [2.1.0] - 2026-06-07: Grok Build 0.2.32, probe drift acknowledgement, docs currency
 
 ### Added
@@ -221,7 +262,7 @@ to end with a verdaccio reproduction.
 - Consumer `npm ls` exits ELSPROBLEMS: the pinned `tar-stream@3.1.7` sits
   outside `tar-fs`'s `^2.1.4` range. Inherent to the out-of-range pin; disappears
   in 2.0.0 (Phase B / node:sqlite) when the `better-sqlite3 → prebuild-install
-  → tar-fs` chain leaves the prod graph entirely.
+→ tar-fs` chain leaves the prod graph entirely.
 - Local-tarball installs still resolve `tar-stream@2.2.0` (shrinkwrap ignored on
   that path); the audit's advisory carve-out stays until Phase B.
 

package/dist/index.d.ts

@@ -44,6 +44,7 @@ declare const logger: {
     debug: (message: string, ...args: any[]) => void;
 };
 type GatewayLogger = typeof logger;
+export declare function buildServerInstructions(asyncJobsEnabled: boolean): string;
 export declare const MAX_TURNS_SCHEMA: z.ZodNumber;
 export declare const MAX_TOKENS_SCHEMA: z.ZodNumber;
 export declare const MAX_PRICE_SCHEMA: z.ZodNumber;

package/dist/index.js

@@ -141,16 +141,21 @@ function loadSkills() {
     return skills;
 }
 const loadedSkills = loadSkills();
-const SERVER_INSTRUCTIONS = `llm-cli-gateway: Multi-LLM orchestration via MCP.
+export function buildServerInstructions(asyncJobsEnabled) {
+    const asyncToolsNote = asyncJobsEnabled ? " | *_request_async (async)" : "";
+    const jobsLine = asyncJobsEnabled ? "Jobs: llm_job_status, llm_job_result, llm_job_cancel\n" : "";
+    const deferralLine = asyncJobsEnabled
+        ? `- Sync auto-defers at ${SYNC_DEADLINE_MS}ms. Poll deferred jobs via llm_job_status/llm_job_result.`
+        : '- Async jobs are DISABLED (persistence.backend = "none"): *_request_async and llm_job_* tools are not registered, and sync requests run to completion (no auto-deferral).';
+    return `llm-cli-gateway: Multi-LLM orchestration via MCP.
 
-Tools: claude_request, codex_request, gemini_request, grok_request, mistral_request (sync) | *_request_async (async) | codex_fork_session (fork a Codex session into a new branch)
+Tools: claude_request, codex_request, gemini_request, grok_request, mistral_request (sync)${asyncToolsNote} | codex_fork_session (fork a Codex session into a new branch)
 Validation: validate_with_models, second_opinion, compare_answers, red_team_review, consensus_check, ask_model, synthesize_validation, list_available_models | job_status/job_result (validation jobs)
-Jobs: llm_job_status, llm_job_result, llm_job_cancel
-Sessions: session_create, session_list, session_set_active, session_get, session_delete, session_clear_all
+${jobsLine}Sessions: session_create, session_list, session_set_active, session_get, session_delete, session_clear_all
 Other: list_models, cli_versions, upstream_contracts (use --probe-installed after CLI upgrades to detect drift), cli_upgrade, approval_list, llm_process_health, llm_request_result (read back any persisted request — sync or async — by correlationId)
 
 Key behaviors:
-- Sync auto-defers at ${SYNC_DEADLINE_MS}ms. Poll deferred jobs via llm_job_status/llm_job_result.
+${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.
 - Approval gates: opt-in via approvalStrategy:"mcp_managed".
 - Upstream drift detection: After upgrading any provider CLI (especially grok), use the upstream_contracts tool with probeInstalled: true (or the CLI command "llm-cli-gateway contracts --json --probe-installed"). This is the primary reliable way to detect when an installed binary has gained or lost flags compared to the gateway's declared contract. The probe is safe and read-only.
@@ -158,8 +163,9 @@ Key behaviors:
 
 Skills (full docs via MCP resources):
 ${loadedSkills.map(s => `- skills://${s.name} — ${s.description}`).join("\n")}`;
-function newGatewayMcpServer() {
-    return new McpServer({ name: "llm-cli-gateway", version: packageVersion() }, { instructions: SERVER_INSTRUCTIONS });
+}
+function newGatewayMcpServer(asyncJobsEnabled = true) {
+    return new McpServer({ name: "llm-cli-gateway", version: packageVersion() }, { instructions: buildServerInstructions(asyncJobsEnabled) });
 }
 let sessionManager;
 let db = null;
@@ -307,7 +313,10 @@ async function awaitJobOrDefer(cli, args, corrId, idleTimeoutMs, outputFormat, f
         consumeOnComplete();
         throw err;
     }
-    if (SYNC_DEADLINE_MS === 0) {
+    const deferralAvailable = runtime.persistence.backend !== "none" &&
+        runtime.persistence.asyncJobsEnabled &&
+        runtime.asyncJobManager.hasStore();
+    if (SYNC_DEADLINE_MS === 0 || !deferralAvailable) {
         const command = cli === "mistral" ? "vibe" : cli;
         try {
             return await executeCli(command, args, {
@@ -2503,7 +2512,7 @@ export async function handleCodexRequestAsync(deps, params) {
                 effectiveSessionId = activeSession.id;
             }
             else {
-                const newSession = await deps.sessionManager.createSession("codex", "Codex Session");
+                const newSession = await deps.sessionManager.createSession("codex", "Codex Session", `${GATEWAY_SESSION_PREFIX}${randomUUID()}`);
                 effectiveSessionId = newSession.id;
             }
         }
@@ -2511,7 +2520,7 @@ export async function handleCodexRequestAsync(deps, params) {
             await deps.sessionManager.updateSessionUsage(params.sessionId);
         }
         else if (params.createNewSession) {
-            const newSession = await deps.sessionManager.createSession("codex", "Codex Session");
+            const newSession = await deps.sessionManager.createSession("codex", "Codex Session", `${GATEWAY_SESSION_PREFIX}${randomUUID()}`);
             effectiveSessionId = newSession.id;
         }
         let worktreeResolution = {};
@@ -2567,10 +2576,10 @@ export function createGatewayServer(deps = {}) {
     void flightRecorder;
     void cacheAwareness;
     const asyncJobsEnabled = persistence.backend !== "none" && persistence.asyncJobsEnabled && asyncJobManager.hasStore();
-    const server = newGatewayMcpServer();
+    const server = newGatewayMcpServer(asyncJobsEnabled);
     registerBaseResources(server, runtime);
     registerValidationTools(server, { asyncJobManager });
-    server.tool("claude_request", {
+    server.tool("claude_request", "Run a Claude Code 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.", {
         prompt: z
             .string()
             .min(1, "Prompt cannot be empty")
@@ -2586,8 +2595,14 @@ export function createGatewayServer(deps = {}) {
             .enum(["text", "json", "stream-json"])
             .default("stream-json")
             .describe("Output format (text|json|stream-json). DEFAULT: stream-json — the gateway parses NDJSON usage events to extract input/output/cache_read/cache_creation tokens + cost + model, persists them to the flight recorder for cache_state aggregates, and still returns the assistant text. Override to 'text' only when you truly want unparsed stdout (loses observability)."),
-        sessionId: z.string().optional().describe("Session ID (uses active if omitted)"),
-        continueSession: z.boolean().default(false).describe("Continue active session"),
+        sessionId: z
+            .string()
+            .optional()
+            .describe("Gateway session record to associate (uses the active session if omitted). Claude continuity itself is via continueSession (--continue); this ID is gateway bookkeeping, not a Claude-native session."),
+        continueSession: z
+            .boolean()
+            .default(false)
+            .describe("Continue the most recent Claude conversation in this cwd (emits --continue; real CLI continuity)."),
         createNewSession: z.boolean().default(false).describe("Force new session"),
         allowedTools: z
             .array(z.string())
@@ -2703,6 +2718,12 @@ export function createGatewayServer(deps = {}) {
             .boolean()
             .default(false)
             .describe("Bypass dedup and force a fresh CLI run even if a recent identical request exists"),
+    }, {
+        title: "Claude Code request",
+        readOnlyHint: false,
+        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, }) => {
         const startTime = Date.now();
         if (systemPrompt !== undefined && appendSystemPrompt !== undefined) {
@@ -2897,7 +2918,7 @@ export function createGatewayServer(deps = {}) {
             performanceMetrics.recordRequest("claude", finalizedDurationMs, wasSuccessful);
         }
     });
-    server.tool("codex_request", {
+    server.tool("codex_request", "Run an OpenAI Codex 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.", {
         prompt: z
             .string()
             .min(1, "Prompt cannot be empty")
@@ -3004,6 +3025,12 @@ export function createGatewayServer(deps = {}) {
             .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."),
         worktree: WORKTREE_SCHEMA.optional(),
+    }, {
+        title: "Codex request",
+        readOnlyHint: false,
+        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, }) => {
         const startTime = Date.now();
         const prep = prepareCodexRequest({
@@ -3089,7 +3116,7 @@ export function createGatewayServer(deps = {}) {
                     effectiveSessionId = activeSession.id;
                 }
                 else {
-                    const newSession = await sessionManager.createSession("codex", "Codex Session");
+                    const newSession = await sessionManager.createSession("codex", "Codex Session", `${GATEWAY_SESSION_PREFIX}${randomUUID()}`);
                     effectiveSessionId = newSession.id;
                 }
             }
@@ -3097,7 +3124,7 @@ export function createGatewayServer(deps = {}) {
                 await sessionManager.updateSessionUsage(sessionId);
             }
             else if (createNewSession) {
-                const newSession = await sessionManager.createSession("codex", "Codex Session");
+                const newSession = await sessionManager.createSession("codex", "Codex Session", `${GATEWAY_SESSION_PREFIX}${randomUUID()}`);
                 effectiveSessionId = newSession.id;
             }
             logger.info(`[${corrId}] codex_request completed successfully in ${durationMs}ms`);
@@ -3145,7 +3172,7 @@ export function createGatewayServer(deps = {}) {
             performanceMetrics.recordRequest("codex", finalizedDurationMs, wasSuccessful);
         }
     });
-    server.tool("codex_fork_session", {
+    server.tool("codex_fork_session", "Fork an existing Codex session into a new branch (codex fork <ID|--last>) and run a prompt against the fork without mutating the original.", {
         prompt: z
             .string()
             .min(1, "Prompt cannot be empty")
@@ -3176,6 +3203,12 @@ export function createGatewayServer(deps = {}) {
             .max(3_600_000)
             .optional()
             .describe("Idle timeout in ms (min 30s, max 1h, omit=CLI default)"),
+    }, {
+        title: "Fork Codex session",
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
     }, async ({ prompt, sessionId, forkLast, model, sandboxMode, askForApproval, correlationId, idleTimeoutMs, }) => {
         const corrId = correlationId || randomUUID();
         const startTime = Date.now();
@@ -3232,7 +3265,7 @@ export function createGatewayServer(deps = {}) {
             performanceMetrics.recordRequest("codex", finalizedDurationMs, wasSuccessful);
         }
     });
-    server.tool("gemini_request", {
+    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.", {
         prompt: z
             .string()
             .min(1, "Prompt cannot be empty")
@@ -3244,7 +3277,10 @@ export function createGatewayServer(deps = {}) {
             .string()
             .optional()
             .describe("Model name or alias (e.g. gemini-3-pro-preview, gemini-2.5-flash, pro, flash, latest)"),
-        sessionId: z.string().optional().describe("Session ID or '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"),
         createNewSession: z.boolean().default(false).describe("Force new session"),
         approvalMode: z
@@ -3299,6 +3335,12 @@ export function createGatewayServer(deps = {}) {
             .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."),
         worktree: WORKTREE_SCHEMA.optional(),
+    }, {
+        title: "Gemini request",
+        readOnlyHint: false,
+        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, }) => {
         return handleGeminiRequest({ sessionManager, logger, runtime }, {
             prompt,
@@ -3328,7 +3370,7 @@ export function createGatewayServer(deps = {}) {
             worktree,
         });
     });
-    server.tool("grok_request", {
+    server.tool("grok_request", "Run an xAI Grok 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.", {
         prompt: z
             .string()
             .min(1, "Prompt cannot be empty")
@@ -3344,7 +3386,7 @@ export function createGatewayServer(deps = {}) {
         sessionId: z
             .string()
             .optional()
-            .describe("Session ID (user-provided CLI handle for --resume)"),
+            .describe("Provider-native session ID to resume (emits --resume <id>; use resumeLatest for --continue)"),
         resumeLatest: z
             .boolean()
             .default(false)
@@ -3503,6 +3545,12 @@ export function createGatewayServer(deps = {}) {
             .optional()
             .describe("Grok -w/--worktree: native CLI worktree flag (`true` → bare `--worktree`, string → named). NOT gateway slice λ `worktree`."),
         worktree: WORKTREE_SCHEMA.optional(),
+    }, {
+        title: "Grok request",
+        readOnlyHint: false,
+        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, }) => {
         return handleGrokRequest({ sessionManager, logger, runtime }, {
             prompt,
@@ -3557,7 +3605,7 @@ export function createGatewayServer(deps = {}) {
             worktree,
         });
     });
-    server.tool("mistral_request", {
+    server.tool("mistral_request", "Run a Mistral Vibe 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.", {
         prompt: z
             .string()
             .min(1, "Prompt cannot be empty")
@@ -3637,6 +3685,12 @@ export function createGatewayServer(deps = {}) {
             .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)."),
         worktree: WORKTREE_SCHEMA.optional(),
+    }, {
+        title: "Mistral Vibe request",
+        readOnlyHint: false,
+        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, }) => {
         return handleMistralRequest({ sessionManager, logger, runtime }, {
             prompt,
@@ -3667,7 +3721,7 @@ export function createGatewayServer(deps = {}) {
         });
     });
     if (asyncJobsEnabled) {
-        server.tool("claude_request_async", {
+        server.tool("claude_request_async", "Start a Claude Code CLI request as a durable background job. Poll with llm_job_status, collect with llm_job_result.", {
             prompt: z
                 .string()
                 .min(1, "Prompt cannot be empty")
@@ -3683,8 +3737,14 @@ export function createGatewayServer(deps = {}) {
                 .enum(["text", "json", "stream-json"])
                 .default("stream-json")
                 .describe("Output format (text|json|stream-json). DEFAULT: stream-json — same rationale as claude_request: keeps usage/cache/cost observable for cache_state aggregates. Override to 'text' only when raw stdout is required (loses observability)."),
-            sessionId: z.string().optional().describe("Session ID (uses active if omitted)"),
-            continueSession: z.boolean().default(false).describe("Continue active session"),
+            sessionId: z
+                .string()
+                .optional()
+                .describe("Gateway session record to associate (uses the active session if omitted). Claude continuity itself is via continueSession (--continue); this ID is gateway bookkeeping, not a Claude-native session."),
+            continueSession: z
+                .boolean()
+                .default(false)
+                .describe("Continue the most recent Claude conversation in this cwd (emits --continue; real CLI continuity)."),
             createNewSession: z.boolean().default(false).describe("Force new session"),
             allowedTools: z
                 .array(z.string())
@@ -3799,6 +3859,12 @@ export function createGatewayServer(deps = {}) {
                 .boolean()
                 .default(false)
                 .describe("Bypass dedup and force a fresh CLI run even if a recent identical request exists"),
+        }, {
+            title: "Claude Code request (async job)",
+            readOnlyHint: false,
+            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, }) => {
             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)."));
@@ -3920,7 +3986,7 @@ export function createGatewayServer(deps = {}) {
                 return createErrorResponse("claude_request_async", 1, "", corrId, error);
             }
         });
-        server.tool("codex_request_async", {
+        server.tool("codex_request_async", "Start an OpenAI Codex CLI request as a durable background job. Poll with llm_job_status, collect with llm_job_result.", {
             prompt: z
                 .string()
                 .min(1, "Prompt cannot be empty")
@@ -4011,6 +4077,12 @@ export function createGatewayServer(deps = {}) {
                 .optional()
                 .describe("Codex --add-dir <DIR>: additional writable workspace directories (repeat per entry). New sessions only."),
             worktree: WORKTREE_SCHEMA.optional(),
+        }, {
+            title: "Codex request (async job)",
+            readOnlyHint: false,
+            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, }) => {
             return handleCodexRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
@@ -4045,7 +4117,7 @@ export function createGatewayServer(deps = {}) {
                 worktree,
             });
         });
-        server.tool("gemini_request_async", {
+        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.", {
             prompt: z
                 .string()
                 .min(1, "Prompt cannot be empty")
@@ -4060,7 +4132,7 @@ export function createGatewayServer(deps = {}) {
             sessionId: z
                 .string()
                 .optional()
-                .describe("Session ID (user-provided CLI handle for --resume)"),
+                .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"),
             createNewSession: z.boolean().default(false).describe("Force new session"),
             approvalMode: z
@@ -4114,6 +4186,12 @@ export function createGatewayServer(deps = {}) {
                 .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."),
             worktree: WORKTREE_SCHEMA.optional(),
+        }, {
+            title: "Gemini request (async job)",
+            readOnlyHint: false,
+            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, }) => {
             return handleGeminiRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
@@ -4142,7 +4220,7 @@ export function createGatewayServer(deps = {}) {
                 worktree,
             });
         });
-        server.tool("grok_request_async", {
+        server.tool("grok_request_async", "Start an xAI Grok CLI request as a durable background job. Poll with llm_job_status, collect with llm_job_result.", {
             prompt: z
                 .string()
                 .min(1, "Prompt cannot be empty")
@@ -4158,7 +4236,7 @@ export function createGatewayServer(deps = {}) {
             sessionId: z
                 .string()
                 .optional()
-                .describe("Session ID (user-provided CLI handle for --resume)"),
+                .describe("Provider-native session ID to resume (emits --resume <id>; use resumeLatest for --continue)"),
             resumeLatest: z
                 .boolean()
                 .default(false)
@@ -4319,6 +4397,12 @@ export function createGatewayServer(deps = {}) {
                 .optional()
                 .describe("Grok -w/--worktree: native CLI worktree flag (`true` → bare `--worktree`, string → named). NOT gateway slice λ `worktree`."),
             worktree: WORKTREE_SCHEMA.optional(),
+        }, {
+            title: "Grok request (async job)",
+            readOnlyHint: false,
+            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, }) => {
             return handleGrokRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
@@ -4372,7 +4456,7 @@ export function createGatewayServer(deps = {}) {
                 worktree,
             });
         });
-        server.tool("mistral_request_async", {
+        server.tool("mistral_request_async", "Start a Mistral Vibe CLI request as a durable background job. Poll with llm_job_status, collect with llm_job_result.", {
             prompt: z
                 .string()
                 .min(1, "Prompt cannot be empty")
@@ -4451,6 +4535,12 @@ export function createGatewayServer(deps = {}) {
                 .optional()
                 .describe("Vibe --add-dir <DIR>: additional writable workspace directories. Each entry is emitted as its own --add-dir instance."),
             worktree: WORKTREE_SCHEMA.optional(),
+        }, {
+            title: "Mistral Vibe request (async job)",
+            readOnlyHint: false,
+            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, }) => {
             return handleMistralRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
@@ -4479,8 +4569,14 @@ export function createGatewayServer(deps = {}) {
                 worktree,
             });
         });
-        server.tool("llm_job_status", {
+        server.tool("llm_job_status", "Check lifecycle status (running|completed|failed|canceled|orphaned) of a gateway async or deferred-sync job by jobId.", {
             jobId: z.string().describe("Async job ID from *_request_async"),
+        }, {
+            title: "Async job status",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
         }, async ({ jobId }) => {
             const job = asyncJobManager.getJobSnapshot(jobId);
             if (!job) {
@@ -4510,7 +4606,7 @@ export function createGatewayServer(deps = {}) {
                 ],
             };
         });
-        server.tool("llm_job_result", {
+        server.tool("llm_job_result", "Retrieve captured stdout/stderr for a gateway async or deferred-sync job by jobId.", {
             jobId: z.string().describe("Async job ID from *_request_async"),
             maxChars: z
                 .number()
@@ -4519,6 +4615,12 @@ export function createGatewayServer(deps = {}) {
                 .max(2000000)
                 .default(200000)
                 .describe("Max chars returned per stream"),
+        }, {
+            title: "Async job result",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
         }, async ({ jobId, maxChars }) => {
             const result = asyncJobManager.getJobResult(jobId, maxChars);
             if (!result) {
@@ -4564,8 +4666,14 @@ export function createGatewayServer(deps = {}) {
                 ],
             };
         });
-        server.tool("llm_job_cancel", {
+        server.tool("llm_job_cancel", "Cancel a running gateway async or deferred-sync job by jobId.", {
             jobId: z.string().describe("Async job ID from *_request_async"),
+        }, {
+            title: "Cancel async job",
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: false,
         }, async ({ jobId }) => {
             const cancel = asyncJobManager.cancelJob(jobId);
             if (!cancel.canceled) {
@@ -4596,7 +4704,7 @@ export function createGatewayServer(deps = {}) {
             };
         });
     }
-    server.tool("llm_request_result", {
+    server.tool("llm_request_result", "Read back any persisted request (sync or async) from the flight recorder by correlationId, including prompt and response.", {
         correlationId: z
             .string()
             .min(1)
@@ -4612,6 +4720,12 @@ export function createGatewayServer(deps = {}) {
             .boolean()
             .default(false)
             .describe("Include the full persisted prompt text in the result"),
+    }, {
+        title: "Persisted request lookup",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
     }, async ({ correlationId, maxChars, includePrompt }) => {
         const record = readPersistedRequest(flightRecorder, correlationId, {
             maxChars,
@@ -4642,7 +4756,13 @@ export function createGatewayServer(deps = {}) {
             ],
         };
     });
-    server.tool("llm_process_health", {}, async () => {
+    server.tool("llm_process_health", "Report gateway process health: async-job manager state plus the resolved persistence configuration and paths.", {}, {
+        title: "Gateway process health",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    }, async () => {
         const health = asyncJobManager.getJobHealth();
         const persistenceBlock = {
             backend: persistence.backend,
@@ -4666,7 +4786,7 @@ export function createGatewayServer(deps = {}) {
             ],
         };
     });
-    server.tool("approval_list", {
+    server.tool("approval_list", "List recent MCP-managed approval decisions recorded by the gateway (approvalStrategy: mcp_managed).", {
         limit: z
             .number()
             .int()
@@ -4678,6 +4798,12 @@ export function createGatewayServer(deps = {}) {
             .enum(["claude", "codex", "gemini", "grok", "mistral"])
             .optional()
             .describe("Optional CLI filter"),
+    }, {
+        title: "Approval decisions",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
     }, async ({ limit, cli }) => {
         const approvals = approvalManager.list(limit, cli);
         return {
@@ -4693,24 +4819,36 @@ export function createGatewayServer(deps = {}) {
             ],
         };
     });
-    server.tool("list_models", {
+    server.tool("list_models", "List models, aliases, and defaults for one provider CLI (claude|codex|gemini|grok|mistral).", {
         cli: z
             .preprocess(value => (value === "" || value === null ? undefined : value), z.enum(["claude", "codex", "gemini", "grok", "mistral"]).optional())
             .describe("CLI filter (claude|codex|gemini|grok|mistral)"),
+    }, {
+        title: "Provider models",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
     }, async ({ cli }) => {
         const cliInfo = getAvailableCliInfo();
         const result = cli ? { [cli]: cliInfo[cli] } : cliInfo;
         return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     });
-    server.tool("cli_versions", {
+    server.tool("cli_versions", "Report installed provider CLI versions, availability, and login status for all five providers or one.", {
         cli: z
             .preprocess(value => (value === "" || value === null ? undefined : value), z.enum(["claude", "codex", "gemini", "grok", "mistral"]).optional())
             .describe("CLI filter (claude|codex|gemini|grok|mistral)"),
+    }, {
+        title: "Provider CLI versions",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
     }, async ({ cli }) => {
         const versions = await getCliVersions(cli);
         return { content: [{ type: "text", text: JSON.stringify({ versions }, null, 2) }] };
     });
-    server.tool("upstream_contracts", {
+    server.tool("upstream_contracts", "Return the gateway's declared provider CLI contracts; with probeInstalled true, diff against installed --help surfaces to detect flag drift.", {
         cli: z
             .preprocess(value => (value === "" || value === null ? undefined : value), SESSION_PROVIDER_ENUM.optional())
             .describe("CLI filter (claude|codex|gemini|grok|mistral)"),
@@ -4718,11 +4856,17 @@ export function createGatewayServer(deps = {}) {
             .boolean()
             .default(false)
             .describe("When true, run local --help probes and compare advertised flags against the declared contract. Strongly recommended after any provider CLI upgrade to detect drift."),
+    }, {
+        title: "Provider CLI contracts",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
     }, async ({ cli, probeInstalled }) => {
         const report = buildUpstreamContractReport({ cli, probeInstalled });
         return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
     });
-    server.tool("cli_upgrade", {
+    server.tool("cli_upgrade", "Plan (dryRun, default true) or execute an upgrade for one provider CLI using its native update mechanism.", {
         cli: z.enum(["claude", "codex", "gemini", "grok", "mistral"]).describe("CLI to upgrade"),
         target: z
             .string()
@@ -4740,6 +4884,12 @@ export function createGatewayServer(deps = {}) {
             .max(3_600_000)
             .optional()
             .describe("Upgrade timeout in ms when dryRun=false"),
+    }, {
+        title: "Upgrade provider CLI",
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
     }, async ({ cli, target, dryRun, timeoutMs }) => {
         try {
             const result = await runCliUpgrade({ cli, target, dryRun, timeoutMs, logger });
@@ -4771,10 +4921,16 @@ export function createGatewayServer(deps = {}) {
             };
         }
     });
-    server.tool("session_create", {
+    server.tool("session_create", "Create a gateway session record for a provider CLI. NOTE: this is gateway bookkeeping (gw-* ID), not a provider-native session — Codex resume needs a real Codex UUID.", {
         cli: SESSION_PROVIDER_ENUM.describe("CLI type (claude|codex|gemini|grok|mistral)"),
         description: z.string().optional().describe("Session description"),
         setAsActive: z.boolean().default(true).describe("Set as active session"),
+    }, {
+        title: "Create session record",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
     }, async ({ cli, description, setAsActive }) => {
         try {
             const session = await sessionManager.createSession(cli, description);
@@ -4804,8 +4960,14 @@ export function createGatewayServer(deps = {}) {
             return createErrorResponse("session_create", 1, "", undefined, error);
         }
     });
-    server.tool("session_list", {
+    server.tool("session_list", "List gateway session records and the active session per CLI, optionally filtered by CLI.", {
         cli: SESSION_PROVIDER_ENUM.optional().describe("CLI filter (claude|codex|gemini|grok|mistral)"),
+    }, {
+        title: "List sessions",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
     }, async ({ cli }) => {
         try {
             const sessions = await sessionManager.listSessions(cli);
@@ -4847,9 +5009,15 @@ export function createGatewayServer(deps = {}) {
             return createErrorResponse("session_list", 1, "", undefined, error);
         }
     });
-    server.tool("session_set_active", {
+    server.tool("session_set_active", "Set or clear the active session for a CLI; the active session is used when a request omits sessionId.", {
         cli: SESSION_PROVIDER_ENUM.describe("CLI type (claude|codex|gemini|grok|mistral)"),
         sessionId: z.string().nullable().describe("Session ID (null to clear)"),
+    }, {
+        title: "Set active session",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
     }, async ({ cli, sessionId }) => {
         try {
             const success = await sessionManager.setActiveSession(cli, sessionId || null);
@@ -4885,8 +5053,14 @@ export function createGatewayServer(deps = {}) {
             return createErrorResponse("session_set_active", 1, "", undefined, error);
         }
     });
-    server.tool("session_delete", {
+    server.tool("session_delete", "Delete a gateway session record by ID (also removes any gateway-owned worktree attached to it).", {
         sessionId: z.string().describe("Session ID"),
+    }, {
+        title: "Delete session",
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false,
     }, async ({ sessionId }) => {
         try {
             const session = await sessionManager.getSession(sessionId);
@@ -4926,8 +5100,14 @@ export function createGatewayServer(deps = {}) {
             return createErrorResponse("session_delete", 1, "", undefined, error);
         }
     });
-    server.tool("session_get", {
+    server.tool("session_get", "Get one gateway session record by session ID, including recent request history when available.", {
         sessionId: z.string().describe("Session ID"),
+    }, {
+        title: "Get session",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
     }, async ({ sessionId }) => {
         try {
             const session = await sessionManager.getSession(sessionId);
@@ -4989,8 +5169,14 @@ export function createGatewayServer(deps = {}) {
             return createErrorResponse("session_get", 1, "", undefined, error);
         }
     });
-    server.tool("session_clear_all", {
+    server.tool("session_clear_all", "Delete all gateway session records, optionally scoped to one CLI.", {
         cli: SESSION_PROVIDER_ENUM.optional().describe("CLI filter (claude|codex|gemini|grok|mistral)"),
+    }, {
+        title: "Clear sessions",
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false,
     }, async ({ cli }) => {
         try {
             const count = await sessionManager.clearAllSessions(cli);

package/dist/validation-tools.js

@@ -47,7 +47,7 @@ function findHumanReadableReport(value) {
     return null;
 }
 export function registerValidationTools(server, deps) {
-    server.tool("validate_with_models", {
+    server.tool("validate_with_models", "Ask two or more provider CLIs to independently validate a question. Starts validation jobs — poll with job_status, collect with job_result (not llm_job_*).", {
         question: z.string().min(1).describe("Question or content to validate."),
         models: providerListSchema.describe("Providers to ask. Defaults to Claude and Codex."),
         focus: z
@@ -57,6 +57,12 @@ export function registerValidationTools(server, deps) {
         judgeModel: providerSchema
             .optional()
             .describe("Optional provider to run an explicit judge synthesis job."),
+    }, {
+        title: "Multi-model validation",
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
     }, async ({ question, models, focus, judgeModel }) => textResponse({
         success: true,
         tool: "validate_with_models",
@@ -69,10 +75,16 @@ export function registerValidationTools(server, deps) {
             judgeProvider: judgeModel,
         }),
     }));
-    server.tool("second_opinion", {
+    server.tool("second_opinion", "Ask one provider CLI to review an answer (starts a validation job; poll job_status, collect job_result).", {
         answer: z.string().min(1).describe("Answer to review."),
         question: z.string().optional().describe("Original question, if available."),
         model: providerSchema.default("codex").describe("Provider to ask for the second opinion."),
+    }, {
+        title: "Second opinion",
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
     }, async ({ answer, question, model }) => textResponse({
         success: true,
         tool: "second_opinion",
@@ -84,9 +96,15 @@ export function registerValidationTools(server, deps) {
             providers: [model],
         }),
     }));
-    server.tool("compare_answers", {
+    server.tool("compare_answers", "Summarize agreement/differences between caller-provided answers LOCALLY — does not call any provider.", {
         question: z.string().min(1).describe("Question the answers respond to."),
         answers: z.array(z.string().min(1)).min(2).describe("Two or more answers to compare."),
+    }, {
+        title: "Compare answers (local)",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
     }, async ({ question, answers }) => textResponse({
         success: true,
         tool: "compare_answers",
@@ -99,13 +117,19 @@ export function registerValidationTools(server, deps) {
             note: "Use validate_with_models when independent provider review is needed.",
         },
     }));
-    server.tool("red_team_review", {
+    server.tool("red_team_review", "Challenge a plan, answer, or document for risks and failure modes via provider CLIs (starts validation jobs).", {
         content: z.string().min(1).describe("Plan, answer, or document to challenge."),
         riskLevel: z
             .enum(["normal", "high"])
             .default("normal")
             .describe("How aggressively to review."),
         models: providerListSchema.describe("Providers to ask for adversarial review."),
+    }, {
+        title: "Red-team review",
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
     }, async ({ content, riskLevel, models }) => textResponse({
         success: true,
         tool: "red_team_review",
@@ -117,9 +141,15 @@ export function registerValidationTools(server, deps) {
             riskLevel,
         }),
     }));
-    server.tool("consensus_check", {
+    server.tool("consensus_check", "Ask provider CLIs whether they agree or disagree with a claim (starts validation jobs).", {
         claim: z.string().min(1).describe("Claim to check across providers."),
         models: providerListSchema.describe("Providers to ask for agreement or disagreement."),
+    }, {
+        title: "Consensus check",
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
     }, async ({ claim, models }) => textResponse({
         success: true,
         tool: "consensus_check",
@@ -130,9 +160,15 @@ export function registerValidationTools(server, deps) {
             providers: models,
         }),
     }));
-    server.tool("ask_model", {
+    server.tool("ask_model", "Ask one provider CLI a question through the simplified validation surface (starts a validation job).", {
         question: z.string().min(1).describe("Question for one provider."),
         model: providerSchema.default("claude").describe("Provider to ask."),
+    }, {
+        title: "Ask one model",
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
     }, async ({ question, model }) => textResponse({
         success: true,
         tool: "ask_model",
@@ -143,13 +179,19 @@ export function registerValidationTools(server, deps) {
             providers: [model],
         }),
     }));
-    server.tool("synthesize_validation", {
+    server.tool("synthesize_validation", "Run an explicit judge model over already-collected validation results to produce a synthesis.", {
         question: z.string().min(1).describe("Original request that was validated."),
         providerResults: z
             .array(normalizedProviderResultSchema)
             .min(1)
             .describe("Terminal normalized provider results from job_result."),
         judgeModel: providerSchema.default("codex").describe("Provider to run the judge synthesis."),
+    }, {
+        title: "Synthesize validation",
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
     }, async ({ question, providerResults, judgeModel }) => textResponse({
         success: true,
         tool: "synthesize_validation",
@@ -160,9 +202,21 @@ export function registerValidationTools(server, deps) {
             judgeProvider: judgeModel,
         }),
     }));
-    server.tool("list_available_models", {}, async () => textResponse({ success: true, models: getAvailableCliInfo() }));
-    server.tool("job_status", {
+    server.tool("list_available_models", "List models and capabilities for every available provider CLI (takes no arguments; complements per-provider list_models).", {}, {
+        title: "All provider models",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    }, async () => textResponse({ success: true, models: getAvailableCliInfo() }));
+    server.tool("job_status", "Check a VALIDATION job's status (jobs started by validate_with_models/ask_model/etc.) — distinct from llm_job_status, which tracks provider request jobs.", {
         jobId: z.string().min(1).describe("Validation job ID."),
+    }, {
+        title: "Validation job status",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
     }, async ({ jobId }) => {
         const job = deps.asyncJobManager.getJobSnapshot(jobId);
         if (!job) {
@@ -170,7 +224,7 @@ export function registerValidationTools(server, deps) {
         }
         return textResponse({ success: true, job });
     });
-    server.tool("job_result", {
+    server.tool("job_result", "Collect a VALIDATION job's normalized provider output — distinct from llm_job_result, which returns raw provider request job output.", {
         jobId: z.string().min(1).describe("Validation job ID."),
         provider: providerSchema
             .optional()
@@ -182,6 +236,12 @@ export function registerValidationTools(server, deps) {
             .max(2000000)
             .default(200000)
             .describe("Maximum result size."),
+    }, {
+        title: "Validation job result",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
     }, async ({ jobId, provider, maxChars }) => {
         const result = deps.asyncJobManager.getJobResult(jobId, maxChars);
         if (!result) {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "llm-cli-gateway",
-  "version": "2.0.0",
+  "version": "2.3.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "llm-cli-gateway",
-      "version": "2.0.0",
+      "version": "2.3.0",
       "license": "MIT",
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.29.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-cli-gateway",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "mcpName": "io.github.verivus-oss/llm-cli-gateway",
   "description": "MCP server providing unified access to Claude Code, Codex, Gemini, Grok, and Mistral Vibe CLIs with session management, retry logic, async job orchestration, durable job results, and cross-LLM validation.",
   "license": "MIT",