llm-cli-gateway 1.15.3 → 1.16.1

package/CHANGELOG.md

@@ -4,6 +4,55 @@ All notable changes to the llm-cli-gateway project.
 
 ## Unreleased
 
+## [1.16.1] - 2026-05-29 — align Mistral Vibe CLI contract
+
+Patch release for the current `mistral-vibe` CLI surface.
+
+### Fixed
+
+- Updated Mistral Vibe requests to emit `--output text|json|streaming` instead
+  of the removed `--output-format` flag.
+- Kept legacy MCP aliases working by mapping `plain` to `text` and
+  `stream-json` to `streaming`.
+- Added `maxTokens` support for Mistral Vibe via `--max-tokens`.
+- Updated Vibe install, upgrade, and doctor guidance for the current
+  `mistral-vibe` package and default-on session logging.
+
+## [1.16.0] - 2026-05-29 — remove Redis session dependency
+
+Feature release that removes the optional Redis/ioredis layer from the
+PostgreSQL-backed session manager and tightens the public README around the
+project's current demand and quality signals.
+
+### Removed
+
+- Removed the optional `ioredis` peer/dev dependency and its transitive
+  packages from the install graph.
+- Removed `REDIS_URL` as a requirement for PostgreSQL-backed sessions.
+- Removed Redis from the PostgreSQL test Docker Compose stack and PG test
+  harness.
+
+### Changed
+
+- PostgreSQL-backed sessions now require only `DATABASE_URL` plus the optional
+  `pg` peer dependency. PostgreSQL remains the source of truth for session
+  records and active-session state.
+- Simplified database health reporting to PostgreSQL connectivity only.
+- Simplified the PG session manager by removing Redis cache-aside reads/writes
+  and Redis lock handling.
+- Updated migration and testing docs to describe the Postgres-only backend.
+- Updated release-readiness and Socket-alert documentation now that the Redis
+  client dependency is no longer present.
+- Refocused the README first screen around the strongest current trust and
+  demand signals: npm monthly downloads, passing CI/security workflows,
+  OpenSSF status, Sigstore-signed releases, and MIT licensing.
+
+### Added
+
+- Added `docs/plans/provider-workflow-assets.dag.toml`, a machine-readable
+  implementation plan for provider-specific skill and DAG-TOML pairs for
+  Claude, Codex, Gemini, Grok, and Mistral Vibe.
+
 ## [1.15.3] - 2026-05-29 — remove retired PyPI plugin
 
 Patch release removing the retired Python `llm` plugin integration so the

package/README.md

