llm-cli-gateway 1.5.15 → 1.5.17

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to the llm-cli-gateway project.
 
+## [1.5.17] - 2026-05-24
+
+### Fixed
+
+- Make desktop bootstrapper `doctor --json` delegate to the installed Node gateway doctor when a verified bundle is installed, so provider availability and `gateway.version` reflect the active bundle instead of stale bootstrapper-side placeholders.
+- Add `gateway.bootstrapper_version` and `gateway.diagnostic_source` to desktop doctor output so bundle version and bootstrapper version are distinguishable.
+- Include `bootstrapper_version` in desktop `upgrade` output and make the post-upgrade note explicit that command fixes require replacing the bootstrapper executable.
+
+## [1.5.16] - 2026-05-24
+
+### Fixed
+
+- Remove the stale hardcoded Mistral Vibe `devstral-medium` default from the gateway request path.
+- Discover Mistral Vibe model aliases from `~/.vibe/config.toml`, `VIBE_MODELS`, `VIBE_ACTIVE_MODEL`, and gateway env overrides before injecting `VIBE_ACTIVE_MODEL`.
+- Recover stale Vibe config such as `active_model = "devstral-medium"` to `mistral-medium-3.5`, and retry one synchronous Mistral request after a model-not-found failure with refreshed discovery.
+- Build provider CLI PATH values with the platform delimiter so Windows desktop installs can find CLIs in locations such as `%USERPROFILE%\.local\bin`, and normalize Windows `-4058` launch failures to command-not-found guidance.
+
 ## [1.5.15] - 2026-05-24
 
 ### Fixed
@@ -134,7 +151,7 @@ Lands DAG layers 6-12 — the personal-MCP MVP terminal plus all of Phase 0-3 pr
 - **U13 / U16 — Release packaging + dogfood readiness.** `installer/build-release.sh` cross-compiles 5 OS/arch targets (linux/{amd64,arm64}, darwin/{amd64,arm64}, windows/amd64) + Node bundle + `SHA256SUMS` + `release-manifest.json`. New `cli_upgrade --uninstall` (idempotent, dry-run by default) and `cli_upgrade --check`. New `Dockerfile.personal` + `docker-compose.personal.yml` for the personal-MCP container path. New `installer/packaging/README.md`. New `package.json` scripts `release:build`, `release:checksums`, `release:docker`. Comprehensive `docs/personal-mcp/{DOGFOODING_RESULTS,RELEASE_READINESS,SINGLE_BINARY_INSTALLER,ENDPOINT_EXPOSURE,PRODUCT_CONTRACT,PROVIDER_SUPPORT_MATRIX,VALIDATION_REPORT_FORMAT}.md` + per-provider `connect-*.md` guides + `setup/assistants/*-install-prompt.md` install-prompt corpus.
 - **U21 — Phase-0 parity fixes.** `SESSION_PROVIDER_VALUES` / `SESSION_PROVIDER_ENUM` now expose the full provider set (grok was previously absent from `session_create`/`session_list`/`session_clear_all` Zod enums despite the storage layer supporting it). `prepareGeminiRequest` emits `["-p", prompt, ...]` instead of a positional prompt, eliminating the dependency on Gemini's TTY/mode-detection heuristics. 6 new tests pin both fixes.
 - **U22 — Mistral Vibe is the fifth supported provider.** New `mistral_request` and `mistral_request_async` MCP tools register alongside the four incumbents and route through the same async job manager, dedup store, flight recorder, approval manager, and validation orchestrator. Five Vibe-specific divergences are documented in `docs/personal-mcp/PROVIDER_MODERNISATION_AUDIT.md`:
