@cognisos/liminal 0.1.0

package/dist/bin.js

@@ -0,0 +1,1496 @@
+#!/usr/bin/env node
+
+// src/version.ts
+var VERSION = true ? "0.1.0" : "0.1.0";
+var BANNER_LINES = [
+  " ___       ___  _____ ______   ___  ________   ________  ___",
+  "|\\  \\     |\\  \\|\\   _ \\  _   \\|\\  \\|\\   ___  \\|\\   __  \\|\\  \\",
+  "\\ \\  \\    \\ \\  \\ \\  \\\\\\__\\ \\  \\ \\  \\ \\  \\\\ \\  \\ \\  \\|\\  \\ \\  \\",
+  " \\ \\  \\    \\ \\  \\ \\  \\\\|__| \\  \\ \\  \\ \\  \\\\ \\  \\ \\   __  \\ \\  \\",
+  "  \\ \\  \\____\\ \\  \\ \\  \\    \\ \\  \\ \\  \\ \\  \\\\ \\  \\ \\  \\ \\  \\ \\  \\____",
+  "   \\ \\_______\\ \\__\\ \\__\\    \\ \\__\\ \\__\\ \\__\\\\ \\__\\ \\__\\ \\__\\ \\_______\\",
+  "    \\|_______|\\|__|\\|__|     \\|__|\\|__|\\|__| \\|__|\\|__|\\|__|\\|_______|"
+];
+function printBanner() {
+  console.log();
+  for (const line of BANNER_LINES) {
+    console.log(line);
+  }
+  console.log();
+  console.log(`  v${VERSION} -- brought to you by Cognisos`);
+  console.log();
+}
+
+// src/commands/init.ts
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+import { RSCTransport, CircuitBreaker } from "@cognisos/rsc-sdk";
+
+// src/config/loader.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { dirname } from "path";
+
+// src/config/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+var LIMINAL_DIR = join(homedir(), ".liminal");
+var CONFIG_FILE = join(LIMINAL_DIR, "config.json");
+var PID_FILE = join(LIMINAL_DIR, "liminal.pid");
+var LOG_DIR = join(LIMINAL_DIR, "logs");
+var LOG_FILE = join(LOG_DIR, "liminal.log");
+
+// src/config/schema.ts
+var DEFAULTS = {
+  apiBaseUrl: "https://rsc-platform-production.up.railway.app",
+  upstreamBaseUrl: "https://api.openai.com",
+  anthropicUpstreamUrl: "https://api.anthropic.com",
+  port: 3141,
+  compressionThreshold: 100,
+  compressRoles: ["user"],
+  learnFromResponses: true,
+  latencyBudgetMs: 0,
+  enabled: true,
+  tools: []
+};
+var CONFIGURABLE_KEYS = /* @__PURE__ */ new Set([
+  "apiBaseUrl",
+  "upstreamBaseUrl",
+  "anthropicUpstreamUrl",
+  "port",
+  "compressionThreshold",
+  "compressRoles",
+  "learnFromResponses",
+  "latencyBudgetMs",
+  "enabled",
+  "tools"
+]);
+
+// src/config/loader.ts
+function loadConfig() {
+  let fileConfig = {};
+  if (existsSync(CONFIG_FILE)) {
+    try {
+      const raw = readFileSync(CONFIG_FILE, "utf-8");
+      fileConfig = JSON.parse(raw);
+    } catch {
+    }
+  }
+  const merged = {
+    apiKey: fileConfig.apiKey ?? "",
+    apiBaseUrl: DEFAULTS.apiBaseUrl,
+    upstreamBaseUrl: DEFAULTS.upstreamBaseUrl,
+    anthropicUpstreamUrl: DEFAULTS.anthropicUpstreamUrl,
+    port: DEFAULTS.port,
+    compressionThreshold: DEFAULTS.compressionThreshold,
+    compressRoles: DEFAULTS.compressRoles,
+    learnFromResponses: DEFAULTS.learnFromResponses,
+    latencyBudgetMs: DEFAULTS.latencyBudgetMs,
+    enabled: DEFAULTS.enabled,
+    tools: DEFAULTS.tools,
+    ...fileConfig
+  };
+  if (process.env.LIMINAL_API_KEY) merged.apiKey = process.env.LIMINAL_API_KEY;
+  if (process.env.LIMINAL_API_URL) merged.apiBaseUrl = process.env.LIMINAL_API_URL;
+  if (process.env.LIMINAL_UPSTREAM_URL) merged.upstreamBaseUrl = process.env.LIMINAL_UPSTREAM_URL;
+  if (process.env.LIMINAL_ANTHROPIC_URL) merged.anthropicUpstreamUrl = process.env.LIMINAL_ANTHROPIC_URL;
+  if (process.env.LIMINAL_PORT) merged.port = parseInt(process.env.LIMINAL_PORT, 10);
+  return merged;
+}
+function applyOverrides(config, overrides) {
+  return { ...config, ...overrides };
+}
+function saveConfig(config) {
+  ensureDirectories();
+  let existing = {};
+  if (existsSync(CONFIG_FILE)) {
+    try {
+      existing = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    } catch {
+    }
+  }
+  const merged = { ...existing, ...config };
+  writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+}
+function ensureDirectories() {
+  if (!existsSync(LIMINAL_DIR)) mkdirSync(LIMINAL_DIR, { recursive: true });
+  if (!existsSync(LOG_DIR)) mkdirSync(LOG_DIR, { recursive: true });
+  const configDir = dirname(CONFIG_FILE);
+  if (!existsSync(configDir)) mkdirSync(configDir, { recursive: true });
+}
+function isConfigured() {
+  try {
+    const config = loadConfig();
+    return config.apiKey.length > 0;
+  } catch {
+    return false;
+  }
+}
+function maskApiKey(key) {
+  if (key.length <= 12) return "****";
+  return key.slice(0, 8) + "..." + key.slice(-4);
+}
+
+// src/commands/init.ts
+var TOOL_MAP = {
+  "1": "claude-code",
+  "2": "codex",
+  "3": "cursor",
+  "4": "openai-compatible"
+};
+function parseToolSelection(input) {
+  const nums = input.split(",").map((s) => s.trim()).filter(Boolean);
+  const tools = nums.map((n) => TOOL_MAP[n]).filter((t) => !!t);
+  return tools.length > 0 ? tools : ["claude-code"];
+}
+function printToolInstructions(tool, port) {
+  const base = `http://127.0.0.1:${port}`;
+  switch (tool) {
+    case "claude-code":
+      console.log("    Claude Code:");
+      console.log(`      export ANTHROPIC_BASE_URL=${base}`);
+      console.log("      (Add to your shell profile for persistence)");
+      console.log();
+      break;
+    case "codex":
+      console.log("    Codex:");
+      console.log(`      export OPENAI_BASE_URL=${base}/v1`);
+      console.log("      (Add to your shell profile for persistence)");
+      console.log();
+      break;
+    case "cursor":
+      console.log("    Cursor:");
+      console.log(`      Settings > Models > OpenAI API Base URL: ${base}/v1`);
+      console.log();
+      break;
+    case "openai-compatible":
+      console.log("    OpenAI-compatible tools:");
+      console.log(`      Set your base URL to: ${base}/v1`);
+      console.log();
+      break;
+  }
+}
+async function initCommand() {
+  const rl = createInterface({ input: stdin, output: stdout });
+  printBanner();
+  console.log("  Welcome to Liminal -- Your Transparency & Context Partner");
+  console.log();
+  console.log("  Let's start evolving.");
+  console.log();
+  try {
+    const apiKey = await rl.question("  \x1B[1mLiminal API key\x1B[0m: ");
+    if (!apiKey.trim()) {
+      console.error("\n  Error: API key is required.");
+      process.exit(1);
+    }
+    const apiBaseUrlInput = await rl.question(`  Liminal API URL [${DEFAULTS.apiBaseUrl}]: `);
+    const apiBaseUrl = apiBaseUrlInput.trim() || DEFAULTS.apiBaseUrl;
+    const portInput = await rl.question(`  Proxy port [${DEFAULTS.port}]: `);
+    const port = portInput.trim() ? parseInt(portInput.trim(), 10) : DEFAULTS.port;
+    if (isNaN(port) || port < 1 || port > 65535) {
+      console.error("\n  Error: Invalid port number.");
+      process.exit(1);
+    }
+    console.log();
+    console.log("  Which AI tools will you use with Liminal?");
+    console.log();
+    console.log("    1) Claude Code");
+    console.log("    2) Codex");
+    console.log("    3) Cursor");
+    console.log("    4) Other / OpenAI-compatible");
+    console.log();
+    const toolsInput = await rl.question("  Select tools (comma-separated, e.g. 1,3) [1]: ");
+    const tools = parseToolSelection(toolsInput.trim() || "1");
+    const learnInput = await rl.question("  Learn from LLM responses? [Y/n]: ");
+    const learnFromResponses = learnInput.trim().toLowerCase() !== "n";
+    console.log();
+    process.stdout.write("  Validating API key... ");
+    try {
+      const breaker = new CircuitBreaker(3, 1e4);
+      const transport = new RSCTransport({
+        baseUrl: apiBaseUrl,
+        apiKey: apiKey.trim(),
+        timeout: 1e4,
+        maxRetries: 1,
+        circuitBreaker: breaker
+      });
+      await transport.get("/health");
+      console.log("OK");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.log("FAILED");
+      console.error(`
+  Could not connect to Liminal API: ${message}`);
+      console.error("  Check your API key and URL, then try again.");
+      process.exit(1);
+    }
+    ensureDirectories();
+    saveConfig({
+      apiKey: apiKey.trim(),
+      apiBaseUrl,
+      upstreamBaseUrl: DEFAULTS.upstreamBaseUrl,
+      anthropicUpstreamUrl: DEFAULTS.anthropicUpstreamUrl,
+      port,
+      learnFromResponses,
+      tools,
+      compressionThreshold: DEFAULTS.compressionThreshold,
+      compressRoles: DEFAULTS.compressRoles,
+      latencyBudgetMs: DEFAULTS.latencyBudgetMs,
+      enabled: DEFAULTS.enabled
+    });
+    console.log();
+    console.log(`  Configuration saved to ${CONFIG_FILE}`);
+    console.log();
+    console.log("  Next steps:");
+    console.log("    1. Start the proxy:  liminal start");
+    console.log("    2. Connect your tools:");
+    console.log();
+    for (const tool of tools) {
+      printToolInstructions(tool, port);
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+// src/rsc/pipeline.ts
+import {
+  CompressionPipeline,
+  RSCTransport as RSCTransport2,
+  RSCEventEmitter,
+  Session,
+  CircuitBreaker as CircuitBreaker2
+} from "@cognisos/rsc-sdk";
+var RSCPipelineWrapper = class {
+  pipeline;
+  session;
+  events;
+  transport;
+  circuitBreaker;
+  constructor(config) {
+    this.circuitBreaker = new CircuitBreaker2(5, 5 * 60 * 1e3);
+    this.transport = new RSCTransport2({
+      baseUrl: config.rscBaseUrl,
+      apiKey: config.rscApiKey,
+      timeout: 3e4,
+      maxRetries: 3,
+      circuitBreaker: this.circuitBreaker
+    });
+    this.events = new RSCEventEmitter();
+    this.session = new Session(config.sessionId);
+    this.pipeline = new CompressionPipeline(
+      this.transport,
+      {
+        threshold: config.compressionThreshold,
+        learnFromResponses: config.learnFromResponses,
+        latencyBudgetMs: config.latencyBudgetMs,
+        sessionId: this.session.sessionId
+      },
+      this.events
+    );
+  }
+  async healthCheck() {
+    try {
+      await this.transport.get("/health");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getSessionSummary() {
+    return this.session.getSummary();
+  }
+  getCircuitState() {
+    return this.circuitBreaker.getState();
+  }
+  isCircuitOpen() {
+    return this.circuitBreaker.getState() === "open";
+  }
+  resetCircuitBreaker() {
+    this.circuitBreaker.reset();
+  }
+};
+
+// src/proxy/completions.ts
+import { RSCCircuitOpenError as RSCCircuitOpenError2 } from "@cognisos/rsc-sdk";
+
+// src/rsc/message-compressor.ts
+import { RSCCircuitOpenError } from "@cognisos/rsc-sdk";
+async function compressMessages(messages, pipeline, session, compressRoles) {
+  let anyCompressed = false;
+  let totalTokensSaved = 0;
+  const compressed = await Promise.all(
+    messages.map(async (msg) => {
+      if (!compressRoles.has(msg.role)) return msg;
+      if (typeof msg.content === "string") {
+        return compressStringContent(msg, pipeline, session, (c, saved) => {
+          anyCompressed = anyCompressed || c;
+          totalTokensSaved += saved;
+        });
+      }
+      if (Array.isArray(msg.content)) {
+        return compressArrayContent(msg, pipeline, session, (c, saved) => {
+          anyCompressed = anyCompressed || c;
+          totalTokensSaved += saved;
+        });
+      }
+      return msg;
+    })
+  );
+  return { messages: compressed, anyCompressed, totalTokensSaved };
+}
+async function compressStringContent(msg, pipeline, session, record) {
+  try {
+    const result = await pipeline.compressForLLM(msg.content);
+    session.recordCompression(result.metrics);
+    record(!result.metrics.skipped, result.metrics.tokensSaved);
+    return { ...msg, content: result.text };
+  } catch (err) {
+    if (err instanceof RSCCircuitOpenError) {
+      session.recordFailure();
+      throw err;
+    }
+    session.recordFailure();
+    return msg;
+  }
+}
+async function compressArrayContent(msg, pipeline, session, record) {
+  const parts = msg.content;
+  const compressedParts = await Promise.all(
+    parts.map(async (part) => {
+      if (part.type === "text" && typeof part.text === "string") {
+        try {
+          const result = await pipeline.compressForLLM(part.text);
+          session.recordCompression(result.metrics);
+          record(!result.metrics.skipped, result.metrics.tokensSaved);
+          return { ...part, text: result.text };
+        } catch (err) {
+          if (err instanceof RSCCircuitOpenError) {
+            session.recordFailure();
+            throw err;
+          }
+          session.recordFailure();
+          return part;
+        }
+      }
+      return part;
+    })
+  );
+  return { ...msg, content: compressedParts };
+}
+
+// src/rsc/learning.ts
+function createStreamLearningBuffer(pipeline) {
+  let buffer = "";
+  return {
+    /** Append a text delta from an SSE chunk */
+    append(text) {
+      buffer += text;
+    },
+    /** Flush the buffer — triggers fire-and-forget learning */
+    flush() {
+      if (buffer.length > 0) {
+        pipeline.triggerLearning(buffer);
+        buffer = "";
+      }
+    },
+    /** Get current buffer contents (for testing) */
+    getBuffer() {
+      return buffer;
+    }
+  };
+}
+
+// src/proxy/streaming.ts
+async function pipeSSEResponse(upstreamResponse, clientRes, onContentDelta, onComplete) {
+  clientRes.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive",
+    "Access-Control-Allow-Origin": "*"
+  });
+  const reader = upstreamResponse.body.getReader();
+  const decoder = new TextDecoder();
+  let lineBuf = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = decoder.decode(value, { stream: true });
+      clientRes.write(chunk);
+      lineBuf += chunk;
+      const lines = lineBuf.split("\n");
+      lineBuf = lines.pop() || "";
+      for (const line of lines) {
+        if (line.startsWith("data: ") && line !== "data: [DONE]") {
+          try {
+            const json = JSON.parse(line.slice(6));
+            const content = json?.choices?.[0]?.delta?.content;
+            if (typeof content === "string") {
+              onContentDelta(content);
+            }
+          } catch {
+          }
+        }
+      }
+    }
+  } finally {
+    clientRes.end();
+    onComplete();
+  }
+}
+
+// src/proxy/completions.ts
+function setCORSHeaders(res) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+}
+function sendJSON(res, status, body) {
+  setCORSHeaders(res);
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+function extractBearerToken(req) {
+  const auth = req.headers.authorization;
+  if (!auth || !auth.startsWith("Bearer ")) return null;
+  return auth.slice(7);
+}
+async function handleChatCompletions(req, res, body, pipeline, config, logger) {
+  const request = body;
+  if (!request.messages || !Array.isArray(request.messages)) {
+    sendJSON(res, 400, {
+      error: { message: "messages is required and must be an array", type: "invalid_request_error" }
+    });
+    return;
+  }
+  const llmApiKey = extractBearerToken(req);
+  if (!llmApiKey) {
+    sendJSON(res, 401, {
+      error: { message: "Authorization header with Bearer token is required", type: "authentication_error" }
+    });
+    return;
+  }
+  let messages = request.messages;
+  let anyCompressed = false;
+  if (config.enabled && !pipeline.isCircuitOpen()) {
+    try {
+      const compressRoles = new Set(config.compressRoles);
+      const result = await compressMessages(
+        request.messages,
+        pipeline.pipeline,
+        pipeline.session,
+        compressRoles
+      );
+      messages = result.messages;
+      anyCompressed = result.anyCompressed;
+      if (result.totalTokensSaved > 0) {
+        logger.log(`[COMPRESS] Saved ${result.totalTokensSaved} tokens`);
+      }
+    } catch (err) {
+      if (err instanceof RSCCircuitOpenError2) {
+        logger.log("[DEGRADE] Circuit breaker open \u2014 passing through directly");
+      } else {
+        logger.log(`[ERROR] Compression failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      messages = request.messages;
+    }
+  }
+  const upstreamUrl = `${config.upstreamBaseUrl}/v1/chat/completions`;
+  const upstreamBody = { ...request, messages };
+  const upstreamHeaders = {
+    "Authorization": `Bearer ${llmApiKey}`,
+    "Content-Type": "application/json"
+  };
+  if (request.stream) {
+    upstreamHeaders["Accept"] = "text/event-stream";
+  }
+  try {
+    const upstreamResponse = await fetch(upstreamUrl, {
+      method: "POST",
+      headers: upstreamHeaders,
+      body: JSON.stringify(upstreamBody)
+    });
+    if (!upstreamResponse.ok) {
+      const errorBody = await upstreamResponse.text();
+      setCORSHeaders(res);
+      res.writeHead(upstreamResponse.status, {
+        "Content-Type": upstreamResponse.headers.get("Content-Type") || "application/json"
+      });
+      res.end(errorBody);
+      return;
+    }
+    if (request.stream && upstreamResponse.body) {
+      const learningBuffer = anyCompressed ? createStreamLearningBuffer(pipeline.pipeline) : null;
+      await pipeSSEResponse(
+        upstreamResponse,
+        res,
+        (text) => learningBuffer?.append(text),
+        () => learningBuffer?.flush()
+      );
+      return;
+    }
+    const responseBody = await upstreamResponse.text();
+    setCORSHeaders(res);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(responseBody);
+    if (anyCompressed) {
+      try {
+        const parsed = JSON.parse(responseBody);
+        const content = parsed?.choices?.[0]?.message?.content;
+        if (typeof content === "string" && content.length > 0) {
+          pipeline.pipeline.triggerLearning(content);
+        }
+      } catch {
+      }
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.log(`[ERROR] Upstream request failed: ${message}`);
+    if (!res.headersSent) {
+      sendJSON(res, 502, {
+        error: { message: `Failed to reach upstream LLM: ${message}`, type: "server_error" }
+      });
+    }
+  }
+}
+
+// src/proxy/messages.ts
+import { RSCCircuitOpenError as RSCCircuitOpenError3 } from "@cognisos/rsc-sdk";
+
+// src/proxy/anthropic-streaming.ts
+async function pipeAnthropicSSEResponse(upstreamResponse, clientRes, onContentDelta, onComplete) {
+  clientRes.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive",
+    "Access-Control-Allow-Origin": "*"
+  });
+  const reader = upstreamResponse.body.getReader();
+  const decoder = new TextDecoder();
+  let lineBuf = "";
+  let currentEvent = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = decoder.decode(value, { stream: true });
+      clientRes.write(chunk);
+      lineBuf += chunk;
+      const lines = lineBuf.split("\n");
+      lineBuf = lines.pop() || "";
+      for (const line of lines) {
+        if (line.startsWith("event: ")) {
+          currentEvent = line.slice(7).trim();
+        } else if (line.startsWith("data: ") && currentEvent === "content_block_delta") {
+          try {
+            const json = JSON.parse(line.slice(6));
+            if (json?.delta?.type === "text_delta" && typeof json.delta.text === "string") {
+              onContentDelta(json.delta.text);
+            }
+          } catch {
+          }
+        }
+      }
+    }
+  } finally {
+    clientRes.end();
+    onComplete();
+  }
+}
+
+// src/proxy/messages.ts
+function setCORSHeaders2(res) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, x-api-key, anthropic-version, anthropic-beta");
+}
+function sendAnthropicError(res, status, type, message) {
+  setCORSHeaders2(res);
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ type: "error", error: { type, message } }));
+}
+function extractAnthropicApiKey(req) {
+  const key = req.headers["x-api-key"];
+  if (typeof key === "string" && key.length > 0) return key;
+  return null;
+}
+function convertAnthropicToCompressible(messages) {
+  return messages.map((msg) => ({
+    role: msg.role,
+    content: msg.content
+  }));
+}
+function convertCompressedToAnthropic(messages) {
+  return messages.map((msg) => ({
+    role: msg.role,
+    content: msg.content
+  }));
+}
+async function handleAnthropicMessages(req, res, body, pipeline, config, logger) {
+  const request = body;
+  if (!request.messages || !Array.isArray(request.messages)) {
+    sendAnthropicError(res, 400, "invalid_request_error", "messages is required and must be an array");
+    return;
+  }
+  if (typeof request.max_tokens !== "number") {
+    sendAnthropicError(res, 400, "invalid_request_error", "max_tokens is required");
+    return;
+  }
+  const apiKey = extractAnthropicApiKey(req);
+  if (!apiKey) {
+    sendAnthropicError(res, 401, "authentication_error", "x-api-key header is required");
+    return;
+  }
+  let messages = request.messages;
+  let anyCompressed = false;
+  if (config.enabled && !pipeline.isCircuitOpen()) {
+    try {
+      const compressRoles = new Set(config.compressRoles);
+      const compressible = convertAnthropicToCompressible(request.messages);
+      const result = await compressMessages(
+        compressible,
+        pipeline.pipeline,
+        pipeline.session,
+        compressRoles
+      );
+      messages = convertCompressedToAnthropic(result.messages);
+      anyCompressed = result.anyCompressed;
+      if (result.totalTokensSaved > 0) {
+        logger.log(`[COMPRESS] Saved ${result.totalTokensSaved} tokens`);
+      }
+    } catch (err) {
+      if (err instanceof RSCCircuitOpenError3) {
+        logger.log("[DEGRADE] Circuit breaker open -- passing through directly");
+      } else {
+        logger.log(`[ERROR] Compression failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      messages = request.messages;
+    }
+  }
+  const upstreamUrl = `${config.anthropicUpstreamUrl}/v1/messages`;
+  const upstreamBody = { ...request, messages };
+  const upstreamHeaders = {
+    "x-api-key": apiKey,
+    "anthropic-version": req.headers["anthropic-version"] || "2023-06-01",
+    "Content-Type": "application/json"
+  };
+  const betaHeader = req.headers["anthropic-beta"];
+  if (typeof betaHeader === "string") {
+    upstreamHeaders["anthropic-beta"] = betaHeader;
+  }
+  try {
+    const upstreamResponse = await fetch(upstreamUrl, {
+      method: "POST",
+      headers: upstreamHeaders,
+      body: JSON.stringify(upstreamBody)
+    });
+    if (!upstreamResponse.ok) {
+      const errorBody = await upstreamResponse.text();
+      setCORSHeaders2(res);
+      res.writeHead(upstreamResponse.status, {
+        "Content-Type": upstreamResponse.headers.get("Content-Type") || "application/json"
+      });
+      res.end(errorBody);
+      return;
+    }
+    if (request.stream && upstreamResponse.body) {
+      const learningBuffer = anyCompressed ? createStreamLearningBuffer(pipeline.pipeline) : null;
+      await pipeAnthropicSSEResponse(
+        upstreamResponse,
+        res,
+        (text) => learningBuffer?.append(text),
+        () => learningBuffer?.flush()
+      );
+      return;
+    }
+    const responseBody = await upstreamResponse.text();
+    setCORSHeaders2(res);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(responseBody);
+    if (anyCompressed) {
+      try {
+        const parsed = JSON.parse(responseBody);
+        const textBlocks = parsed?.content?.filter(
+          (b) => b.type === "text" && typeof b.text === "string"
+        );
+        const content = textBlocks?.map((b) => b.text).join("");
+        if (typeof content === "string" && content.length > 0) {
+          pipeline.pipeline.triggerLearning(content);
+        }
+      } catch {
+      }
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.log(`[ERROR] Upstream request failed: ${message}`);
+    if (!res.headersSent) {
+      sendAnthropicError(res, 502, "api_error", `Failed to reach upstream: ${message}`);
+    }
+  }
+}
+
+// src/proxy/handler.ts
+function setCORSHeaders3(res) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, x-api-key, anthropic-version, anthropic-beta");
+  res.setHeader("Access-Control-Max-Age", "86400");
+}
+function sendJSON2(res, status, body) {
+  setCORSHeaders3(res);
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+function createRequestHandler(pipeline, config, logger) {
+  const startTime = Date.now();
+  return async (req, res) => {
+    try {
+      const method = req.method?.toUpperCase() ?? "";
+      const url = req.url ?? "";
+      if (method === "OPTIONS") {
+        setCORSHeaders3(res);
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      if (method === "GET" && (url === "/health" || url === "/")) {
+        const summary = pipeline.getSessionSummary();
+        sendJSON2(res, 200, {
+          status: "ok",
+          version: config.rscApiKey ? "connected" : "no-api-key",
+          rsc_connected: !pipeline.isCircuitOpen(),
+          circuit_state: pipeline.getCircuitState(),
+          session_id: summary.sessionId,
+          uptime_ms: Date.now() - startTime,
+          session: {
+            tokens_processed: summary.tokensProcessed,
+            tokens_saved: summary.tokensSaved,
+            calls_total: summary.totalCalls,
+            calls_compressed: summary.compressedCalls,
+            calls_skipped: summary.skippedCalls,
+            calls_failed: summary.failedCalls,
+            patterns_learned: summary.patternsLearned,
+            estimated_cost_saved_usd: summary.estimatedCostSaved
+          }
+        });
+        return;
+      }
+      if (method === "GET" && (url === "/v1/models" || url === "/models")) {
+        const llmApiKey = req.headers.authorization?.slice(7);
+        if (!llmApiKey) {
+          sendJSON2(res, 401, {
+            error: { message: "Authorization header with Bearer token is required", type: "authentication_error" }
+          });
+          return;
+        }
+        try {
+          const upstreamRes = await fetch(`${config.upstreamBaseUrl}/v1/models`, {
+            headers: { "Authorization": `Bearer ${llmApiKey}` }
+          });
+          const body = await upstreamRes.text();
+          setCORSHeaders3(res);
+          res.writeHead(upstreamRes.status, {
+            "Content-Type": upstreamRes.headers.get("Content-Type") || "application/json"
+          });
+          res.end(body);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          sendJSON2(res, 502, {
+            error: { message: `Failed to reach upstream: ${message}`, type: "server_error" }
+          });
+        }
+        return;
+      }
+      if (method === "POST" && (url === "/v1/chat/completions" || url === "/chat/completions")) {
+        const body = await readBody(req);
+        let parsed;
+        try {
+          parsed = JSON.parse(body);
+        } catch {
+          sendJSON2(res, 400, {
+            error: { message: "Invalid JSON body", type: "invalid_request_error" }
+          });
+          return;
+        }
+        await handleChatCompletions(req, res, parsed, pipeline, config, logger);
+        return;
+      }
+      if (method === "POST" && (url === "/v1/messages" || url === "/messages")) {
+        const body = await readBody(req);
+        let parsed;
+        try {
+          parsed = JSON.parse(body);
+        } catch {
+          sendJSON2(res, 400, {
+            type: "error",
+            error: { type: "invalid_request_error", message: "Invalid JSON body" }
+          });
+          return;
+        }
+        await handleAnthropicMessages(req, res, parsed, pipeline, config, logger);
+        return;
+      }
+      sendJSON2(res, 404, {
+        error: { message: `Not found: ${method} ${url}`, type: "invalid_request_error" }
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger.log(`[ERROR] Proxy handler error: ${message}`);
+      if (!res.headersSent) {
+        sendJSON2(res, 500, {
+          error: { message: "Internal proxy error", type: "server_error" }
+        });
+      }
+    }
+  };
+}
+
+// src/proxy/server.ts
+import * as http from "http";
+var MAX_PORT_RETRIES = 5;
+var ProxyServer = class {
+  server = null;
+  activePort = null;
+  requestedPort;
+  handler;
+  constructor(port, handler) {
+    this.requestedPort = port;
+    this.handler = handler;
+  }
+  async start() {
+    let lastError = null;
+    for (let attempt = 0; attempt < MAX_PORT_RETRIES; attempt++) {
+      const port = this.requestedPort + attempt;
+      try {
+        await this.listen(port);
+        this.activePort = port;
+        return port;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (err.code !== "EADDRINUSE") {
+          throw lastError;
+        }
+      }
+    }
+    throw lastError ?? new Error(`All ports ${this.requestedPort}-${this.requestedPort + MAX_PORT_RETRIES - 1} in use`);
+  }
+  listen(port) {
+    return new Promise((resolve, reject) => {
+      const server = http.createServer(this.handler);
+      server.on("error", reject);
+      server.listen(port, "127.0.0.1", () => {
+        server.removeListener("error", reject);
+        this.server = server;
+        resolve();
+      });
+    });
+  }
+  async stop() {
+    if (!this.server) return;
+    return new Promise((resolve) => {
+      this.server.close(() => {
+        this.server = null;
+        this.activePort = null;
+        resolve();
+      });
+    });
+  }
+  isRunning() {
+    return this.server !== null && this.server.listening;
+  }
+  getPort() {
+    return this.activePort;
+  }
+};
+
+// src/daemon/logger.ts
+import { appendFileSync, statSync, renameSync, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+var MAX_LOG_SIZE = 10 * 1024 * 1024;
+var MAX_BACKUPS = 2;
+var FileLogger = class {
+  logFile;
+  mirrorStdout;
+  constructor(options) {
+    this.logFile = options?.logFile ?? LOG_FILE;
+    this.mirrorStdout = options?.mirrorStdout ?? false;
+    const logDir = dirname2(this.logFile);
+    if (!existsSync2(logDir)) {
+      mkdirSync2(logDir, { recursive: true });
+    }
+  }
+  log(message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+    const line = `[${timestamp}] ${message}
+`;
+    try {
+      appendFileSync(this.logFile, line);
+    } catch {
+      process.stderr.write(`[LOG-WRITE-FAILED] ${line}`);
+    }
+    if (this.mirrorStdout) {
+      process.stdout.write(line);
+    }
+    this.rotateIfNeeded();
+  }
+  rotateIfNeeded() {
+    try {
+      const stats = statSync(this.logFile);
+      if (stats.size <= MAX_LOG_SIZE) return;
+      for (let i = MAX_BACKUPS - 1; i >= 1; i--) {
+        const from = `${this.logFile}.${i}`;
+        const to = `${this.logFile}.${i + 1}`;
+        if (existsSync2(from)) renameSync(from, to);
+      }
+      renameSync(this.logFile, `${this.logFile}.1`);
+    } catch {
+    }
+  }
+  getLogFile() {
+    return this.logFile;
+  }
+};
+
+// src/daemon/lifecycle.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, existsSync as existsSync3 } from "fs";
+import { fork } from "child_process";
+import { fileURLToPath } from "url";
+function writePidFile(pid) {
+  writeFileSync2(PID_FILE, String(pid), "utf-8");
+}
+function readPidFile() {
+  if (!existsSync3(PID_FILE)) return null;
+  try {
+    const content = readFileSync2(PID_FILE, "utf-8").trim();
+    const pid = parseInt(content, 10);
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+function removePidFile() {
+  try {
+    if (existsSync3(PID_FILE)) unlinkSync(PID_FILE);
+  } catch {
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isDaemonRunning() {
+  const pid = readPidFile();
+  if (pid === null) return { running: false };
+  if (isProcessAlive(pid)) {
+    return { running: true, pid };
+  }
+  removePidFile();
+  return { running: false };
+}
+function setupSignalHandlers(server, logger) {
+  const shutdown = async (signal) => {
+    logger.log(`[DAEMON] Received ${signal}, shutting down...`);
+    try {
+      await server.stop();
+    } catch {
+    }
+    removePidFile();
+    logger.log("[DAEMON] Stopped.");
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("uncaughtException", (err) => {
+    logger.log(`[FATAL] Uncaught exception: ${err.message}`);
+    removePidFile();
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    const message = reason instanceof Error ? reason.message : String(reason);
+    logger.log(`[FATAL] Unhandled rejection: ${message}`);
+    removePidFile();
+    process.exit(1);
+  });
+}
+function forkDaemon(binPath, extraArgs = []) {
+  const child = fork(binPath, ["start", "--_forked", ...extraArgs], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  return child.pid;
+}
+function resolveBinPath(importMetaUrl) {
+  return fileURLToPath(importMetaUrl);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/commands/start.ts
+async function startCommand(flags) {
+  const isDaemon = flags.has("d") || flags.has("daemon");
+  const isForked = flags.has("_forked");
+  if (!isForked) {
+    const state = isDaemonRunning();
+    if (state.running) {
+      console.error(`Liminal daemon is already running (PID ${state.pid}).`);
+      console.error('Use "liminal stop" first, or "liminal status" to check.');
+      process.exit(1);
+    }
+  }
+  if (!isConfigured()) {
+    console.error('Liminal is not configured. Run "liminal init" first.');
+    process.exit(1);
+  }
+  let config = loadConfig();
+  const portOverride = flags.get("port");
+  const upstreamOverride = flags.get("upstream");
+  config = applyOverrides(config, {
+    ...typeof portOverride === "string" ? { port: parseInt(portOverride, 10) } : {},
+    ...typeof upstreamOverride === "string" ? { upstreamBaseUrl: upstreamOverride } : {}
+  });
+  if (isDaemon && !isForked) {
+    const extraArgs = [];
+    if (portOverride) extraArgs.push("--port", String(portOverride));
+    if (upstreamOverride) extraArgs.push("--upstream", String(upstreamOverride));
+    const binPath = resolveBinPath(import.meta.url);
+    const childPid = forkDaemon(binPath, extraArgs);
+    console.log(`Liminal daemon started in background (PID ${childPid})`);
+    console.log(`Proxy: http://127.0.0.1:${config.port}/v1`);
+    console.log("Logs:  ~/.liminal/logs/liminal.log");
+    process.exit(0);
+  }
+  const isForeground = !isDaemon || isForked;
+  const logger = new FileLogger({ mirrorStdout: isForeground && !isForked });
+  const resolvedConfig = {
+    rscApiKey: config.apiKey,
+    rscBaseUrl: config.apiBaseUrl,
+    proxyPort: config.port,
+    compressionThreshold: config.compressionThreshold,
+    compressRoles: config.compressRoles,
+    learnFromResponses: config.learnFromResponses,
+    latencyBudgetMs: config.latencyBudgetMs || void 0,
+    upstreamBaseUrl: config.upstreamBaseUrl,
+    anthropicUpstreamUrl: config.anthropicUpstreamUrl,
+    enabled: config.enabled,
+    tools: config.tools
+  };
+  const pipeline = new RSCPipelineWrapper({
+    rscApiKey: config.apiKey,
+    rscBaseUrl: config.apiBaseUrl,
+    compressionThreshold: config.compressionThreshold,
+    learnFromResponses: config.learnFromResponses,
+    latencyBudgetMs: config.latencyBudgetMs || void 0
+  });
+  pipeline.events.on("compression", (event) => {
+    if (event.tokensSaved > 0) {
+      logger.log(`[LIMINAL] Compressed: ${event.tokensSaved} tokens saved (${event.ratio.toFixed(3)} ratio)`);
+    }
+  });
+  pipeline.events.on("compression_skipped", (event) => {
+    logger.log(`[LIMINAL] Skipped: ${event.reason}`);
+  });
+  pipeline.events.on("error", (event) => {
+    logger.log(`[LIMINAL] Error: ${event.error.message}`);
+  });
+  pipeline.events.on("degradation", (event) => {
+    logger.log(`[LIMINAL] Circuit ${event.circuitState}: ${event.reason}`);
+  });
+  const handler = createRequestHandler(pipeline, resolvedConfig, logger);
+  const server = new ProxyServer(config.port, handler);
+  setupSignalHandlers(server, logger);
+  try {
+    const actualPort = await server.start();
+    writePidFile(process.pid);
+    logger.log(`[DAEMON] Liminal proxy started on http://127.0.0.1:${actualPort}`);
+    logger.log(`[DAEMON] Upstream (OpenAI): ${config.upstreamBaseUrl}`);
+    logger.log(`[DAEMON] Upstream (Anthropic): ${config.anthropicUpstreamUrl}`);
+    logger.log(`[DAEMON] Liminal API: ${config.apiBaseUrl}`);
+    logger.log(`[DAEMON] PID: ${process.pid}`);
+    if (isForeground && !isForked) {
+      printBanner();
+      console.log(`  Liminal proxy running on http://127.0.0.1:${actualPort}/v1`);
+      console.log(`  Upstream: ${config.upstreamBaseUrl}`);
+      console.log();
+      console.log("  Point your AI tool's base URL here. Press Ctrl+C to stop.");
+      console.log();
+    }
+    const healthy = await pipeline.healthCheck();
+    if (healthy) {
+      logger.log("[DAEMON] Liminal API health check: OK");
+    } else {
+      logger.log("[DAEMON] Liminal API health check: FAILED (will retry on first request)");
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to start proxy: ${message}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/stop.ts
+async function stopCommand() {
+  const state = isDaemonRunning();
+  if (!state.running || !state.pid) {
+    console.log("Liminal daemon is not running.");
+    return;
+  }
+  const pid = state.pid;
+  console.log(`Stopping Liminal daemon (PID ${pid})...`);
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    removePidFile();
+    console.log("Liminal daemon stopped.");
+    return;
+  }
+  for (let i = 0; i < 25; i++) {
+    await sleep(200);
+    if (!isProcessAlive(pid)) {
+      removePidFile();
+      console.log(`Liminal daemon stopped (PID ${pid}).`);
+      return;
+    }
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+  removePidFile();
+  console.log(`Liminal daemon force-killed (PID ${pid}).`);
+}
+
+// src/commands/status.ts
+async function statusCommand() {
+  if (!isConfigured()) {
+    console.log("Liminal: not configured");
+    console.log('Run "liminal init" to set up.');
+    return;
+  }
+  const state = isDaemonRunning();
+  if (!state.running || !state.pid) {
+    console.log("Liminal Daemon: stopped");
+    console.log('Run "liminal start" to start the proxy.');
+    return;
+  }
+  const config = loadConfig();
+  const port = config.port;
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/health`, {
+      signal: AbortSignal.timeout(3e3)
+    });
+    const data = await res.json();
+    const uptime = formatUptime(data.uptime_ms);
+    console.log(`Liminal Daemon: running (PID ${state.pid}, port ${port})`);
+    console.log(`Circuit:    ${data.circuit_state}`);
+    console.log(`Session:    ${data.session_id}`);
+    console.log(`Uptime:     ${uptime}`);
+    if (data.session) {
+      const s = data.session;
+      const savingsPercent = s.tokens_processed > 0 ? (s.tokens_saved / s.tokens_processed * 100).toFixed(1) : "0.0";
+      console.log();
+      console.log(`Tokens:     ${s.tokens_processed.toLocaleString()} processed, ${s.tokens_saved.toLocaleString()} saved (${savingsPercent}%)`);
+      console.log(`Calls:      ${s.calls_total} total (${s.calls_compressed} compressed, ${s.calls_skipped} skipped, ${s.calls_failed} failed)`);
+    }
+  } catch {
+    console.log(`Liminal Daemon: running (PID ${state.pid}, port ${port})`);
+    console.log("Circuit:    unknown (could not reach /health)");
+  }
+}
+function formatUptime(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ${hours % 24}h ${minutes % 60}m`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
+}
+
+// src/commands/summary.ts
+async function summaryCommand() {
+  if (!isConfigured()) {
+    console.log('Liminal is not configured. Run "liminal init" first.');
+    return;
+  }
+  const state = isDaemonRunning();
+  if (!state.running || !state.pid) {
+    console.log('Liminal daemon is not running. Start it with "liminal start".');
+    return;
+  }
+  const config = loadConfig();
+  const port = config.port;
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/health`, {
+      signal: AbortSignal.timeout(3e3)
+    });
+    const data = await res.json();
+    const uptime = formatUptime2(data.uptime_ms);
+    console.log();
+    console.log(`  Session: ${data.session_id}`);
+    console.log(`  Uptime:  ${uptime}`);
+    console.log();
+    if (data.session) {
+      const s = data.session;
+      const savingsPercent = s.tokens_processed > 0 ? (s.tokens_saved / s.tokens_processed * 100).toFixed(1) : "0.0";
+      const compressionRate = s.calls_total > 0 ? (s.calls_compressed / s.calls_total * 100).toFixed(0) : "0";
+      console.log("  Compression:");
+      console.log(`    Tokens processed:  ${s.tokens_processed.toLocaleString()}`);
+      console.log(`    Tokens saved:      ${s.tokens_saved.toLocaleString()} (${savingsPercent}%)`);
+      console.log(`    Compression rate:  ${compressionRate}% of calls compressed`);
+      console.log(`    Patterns learned:  ${s.patterns_learned.toLocaleString()}`);
+      console.log();
+      console.log("  Calls:");
+      console.log(`    Total:      ${s.calls_total}`);
+      console.log(`    Compressed: ${s.calls_compressed}`);
+      console.log(`    Skipped:    ${s.calls_skipped}`);
+      console.log(`    Failed:     ${s.calls_failed}`);
+      console.log();
+      console.log("  Cost Savings:");
+      console.log(`    Estimated:  $${s.estimated_cost_saved_usd.toFixed(4)} USD`);
+      console.log();
+    } else {
+      console.log("  No session data available yet.");
+      console.log();
+    }
+    console.log(`  Circuit: ${data.circuit_state}`);
+    console.log(`  API: ${config.apiBaseUrl}`);
+    console.log(`  Upstream: ${config.upstreamBaseUrl}`);
+    console.log();
+  } catch {
+    console.error("Could not reach the Liminal daemon. Is it running?");
+    console.error(`Tried http://127.0.0.1:${port}/health`);
+    process.exit(1);
+  }
+}
+function formatUptime2(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ${hours % 24}h ${minutes % 60}m`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
+}
+
+// src/commands/config.ts
+async function configCommand(flags) {
+  const getKey = flags.get("get");
+  const setKv = flags.get("set");
+  if (typeof getKey === "string") {
+    if (!isConfigured()) {
+      console.error('Liminal is not configured. Run "liminal init" first.');
+      process.exit(1);
+    }
+    const config2 = loadConfig();
+    const value = config2[getKey];
+    if (value === void 0) {
+      console.error(`Unknown config key: ${getKey}`);
+      process.exit(1);
+    }
+    console.log(getKey === "apiKey" ? maskApiKey(String(value)) : String(value));
+    return;
+  }
+  if (typeof setKv === "string") {
+    const eqIdx = setKv.indexOf("=");
+    if (eqIdx === -1) {
+      console.error("Usage: liminal config --set key=value");
+      process.exit(1);
+    }
+    const key = setKv.slice(0, eqIdx);
+    const rawValue = setKv.slice(eqIdx + 1);
+    if (!CONFIGURABLE_KEYS.has(key) && key !== "apiKey") {
+      console.error(`Unknown or non-configurable key: ${key}`);
+      console.error(`Configurable keys: ${[...CONFIGURABLE_KEYS].join(", ")}`);
+      process.exit(1);
+    }
+    let parsedValue = rawValue;
+    if (key === "port" || key === "compressionThreshold" || key === "latencyBudgetMs") {
+      parsedValue = parseInt(rawValue, 10);
+      if (isNaN(parsedValue)) {
+        console.error(`Invalid number for ${key}: ${rawValue}`);
+        process.exit(1);
+      }
+    } else if (key === "learnFromResponses" || key === "enabled") {
+      parsedValue = rawValue === "true" || rawValue === "1";
+    } else if (key === "compressRoles") {
+      parsedValue = rawValue.split(",").map((s) => s.trim());
+    }
+    saveConfig({ [key]: parsedValue });
+    console.log(`Set ${key} = ${key === "apiKey" ? maskApiKey(rawValue) : rawValue}`);
+    return;
+  }
+  if (!isConfigured()) {
+    console.log(`Liminal is not configured. Run "liminal init" first.`);
+    console.log(`Config file: ${CONFIG_FILE}`);
+    return;
+  }
+  const config = loadConfig();
+  console.log();
+  console.log(`  Config: ${CONFIG_FILE}`);
+  console.log();
+  console.log(`  apiKey:                ${maskApiKey(config.apiKey)}`);
+  console.log(`  apiBaseUrl:            ${config.apiBaseUrl}`);
+  console.log(`  upstreamBaseUrl:       ${config.upstreamBaseUrl}`);
+  console.log(`  anthropicUpstreamUrl:  ${config.anthropicUpstreamUrl}`);
+  console.log(`  tools:                 ${config.tools.length > 0 ? config.tools.join(", ") : "(none)"}`);
+  console.log(`  port:                  ${config.port}`);
+  console.log(`  compressionThreshold:  ${config.compressionThreshold}`);
+  console.log(`  compressRoles:         ${config.compressRoles.join(", ")}`);
+  console.log(`  learnFromResponses:    ${config.learnFromResponses}`);
+  console.log(`  latencyBudgetMs:       ${config.latencyBudgetMs || "auto"}`);
+  console.log(`  enabled:               ${config.enabled}`);
+  console.log();
+}
+
+// src/commands/logs.ts
+import { readFileSync as readFileSync3, existsSync as existsSync4, statSync as statSync2, createReadStream } from "fs";
+import { watchFile, unwatchFile } from "fs";
+async function logsCommand(flags) {
+  const follow = flags.has("follow") || flags.has("f");
+  const linesFlag = flags.get("lines") ?? flags.get("n");
+  const lines = typeof linesFlag === "string" ? parseInt(linesFlag, 10) : 50;
+  if (!existsSync4(LOG_FILE)) {
+    console.log('No log file found. Start the daemon with "liminal start" to generate logs.');
+    return;
+  }
+  const content = readFileSync3(LOG_FILE, "utf-8");
+  const allLines = content.split("\n");
+  const tail = allLines.slice(-lines - 1);
+  process.stdout.write(tail.join("\n"));
+  if (!follow) return;
+  let lastSize = statSync2(LOG_FILE).size;
+  watchFile(LOG_FILE, { interval: 500 }, (curr) => {
+    if (curr.size > lastSize) {
+      const stream = createReadStream(LOG_FILE, { start: lastSize, encoding: "utf-8" });
+      stream.on("data", (chunk) => process.stdout.write(chunk));
+      stream.on("end", () => {
+        lastSize = curr.size;
+      });
+    } else if (curr.size < lastSize) {
+      lastSize = 0;
+    }
+  });
+  process.on("SIGINT", () => {
+    unwatchFile(LOG_FILE);
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+
+// src/bin.ts
+var USAGE = `
+  liminal v${VERSION} \u2014 Transparent LLM context compression proxy
+
+  Usage:
+    liminal init                          Set up Liminal (API key, config)
+    liminal start [-d] [--port PORT]      Start the compression proxy
+    liminal stop                          Stop the running proxy
+    liminal status                        Show proxy health and stats
+    liminal summary                       Detailed session metrics
+    liminal config [--set k=v] [--get k]  View or edit configuration
+    liminal logs [--follow] [--lines N]   View proxy logs
+
+  Options:
+    -h, --help       Show this help message
+    -v, --version    Show version number
+
+  Getting started:
+    1. liminal init                          # Enter your API key + select tools
+    2. liminal start                         # Start the proxy
+    3. Connect your AI tools:
+       Claude Code:   export ANTHROPIC_BASE_URL=http://localhost:3141
+       Codex:         export OPENAI_BASE_URL=http://localhost:3141/v1
+       Cursor:        Settings > Models > Base URL > http://localhost:3141/v1
+`;
+function parseArgs(argv) {
+  const command = argv[2] ?? "";
+  const flags = /* @__PURE__ */ new Map();
+  for (let i = 3; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+        flags.set(key, argv[i + 1]);
+        i++;
+      } else {
+        flags.set(key, true);
+      }
+    } else if (arg.startsWith("-") && arg.length === 2) {
+      const key = arg.slice(1);
+      if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+        flags.set(key, argv[i + 1]);
+        i++;
+      } else {
+        flags.set(key, true);
+      }
+    }
+  }
+  return { command, flags };
+}
+async function main() {
+  const { command, flags } = parseArgs(process.argv);
+  if (flags.has("h") || flags.has("help") || command === "help" || command === "--help" || command === "-h") {
+    console.log(USAGE);
+    process.exit(0);
+  }
+  if (flags.has("v") || flags.has("version") || command === "version" || command === "--version" || command === "-v") {
+    console.log(VERSION);
+    process.exit(0);
+  }
+  try {
+    switch (command) {
+      case "init":
+        await initCommand();
+        break;
+      case "start":
+        await startCommand(flags);
+        break;
+      case "stop":
+        await stopCommand();
+        break;
+      case "status":
+        await statusCommand();
+        break;
+      case "summary":
+        await summaryCommand();
+        break;
+      case "config":
+        await configCommand(flags);
+        break;
+      case "logs":
+        await logsCommand(flags);
+        break;
+      case "":
+        console.log(USAGE);
+        process.exit(0);
+        break;
+      default:
+        console.error(`Unknown command: ${command}`);
+        console.log(USAGE);
+        process.exit(1);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=bin.js.map