@@ -3,19 +3,38 @@
 [![CI](https://github.com/verivus-oss/llm-cli-gateway/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/verivus-oss/llm-cli-gateway/actions/workflows/ci.yml)
 [![Security](https://github.com/verivus-oss/llm-cli-gateway/actions/workflows/security.yml/badge.svg?branch=main)](https://github.com/verivus-oss/llm-cli-gateway/actions/workflows/security.yml)
 [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/verivus-oss/llm-cli-gateway/badge)](https://scorecard.dev/viewer/?uri=github.com/verivus-oss/llm-cli-gateway)
-[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/13025/badge)](https://www.bestpractices.dev/projects/13025)
 [![npm](https://img.shields.io/npm/v/llm-cli-gateway.svg)](https://www.npmjs.com/package/llm-cli-gateway)
-[![npm weekly downloads](https://img.shields.io/npm/dw/llm-cli-gateway.svg)](https://www.npmjs.com/package/llm-cli-gateway)
 [![npm monthly downloads](https://img.shields.io/npm/dm/llm-cli-gateway.svg)](https://www.npmjs.com/package/llm-cli-gateway)
-[![GitHub release downloads](https://img.shields.io/github/downloads/verivus-oss/llm-cli-gateway/total.svg)](https://github.com/verivus-oss/llm-cli-gateway/releases)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
-[![Releases: Sigstore signed](https://img.shields.io/badge/releases-Sigstore%20signed-2e7d32.svg)](SECURITY.md#release-signing)
 
 > _"Without consultation, plans are frustrated, but with many counselors they succeed."_
 > — Proverbs 15:22 (LSB)
 
 A Model Context Protocol (MCP) gateway for running Claude Code, Codex, Gemini, Grok, and Mistral (Vibe) CLIs from one MCP endpoint, with durable async jobs, session continuity, cache-aware prompting, observability, and personal-appliance setup tooling.
 
+**Why developers try it:** one local MCP endpoint for cross-LLM validation, multi-agent coding workflows, and repeatable assistant-led setup across five provider CLIs.
+
+**Current signals:** crossed 5k monthly npm downloads in May 2026; live npm downloads are shown above. CI and security workflows pass on `main`, OpenSSF Scorecard is published, OpenSSF Best Practices is passing, releases use Sigstore signing, and the package is MIT licensed.
+
+## Quick Start
+
+```bash
+npm install -g llm-cli-gateway
+```
+
+Or use directly with `npx` from an MCP client:
+
+```json
+{
+  "mcpServers": {
+    "llm-gateway": {
+      "command": "npx",
+      "args": ["-y", "llm-cli-gateway"]
+    }
+  }
+}
+```
+
 ## What It Provides Today
 
 `llm-cli-gateway` is a single-user MCP gateway for cross-LLM validation and multi-agent coding workflows. It is more than a thin CLI wrapper:
@@ -27,6 +46,24 @@ A Model Context Protocol (MCP) gateway for running Claude Code, Codex, Gemini, G
 - Can run requests inside gateway-managed git worktrees for isolated multi-agent review and implementation loops.
 - Ships personal-appliance setup surfaces: HTTP transport with bearer-token auth, `doctor --json`, setup UI artifacts, provider setup snippets, Docker fallback, and checked release bundles.
 
+## Workflow Assets
+
+The repo ships agent-ready workflow skills under [`.agents/skills`](.agents/skills) for async orchestration, session continuity, multi-LLM review, implement-review-fix loops, and secure approval-gated dispatch. Machine-readable DAG-TOML plans live under [`docs/plans`](docs/plans) and [`setup/install-plan.dag.toml`](setup/install-plan.dag.toml) for workflows that need deterministic sequencing and verification gates.
+
+The next documentation focus is provider-specific skill and DAG-TOML pairs for each outbound CLI: Claude, Codex, Gemini, Grok, and Mistral Vibe. The implementation plan is tracked in [`docs/plans/provider-workflow-assets.dag.toml`](docs/plans/provider-workflow-assets.dag.toml), with each provider asset expected to cover install/login checks, session behavior, approval modes, cache/telemetry surfaces, failure modes, and a smoke-test gate.
+
+## Trust & Supply Chain
+
+[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/13025/badge)](https://www.bestpractices.dev/projects/13025)
+[![npm weekly downloads](https://img.shields.io/npm/dw/llm-cli-gateway.svg)](https://www.npmjs.com/package/llm-cli-gateway)
+[![GitHub release downloads](https://img.shields.io/github/downloads/verivus-oss/llm-cli-gateway/total.svg)](https://github.com/verivus-oss/llm-cli-gateway/releases)
+[![Releases: Sigstore signed](https://img.shields.io/badge/releases-Sigstore%20signed-2e7d32.svg)](SECURITY.md#release-signing)
+
+- CI runs build, lint, format, tests, package checks, and npm audit.
+- Security CI runs actionlint, zizmor, shellcheck, typos, osv-scanner, gitleaks, and lychee.
+- GitHub release installer artifacts are checksummed and signed with Sigstore keyless signing.
+- npm releases use provenance through OIDC trusted publishing.
+
 ## Personal MCP Appliance
 
 The personal-appliance contract keeps that surface intentionally narrow: one trusted user runs the gateway on a machine or volume they own, connects one MCP endpoint, and asks any connected client for cross-LLM validation.
@@ -216,13 +253,16 @@ grok login   # OAuth flow, or set GROK_CODE_XAI_API_KEY
 
 ```bash
 # Pick one — the gateway's cli_upgrade auto-detects which one you used.
-pip install vibe-cli
-uv tool install vibe-cli
+curl -LsSf https://mistral.ai/vibe/install.sh | bash
+pip install mistral-vibe
+uv tool install mistral-vibe
 brew install mistral-vibe
 
 vibe auth login
-# Required for `mistral_request --resume` / `--continue` to persist sessions:
-vibe config set session_logging.enabled true   # or edit ~/.vibe/config.toml
+# Current Vibe defaults session logging to enabled. If an older config disabled it,
+# edit ~/.vibe/config.toml and set:
+# [session_logging]
+# enabled = true
 ```
 
 Vibe-specific notes:
@@ -699,7 +739,8 @@ Run a Mistral Vibe agentic coding request. Like `grok_request` in shape, but wit
 - `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.
-- `sessionId` / `resumeLatest` / `createNewSession`: standard session controls. Continuity requires `[session_logging] enabled = true` in `~/.vibe/config.toml` — `doctor --json` surfaces an actionable next-action when the toggle is missing.
+- `outputFormat` (string, optional): Vibe 2.x values are `"text"`, `"json"`, or `"streaming"`; legacy aliases `"plain"` and `"stream-json"` are accepted and normalized before spawn.
+- `sessionId` / `resumeLatest` / `createNewSession`: standard session controls. Current Vibe defaults session logging to enabled; if an older config has `[session_logging] enabled = false`, `doctor --json` surfaces an actionable next-action.
 
 ##### `claude_request_async` / `codex_request_async` / `gemini_request_async` / `grok_request_async` / `mistral_request_async`
 
@@ -1143,7 +1184,6 @@ If you're vetting `llm-cli-gateway` through [Socket](https://socket.dev/npm/pack
 | **Shell access**                 | `src/executor.ts` uses `child_process.spawn(cmd, args, …)` to invoke the underlying LLM CLIs.                                                                                                    | `spawn` is called with an argument array and **never** `shell: true`, so there is no shell interpolation path for caller input. The command name is restricted to an allow-list of known CLI binaries (`claude`, `codex`, `gemini`, `grok`, `vibe`).                                                                                                                                                 |
 | **Uses eval**                    | None in our source. Transitive: `@modelcontextprotocol/sdk` → `ajv@8` uses `new Function(...)` in `ajv/dist/compile/index.js` to compile JSON Schema validators.                                 | This is ajv's standard codegen path. Only known schemas (defined in our source and the MCP SDK) flow into it; no caller-supplied data ever reaches the compiled function body.                                                                                                                                                                                                                       |
 | **better-sqlite3 PRAGMA helper** | Transitive: `better-sqlite3/lib/methods/pragma.js` interpolates its caller-provided `source` into a `PRAGMA ${source}` statement.                                                                | We do not call `db.pragma()` from production source. Internal SQLite setup uses fixed literal `db.exec("PRAGMA ...")` statements, and `npm run security:audit` fails the release if production code reintroduces `.pragma()` calls.                                                                                                                                                                  |
-| **ioredis obfuscated code**      | Optional peer/dev dependency: `ioredis@5.10.1` may be flagged at `built/constants/TLSProfiles.js` for base64-looking strings.                                                                    | Reviewed as a false positive. The file is a Redis Cloud TLS CA certificate bundle in PEM format, which is base64 by design. It contains no decoder loop, dynamic evaluation, network call, or hidden execution path. The same file is byte-for-byte identical in `ioredis@5.9.2`; our default production install does not install `ioredis`, and our code does not pass ioredis TLS profile options. |
 | **Dependency ownership**         | A handful of small transitive packages (e.g. `bindings` via `better-sqlite3`, `media-typer` via `@modelcontextprotocol/sdk`) trip Socket's "unstable ownership" or "obfuscated code" heuristics. | These are pinned, well-known micro-deps in the Node ecosystem with no known issues. We pin direct override versions of `content-type` and `type-is` in `package.json#overrides`. Our previous direct dependency on `toml@3.0.0` (also single-maintainer, last released 2020) was replaced with the actively-maintained `smol-toml` to reduce inherited risk.                                         |
 
 See [`socket.yml`](./socket.yml) for the same context in machine-readable form.

package/dist/cli-updater.js

@@ -1,6 +1,8 @@
 import { spawnSync } from "node:child_process";
 import { executeCli } from "./executor.js";
 import { getProviderRuntimeStatus } from "./provider-status.js";
+const MISTRAL_VIBE_PACKAGE = "mistral-vibe";
+const LEGACY_VIBE_PACKAGE = "vibe-cli";
 /**
  * Detect how Vibe was installed on this machine. Vibe does not self-update, so
  * cli_upgrade has to dispatch to the package manager that owns the binary.
@@ -16,15 +18,19 @@ export function detectMistralInstallMethod(exec = (cmd, args) => {
         stdout: result.stdout || "",
     };
 }) {
-    const pip = exec("pip", ["show", "vibe-cli"]);
-    if (pip.exitCode === 0 && /Name:\s*vibe-cli/i.test(pip.stdout)) {
+    const pip = exec("pip", ["show", MISTRAL_VIBE_PACKAGE]);
+    if (pip.exitCode === 0 && /Name:\s*mistral-vibe/i.test(pip.stdout)) {
+        return "pip";
+    }
+    const legacyPip = exec("pip", ["show", LEGACY_VIBE_PACKAGE]);
+    if (legacyPip.exitCode === 0 && /Name:\s*vibe-cli/i.test(legacyPip.stdout)) {
         return "pip";
     }
     const uv = exec("uv", ["tool", "list"]);
-    if (uv.exitCode === 0 && /\bvibe(?:-cli)?\b/i.test(uv.stdout)) {
+    if (uv.exitCode === 0 && /\b(?:mistral-vibe|vibe-cli|vibe)\b/i.test(uv.stdout)) {
         return "uv";
     }
-    const brew = exec("brew", ["list", "mistral-vibe"]);
+    const brew = exec("brew", ["list", MISTRAL_VIBE_PACKAGE]);
     if (brew.exitCode === 0) {
         return "brew";
     }
@@ -154,7 +160,9 @@ function buildMistralUpgradePlan(normalizedTarget, detectMistral) {
     // (we surface it as a no-op plan with `command: ""` so runCliUpgrade can
     // throw before spawning anything).
     if (method === "pip") {
-        const pkg = normalizedTarget === "latest" ? "vibe-cli" : `vibe-cli==${normalizedTarget}`;
+        const pkg = normalizedTarget === "latest"
+            ? MISTRAL_VIBE_PACKAGE
+            : `${MISTRAL_VIBE_PACKAGE}==${normalizedTarget}`;
         return {
             cli: "mistral",
             target: normalizedTarget,
@@ -170,7 +178,7 @@ function buildMistralUpgradePlan(normalizedTarget, detectMistral) {
             cli: "mistral",
             target: normalizedTarget,
             command: "uv",
-            args: ["tool", "upgrade", "vibe-cli"],
+            args: ["tool", "upgrade", MISTRAL_VIBE_PACKAGE],
             strategy: "uv-tool-upgrade",
             requiresNetwork: true,
             note: normalizedTarget === "latest"
@@ -183,7 +191,7 @@ function buildMistralUpgradePlan(normalizedTarget, detectMistral) {
             cli: "mistral",
             target: normalizedTarget,
             command: "brew",
-            args: ["upgrade", "mistral-vibe"],
+            args: ["upgrade", MISTRAL_VIBE_PACKAGE],
             strategy: "brew-upgrade",
             requiresNetwork: true,
             note: normalizedTarget === "latest"
@@ -191,7 +199,7 @@ function buildMistralUpgradePlan(normalizedTarget, detectMistral) {
                 : "brew upgrade does not honour explicit version targets; running upgrade to latest.",
         };
     }
-    throw new Error("Could not detect how Mistral Vibe was installed. Install it via pip (`pip install vibe-cli`), uv (`uv tool install vibe-cli`), or Homebrew (`brew install mistral-vibe`) before running cli_upgrade.");
+    throw new Error("Could not detect how Mistral Vibe was installed. Install it via pip (`pip install mistral-vibe`), uv (`uv tool install mistral-vibe`), or Homebrew (`brew install mistral-vibe`) before running cli_upgrade.");
 }
 async function fallbackCliVersion(cli, args) {
     try {

package/dist/config.d.ts

@@ -1,9 +1,4 @@
 import type { Logger } from "./logger.js";
-export interface CacheTtl {
-    session: number;
-    activeSession: number;
-    sessionList: number;
-}
 export interface DatabaseConfig {
     connectionString: string;
     pool: {
@@ -13,25 +8,15 @@ export interface DatabaseConfig {
         statementTimeout: number;
     };
 }
-export interface RedisConfig {
-    url: string;
-    retryStrategy: {
-        maxRetries: number;
-        initialDelay: number;
-        maxDelay: number;
-    };
-}
 export declare const DEFAULT_SESSION_TTL_SECONDS = 2592000;
 export interface Config {
     database?: DatabaseConfig;
-    redis?: RedisConfig;
-    cacheTtl: CacheTtl;
     sessionTtl: number;
 }
 /**
  * Load configuration from environment variables.
- * Always returns a Config object with base fields (cacheTtl, sessionTtl).
- * Database and Redis fields are populated only when both env vars are set.
+ * Always returns a Config object with base fields.
+ * Database fields are populated when DATABASE_URL is set.
  */
 export declare function loadConfig(): Config;
 export declare const PERSISTENCE_BACKENDS: readonly ["sqlite", "postgres", "memory", "none"];

package/dist/config.js

@@ -11,37 +11,28 @@ const DatabaseUrlSchema = z
     .refine(url => url.startsWith("postgresql://") || url.startsWith("postgres://"), {
     message: "Database URL must start with postgresql:// or postgres://",
 });
-const RedisUrlSchema = z.string().url().startsWith("redis://");
 export const DEFAULT_SESSION_TTL_SECONDS = 2592000; // 30 days
 /**
  * Load configuration from environment variables.
- * Always returns a Config object with base fields (cacheTtl, sessionTtl).
- * Database and Redis fields are populated only when both env vars are set.
+ * Always returns a Config object with base fields.
+ * Database fields are populated when DATABASE_URL is set.
  */
 export function loadConfig() {
     const databaseUrl = process.env.DATABASE_URL;
-    const redisUrl = process.env.REDIS_URL;
-    // Default cache TTLs
-    const cacheTtl = {
-        session: 3600, // 1 hour
-        activeSession: 1800, // 30 minutes
-        sessionList: 120, // 2 minutes
-    };
     const rawSessionTtl = parseInt(process.env.SESSION_TTL || String(DEFAULT_SESSION_TTL_SECONDS), 10);
     const sessionTtl = Number.isFinite(rawSessionTtl) && rawSessionTtl > 0
         ? rawSessionTtl
         : DEFAULT_SESSION_TTL_SECONDS;
     // If no database config, return base config (file-based storage)
-    if (!databaseUrl || !redisUrl) {
-        return { cacheTtl, sessionTtl };
+    if (!databaseUrl) {
+        return { sessionTtl };
     }
-    // Validate URLs
+    // Validate URL
     try {
         DatabaseUrlSchema.parse(databaseUrl);
-        RedisUrlSchema.parse(redisUrl);
     }
     catch (error) {
-        throw new Error(`Invalid database or redis URL: ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`Invalid database URL: ${error instanceof Error ? error.message : String(error)}`);
     }
     return {
         database: {
@@ -53,15 +44,6 @@ export function loadConfig() {
                 statementTimeout: 10000,
             },
         },
-        redis: {
-            url: redisUrl,
-            retryStrategy: {
-                maxRetries: 3,
-                initialDelay: 50,
-                maxDelay: 2000,
-            },
-        },
-        cacheTtl,
         sessionTtl,
     };
 }

package/dist/db.d.ts

@@ -1,5 +1,4 @@
 import type { Pool } from "pg";
-import type { Redis } from "ioredis";
 import { Config } from "./config.js";
 import type { Logger } from "./logger.js";
 export interface HealthCheckResult {
@@ -7,22 +6,17 @@ export interface HealthCheckResult {
         connected: boolean;
         latency: number;
     };
-    redis: {
-        connected: boolean;
-        latency: number;
-    };
 }
 /**
- * Database connection manager for PostgreSQL and Redis
+ * Database connection manager for PostgreSQL-backed sessions.
  */
 export declare class DatabaseConnection {
     private logger;
     private pool;
-    private redis;
     private config;
     constructor(config: Config, logger?: Logger);
     /**
-     * Initialize connections to PostgreSQL and Redis
+     * Initialize connection to PostgreSQL.
      */
     connect(): Promise<void>;
     /**
@@ -30,17 +24,13 @@ export declare class DatabaseConnection {
      */
     disconnect(): Promise<void>;
     /**
-     * Health check for PostgreSQL and Redis
+     * Health check for PostgreSQL.
      */
     healthCheck(): Promise<HealthCheckResult>;
     /**
      * Get PostgreSQL pool
      */
     getPool(): Pool;
-    /**
-     * Get Redis client
-     */
-    getRedis(): Redis;
 }
 /**
  * Factory function to create and connect DatabaseConnection

package/dist/db.js

@@ -1,25 +1,23 @@
 import { noopLogger } from "./logger.js";
 /**
- * Database connection manager for PostgreSQL and Redis
+ * Database connection manager for PostgreSQL-backed sessions.
  */
 export class DatabaseConnection {
     logger;
     pool = null;
-    redis = null;
     config;
     constructor(config, logger = noopLogger) {
         this.logger = logger;
-        if (!config.database || !config.redis) {
-            throw new Error("Database and Redis configuration required");
+        if (!config.database) {
+            throw new Error("Database configuration required");
         }
         this.config = config;
     }
     /**
-     * Initialize connections to PostgreSQL and Redis
+     * Initialize connection to PostgreSQL.
      */
     async connect() {
         const { Pool } = await importOptionalPg();
-        const Redis = await importOptionalRedis();
         // Initialize PostgreSQL pool
         const poolConfig = {
             connectionString: this.config.database.connectionString,
@@ -40,32 +38,6 @@ export class DatabaseConnection {
             this.logger.error("Failed to connect to PostgreSQL", { error });
             throw new Error(`Failed to connect to PostgreSQL: ${error instanceof Error ? error.message : String(error)}`);
         }
-        // Initialize Redis client
-        const redisOptions = {
-            retryStrategy: (times) => {
-                const { maxRetries, initialDelay, maxDelay } = this.config.redis.retryStrategy;
-                if (times > maxRetries) {
-                    return null; // Stop retrying
-                }
-                return Math.min(initialDelay * times, maxDelay);
-            },
-            lazyConnect: false,
-            reconnectOnError: (err) => {
-                // Reconnect on READONLY and ECONNRESET errors
-                const targetErrors = ["READONLY", "ECONNRESET"];
-                return targetErrors.some(targetError => err.message.includes(targetError));
-            },
-        };
-        this.redis = new Redis(this.config.redis.url, redisOptions);
-        // Test Redis connection
-        try {
-            await this.redis.ping();
-            this.logger.info("Redis connection established");
-        }
-        catch (error) {
-            this.logger.error("Failed to connect to Redis", { error });
-            throw new Error(`Failed to connect to Redis: ${error instanceof Error ? error.message : String(error)}`);
-        }
     }
     /**
      * Graceful shutdown - close all connections
@@ -82,26 +54,16 @@ export class DatabaseConnection {
                 errors.push(new Error(`PostgreSQL disconnect error: ${error instanceof Error ? error.message : String(error)}`));
             }
         }
-        if (this.redis) {
-            try {
-                this.redis.disconnect();
-                this.redis = null;
-            }
-            catch (error) {
-                errors.push(new Error(`Redis disconnect error: ${error instanceof Error ? error.message : String(error)}`));
-            }
-        }
         if (errors.length > 0) {
             throw new Error(`Disconnect errors: ${errors.map(e => e.message).join("; ")}`);
         }
     }
     /**
-     * Health check for PostgreSQL and Redis
+     * Health check for PostgreSQL.
      */
     async healthCheck() {
         const result = {
             postgres: { connected: false, latency: 0 },
-            redis: { connected: false, latency: 0 },
         };
         // Check PostgreSQL
         if (this.pool) {
@@ -123,21 +85,8 @@ export class DatabaseConnection {
                 }
             }
         }
-        // Check Redis
-        if (this.redis) {
-            const redisStart = Date.now();
-            try {
-                await this.redis.ping();
-                result.redis.connected = true;
-                result.redis.latency = Date.now() - redisStart;
-            }
-            catch (error) {
-                result.redis.connected = false;
-            }
-        }
         this.logger.debug("Health check completed", {
             postgres: result.postgres.connected,
-            redis: result.redis.connected,
         });
         return result;
     }
@@ -150,15 +99,6 @@ export class DatabaseConnection {
         }
         return this.pool;
     }
-    /**
-     * Get Redis client
-     */
-    getRedis() {
-        if (!this.redis) {
-            throw new Error("Redis client not initialized");
-        }
-        return this.redis;
-    }
 }
 async function importOptionalPg() {
     try {
@@ -166,19 +106,7 @@ async function importOptionalPg() {
     }
     catch (error) {
         if (error?.code === "ERR_MODULE_NOT_FOUND" || error?.code === "MODULE_NOT_FOUND") {
-            throw new Error("PostgreSQL sessions require optional peer dependency 'pg'. Install it alongside llm-cli-gateway to use DATABASE_URL/REDIS_URL-backed sessions.");
-        }
-        throw error;
-    }
-}
-async function importOptionalRedis() {
-    try {
-        const mod = await import("ioredis");
-        return mod.Redis ?? mod.default;
-    }
-    catch (error) {
-        if (error?.code === "ERR_MODULE_NOT_FOUND" || error?.code === "MODULE_NOT_FOUND") {
-            throw new Error("PostgreSQL sessions require optional peer dependency 'ioredis'. Install it alongside llm-cli-gateway to use DATABASE_URL/REDIS_URL-backed sessions.");
+            throw new Error("PostgreSQL sessions require optional peer dependency 'pg'. Install it alongside llm-cli-gateway to use DATABASE_URL-backed sessions.");
         }
         throw error;
     }

package/dist/doctor.d.ts

@@ -51,10 +51,10 @@ export interface GeminiConfigStatus {
     next_actions: string[];
 }
 /**
- * Probe ~/.vibe/config.toml to see whether session_logging is enabled. Vibe
- * persists session logs (which sessionId/--continue depends on) only when
- * `[session_logging] enabled = true` is set. The probe is read-only: the
- * gateway never mutates this file.
+ * Probe ~/.vibe/config.toml to see whether session_logging is enabled. Current
+ * Mistral Vibe defaults session logging to enabled; an explicit
+ * `[session_logging] enabled = false` disables `--continue` / `--resume`.
+ * The probe is read-only: the gateway never mutates this file.
  */
 export declare function checkVibeSessionLogging(home?: string): VibeSessionLoggingStatus;
 /**

package/dist/doctor.js

@@ -10,10 +10,10 @@ import { loadCacheAwarenessConfig } from "./config.js";
 import { computeGlobalCacheStats } from "./cache-stats.js";
 import { FlightRecorder, resolveFlightRecorderDbPath } from "./flight-recorder.js";
 /**
- * Probe ~/.vibe/config.toml to see whether session_logging is enabled. Vibe
- * persists session logs (which sessionId/--continue depends on) only when
- * `[session_logging] enabled = true` is set. The probe is read-only: the
- * gateway never mutates this file.
+ * Probe ~/.vibe/config.toml to see whether session_logging is enabled. Current
+ * Mistral Vibe defaults session logging to enabled; an explicit
+ * `[session_logging] enabled = false` disables `--continue` / `--resume`.
+ * The probe is read-only: the gateway never mutates this file.
  */
 export function checkVibeSessionLogging(home = homedir()) {
     const configPath = join(home, ".vibe", "config.toml");
@@ -21,26 +21,28 @@ export function checkVibeSessionLogging(home = homedir()) {
         return {
             config_path: configPath,
             config_present: false,
-            session_logging_enabled: false,
-            note: "~/.vibe/config.toml not found. Run `vibe config set session_logging.enabled true` or create the file with a [session_logging]\\nenabled = true block.",
+            session_logging_enabled: true,
+            note: "~/.vibe/config.toml not found; current Vibe defaults session_logging.enabled to true. If resume fails, create ~/.vibe/config.toml with [session_logging]\\nenabled = true.",
         };
     }
     try {
         const text = readFileSync(configPath, "utf8");
         const enabled = parseVibeSessionLoggingEnabled(text);
-        if (enabled) {
+        if (enabled !== false) {
             return {
                 config_path: configPath,
                 config_present: true,
                 session_logging_enabled: true,
-                note: "session_logging.enabled is true; --continue/--resume will work for mistral_request.",
+                note: enabled === true
+                    ? "session_logging.enabled is true; --continue/--resume will work for mistral_request."
+                    : "session_logging.enabled is not set; current Vibe defaults it to true.",
             };
         }
         return {
             config_path: configPath,
             config_present: true,
             session_logging_enabled: false,
-            note: "[session_logging] enabled = false (or missing). Run `vibe config set session_logging.enabled true` or edit ~/.vibe/config.toml so mistral_request --resume / --continue can persist sessions.",
+            note: "[session_logging] enabled = false. Edit ~/.vibe/config.toml so the [session_logging] block sets enabled = true before using mistral_request --resume / --continue.",
         };
     }
     catch (err) {
@@ -54,7 +56,7 @@ export function checkVibeSessionLogging(home = homedir()) {
     }
 }
 /**
- * Tiny TOML probe focused on `[session_logging] enabled = true`. Avoids pulling
+ * Tiny TOML probe focused on `[session_logging] enabled = ...`. Avoids pulling
  * in the full `toml` parser when only one boolean is needed.
  */
 function parseVibeSessionLoggingEnabled(text) {
@@ -73,7 +75,11 @@ function parseVibeSessionLoggingEnabled(text) {
             const kv = line.match(/^enabled\s*=\s*(.+)$/);
             if (kv) {
                 const value = kv[1].trim().toLowerCase();
-                return value === "true";
+                if (value === "true")
+                    return true;
+                if (value === "false")
+                    return false;
+                return undefined;
             }
         }
         else {
@@ -81,11 +87,15 @@ function parseVibeSessionLoggingEnabled(text) {
             const dotted = line.match(/^session_logging\.enabled\s*=\s*(.+)$/);
             if (dotted) {
                 const value = dotted[1].trim().toLowerCase();
-                return value === "true";
+                if (value === "true")
+                    return true;
+                if (value === "false")
+                    return false;
+                return undefined;
             }
         }
     }
-    return false;
+    return undefined;
 }
 /**
  * U27: Probe Gemini's project/user config locations.

package/dist/health.d.ts

@@ -6,10 +6,6 @@ export interface HealthStatus {
         status: "up" | "down";
         latency: number;
     };
-    redis: {
-        status: "up" | "down";
-        latency: number;
-    };
     timestamp: string;
 }
 export interface ProviderRuntimeHealth {
@@ -18,10 +14,7 @@ export interface ProviderRuntimeHealth {
     timestamp: string;
 }
 /**
- * Check health status of PostgreSQL and Redis
- * - Both up → healthy
- * - Only PostgreSQL up → degraded (Redis down but DB works)
- * - PostgreSQL down → unhealthy (critical failure)
+ * Check health status of PostgreSQL.
  */
 export declare function checkHealth(db: DatabaseConnection): Promise<HealthStatus>;
 export declare function checkProviderRuntimeHealth(): ProviderRuntimeHealth;