@elvatis_com/openclaw-cli-bridge-elvatis 2.5.0 → 2.6.0

package/src/provider-sessions.ts

@@ -0,0 +1,264 @@
+/**
+ * provider-sessions.ts
+ *
+ * Persistent session registry for CLI bridge provider sessions.
+ *
+ * A "provider session" represents a long-lived context with a CLI provider
+ * (Claude, Gemini, Codex, etc.). Sessions survive across individual runs:
+ * when a run times out, the session persists so that follow-up runs can
+ * resume in the same context.
+ *
+ * Session vs Run:
+ *   - Session: long-lived unit (provider context, profile, remote session ID)
+ *   - Run: single request within a session (messages, tools, timeout)
+ *
+ * Storage: in-memory Map + periodic flush to ~/.openclaw/cli-bridge/sessions.json.
+ */
+
+import { randomBytes } from "node:crypto";
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import {
+  PROVIDER_SESSIONS_FILE,
+  PROVIDER_SESSION_TTL_MS,
+  PROVIDER_SESSION_SWEEP_MS,
+} from "./config.js";
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Types
+// ──────────────────────────────────────────────────────────────────────────────
+
+export type ProviderAlias = "claude" | "gemini" | "grok" | "codex" | "opencode" | "pi" | "bitnet" | string;
+
+export type SessionState = "active" | "idle" | "expired";
+
+export interface ProviderSession {
+  /** Unique session ID, e.g. "claude:session-a1b2c3d4". */
+  id: string;
+  /** Provider type. */
+  provider: ProviderAlias;
+  /** Full model alias, e.g. "cli-claude/claude-sonnet-4-6". */
+  modelAlias: string;
+  /** Unix timestamp when the session was created. */
+  createdAt: number;
+  /** Unix timestamp of the last activity (run start, touch). */
+  updatedAt: number;
+  /** Current session state. */
+  state: SessionState;
+  /** Total runs executed in this session. */
+  runCount: number;
+  /** Number of runs that timed out. */
+  timeoutCount: number;
+  /** Provider-specific state (profile path, remote session ID, etc.). */
+  meta: Record<string, unknown>;
+}
+
+export interface CreateSessionOptions {
+  /** Provider-specific metadata. */
+  meta?: Record<string, unknown>;
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Registry
+// ──────────────────────────────────────────────────────────────────────────────
+
+/** Serialized format of the sessions file. */
+interface SessionStore {
+  version: 1;
+  sessions: ProviderSession[];
+}
+
+export class ProviderSessionRegistry {
+  private sessions = new Map<string, ProviderSession>();
+  private sweepTimer: ReturnType<typeof setInterval> | null = null;
+  private dirty = false;
+
+  constructor() {
+    this.load();
+    this.sweepTimer = setInterval(() => this.sweep(), PROVIDER_SESSION_SWEEP_MS);
+    if (this.sweepTimer.unref) this.sweepTimer.unref();
+  }
+
+  // ── CRUD ─────────────────────────────────────────────────────────────────
+
+  /**
+   * Create a new provider session.
+   * Returns the session with a unique ID.
+   */
+  createSession(
+    provider: ProviderAlias,
+    modelAlias: string,
+    opts: CreateSessionOptions = {}
+  ): ProviderSession {
+    const now = Date.now();
+    const id = `${provider}:session-${randomBytes(6).toString("hex")}`;
+    const session: ProviderSession = {
+      id,
+      provider,
+      modelAlias,
+      createdAt: now,
+      updatedAt: now,
+      state: "active",
+      runCount: 0,
+      timeoutCount: 0,
+      meta: opts.meta ?? {},
+    };
+    this.sessions.set(id, session);
+    this.dirty = true;
+    this.flush();
+    return session;
+  }
+
+  /** Get a session by ID. Returns undefined if not found. */
+  getSession(id: string): ProviderSession | undefined {
+    return this.sessions.get(id);
+  }
+
+  /**
+   * Find an existing active session for the given provider+model.
+   * Returns the most recently updated match, or undefined.
+   */
+  findSession(provider: ProviderAlias, modelAlias: string): ProviderSession | undefined {
+    let best: ProviderSession | undefined;
+    for (const s of this.sessions.values()) {
+      if (s.provider !== provider || s.modelAlias !== modelAlias) continue;
+      if (s.state === "expired") continue;
+      if (!best || s.updatedAt > best.updatedAt) best = s;
+    }
+    return best;
+  }
+
+  /**
+   * Get or create a session for the given provider+model.
+   * Reuses existing active session if available.
+   */
+  ensureSession(
+    provider: ProviderAlias,
+    modelAlias: string,
+    opts: CreateSessionOptions = {}
+  ): ProviderSession {
+    const existing = this.findSession(provider, modelAlias);
+    if (existing) {
+      this.touchSession(existing.id);
+      return existing;
+    }
+    return this.createSession(provider, modelAlias, opts);
+  }
+
+  /**
+   * Update the session's last-activity timestamp and set state to active.
+   * Call this at the start of every run.
+   */
+  touchSession(id: string): boolean {
+    const session = this.sessions.get(id);
+    if (!session) return false;
+    session.updatedAt = Date.now();
+    if (session.state === "idle") session.state = "active";
+    this.dirty = true;
+    return true;
+  }
+
+  /** Record that a run completed in this session. */
+  recordRun(id: string, timedOut: boolean): void {
+    const session = this.sessions.get(id);
+    if (!session) return;
+    session.runCount++;
+    if (timedOut) session.timeoutCount++;
+    session.updatedAt = Date.now();
+    session.state = "idle"; // run finished, session stays alive
+    this.dirty = true;
+    this.flush();
+  }
+
+  /** Delete a session by ID. */
+  deleteSession(id: string): boolean {
+    const deleted = this.sessions.delete(id);
+    if (deleted) {
+      this.dirty = true;
+      this.flush();
+    }
+    return deleted;
+  }
+
+  /** List all sessions. */
+  listSessions(): ProviderSession[] {
+    return [...this.sessions.values()];
+  }
+
+  /** Get summary stats for logging/status. */
+  stats(): { total: number; active: number; idle: number; expired: number } {
+    let active = 0, idle = 0, expired = 0;
+    for (const s of this.sessions.values()) {
+      if (s.state === "active") active++;
+      else if (s.state === "idle") idle++;
+      else expired++;
+    }
+    return { total: this.sessions.size, active, idle, expired };
+  }
+
+  // ── Lifecycle ────────────────────────────────────────────────────────────
+
+  /** Sweep stale sessions (older than PROVIDER_SESSION_TTL_MS without activity). */
+  sweep(): void {
+    const now = Date.now();
+    let changed = false;
+    for (const [id, session] of this.sessions) {
+      if (now - session.updatedAt > PROVIDER_SESSION_TTL_MS) {
+        session.state = "expired";
+        this.sessions.delete(id);
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.dirty = true;
+      this.flush();
+    }
+  }
+
+  /** Stop the sweep timer (for graceful shutdown). */
+  stop(): void {
+    if (this.sweepTimer) {
+      clearInterval(this.sweepTimer);
+      this.sweepTimer = null;
+    }
+    this.flush();
+  }
+
+  // ── Persistence ──────────────────────────────────────────────────────────
+
+  /** Load sessions from disk. */
+  private load(): void {
+    try {
+      const raw = readFileSync(PROVIDER_SESSIONS_FILE, "utf-8");
+      const store = JSON.parse(raw) as SessionStore;
+      if (store.version === 1 && Array.isArray(store.sessions)) {
+        for (const s of store.sessions) {
+          // Skip expired sessions on load
+          if (Date.now() - s.updatedAt > PROVIDER_SESSION_TTL_MS) continue;
+          this.sessions.set(s.id, s);
+        }
+      }
+    } catch {
+      // No file yet or corrupt — start fresh
+    }
+  }
+
+  /** Flush dirty sessions to disk. */
+  private flush(): void {
+    if (!this.dirty) return;
+    try {
+      mkdirSync(dirname(PROVIDER_SESSIONS_FILE), { recursive: true });
+      const store: SessionStore = {
+        version: 1,
+        sessions: [...this.sessions.values()],
+      };
+      writeFileSync(PROVIDER_SESSIONS_FILE, JSON.stringify(store, null, 2) + "\n", "utf-8");
+      this.dirty = false;
+    } catch {
+      // Non-fatal — sessions are still in memory
+    }
+  }
+}
+
+/** Shared singleton instance. */
+export const providerSessions = new ProviderSessionRegistry();

package/src/proxy-server.ts

@@ -20,6 +20,17 @@ import type { BrowserContext } from "playwright";
 import { renderStatusPage, type StatusProvider } from "./status-template.js";
 import { sessionManager } from "./session-manager.js";
 import { metrics } from "./metrics.js";
+import { providerSessions } from "./provider-sessions.js";
+import {
+  DEFAULT_PROXY_TIMEOUT_MS,
+  MAX_EFFECTIVE_TIMEOUT_MS,
+  TIMEOUT_PER_EXTRA_MSG_MS,
+  TIMEOUT_PER_TOOL_MS,
+  SSE_KEEPALIVE_INTERVAL_MS,
+  DEFAULT_BITNET_SERVER_URL,
+  BITNET_MAX_MESSAGES,
+  BITNET_SYSTEM_PROMPT,
+} from "./config.js";
 
 export type GrokCompleteOptions = Parameters<typeof grokComplete>[1];
 export type GrokCompleteStreamOptions = Parameters<typeof grokCompleteStream>[1];
@@ -153,10 +164,11 @@ export function startProxyServer(opts: ProxyServerOptions): Promise<http.Server>
       });
     });
 
