llm-cli-gateway 1.15.2 → 1.16.0

package/CHANGELOG.md

@@ -4,6 +4,64 @@ All notable changes to the llm-cli-gateway project.
 
 ## Unreleased
 
+## [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
+project no longer depends on Simon Willison's `llm` package.
+
+### Removed
+
+- Removed `integrations/llm-plugin/`, including the `gateway-claude`,
+  `gateway-codex`, and `gateway-gemini` aliases that were registered through
+  the external `llm` package.
+- Removed the PyPI trusted-publishing workflow. Releases now publish npm and
+  signed GitHub installer artifacts only.
+- Removed the plugin-specific Dependabot and security-lint wiring for the
+  deleted Python package.
+
+### Changed
+
+- Removed README guidance that advertised `llm install llm-gateway` and
+  `llm -m gateway-*` usage.
+- Added an archived PyPI retirement description explaining the supported npm
+  and direct-MCP install paths for users who discover the historical PyPI
+  package.
+
 ## [1.15.2] - 2026-05-29 — security quality follow-up
 
 Patch release for GitHub Security & quality follow-up findings and Scorecard

package/README.md

@@ -3,16 +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 monthly downloads](https://img.shields.io/npm/dm/llm-cli-gateway.svg)](https://www.npmjs.com/package/llm-cli-gateway)
 [![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:
@@ -24,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.
@@ -173,7 +213,7 @@ Opt-in flags (all default off) live under `[cache_awareness]` in `~/.llm-cli-gat
 - **No Secret Leakage**: Generic session descriptions only (file permissions 0o600)
 - **No ReDoS**: Bounded regex patterns prevent catastrophic backtracking
 - **Type Safety**: Strict TypeScript with comprehensive error handling
-- **Supply-chain hardening**: a dedicated `.github/workflows/security.yml` runs actionlint, zizmor, shellcheck, typos, osv-scanner, gitleaks, ruff, bandit, and lychee on every push and PR (see `SECURITY.md` for the threat model)
+- **Supply-chain hardening**: a dedicated `.github/workflows/security.yml` runs actionlint, zizmor, shellcheck, typos, osv-scanner, gitleaks, and lychee on every push and PR (see `SECURITY.md` for the threat model)
 
 ## Prerequisites
 
@@ -967,25 +1007,6 @@ Each CLI can be configured through its own configuration files:
 - Codex: `~/.codex/config.toml`
 - Gemini: `~/.gemini/config.json`
 
-## For Fans of Simon Willison
-
-Simon's `llm` tool made it trivially easy to talk to any LLM from the command line. But as AI-assisted development matures, the challenge shifts from "how do I call a model" to "how do I orchestrate multiple models reliably, and what did they actually do?"
-
-**Multiple models increase the confidence factor.** When Claude writes code, Codex reviews it, and Gemini checks for bugs -- each bringing different training data and reasoning patterns -- the result is more robust than any single model alone. And often this isn't even enough. Having the models do iterative reviews is where you start getting real confidence.
-
-**Every interaction should be queryable data.** Inspired by `llm`'s SQLite logging philosophy, the gateway records every request and response to a local SQLite database. Not just prompts and responses -- retry counts, circuit breaker states, approval decisions, thinking blocks, cost estimates. Open it with Datasette and you have a complete operational picture of your AI usage:
-
-    datasette ~/.llm-cli-gateway/logs.db
-
-**The `llm-gateway` plugin bridges both worlds.** Install it, and your existing `llm` workflows gain orchestration features without changing how you work:
-
-    llm install llm-gateway
-    llm -m gateway-claude "explain this function"
-
-Your gateway interactions appear in both `llm logs` (for your personal history) and the gateway's flight recorder (for operational observability). Two audiences, one workflow.
-
-**Composability over monoliths.** The gateway doesn't replace `llm` -- it complements it. Use `llm` directly when you want simplicity. Route through the gateway when you want resilience, multi-model coordination, or detailed operational telemetry. The plugin is the bridge, not the destination.
-
 ## Development
 
 ### Project Structure
@@ -1159,7 +1180,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/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/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;

package/dist/health.js

@@ -1,9 +1,6 @@
 import { listProviderRuntimeStatuses } from "./provider-status.js";
 /**
- * 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 async function checkHealth(db) {
     const result = await db.healthCheck();
@@ -13,22 +10,9 @@ export async function checkHealth(db) {
             status: result.postgres.connected ? "up" : "down",
             latency: result.postgres.latency,
         },
-        redis: {
-            status: result.redis.connected ? "up" : "down",
-            latency: result.redis.latency,
-        },
         timestamp: new Date().toISOString(),
     };
-    // Determine overall health status
-    if (result.postgres.connected && result.redis.connected) {
-        health.status = "healthy";
-    }
-    else if (result.postgres.connected && !result.redis.connected) {
-        health.status = "degraded";
-    }
-    else {
-        health.status = "unhealthy";
-    }
+    health.status = result.postgres.connected ? "healthy" : "unhealthy";
     return health;
 }
 export function checkProviderRuntimeHealth() {

package/dist/index.js

@@ -5101,8 +5101,8 @@ async function initializeSessionManager() {
     // own a single filesystem); revisit if/when worktree support extends
     // there.
     const worktreeCleanupHook = createWorktreeSessionCleanupHook(logger);
-    if (config.database && config.redis) {
-        logger.info("Initializing PostgreSQL + Redis session manager");
+    if (config.database) {
+        logger.info("Initializing PostgreSQL session manager");
         const { createDatabaseConnection } = await import("./db.js");
         db = await createDatabaseConnection(config, logger);
         sessionManager = await createSessionManager(config, db, logger);

package/dist/migrate-sessions.js

@@ -82,7 +82,6 @@ Options:
 
 Environment Variables:
   DATABASE_URL     PostgreSQL connection string (required)
-  REDIS_URL        Redis connection string (required)
 `);
         process.exit(args[0] === "--help" || args[0] === "-h" ? 0 : 1);
     }
@@ -97,18 +96,17 @@ Environment Variables:
     console.error(`Migration Configuration:`);
     console.error(`  Source: ${filePath}`);
     console.error(`  DATABASE_URL: ${process.env.DATABASE_URL ? "[set]" : "[not set]"}`);
-    console.error(`  REDIS_URL: ${process.env.REDIS_URL ? "[set]" : "[not set]"}`);
     console.error("");
     // Load config
     const config = loadConfig();
-    if (!config.database || !config.redis) {
-        console.error("ERROR: DATABASE_URL and REDIS_URL must be set");
+    if (!config.database) {
+        console.error("ERROR: DATABASE_URL must be set");
         process.exit(1);
     }
     // Connect to database
     console.error("Connecting to database...");
     const db = await createDatabaseConnection(config, logger);
-    const pgManager = new PostgreSQLSessionManager(db.getPool(), db.getRedis(), config.cacheTtl, logger);
+    const pgManager = new PostgreSQLSessionManager(db.getPool());
     console.error("✓ Connected to database\n");
     try {
         // Run migration

package/dist/session-manager-pg.d.ts

@@ -1,77 +1,48 @@
 import type { Pool } from "pg";
-import type { Redis } from "ioredis";
 import { Session, CliType } from "./session-manager.js";
-import { CacheTtl } from "./config.js";
-import type { Logger } from "./logger.js";
 export type { Logger } from "./logger.js";
 /**
- * PostgreSQL-backed session manager with Redis caching
+ * PostgreSQL-backed session manager. PostgreSQL is the source of truth and
+ * the only required service for this backend.
  */
 export declare class PostgreSQLSessionManager {
     private pool;
-    private redis;
-    private cacheTtl;
-    private logger;
-    constructor(pool: Pool, redis: Redis, cacheTtl: CacheTtl, logger: Logger);
+    constructor(pool: Pool);
     /**
-     * Acquire distributed lock using Redis SET NX EX
-     * Returns [success, lockValue] tuple
-     */
-    private acquireLock;
-    private sleep;
-    /**
-     * Acquire a distributed lock with bounded retries to smooth contention spikes.
-     */
-    private acquireLockWithRetry;
-    /**
-     * Release distributed lock with optimistic Redis transaction semantics.
-     * Only releases if lockValue matches, which prevents releasing another
-     * process's lock after expiry/reacquire.
-     */
-    private releaseLock;
-    /**
-     * Invalidate session cache
-     */
-    private invalidateCache;
-    /**
-     * Invalidate session list cache using SCAN (non-blocking)
-     */
-    private invalidateListCache;
-    /**
-     * Create a new session
+     * Create a new session.
      */
     createSession(cli: CliType, description?: string, sessionId?: string): Promise<Session>;
     /**
-     * Get session by ID (cache-aside pattern)
+     * Get session by ID.
      */
     getSession(sessionId: string): Promise<Session | null>;
     /**
-     * List all sessions, optionally filtered by CLI
+     * List all sessions, optionally filtered by CLI.
      */
     listSessions(cli?: CliType): Promise<Session[]>;
     /**
-     * Delete a session
+     * Delete a session.
      */
     deleteSession(sessionId: string): Promise<boolean>;
     /**
-     * Set active session for a CLI (with distributed locking)
+     * Set active session for a CLI. The row-level update is serialized by
+     * PostgreSQL and the session FK keeps stale IDs from being recorded.
      */
     setActiveSession(cli: CliType, sessionId: string | null): Promise<boolean>;
     /**
-     * Get active session for a CLI
+     * Get active session for a CLI.
      */
     getActiveSession(cli: CliType): Promise<Session | null>;
     /**
-     * Update session usage timestamp
+     * Update session usage timestamp.
      */
     updateSessionUsage(sessionId: string): Promise<void>;
     /**
-     * Update session metadata (atomic JSONB merge)
+     * Update session metadata using PostgreSQL's atomic JSONB merge.
      */
     updateSessionMetadata(sessionId: string, metadata: Record<string, any>): Promise<boolean>;
     /**
-     * Clear all sessions, optionally filtered by CLI
-     * Invalidates all related caches (session, active, list)
+     * Clear all sessions, optionally filtered by CLI.
      */
     clearAllSessions(cli?: CliType): Promise<number>;
 }

package/dist/session-manager-pg.js

@@ -7,112 +7,16 @@ const DEFAULT_SESSION_DESCRIPTIONS = {
     mistral: "Mistral Session",
 };
 /**
- * PostgreSQL-backed session manager with Redis caching
+ * PostgreSQL-backed session manager. PostgreSQL is the source of truth and
+ * the only required service for this backend.
  */
 export class PostgreSQLSessionManager {
     pool;
-    redis;
-    cacheTtl;
-    logger;
-    constructor(pool, redis, cacheTtl, logger) {
+    constructor(pool) {
         this.pool = pool;
-        this.redis = redis;
-        this.cacheTtl = cacheTtl;
-        this.logger = logger;
     }
     /**
-     * Acquire distributed lock using Redis SET NX EX
-     * Returns [success, lockValue] tuple
-     */
-    async acquireLock(key, ttlSeconds) {
-        const lockKey = `lock:${key}`;
-        const lockValue = randomUUID();
-        // SET NX EX atomic operation
-        const result = await this.redis.set(lockKey, lockValue, "EX", ttlSeconds, "NX");
-        return [result === "OK", lockValue];
-    }
-    async sleep(ms) {
-        await new Promise(resolve => setTimeout(resolve, ms));
-    }
-    /**
-     * Acquire a distributed lock with bounded retries to smooth contention spikes.
-     */
-    async acquireLockWithRetry(key, ttlSeconds, errorLabel, maxWaitMs = 6000) {
-        const deadline = Date.now() + maxWaitMs;
-        while (true) {
-            const [lockAcquired, lockValue] = await this.acquireLock(key, ttlSeconds);
-            if (lockAcquired) {
-                return lockValue;
-            }
-            if (Date.now() >= deadline) {
-                throw new Error(`Failed to acquire lock for ${errorLabel}`);
-            }
-            // Small jitter avoids lock-step retries from concurrent callers.
-            await this.sleep(25 + Math.floor(Math.random() * 25));
-        }
-    }
-    /**
-     * Release distributed lock with optimistic Redis transaction semantics.
-     * Only releases if lockValue matches, which prevents releasing another
-     * process's lock after expiry/reacquire.
-     */
-    async releaseLock(key, lockValue) {
-        const lockKey = `lock:${key}`;
-        await this.redis.watch(lockKey);
-        try {
-            const currentValue = await this.redis.get(lockKey);
-            if (currentValue !== lockValue) {
-                await this.redis.unwatch();
-                return;
-            }
-            await this.redis.multi().del(lockKey).exec();
-        }
-        catch (error) {
-            await this.redis.unwatch().catch(() => undefined);
-            throw error;
-        }
-    }
-    /**
-     * Invalidate session cache
-     */
-    async invalidateCache(sessionId) {
-        try {
-            await this.redis.del(`session:${sessionId}`);
-        }
-        catch (error) {
-            // Graceful degradation - log but don't fail
-            this.logger.error(`Cache invalidation failed for session ${sessionId}`, { error, sessionId });
-        }
-    }
-    /**
-     * Invalidate session list cache using SCAN (non-blocking)
-     */
-    async invalidateListCache(cli) {
-        try {
-            if (cli) {
-                await this.redis.del(`session_list:${cli}`);
-            }
-            else {
-                // Use SCAN instead of KEYS to avoid blocking Redis
-                const keys = [];
-                let cursor = "0";
-                do {
-                    const [nextCursor, matchedKeys] = await this.redis.scan(cursor, "MATCH", "session_list:*", "COUNT", 100);
-                    cursor = nextCursor;
-                    keys.push(...matchedKeys);
-                } while (cursor !== "0");
-                // Delete in batches to avoid overwhelming Redis
-                if (keys.length > 0) {
-                    await this.redis.del(...keys);
-                }
-            }
-        }
-        catch (error) {
-            this.logger.error("List cache invalidation failed", { error });
-        }
-    }
-    /**
-     * Create a new session
+     * Create a new session.
      */
     async createSession(cli, description, sessionId) {
         const id = sessionId || randomUUID();
@@ -121,32 +25,19 @@ export class PostgreSQLSessionManager {
         const client = await this.pool.connect();
         try {
             await client.query("BEGIN");
-            // Insert session
             await client.query(`INSERT INTO sessions (id, cli, description, created_at, last_used_at)
          VALUES ($1, $2, $3, $4, $5)`, [id, cli, sessionDescription, now, now]);
-            // Set as active if none exists
             await client.query(`INSERT INTO active_sessions (cli, session_id, updated_at)
          VALUES ($1, $2, $3)
          ON CONFLICT (cli) DO NOTHING`, [cli, id, now]);
             await client.query("COMMIT");
-            const session = {
+            return {
                 id,
                 cli,
                 createdAt: now,
                 lastUsedAt: now,
                 description: sessionDescription,
             };
-            // Write-through to cache
-            try {
-                await this.redis.setex(`session:${id}`, this.cacheTtl.session, JSON.stringify(session));
-            }
-            catch (error) {
-                // Graceful degradation
-                this.logger.error("Cache write failed", { error });
-            }
-            // Invalidate list cache
-            await this.invalidateListCache(cli);
-            return session;
         }
         catch (error) {
             await client.query("ROLLBACK");
@@ -157,55 +48,18 @@ export class PostgreSQLSessionManager {
         }
     }
     /**
-     * Get session by ID (cache-aside pattern)
+     * Get session by ID.
      */
     async getSession(sessionId) {
-        // Try cache first
-        try {
-            const cached = await this.redis.get(`session:${sessionId}`);
-            if (cached) {
-                return JSON.parse(cached);
-            }
-        }
-        catch (error) {
-            // Graceful degradation - fallback to DB
-            this.logger.error("Cache read failed", { error });
-        }
-        // Cache miss - query database
         const result = await this.pool.query(`SELECT id, cli, description, metadata, created_at AS "createdAt", last_used_at AS "lastUsedAt"
        FROM sessions
        WHERE id = $1`, [sessionId]);
-        if (result.rows.length === 0) {
-            return null;
-        }
-        const session = result.rows[0];
-        // Populate cache
-        try {
-            await this.redis.setex(`session:${sessionId}`, this.cacheTtl.session, JSON.stringify(session));
-        }
-        catch (error) {
-            this.logger.error("Cache write failed", { error });
-        }
-        return session;
+        return result.rows[0] ?? null;
     }
     /**
-     * List all sessions, optionally filtered by CLI
+     * List all sessions, optionally filtered by CLI.
      */
     async listSessions(cli) {
-        // Try cache for CLI-specific lists
-        const cacheKey = cli ? `session_list:${cli}` : null;
-        if (cacheKey) {
-            try {
-                const cached = await this.redis.get(cacheKey);
-                if (cached) {
-                    return JSON.parse(cached);
-                }
-            }
-            catch (error) {
-                this.logger.error("Cache read failed", { error });
-            }
-        }
-        // Query database
         const query = cli
             ? `SELECT id, cli, description, metadata, created_at AS "createdAt", last_used_at AS "lastUsedAt"
          FROM sessions
@@ -217,176 +71,70 @@ export class PostgreSQLSessionManager {
         const result = cli
             ? await this.pool.query(query, [cli])
             : await this.pool.query(query);
-        const sessions = result.rows;
-        // Cache CLI-specific lists
-        if (cacheKey) {
-            try {
-                await this.redis.setex(cacheKey, this.cacheTtl.sessionList, JSON.stringify(sessions));
-            }
-            catch (error) {
-                this.logger.error("Cache write failed", { error });
-            }
-        }
-        return sessions;
+        return result.rows;
     }
     /**
-     * Delete a session
+     * Delete a session.
      */
     async deleteSession(sessionId) {
-        // Get session to find CLI type
         const session = await this.getSession(sessionId);
         if (!session) {
             return false;
         }
-        // Delete from database (CASCADE will handle active_sessions)
         const result = await this.pool.query("DELETE FROM sessions WHERE id = $1", [sessionId]);
-        if (result.rowCount === 0) {
-            return false;
-        }
-        // Invalidate caches (session, active session for this CLI, and list)
-        await this.invalidateCache(sessionId);
-        try {
-            await this.redis.del(`active_session:${session.cli}`);
-        }
-        catch (error) {
-            this.logger.error(`Failed to invalidate active session cache for ${session.cli}`, { error });
-        }
-        await this.invalidateListCache(session.cli);
-        return true;
+        return result.rowCount !== 0;
     }
     /**
-     * Set active session for a CLI (with distributed locking)
+     * Set active session for a CLI. The row-level update is serialized by
+     * PostgreSQL and the session FK keeps stale IDs from being recorded.
      */
     async setActiveSession(cli, sessionId) {
-        // Validate session exists if not null
         if (sessionId !== null) {
             const session = await this.getSession(sessionId);
             if (!session || session.cli !== cli) {
                 return false;
             }
         }
-        // Acquire lock with bounded retries to avoid failing benign concurrent updates.
-        const lockValue = await this.acquireLockWithRetry(`active_session:${cli}`, 5, `active session ${cli}`);
-        try {
-            // UPSERT active session
-            const now = new Date().toISOString();
-            await this.pool.query(`INSERT INTO active_sessions (cli, session_id, updated_at)
-         VALUES ($1, $2, $3)
-         ON CONFLICT (cli) DO UPDATE SET session_id = $2, updated_at = $3`, [cli, sessionId, now]);
-            // Update cache
-            try {
-                if (sessionId) {
-                    await this.redis.setex(`active_session:${cli}`, this.cacheTtl.activeSession, sessionId);
-                }
-                else {
-                    await this.redis.del(`active_session:${cli}`);
-                }
-            }
-            catch (error) {
-                this.logger.error("Cache update failed", { error });
-            }
-            return true;
-        }
-        finally {
-            // Release lock with ownership verification
-            try {
-                await this.releaseLock(`active_session:${cli}`, lockValue);
-            }
-            catch (error) {
-                this.logger.error(`Failed to release lock for active session ${cli}`, { error, cli });
-            }
-        }
+        const now = new Date().toISOString();
+        await this.pool.query(`INSERT INTO active_sessions (cli, session_id, updated_at)
+       VALUES ($1, $2, $3)
+       ON CONFLICT (cli) DO UPDATE SET session_id = $2, updated_at = $3`, [cli, sessionId, now]);
+        return true;
     }
     /**
-     * Get active session for a CLI
+     * Get active session for a CLI.
      */
     async getActiveSession(cli) {
-        // Try cache first
-        try {
-            const cachedId = await this.redis.get(`active_session:${cli}`);
-            if (cachedId) {
-                return await this.getSession(cachedId);
-            }
-        }
-        catch (error) {
-            this.logger.error("Cache read failed", { error });
-        }
-        // Query database
         const result = await this.pool.query("SELECT session_id FROM active_sessions WHERE cli = $1", [cli]);
-        if (result.rows.length === 0 || !result.rows[0].session_id) {
+        const sessionId = result.rows[0]?.session_id;
+        if (!sessionId) {
             return null;
         }
-        const sessionId = result.rows[0].session_id;
-        // Populate cache
-        try {
-            await this.redis.setex(`active_session:${cli}`, this.cacheTtl.activeSession, sessionId);
-        }
-        catch (error) {
-            this.logger.error("Cache write failed", { error });
-        }
         return await this.getSession(sessionId);
     }
     /**
-     * Update session usage timestamp
+     * Update session usage timestamp.
      */
     async updateSessionUsage(sessionId) {
         const now = new Date().toISOString();
         await this.pool.query("UPDATE sessions SET last_used_at = $1 WHERE id = $2", [now, sessionId]);
-        // Invalidate cache to force refresh
-        await this.invalidateCache(sessionId);
     }
     /**
-     * Update session metadata (atomic JSONB merge)
+     * Update session metadata using PostgreSQL's atomic JSONB merge.
      */
     async updateSessionMetadata(sessionId, metadata) {
-        // Use PostgreSQL JSONB || operator for atomic merge (prevents race conditions)
         const result = await this.pool.query(`UPDATE sessions
        SET metadata = COALESCE(metadata, '{}'::jsonb) || $1::jsonb
        WHERE id = $2
        RETURNING id`, [JSON.stringify(metadata), sessionId]);
-        if (result.rowCount === 0) {
-            return false;
-        }
-        // Invalidate cache
-        await this.invalidateCache(sessionId);
-        return true;
+        return result.rowCount !== 0;
     }
     /**
-     * Clear all sessions, optionally filtered by CLI
-     * Invalidates all related caches (session, active, list)
+     * Clear all sessions, optionally filtered by CLI.
      */
     async clearAllSessions(cli) {
-        // First get all sessions to invalidate their caches
-        const sessions = await this.listSessions(cli);
-        // Delete from database
         const query = cli ? "DELETE FROM sessions WHERE cli = $1" : "DELETE FROM sessions";
         const result = cli ? await this.pool.query(query, [cli]) : await this.pool.query(query);
-        // Invalidate individual session caches (concurrent — each has its own try/catch)
-        await Promise.all(sessions.map(session => this.invalidateCache(session.id)));
-        // Invalidate active session caches
-        if (cli) {
-            try {
-                await this.redis.del(`active_session:${cli}`);
-            }
-            catch (error) {
-                this.logger.error(`Failed to invalidate active session cache for ${cli}`, { error, cli });
-            }
-        }
-        else {
-            // Invalidate all active session caches
-            try {
-                await Promise.all([
-                    this.redis.del("active_session:claude"),
-                    this.redis.del("active_session:codex"),
-                    this.redis.del("active_session:gemini"),
-                ]);
-            }
-            catch (error) {
-                this.logger.error("Failed to invalidate active session caches", { error });
-            }
-        }
-        // Invalidate list caches
-        await this.invalidateListCache(cli);
         return result.rowCount || 0;
     }
 }

package/dist/session-manager.js

@@ -230,15 +230,15 @@ export const SessionManager = FileSessionManager;
  * @param logger - Logger instance for structured logging
  */
 export async function createSessionManager(config, db, logger, opts) {
-    if (config?.database && config?.redis) {
-        // Import dynamically to avoid loading pg/ioredis if not needed
+    if (config?.database) {
+        // Import dynamically to avoid loading pg if not needed.
         const { PostgreSQLSessionManager } = await import("./session-manager-pg.js");
         // Use provided db connection or create new one
         if (!db) {
             const { createDatabaseConnection } = await import("./db.js");
             db = await createDatabaseConnection(config, logger);
         }
-        return new PostgreSQLSessionManager(db.getPool(), db.getRedis(), config.cacheTtl, logger ?? noopLogger);
+        return new PostgreSQLSessionManager(db.getPool());
     }
     else {
         // Use file-based storage with TTL from config

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-cli-gateway",
-  "version": "1.15.2",
+  "version": "1.16.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",
@@ -90,13 +90,9 @@
     "zod": "^3.23.0"
   },
   "peerDependencies": {
-    "ioredis": "^5.4.1",
     "pg": "^8.12.0"
   },
   "peerDependenciesMeta": {
-    "ioredis": {
-      "optional": true
-    },
     "pg": {
       "optional": true
     }
@@ -111,7 +107,6 @@
     "eslint": "^8.57.1",
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-security": "^3.0.1",
-    "ioredis": "5.9.2",
     "pg": "^8.12.0",
     "prettier": "^3.0.0",
     "typescript": "^5.0.0",