-  - **No `--model` flag** — model selection is via the `VIBE_ACTIVE_MODEL` environment variable (default alias: `devstral-medium`); the executor and async job manager forward an `env` override.
+  - **No `--model` flag** — model selection is via the `VIBE_ACTIVE_MODEL` environment variable; the gateway discovers Vibe config/env models, avoids stale hardcoded defaults, and forwards an `env` override only when needed.
   - **Session-logging is opt-in** in `~/.vibe/config.toml` — `doctor --json` probes `[session_logging] enabled = true` (read-only) and surfaces an actionable `next_actions` entry when the toggle is missing.
   - **`--agent` enum** replaces Grok's `--always-approve` (`default | plan | accept-edits | auto-approve | chat | explore | lean`); the gateway always emits `--agent` explicitly and defaults to `auto-approve` for programmatic callers.
   - **`--enabled-tools` allow-list only** — `allowedTools` emits one `--enabled-tools <tool>` per entry; `disallowedTools` is accepted in the schema for caller parity but silently ignored at the CLI boundary (a logged warning records the no-op).

package/README.md

@@ -149,9 +149,10 @@ vibe config set session_logging.enabled true   # or edit ~/.vibe/config.toml
 Vibe-specific notes:
 
 - **Model selection is via the `VIBE_ACTIVE_MODEL` environment variable** —
-  Vibe has no `--model` flag. The gateway resolves the requested model alias
-  (default: `devstral-medium`) and injects it as `VIBE_ACTIVE_MODEL` when
-  spawning `vibe`.
+  Vibe has no `--model` flag. The gateway discovers `~/.vibe/config.toml` /
+  `VIBE_MODELS`, injects `VIBE_ACTIVE_MODEL` only when a model is explicitly
+  requested or Vibe config needs recovery, and retries once after a
+  model-not-found failure with refreshed discovery.
 - **`permissionMode` accepts** `default | plan | accept-edits | auto-approve |
   chat | explore | lean` and emits `--agent <mode>`. The gateway's
   programmatic-mode default is `auto-approve`; pick a stricter mode
@@ -594,7 +595,7 @@ consumes       = ["OUT:mcp-reconnected"]
 ##### `mistral_request`
 Run a Mistral Vibe agentic coding request. Like `grok_request` in shape, but with Vibe's specific surface:
 
-- `model` (string, optional): Resolved alias (e.g. `devstral-medium`, `devstral-large`, `latest`). The resolved value is injected via the `VIBE_ACTIVE_MODEL` environment variable — Vibe has no `--model` flag.
+- `model` (string, optional): Vibe model alias (for example `mistral-medium-3.5` or `latest`). The resolved value is injected via the `VIBE_ACTIVE_MODEL` environment variable; omit it to let the gateway discover Vibe config and avoid stale hardcoded defaults.
 - `permissionMode`: `default | plan | accept-edits | auto-approve | chat | explore | lean` — emitted as `--agent <mode>`. Defaults to `auto-approve` in programmatic mode.
 - `allowedTools` (string[], optional): One `--enabled-tools <tool>` flag per entry (allow-list only).
 - `disallowedTools` (string[], optional): Accepted for parity with the other providers; ignored at the CLI boundary with a logged warning.

package/dist/async-job-manager.js

@@ -20,6 +20,15 @@ function describeProcessLaunchError(cli, error) {
         message: `Failed to launch ${cli} CLI: ${error.message}`,
     };
 }
+function describeWindowsLaunchExit(cli, exitCode) {
+    if (exitCode !== -4058) {
+        return null;
+    }
+    return {
+        exitCode: 127,
+        message: `The '${cli}' command was not found. Install the ${cli} CLI and make sure it is on PATH.`,
+    };
+}
 /**
  * U22 fix: deterministic canonicalisation of an env-var map for the dedup key.
  * Returns "" when env is undefined or empty (preserves dedup key continuity for
@@ -483,7 +492,13 @@ export class AsyncJobManager {
                 this.fireOnComplete(job);
                 return;
             }
-            job.exitCode = code ?? 0;
+            const rawExitCode = code ?? 0;
+            const launchExit = !job.stdout && !job.stderr ? describeWindowsLaunchExit(cli, rawExitCode) : null;
+            job.exitCode = launchExit?.exitCode ?? rawExitCode;
+            if (launchExit) {
+                job.error = launchExit.message;
+                job.stderr = launchExit.message;
+            }
             job.finishedAt = new Date().toISOString();
             if (job.canceled) {
                 job.status = "canceled";

package/dist/executor.js

@@ -1,6 +1,6 @@
 import { spawn, spawnSync } from "child_process";
 import { homedir } from "os";
-import { join, dirname } from "path";
+import { delimiter, join, dirname } from "path";
 import { readdirSync, existsSync } from "fs";
 import { createCircuitBreaker, withRetry } from "./retry.js";
 const MAX_OUTPUT_SIZE = 50 * 1024 * 1024;
@@ -28,7 +28,7 @@ function getNvmPath() {
     try {
         const versions = readdirSync(nvmVersionsDir);
         cachedNvmPath = versions.length
-            ? versions.map(version => join(nvmVersionsDir, version, "bin")).join(":")
+            ? versions.map(version => join(nvmVersionsDir, version, "bin")).join(delimiter)
             : null;
     }
     catch {
@@ -51,7 +51,7 @@ export function getExtendedPath() {
         additionalPaths.push(nvmPath);
     }
     const currentPath = process.env.PATH || "";
-    return [...additionalPaths, currentPath].join(":");
+    return [...additionalPaths, currentPath].join(delimiter);
 }
 /** Registry of active detached process groups for shutdown cleanup. */
 const activeProcessGroups = new Set();