-    // Stop the token refresh interval and session manager when the server closes (timer-leak prevention)
+    // Stop timers and flush state when the server closes (timer-leak prevention)
     server.on("close", () => {
       stopTokenRefresh();
       sessionManager.stop();
+      providerSessions.stop();
     });
 
     server.on("error", (err: NodeJS.ErrnoException) => {
@@ -547,7 +559,7 @@ async function handleRequest(
 
     // ── BitNet local inference routing ────────────────────────────────────────
     if (model.startsWith("local-bitnet/")) {
-      const bitnetUrl = opts.getBitNetServerUrl?.() ?? "http://127.0.0.1:8082";
+      const bitnetUrl = opts.getBitNetServerUrl?.() ?? DEFAULT_BITNET_SERVER_URL;
       const timeoutMs = opts.timeoutMs ?? 120_000;
       // llama-server (BitNet build) crashes with std::runtime_error on multi-part
       // content arrays (ref: https://github.com/ggerganov/llama.cpp/issues/8367).
@@ -564,18 +576,14 @@ async function handleRequest(
       };
       // BitNet has a 4096 token context window. Long sessions blow it up and
       // cause a hard C++ crash (no graceful error). Truncate to system prompt +
-      // last 10 messages (~2k tokens max) to stay safely within the limit.
-      const BITNET_MAX_MESSAGES = 6;
-      // Replace the full system prompt (MEMORY.md etc, ~2k+ tokens) with a
-      // minimal one so BitNet's 4096-token context isn't blown by the system msg alone.
-      const BITNET_SYSTEM = "You are Akido, a concise AI assistant. Answer briefly and directly. Current user: Emre. Timezone: Europe/Berlin.";
+      // last N messages (~2k tokens max) to stay safely within the limit.
       const allFlat = parsed.messages.map((m) => ({
         role: m.role,
         content: flattenContent(m.content),
       }));
       const nonSystemMsgs = allFlat.filter((m) => m.role !== "system");
       const truncated = nonSystemMsgs.slice(-BITNET_MAX_MESSAGES);
-      const bitnetMessages = [{ role: "system", content: BITNET_SYSTEM }, ...truncated];
+      const bitnetMessages = [{ role: "system", content: BITNET_SYSTEM_PROMPT }, ...truncated];
       const requestBody = JSON.stringify({ ...parsed, messages: bitnetMessages, tools: undefined });
 
       const bitnetStart = Date.now();
@@ -639,14 +647,23 @@ async function handleRequest(
     let usedModel = model;
     const routeOpts = { workdir, tools: hasTools ? tools : undefined, mediaFiles: mediaFiles.length ? mediaFiles : undefined, log: opts.log };
 
+    // ── Provider session: ensure a persistent session for this model ────────
+    // Extract provider prefix from model (e.g. "cli-claude" from "cli-claude/claude-sonnet-4-6")
+    const providerPrefix = model.split("/")[0];
+    const incomingSessionId = (parsed as { providerSessionId?: string }).providerSessionId;
+    const session = incomingSessionId
+      ? (providerSessions.getSession(incomingSessionId) ?? providerSessions.ensureSession(providerPrefix, model))
+      : providerSessions.ensureSession(providerPrefix, model);
+    providerSessions.touchSession(session.id);
+
     // ── Dynamic timeout: scale with conversation size ────────────────────────
     // Per-model timeout takes precedence, then global proxyTimeoutMs, then 300s default.
     const perModelTimeout = opts.modelTimeouts?.[model];
-    const baseTimeout = perModelTimeout ?? opts.timeoutMs ?? 300_000;
-    const msgExtra = Math.max(0, cleanMessages.length - 10) * 2_000;
-    const toolExtra = (tools?.length ?? 0) * 5_000;
-    const effectiveTimeout = Math.min(baseTimeout + msgExtra + toolExtra, 600_000);
-    opts.log(`[cli-bridge] ${model} timeout: ${Math.round(effectiveTimeout / 1000)}s (base=${Math.round(baseTimeout / 1000)}s${perModelTimeout ? " per-model" : ""}, +${Math.round(msgExtra / 1000)}s msgs, +${Math.round(toolExtra / 1000)}s tools)`);
+    const baseTimeout = perModelTimeout ?? opts.timeoutMs ?? DEFAULT_PROXY_TIMEOUT_MS;
+    const msgExtra = Math.max(0, cleanMessages.length - 10) * TIMEOUT_PER_EXTRA_MSG_MS;
+    const toolExtra = (tools?.length ?? 0) * TIMEOUT_PER_TOOL_MS;
+    const effectiveTimeout = Math.min(baseTimeout + msgExtra + toolExtra, MAX_EFFECTIVE_TIMEOUT_MS);
+    opts.log(`[cli-bridge] ${model} session=${session.id} timeout: ${Math.round(effectiveTimeout / 1000)}s (base=${Math.round(baseTimeout / 1000)}s${perModelTimeout ? " per-model" : ""}, +${Math.round(msgExtra / 1000)}s msgs, +${Math.round(toolExtra / 1000)}s tools)`);
 
     // ── SSE keepalive: send headers early so OpenClaw doesn't read-timeout ──
     let sseHeadersSent = false;
@@ -660,22 +677,25 @@ async function handleRequest(
       });
       sseHeadersSent = true;
       res.write(": keepalive\n\n");
-      keepaliveInterval = setInterval(() => { res.write(": keepalive\n\n"); }, 15_000);
+      keepaliveInterval = setInterval(() => { res.write(": keepalive\n\n"); }, SSE_KEEPALIVE_INTERVAL_MS);
     }
 
     const cliStart = Date.now();
     try {
       result = await routeToCliRunner(model, cleanMessages, effectiveTimeout, routeOpts);
       metrics.recordRequest(model, Date.now() - cliStart, true);
+      providerSessions.recordRun(session.id, false);
     } catch (err) {
       const primaryDuration = Date.now() - cliStart;
       const msg = (err as Error).message;
       // ── Model fallback: retry once with a lighter model if configured ────
       const isTimeout = msg.includes("timeout:") || msg.includes("exit 143") || msg.includes("exited 143");
+      // Record the run (with timeout flag) — session is preserved, not deleted
+      providerSessions.recordRun(session.id, isTimeout);
       const fallbackModel = opts.modelFallbacks?.[model];
       if (fallbackModel) {
         metrics.recordRequest(model, primaryDuration, false);
-        const reason = isTimeout ? "timeout by supervisor" : msg;
+        const reason = isTimeout ? `timeout by supervisor, session=${session.id} preserved` : msg;
         opts.warn(`[cli-bridge] ${model} failed (${reason}), falling back to ${fallbackModel}`);
         const fallbackStart = Date.now();
         try {
@@ -787,6 +807,8 @@ async function handleRequest(
           },
         ],
         usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+        // Propagate session ID so callers can resume in the same session
+        provider_session_id: session.id,
       };
 
       res.writeHead(200, { "Content-Type": "application/json", ...corsHeaders() });
@@ -906,6 +928,26 @@ async function handleRequest(
     return;
   }
 
+  // ── Provider session endpoints ──────────────────────────────────────────────
+
+  // GET /v1/provider-sessions — list all provider sessions with stats
+  if (url === "/v1/provider-sessions" && req.method === "GET") {
+    const sessions = providerSessions.listSessions();
+    const stats = providerSessions.stats();
+    res.writeHead(200, { "Content-Type": "application/json", ...corsHeaders() });
+    res.end(JSON.stringify({ sessions, stats }));
+    return;
+  }
+
+  // DELETE /v1/provider-sessions/:id — delete a specific provider session
+  const provSessionMatch = url.match(/^\/v1\/provider-sessions\/([a-zA-Z0-9:_-]+)$/);
+  if (provSessionMatch && req.method === "DELETE") {
+    const ok = providerSessions.deleteSession(decodeURIComponent(provSessionMatch[1]));
+    res.writeHead(ok ? 200 : 404, { "Content-Type": "application/json", ...corsHeaders() });
+    res.end(JSON.stringify({ ok }));
+    return;
+  }
+
   // 404
   res.writeHead(404, { "Content-Type": "application/json" });
   res.end(JSON.stringify({ error: { message: `Not found: ${url}`, type: "not_found" } }));

package/src/session-manager.ts

@@ -16,6 +16,11 @@ import { join } from "node:path";
 import { execSync } from "node:child_process";
 import { formatPrompt, type ChatMessage } from "./cli-runner.js";
 import { createIsolatedWorkdir, cleanupWorkdir, sweepOrphanedWorkdirs } from "./workdir.js";
+import {
+  SESSION_TTL_MS,
+  CLEANUP_INTERVAL_MS,
+  SESSION_KILL_GRACE_MS,
+} from "./config.js";
 
 // ──────────────────────────────────────────────────────────────────────────────
 // Types
@@ -92,11 +97,7 @@ function buildMinimalEnv(): Record<string, string> {
 // Session Manager
 // ──────────────────────────────────────────────────────────────────────────────
 
-/** Auto-cleanup interval: 30 minutes. */
-const SESSION_TTL_MS = 30 * 60 * 1000;
-const CLEANUP_INTERVAL_MS = 5 * 60 * 1000;
-/** Grace period between SIGTERM and SIGKILL for session termination. */
-const KILL_GRACE_MS = 5_000;
+// SESSION_TTL_MS, CLEANUP_INTERVAL_MS, SESSION_KILL_GRACE_MS imported from config.ts
 
 export class SessionManager {
   private sessions = new Map<string, SessionEntry>();
@@ -227,7 +228,7 @@ export class SessionManager {
     // If the process doesn't exit within the grace period, force-kill it
     setTimeout(() => {
       try { if (!entry.proc.killed) entry.proc.kill("SIGKILL"); } catch { /* already dead */ }
-    }, KILL_GRACE_MS);
+    }, SESSION_KILL_GRACE_MS);
     return true;
   }
 
@@ -258,7 +259,7 @@ export class SessionManager {
           // Escalate to SIGKILL after grace period
           setTimeout(() => {
             try { if (!entry.proc.killed) entry.proc.kill("SIGKILL"); } catch { /* already dead */ }
-          }, KILL_GRACE_MS);
+          }, SESSION_KILL_GRACE_MS);
         }
         // Clean up isolated workdir if it wasn't cleaned on exit
         if (entry.isolatedWorkdir) {
@@ -284,7 +285,7 @@ export class SessionManager {
         entry.status = "killed";
         setTimeout(() => {
           try { if (!entry.proc.killed) entry.proc.kill("SIGKILL"); } catch { /* already dead */ }
-        }, KILL_GRACE_MS);
+        }, SESSION_KILL_GRACE_MS);
       }
       if (entry.isolatedWorkdir) {
         cleanupWorkdir(entry.isolatedWorkdir);

package/test/config.test.ts

@@ -0,0 +1,102 @@
+/**
+ * Tests for the centralized config module.
+ * No mocks — tests the real exported values.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  DEFAULT_PROXY_PORT,
+  DEFAULT_PROXY_API_KEY,
+  DEFAULT_PROXY_TIMEOUT_MS,
+  DEFAULT_CLI_TIMEOUT_MS,
+  TIMEOUT_GRACE_MS,
+  MAX_MESSAGES,
+  MAX_MSG_CHARS,
+  SESSION_TTL_MS,
+  CLEANUP_INTERVAL_MS,
+  SESSION_KILL_GRACE_MS,
+  DEFAULT_MODEL_TIMEOUTS,
+  DEFAULT_MODEL_FALLBACKS,
+  OPENCLAW_DIR,
+  CLI_TEST_DEFAULT_MODEL,
+  MAX_EFFECTIVE_TIMEOUT_MS,
+  TIMEOUT_PER_EXTRA_MSG_MS,
+  TIMEOUT_PER_TOOL_MS,
+  PROVIDER_SESSION_TTL_MS,
+  MEDIA_TMP_DIR,
+  PROFILE_DIRS,
+  STATE_FILE,
+  PENDING_FILE,
+  PROVIDER_SESSIONS_FILE,
+  DEFAULT_BITNET_SERVER_URL,
+  BITNET_MAX_MESSAGES,
+  BITNET_SYSTEM_PROMPT,
+} from "../src/config.js";
+
+describe("config.ts exports", () => {
+  it("exports sensible timeout defaults", () => {
+    expect(DEFAULT_PROXY_TIMEOUT_MS).toBe(300_000);
+    expect(DEFAULT_CLI_TIMEOUT_MS).toBe(120_000);
+    expect(TIMEOUT_GRACE_MS).toBe(5_000);
+    expect(MAX_EFFECTIVE_TIMEOUT_MS).toBe(600_000);
+    expect(SESSION_TTL_MS).toBe(30 * 60 * 1000);
+    expect(CLEANUP_INTERVAL_MS).toBe(5 * 60 * 1000);
+    expect(SESSION_KILL_GRACE_MS).toBe(5_000);
+    expect(PROVIDER_SESSION_TTL_MS).toBe(2 * 60 * 60 * 1000);
+  });
+
+  it("exports dynamic timeout scaling factors", () => {
+    expect(TIMEOUT_PER_EXTRA_MSG_MS).toBe(2_000);
+    expect(TIMEOUT_PER_TOOL_MS).toBe(5_000);
+  });
+
+  it("exports message limits", () => {
+    expect(MAX_MESSAGES).toBe(20);
+    expect(MAX_MSG_CHARS).toBe(4_000);
+  });
+
+  it("exports proxy defaults", () => {
+    expect(DEFAULT_PROXY_PORT).toBe(31337);
+    expect(DEFAULT_PROXY_API_KEY).toBe("cli-bridge");
+  });
+
+  it("exports per-model timeouts for all major models", () => {
+    expect(DEFAULT_MODEL_TIMEOUTS["cli-claude/claude-opus-4-6"]).toBe(300_000);
+    expect(DEFAULT_MODEL_TIMEOUTS["cli-claude/claude-sonnet-4-6"]).toBe(180_000);
+    expect(DEFAULT_MODEL_TIMEOUTS["cli-claude/claude-haiku-4-5"]).toBe(90_000);
+    expect(DEFAULT_MODEL_TIMEOUTS["cli-gemini/gemini-2.5-pro"]).toBe(180_000);
+    expect(DEFAULT_MODEL_TIMEOUTS["cli-gemini/gemini-2.5-flash"]).toBe(90_000);
+    expect(DEFAULT_MODEL_TIMEOUTS["openai-codex/gpt-5.4"]).toBe(300_000);
+  });
+
+  it("exports model fallback chains", () => {
+    expect(DEFAULT_MODEL_FALLBACKS["cli-claude/claude-sonnet-4-6"]).toBe("cli-claude/claude-haiku-4-5");
+    expect(DEFAULT_MODEL_FALLBACKS["cli-claude/claude-opus-4-6"]).toBe("cli-claude/claude-sonnet-4-6");
+    expect(DEFAULT_MODEL_FALLBACKS["cli-gemini/gemini-2.5-pro"]).toBe("cli-gemini/gemini-2.5-flash");
+  });
+
+  it("exports path constants rooted in ~/.openclaw", () => {
+    expect(OPENCLAW_DIR).toContain(".openclaw");
+    expect(STATE_FILE).toContain("cli-bridge-state.json");
+    expect(PENDING_FILE).toContain("cli-bridge-pending.json");
+    expect(PROVIDER_SESSIONS_FILE).toContain("sessions.json");
+    expect(MEDIA_TMP_DIR).toContain("cli-bridge-media");
+  });
+
+  it("exports browser profile directories", () => {
+    expect(PROFILE_DIRS.grok).toContain("grok-profile");
+    expect(PROFILE_DIRS.gemini).toContain("gemini-profile");
+    expect(PROFILE_DIRS.claude).toContain("claude-profile");
+    expect(PROFILE_DIRS.chatgpt).toContain("chatgpt-profile");
+  });
+
+  it("exports BitNet defaults", () => {
+    expect(DEFAULT_BITNET_SERVER_URL).toBe("http://127.0.0.1:8082");
+    expect(BITNET_MAX_MESSAGES).toBe(6);
+    expect(BITNET_SYSTEM_PROMPT).toContain("Akido");
+  });
+
+  it("exports CLI test default model", () => {
+    expect(CLI_TEST_DEFAULT_MODEL).toBe("cli-claude/claude-sonnet-4-6");
+  });
+});