@@ -315,7 +315,14 @@ export async function executeCli(command, args, options = {}) {
                 reject(error);
                 return;
             }
-            const result = { stdout, stderr, code: code ?? 0 };
+            let result = { stdout, stderr, code: code ?? 0 };
+            if (result.code === -4058 && !stdout && !stderr) {
+                result = {
+                    stdout,
+                    stderr: `The '${command}' command was not found. Install the ${command} CLI and make sure it is on PATH.`,
+                    code: 127,
+                };
+            }
             if (result.code !== 0) {
                 const error = new Error(`Process exited with code ${result.code}`);
                 error.code = result.code;

package/dist/index.js

@@ -16,7 +16,7 @@ import { PerformanceMetrics } from "./metrics.js";
 import { estimateTokens, optimizePrompt as optimizePromptText, optimizeResponse as optimizeResponseText, } from "./optimizer.js";
 import { loadConfig, loadPersistenceConfig } from "./config.js";
 import { checkHealth } from "./health.js";
-import { getCliInfo, resolveModelAlias } from "./model-registry.js";
+import { clearModelRegistryCache, getCliInfo, resolveModelAlias } from "./model-registry.js";
 import { AsyncJobManager } from "./async-job-manager.js";
 import { createJobStore } from "./job-store.js";
 import { ApprovalManager } from "./approval-manager.js";
@@ -320,6 +320,7 @@ function buildDeferredToolResponse(deferred, sessionId) {
 // Helper function for standardized error responses
 function createErrorResponse(cli, code, stderr, correlationId, error) {
     let errorMessage = `Error executing ${cli} CLI`;
+    const isLaunchExit = code === 127 || code === -4058;
     if (error) {
         // Command not found or spawn error
         errorMessage += `:\n${error.message}`;
@@ -338,6 +339,10 @@ function createErrorResponse(cli, code, stderr, correlationId, error) {
         errorMessage += `: Process killed due to inactivity\n${stderr}`;
         logger.error(`[${correlationId || "unknown"}] ${cli} CLI killed due to inactivity`);
     }
+    else if (isLaunchExit) {
+        errorMessage += `:\n${stderr || `The '${cli}' command was not found. Install the ${cli} CLI and make sure it is on PATH.`}`;
+        logger.error(`[${correlationId || "unknown"}] ${cli} CLI failed to launch`);
+    }
     else if (code !== 0) {
         // Other non-zero exit code
         errorMessage += ` (exit code ${code}):\n${stderr}`;
@@ -356,7 +361,9 @@ function createErrorResponse(cli, code, stderr, correlationId, error) {
                     ? "idle_timeout"
                     : error
                         ? "spawn_error"
-                        : "cli_error",
+                        : isLaunchExit
+                            ? "spawn_error"
+                            : "cli_error",
         },
     };
 }
@@ -1057,7 +1064,8 @@ function prepareGrokRequest(params, runtime = resolveGatewayServerRuntime()) {
 function prepareMistralRequest(params, runtime = resolveGatewayServerRuntime()) {
     const corrId = params.correlationId || randomUUID();
     const cliInfo = getCliInfo();
-    const resolvedModel = resolveModelAlias("mistral", params.model, cliInfo) || "devstral-medium";
+    const requestedModel = params.model ?? (cliInfo.mistral.defaultModel ? "default" : undefined);
+    const resolvedModel = resolveModelAlias("mistral", requestedModel, cliInfo);
     const reviewIntegrity = checkReviewIntegrity({
         prompt: params.prompt,
         allowedTools: params.allowedTools,
@@ -1089,7 +1097,10 @@ function prepareMistralRequest(params, runtime = resolveGatewayServerRuntime())
             allowedTools: params.allowedTools,
             disallowedTools: params.disallowedTools,
             policy: params.approvalPolicy,
-            metadata: { model: resolvedModel, vibeActiveModelEnv: true },
+            metadata: {
+                model: resolvedModel ?? "vibe-default",
+                vibeActiveModelEnv: Boolean(resolvedModel),
+            },
             reviewIntegrity,
         });
         if (approvalDecision.status !== "approved") {
@@ -1126,6 +1137,19 @@ function prepareMistralRequest(params, runtime = resolveGatewayServerRuntime())
         mistralEnv: prep.env,
     };
 }
+function isMistralModelSelectionFailure(stderr) {
+    return /active model ['"].+['"] not found|model ['"].+['"] (?:isn't|is not) found|unknown model|model not found/i.test(stderr);
+}
+function selectMistralRecoveryModel(failedModel) {
+    clearModelRegistryCache();
+    const refreshed = getCliInfo(true).mistral;
+    const candidates = [
+        refreshed.defaultModel,
+        ...(refreshed.modelOrder ?? []),
+        ...Object.keys(refreshed.models),
+    ].filter((model) => Boolean(model && model !== failedModel));
+    return candidates.find(model => model !== "local");
+}
 function buildCliResponse(cli, stdout, optimizeResponse, corrId, sessionId, prep, durationMs, resumable, outputFormat) {
     let finalStdout = stdout;
     // Skip response optimization for JSON output to prevent corrupting structured data
@@ -1634,10 +1658,35 @@ export async function handleMistralRequest(deps, params) {
             createNewSession: params.createNewSession,
         });
         args.push(...sessionResult.resumeArgs);
-        const result = await awaitJobOrDefer("mistral", args, corrId, resolveIdleTimeout("mistral", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, runtime, mistralEnv);
+        let result = await awaitJobOrDefer("mistral", args, corrId, resolveIdleTimeout("mistral", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, runtime, mistralEnv);
         if (isDeferredResponse(result)) {
             return buildDeferredToolResponse(result, sessionResult.effectiveSessionId);
         }
+        if (result.code !== 0 && isMistralModelSelectionFailure(result.stderr)) {
+            const recoveryModel = selectMistralRecoveryModel(prep.resolvedModel);
+            if (recoveryModel) {
+                deps.logger.info(`[${corrId}] mistral_request detected stale Vibe model selection; retrying once with ${recoveryModel}`);
+                const retryPrep = buildMistralCliInvocation({
+                    prompt: prep.effectivePrompt,
+                    resolvedModel: recoveryModel,
+                    outputFormat: params.outputFormat,
+                    permissionMode: params.approvalStrategy === "mcp_managed"
+                        ? "auto-approve"
+                        : (params.permissionMode ?? "auto-approve"),
+                    effort: params.effort,
+                    reasoningEffort: params.reasoningEffort,
+                    allowedTools: params.allowedTools,
+                    disallowedTools: params.disallowedTools,
+                });
+                const retryArgs = [...retryPrep.args, ...sessionResult.resumeArgs];
+                result = await awaitJobOrDefer("mistral", retryArgs, corrId, resolveIdleTimeout("mistral", params.idleTimeoutMs), params.outputFormat, true, runtime, retryPrep.env);
+                if (isDeferredResponse(result)) {
+                    return buildDeferredToolResponse(result, sessionResult.effectiveSessionId);
+                }
+                prep.resolvedModel = recoveryModel;
+                prep.args = retryArgs;
+            }
+        }
         const { stdout, stderr, code } = result;
         durationMs = Math.max(0, Date.now() - startTime);
         if (code !== 0) {
@@ -2688,7 +2737,7 @@ export function createGatewayServer(deps = {}) {
         model: z
             .string()
             .optional()
-            .describe("Model alias (e.g. devstral-medium, devstral-large, latest). Resolved alias is injected via VIBE_ACTIVE_MODEL env var — Vibe has no --model flag."),
+            .describe("Model alias (e.g. mistral-medium-3.5, latest). Resolved alias is injected via VIBE_ACTIVE_MODEL env var; Vibe has no --model flag."),
         outputFormat: z
             .enum(["plain", "json", "stream-json"])
             .optional()

package/dist/model-registry.js

@@ -45,18 +45,16 @@ const FALLBACK_INFO = {
         modelOrder: ["grok-build"],
     },
     mistral: {
-        // Mistral Vibe selects the active model via the VIBE_ACTIVE_MODEL environment
-        // variable; there is NO `--model` flag. Aliases here are still resolvable so
-        // callers can pass e.g. `latest` → `devstral-medium`; the resolved value is
-        // injected via env in prepareMistralRequest.
+        // Mistral Vibe selects the active model via VIBE_ACTIVE_MODEL; there is no
+        // `--model` flag. Do not set a bundled default here: Vibe's own default and
+        // user config move independently of this gateway. The model list is only a
+        // low-confidence recovery set for stale config/model-not-found failures.
         description: "Mistral AI's Vibe CLI - agentic coding via Mistral models (model selection via VIBE_ACTIVE_MODEL env var)",
         models: {
-            "devstral-medium": "Default Vibe coding model. Best for: most Vibe sessions (default when VIBE_ACTIVE_MODEL is unset)",
-            "devstral-large": "Higher-capability Devstral model. Best for: harder reasoning/coding tasks",
-            "mistral-large-latest": "General-purpose flagship Mistral model. Best for: non-Devstral reasoning workloads",
+            "mistral-medium-3.5": "Vibe coding model alias observed in Vibe 2.x defaults. Used only when discovery/config requires an explicit VIBE_ACTIVE_MODEL.",
+            "devstral-small": "Vibe coding model alias observed in Vibe 2.x defaults. Used only when configured explicitly.",
         },
-        defaultModel: "devstral-medium",
-        modelOrder: ["devstral-medium", "devstral-large", "mistral-large-latest"],
+        modelOrder: ["mistral-medium-3.5", "devstral-small"],
     },
 };
 const MODEL_CACHE_TTL_MS = 2 * 60 * 1000;
@@ -341,21 +339,116 @@ function applyGrokOverrides(info) {
     info.modelOrder = buildOrder(info, info.defaultModel);
 }
 function applyMistralOverrides(info) {
-    // Vibe selects its active model via VIBE_ACTIVE_MODEL (no --model flag). When
-    // present, treat it as the configured default so resolveModelAlias("latest")
-    // returns the user-selected value.
-    const envDefault = process.env.MISTRAL_DEFAULT_MODEL || process.env.VIBE_ACTIVE_MODEL;
+    const vibeConfig = readVibeConfig(info);
+    addVibeModelEntries(info, parseVibeModels(process.env.VIBE_MODELS, "VIBE_MODELS"), "env");
+    addVibeModelEntries(info, vibeConfig.models, "config");
     addEnvModels(info, "MISTRAL_MODELS");
     addEnvAliases(info, "mistral", "MISTRAL_MODEL_ALIASES");
     addGlobalEnvAliases(info, "mistral");
+    // Vibe uses VIBE_ACTIVE_MODEL instead of a CLI flag. Explicit env values win.
+    const envDefault = process.env.MISTRAL_DEFAULT_MODEL || process.env.VIBE_ACTIVE_MODEL;
     if (envDefault) {
         const source = process.env.MISTRAL_DEFAULT_MODEL
             ? "MISTRAL_DEFAULT_MODEL"
             : "VIBE_ACTIVE_MODEL";
         setDefaultModel(info, envDefault, source, "env");
     }
+    else if (vibeConfig.activeModel) {
+        const configuredActiveModel = vibeConfig.activeModel;
+        if (info.models[configuredActiveModel]) {
+            setDefaultModel(info, configuredActiveModel, vibeConfig.source, "config");
+        }
+        else {
+            const migrated = migrateDeprecatedMistralModel(configuredActiveModel, info);
+            if (migrated) {
+                addWarning(info, `Vibe active_model '${configuredActiveModel}' is not in the discovered model list; using '${migrated}' as the gateway recovery model`);
+                setDefaultModel(info, migrated, `${vibeConfig.source} recovery`, "config");
+            }
+            else {
+                addWarning(info, `Vibe active_model '${configuredActiveModel}' is not in the discovered model list`);
+            }
+        }
+    }
     info.modelOrder = buildOrder(info, info.defaultModel);
 }
+function readVibeConfig(info) {
+    const vibeHome = process.env.VIBE_HOME || path.join(homedir(), ".vibe");
+    const configPath = path.join(vibeHome, "config.toml");
+    const result = { models: [], source: configPath };
+    if (!existsSync(configPath)) {
+        return result;
+    }
+    try {
+        const parsed = parseToml(readFileSync(configPath, "utf-8"));
+        const activeModel = readStringProperty(parsed, "active_model");
+        if (activeModel) {
+            result.activeModel = activeModel.trim();
+        }
+        result.models = parseVibeModelArray(readRecordOrArrayProperty(parsed, "models"), configPath);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        addWarning(info, `Could not parse Vibe config ${configPath}: ${message}`);
+    }
+    return result;
+}
+function parseVibeModels(value, sourceDetail) {
+    if (!value || !value.trim()) {
+        return [];
+    }
+    try {
+        return parseVibeModelArray(JSON.parse(value), sourceDetail);
+    }
+    catch {
+        return [];
+    }
+}
+function parseVibeModelArray(value, sourceDetail) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            return null;
+        }
+        const record = entry;
+        const alias = typeof record.alias === "string" ? record.alias.trim() : "";
+        const name = typeof record.name === "string" ? record.name.trim() : undefined;
+        if (!alias) {
+            return null;
+        }
+        return {
+            alias,
+            name,
+            description: name ? `${alias} (${name}) from Vibe config` : `${alias} from Vibe config`,
+            sourceDetail,
+        };
+    })
+        .filter((entry) => entry !== null);
+}
+function addVibeModelEntries(info, entries, source) {
+    entries.forEach(entry => {
+        addModel(info, entry.alias, entry.description ?? `${entry.alias} from Vibe model configuration`, {
+            source,
+            sourceDetail: entry.sourceDetail,
+            confidence: source === "env" ? "high" : "medium",
+        }, { preferDescription: true });
+        if (entry.name && entry.name !== entry.alias && isValidModelName(entry.name)) {
+            addAlias(info, entry.name, entry.alias, entry.sourceDetail);
+        }
+    });
+}
+function migrateDeprecatedMistralModel(model, info) {
+    const normalized = model.trim().toLowerCase();
+    const replacement = ["devstral-medium", "devstral-large"].includes(normalized)
+        ? "mistral-medium-3.5"
+        : undefined;
+    if (replacement && info.models[replacement]) {
+        return replacement;
+    }
+    return undefined;
+}
 function readJsonStringValue(filePath, paths, info) {
     if (!existsSync(filePath)) {
         return undefined;
@@ -405,6 +498,12 @@ function readRecordProperty(value, key) {
         ? prop
         : {};
 }
+function readRecordOrArrayProperty(value, key) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    return value[key];
+}
 function parseEnvModelEntries(value, source) {
     if (!value) {
         return [];

package/dist/upstream-contracts.js

@@ -368,7 +368,7 @@ export const UPSTREAM_CLI_CONTRACTS = {
                 id: "mistral-minimal",
                 description: "Minimal prompt request with env-selected model",
                 args: ["-p", "hello", "--agent", "auto-approve"],
-                env: { VIBE_ACTIVE_MODEL: "devstral-medium" },
+                env: { VIBE_ACTIVE_MODEL: "mistral-medium-3.5" },
                 expect: "pass",
             },
             {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-cli-gateway",
-  "version": "1.5.15",
+  "version": "1.5.17",
   "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",