@cognisos/liminal 2.3.0 → 2.4.0

package/dist/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/version.ts
-var VERSION = true ? "2.3.0" : "0.2.1";
+var VERSION = true ? "2.4.0" : "0.2.1";
 var BANNER_LINES = [
   " ___       ___  _____ ______   ___  ________   ________  ___",
   "|\\  \\     |\\  \\|\\   _ \\  _   \\|\\  \\|\\   ___  \\|\\   __  \\|\\  \\",
@@ -21,15 +21,8 @@ function printBanner() {
   console.log();
 }
 
-// src/commands/init.ts
-import { createInterface as createInterface2 } from "readline/promises";
-import { stdin as stdin2, stdout as stdout2 } from "process";
-import { existsSync as existsSync2, readFileSync as readFileSync2, appendFileSync } from "fs";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
-
 // src/config/loader.ts
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from "fs";
 import { dirname } from "path";
 
 // src/config/paths.ts
@@ -43,7 +36,7 @@ var LOG_FILE = join(LOG_DIR, "liminal.log");
 
 // src/config/schema.ts
 var DEFAULTS = {
-  apiBaseUrl: "https://rsc-platform-production.up.railway.app",
+  apiBaseUrl: "https://api.cognisos.ai",
   upstreamBaseUrl: "https://api.openai.com",
   anthropicUpstreamUrl: "https://api.anthropic.com",
   port: 3141,
@@ -111,11 +104,15 @@ function saveConfig(config) {
     }
   }
   const merged = { ...existing, ...config };
-  writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  try {
+    chmodSync(CONFIG_FILE, 384);
+  } catch {
+  }
 }
 function ensureDirectories() {
-  if (!existsSync(LIMINAL_DIR)) mkdirSync(LIMINAL_DIR, { recursive: true });
-  if (!existsSync(LOG_DIR)) mkdirSync(LOG_DIR, { recursive: true });
+  if (!existsSync(LIMINAL_DIR)) mkdirSync(LIMINAL_DIR, { recursive: true, mode: 448 });
+  if (!existsSync(LOG_DIR)) mkdirSync(LOG_DIR, { recursive: true, mode: 448 });
   const configDir = dirname(CONFIG_FILE);
   if (!existsSync(configDir)) mkdirSync(configDir, { recursive: true });
 }
@@ -132,6 +129,99 @@ function maskApiKey(key) {
   return key.slice(0, 8) + "..." + key.slice(-4);
 }
 
+// src/config/shell.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, appendFileSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var LIMINAL_BLOCK_HEADER = "# Liminal \u2014 route AI tools through compression proxy";
+function detectShellProfile() {
+  const shell = process.env.SHELL || "";
+  const home = homedir2();
+  if (shell.endsWith("/zsh")) {
+    return { name: "~/.zshrc", path: join2(home, ".zshrc") };
+  }
+  if (shell.endsWith("/bash")) {
+    const bashProfile = join2(home, ".bash_profile");
+    if (existsSync2(bashProfile)) {
+      return { name: "~/.bash_profile", path: bashProfile };
+    }
+    return { name: "~/.bashrc", path: join2(home, ".bashrc") };
+  }
+  const candidates = [
+    { name: "~/.zshrc", path: join2(home, ".zshrc") },
+    { name: "~/.bashrc", path: join2(home, ".bashrc") },
+    { name: "~/.profile", path: join2(home, ".profile") }
+  ];
+  for (const c of candidates) {
+    if (existsSync2(c.path)) return c;
+  }
+  return null;
+}
+function lineExistsInFile(filePath, line) {
+  if (!existsSync2(filePath)) return false;
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    return content.includes(line);
+  } catch {
+    return false;
+  }
+}
+function appendToShellProfile(profile, lines) {
+  const newLines = lines.filter((line) => !lineExistsInFile(profile.path, line));
+  if (newLines.length === 0) return [];
+  const block = [
+    "",
+    LIMINAL_BLOCK_HEADER,
+    ...newLines
+  ].join("\n") + "\n";
+  appendFileSync(profile.path, block, "utf-8");
+  return newLines;
+}
+function removeLiminalFromShellProfile(profile) {
+  if (!existsSync2(profile.path)) return [];
+  let content;
+  try {
+    content = readFileSync2(profile.path, "utf-8");
+  } catch {
+    return [];
+  }
+  const lines = content.split("\n");
+  const removed = [];
+  const kept = [];
+  for (const line of lines) {
+    if (line.trim() === LIMINAL_BLOCK_HEADER) {
+      removed.push(line);
+      continue;
+    }
+    if (isLiminalExportLine(line)) {
+      removed.push(line);
+      continue;
+    }
+    kept.push(line);
+  }
+  if (removed.length > 0) {
+    const cleaned = kept.join("\n").replace(/\n{3,}/g, "\n\n");
+    writeFileSync2(profile.path, cleaned, "utf-8");
+  }
+  return removed;
+}
+function isLiminalExportLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("export ")) return false;
+  if (trimmed.includes("ANTHROPIC_BASE_URL=http://127.0.0.1:")) return true;
+  if (trimmed.includes("OPENAI_BASE_URL=http://127.0.0.1:")) return true;
+  return false;
+}
+function findLiminalExportsInProfile(profile) {
+  if (!existsSync2(profile.path)) return [];
+  try {
+    const content = readFileSync2(profile.path, "utf-8");
+    return content.split("\n").filter(isLiminalExportLine);
+  } catch {
+    return [];
+  }
+}
+
 // src/ui/prompts.ts
 var ANSI = {
   HIDE_CURSOR: "\x1B[?25l",
@@ -190,23 +280,23 @@ function renderMultiSelect(options, cursorIndex, selected, message) {
     lines.push(`  ${pointer} ${box} ${label}${desc}`);
   }
   lines.push("");
-  lines.push(`  ${ANSI.DIM}Space to toggle, Enter to confirm${ANSI.RESET}`);
+  lines.push(`  ${ANSI.DIM}\u2191/\u2193 Navigate  ${ANSI.RESET}${ANSI.CYAN}Space${ANSI.RESET}${ANSI.DIM} Select  ${ANSI.RESET}${ANSI.CYAN}Enter${ANSI.RESET}${ANSI.DIM} Confirm${ANSI.RESET}`);
   lines.push("");
   return { text: lines.join("\n"), lineCount: lines.length };
 }
 function withRawMode(streams, handler) {
-  const { stdin: stdin3, stdout: stdout3 } = streams;
+  const { stdin: stdin2, stdout: stdout2 } = streams;
   return new Promise((resolve, reject) => {
     let cleaned = false;
     function cleanup() {
       if (cleaned) return;
       cleaned = true;
-      stdin3.removeListener("data", onData);
-      if (stdin3.setRawMode) stdin3.setRawMode(false);
-      if ("pause" in stdin3 && typeof stdin3.pause === "function") {
-        stdin3.pause();
+      stdin2.removeListener("data", onData);
+      if (stdin2.setRawMode) stdin2.setRawMode(false);
+      if ("pause" in stdin2 && typeof stdin2.pause === "function") {
+        stdin2.pause();
       }
-      stdout3.write(ANSI.SHOW_CURSOR);
+      stdout2.write(ANSI.SHOW_CURSOR);
       process.removeListener("exit", cleanup);
     }
     function onData(data) {
@@ -223,11 +313,11 @@ function withRawMode(streams, handler) {
     });
     process.on("exit", cleanup);
     try {
-      if (stdin3.setRawMode) stdin3.setRawMode(true);
-      stdout3.write(ANSI.HIDE_CURSOR);
-      stdin3.on("data", onData);
-      if ("resume" in stdin3 && typeof stdin3.resume === "function") {
-        stdin3.resume();
+      if (stdin2.setRawMode) stdin2.setRawMode(true);
+      stdout2.write(ANSI.HIDE_CURSOR);
+      stdin2.on("data", onData);
+      if ("resume" in stdin2 && typeof stdin2.resume === "function") {
+        stdin2.resume();
       }
     } catch (err) {
       cleanup();
@@ -575,59 +665,322 @@ async function runAuthFlow() {
   }
 }
 
-// src/commands/init.ts
-function detectShellProfile() {
-  const shell = process.env.SHELL || "";
-  const home = homedir2();
-  if (shell.endsWith("/zsh")) {
-    const zshrc = join2(home, ".zshrc");
-    return { name: "~/.zshrc", path: zshrc };
+// src/connectors/claude-code.ts
+import { execSync } from "child_process";
+var ENV_VAR = "ANTHROPIC_BASE_URL";
+var INFO = {
+  id: "claude-code",
+  label: "Claude Code",
+  description: "Anthropic CLI for coding with Claude",
+  protocol: "anthropic-messages",
+  automatable: true
+};
+function isClaudeInstalled() {
+  try {
+    execSync("which claude", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
   }
-  if (shell.endsWith("/bash")) {
-    const bashProfile = join2(home, ".bash_profile");
-    if (existsSync2(bashProfile)) {
-      return { name: "~/.bash_profile", path: bashProfile };
+}
+function getCurrentBaseUrl() {
+  return process.env[ENV_VAR] || void 0;
+}
+var claudeCodeConnector = {
+  info: INFO,
+  async detect() {
+    const installed = isClaudeInstalled();
+    const currentUrl = getCurrentBaseUrl();
+    const configured = currentUrl?.includes("127.0.0.1") ?? false;
+    if (!installed) {
+      return { installed, configured: false, detail: "Claude Code not found in PATH" };
     }
-    return { name: "~/.bashrc", path: join2(home, ".bashrc") };
+    if (configured) {
+      return { installed, configured, detail: `Routing through ${currentUrl}` };
+    }
+    return { installed, configured, detail: "Installed but not routing through Liminal" };
+  },
+  getShellExports(port) {
+    return [`export ${ENV_VAR}=http://127.0.0.1:${port}`];
+  },
+  async setup(port) {
+    const exports = this.getShellExports(port);
+    return {
+      success: true,
+      shellExports: exports,
+      postSetupInstructions: [
+        "Claude Code will automatically route through Liminal.",
+        "Make sure to source your shell profile or restart your terminal."
+      ]
+    };
+  },
+  async teardown() {
+    return {
+      success: true,
+      manualSteps: [
+        `Remove the line \`export ${ENV_VAR}=...\` from your shell profile (~/.zshrc or ~/.bashrc).`,
+        "Restart your terminal or run: unset ANTHROPIC_BASE_URL"
+      ]
+    };
   }
-  const candidates = [
-    { name: "~/.zshrc", path: join2(home, ".zshrc") },
-    { name: "~/.bashrc", path: join2(home, ".bashrc") },
-    { name: "~/.profile", path: join2(home, ".profile") }
-  ];
-  for (const c of candidates) {
-    if (existsSync2(c.path)) return c;
+};
+
+// src/connectors/codex.ts
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+var ENV_VAR2 = "OPENAI_BASE_URL";
+var CODEX_CONFIG_DIR = join3(homedir3(), ".codex");
+var CODEX_CONFIG_FILE = join3(CODEX_CONFIG_DIR, "config.toml");
+var INFO2 = {
+  id: "codex",
+  label: "Codex CLI",
+  description: "OpenAI CLI agent for coding (Responses API)",
+  protocol: "openai-responses",
+  automatable: true
+};
+function isCodexInstalled() {
+  try {
+    execSync2("which codex", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
   }
-  return null;
 }
-function getExportLines(tools, port) {
-  const base = `http://127.0.0.1:${port}`;
-  const lines = [];
-  if (tools.includes("claude-code")) {
-    lines.push(`export ANTHROPIC_BASE_URL=${base}`);
-  }
-  if (tools.includes("codex") || tools.includes("openai-compatible")) {
-    lines.push(`export OPENAI_BASE_URL=${base}/v1`);
-  }
-  return lines;
+function getCurrentBaseUrl2() {
+  return process.env[ENV_VAR2] || void 0;
 }
-function lineExistsInFile(filePath, line) {
-  if (!existsSync2(filePath)) return false;
+function hasCodexConfig() {
+  return existsSync3(CODEX_CONFIG_FILE);
+}
+function codexConfigMentionsLiminal() {
+  if (!hasCodexConfig()) return false;
   try {
-    const content = readFileSync2(filePath, "utf-8");
-    return content.includes(line);
+    const content = readFileSync3(CODEX_CONFIG_FILE, "utf-8");
+    return content.includes("127.0.0.1") || content.includes("liminal");
   } catch {
     return false;
   }
 }
-function appendToShellProfile(profile, lines) {
-  const block = [
-    "",
-    "# Liminal \u2014 route AI tools through compression proxy",
-    ...lines
-  ].join("\n") + "\n";
-  appendFileSync(profile.path, block, "utf-8");
+var codexConnector = {
+  info: INFO2,
+  async detect() {
+    const installed = isCodexInstalled();
+    const currentUrl = getCurrentBaseUrl2();
+    const envConfigured = currentUrl?.includes("127.0.0.1") ?? false;
+    const tomlConfigured = codexConfigMentionsLiminal();
+    const configured = envConfigured || tomlConfigured;
+    if (!installed) {
+      return { installed, configured: false, detail: "Codex CLI not found in PATH" };
+    }
+    if (configured) {
+      const via = envConfigured ? ENV_VAR2 : "config.toml";
+      return { installed, configured, detail: `Routing through Liminal (via ${via})` };
+    }
+    return { installed, configured, detail: "Installed but not routing through Liminal" };
+  },
+  getShellExports(port) {
+    return [`export ${ENV_VAR2}=http://127.0.0.1:${port}/v1`];
+  },
+  async setup(port) {
+    const exports = this.getShellExports(port);
+    const instructions = [
+      "Codex CLI will automatically route through Liminal.",
+      "Make sure to source your shell profile or restart your terminal."
+    ];
+    instructions.push(
+      "Codex uses the OpenAI Responses API (/v1/responses) by default."
+    );
+    return {
+      success: true,
+      shellExports: exports,
+      postSetupInstructions: instructions
+    };
+  },
+  async teardown() {
+    const steps = [
+      `Remove the line \`export ${ENV_VAR2}=...\` from your shell profile (~/.zshrc or ~/.bashrc).`,
+      "Restart your terminal or run: unset OPENAI_BASE_URL"
+    ];
+    if (codexConfigMentionsLiminal()) {
+      steps.push(
+        `Remove the Liminal provider block from ${CODEX_CONFIG_FILE}.`
+      );
+    }
+    return { success: true, manualSteps: steps };
+  }
+};
+
+// src/connectors/cursor.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+var INFO3 = {
+  id: "cursor",
+  label: "Cursor",
+  description: "AI-first code editor (GUI config required)",
+  protocol: "openai-chat",
+  automatable: false
+};
+function getCursorPaths() {
+  const platform = process.platform;
+  const home = homedir4();
+  if (platform === "darwin") {
+    return {
+      app: "/Applications/Cursor.app",
+      data: join4(home, "Library", "Application Support", "Cursor")
+    };
+  }
+  if (platform === "win32") {
+    const appData = process.env.APPDATA || join4(home, "AppData", "Roaming");
+    const localAppData = process.env.LOCALAPPDATA || join4(home, "AppData", "Local");
+    return {
+      app: join4(localAppData, "Programs", "Cursor", "Cursor.exe"),
+      data: join4(appData, "Cursor")
+    };
+  }
+  return {
+    app: "/usr/bin/cursor",
+    data: join4(home, ".config", "Cursor")
+  };
+}
+function isCursorInstalled() {
+  const { app, data } = getCursorPaths();
+  return existsSync4(app) || existsSync4(data);
+}
+function getSettingsDbPath() {
+  const { data } = getCursorPaths();
+  return join4(data, "User", "globalStorage", "state.vscdb");
+}
+var cursorConnector = {
+  info: INFO3,
+  async detect() {
+    const installed = isCursorInstalled();
+    const dbExists = existsSync4(getSettingsDbPath());
+    if (!installed) {
+      return { installed, configured: false, detail: "Cursor not found on this system" };
+    }
+    return {
+      installed,
+      configured: false,
+      detail: dbExists ? "Installed \u2014 configuration requires Cursor Settings GUI" : "Installed but settings database not found"
+    };
+  },
+  getShellExports(_port) {
+    return [];
+  },
+  async setup(port) {
+    const baseUrl = `http://127.0.0.1:${port}/v1`;
+    return {
+      success: true,
+      shellExports: [],
+      // No env vars — GUI only
+      postSetupInstructions: [
+        "Cursor requires manual configuration:",
+        "",
+        "  1. Open Cursor Settings (not VS Code settings)",
+        "  2. Go to Models",
+        '  3. Enable "Override OpenAI Base URL (when using key)"',
+        `  4. Set the base URL to: ${baseUrl}`,
+        '  5. Enter any string as the API key (e.g., "liminal")',
+        "  6. Restart Cursor",
+        "",
+        "Cursor uses OpenAI format for all models, including Claude.",
+        "Both Chat Completions and Agent mode (Responses API) are supported."
+      ]
+    };
+  },
+  async teardown() {
+    return {
+      success: true,
+      manualSteps: [
+        "In Cursor Settings > Models:",
+        '  1. Disable "Override OpenAI Base URL (when using key)"',
+        "  2. Clear the base URL field",
+        "  3. Restart Cursor"
+      ]
+    };
+  }
+};
+
+// src/connectors/openai-compatible.ts
+var ENV_VAR3 = "OPENAI_BASE_URL";
+var INFO4 = {
+  id: "openai-compatible",
+  label: "Other / OpenAI-compatible",
+  description: "Any tool that reads OPENAI_BASE_URL",
+  protocol: "openai-chat",
+  automatable: true
+};
+function getCurrentBaseUrl3() {
+  return process.env[ENV_VAR3] || void 0;
+}
+var openaiCompatibleConnector = {
+  info: INFO4,
+  async detect() {
+    const currentUrl = getCurrentBaseUrl3();
+    const configured = currentUrl?.includes("127.0.0.1") ?? false;
+    return {
+      installed: true,
+      // Generic — always "available"
+      configured,
+      detail: configured ? `OPENAI_BASE_URL \u2192 ${currentUrl}` : "OPENAI_BASE_URL not set to Liminal"
+    };
+  },
+  getShellExports(port) {
+    return [`export ${ENV_VAR3}=http://127.0.0.1:${port}/v1`];
+  },
+  async setup(port) {
+    const exports = this.getShellExports(port);
+    return {
+      success: true,
+      shellExports: exports,
+      postSetupInstructions: [
+        "Any tool that reads OPENAI_BASE_URL will route through Liminal.",
+        "Make sure to source your shell profile or restart your terminal.",
+        "",
+        "If your tool uses a different env var (e.g., OPENAI_API_BASE),",
+        `set it to: http://127.0.0.1:${port}/v1`
+      ]
+    };
+  },
+  async teardown() {
+    return {
+      success: true,
+      manualSteps: [
+        `Remove the line \`export ${ENV_VAR3}=...\` from your shell profile (~/.zshrc or ~/.bashrc).`,
+        "Restart your terminal or run: unset OPENAI_BASE_URL"
+      ]
+    };
+  }
+};
+
+// src/connectors/index.ts
+var CONNECTORS = [
+  claudeCodeConnector,
+  codexConnector,
+  cursorConnector,
+  openaiCompatibleConnector
+];
+function getConnector(id) {
+  const connector = CONNECTORS.find((c) => c.info.id === id);
+  if (!connector) {
+    throw new Error(`Unknown connector: ${id}`);
+  }
+  return connector;
+}
+function getConnectors(ids) {
+  return ids.map(getConnector);
 }
+
+// src/commands/init.ts
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var CYAN = "\x1B[36m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var RESET = "\x1B[0m";
 async function initCommand() {
   printBanner();
   console.log("  Welcome to Liminal -- Your Transparency & Context Partner");
@@ -636,29 +989,38 @@ async function initCommand() {
   console.log();
   const apiKey = await runAuthFlow();
   console.log();
-  const rl = createInterface2({ input: stdin2, output: stdout2 });
-  let port;
-  try {
-    const portInput = await rl.question(`  Proxy port [${DEFAULTS.port}]: `);
-    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);
-    }
-  } finally {
-    rl.close();
+  const port = DEFAULTS.port;
+  console.log(`  ${BOLD}Detecting installed tools...${RESET}`);
+  console.log();
+  const detectionResults = await Promise.all(
+    CONNECTORS.map(async (c) => {
+      const status = await c.detect();
+      return { connector: c, status };
+    })
+  );
+  for (const { connector, status } of detectionResults) {
+    const icon = status.installed ? `${GREEN}\u2713${RESET}` : `${DIM}\xB7${RESET}`;
+    console.log(`    ${icon} ${connector.info.label}  ${DIM}${status.detail}${RESET}`);
   }
   console.log();
+  const toolOptions = CONNECTORS.map((c) => {
+    const detected = detectionResults.find((r) => r.connector.info.id === c.info.id);
+    const installed = detected?.status.installed ?? false;
+    let description = c.info.description;
+    if (!installed) description += ` ${DIM}(not detected)${RESET}`;
+    if (!c.info.automatable) description += ` ${DIM}(manual setup)${RESET}`;
+    return {
+      label: c.info.label,
+      value: c.info.id,
+      description,
+      default: c.info.id === "claude-code" && installed
+    };
+  });
   const toolsResult = await multiSelectPrompt({
     message: "Which AI tools will you use with Liminal?",
-    options: [
-      { label: "Claude Code", value: "claude-code", default: true },
-      { label: "Codex", value: "codex" },
-      { label: "Cursor", value: "cursor" },
-      { label: "Other / OpenAI", value: "openai-compatible" }
-    ]
+    options: toolOptions
   });
-  const tools = toolsResult ?? ["claude-code"];
+  const selectedIds = toolsResult ?? ["claude-code"];
   console.log();
   const learnResult = await selectPrompt({
     message: "Learn from LLM responses?",
@@ -670,78 +1032,100 @@ async function initCommand() {
   });
   const learnFromResponses = learnResult ?? true;
   console.log();
-  const apiBaseUrl = DEFAULTS.apiBaseUrl;
   ensureDirectories();
   saveConfig({
     apiKey,
-    apiBaseUrl,
+    apiBaseUrl: DEFAULTS.apiBaseUrl,
     upstreamBaseUrl: DEFAULTS.upstreamBaseUrl,
     anthropicUpstreamUrl: DEFAULTS.anthropicUpstreamUrl,
     port,
     learnFromResponses,
-    tools,
+    tools: selectedIds,
     compressionThreshold: DEFAULTS.compressionThreshold,
     compressRoles: DEFAULTS.compressRoles,
     latencyBudgetMs: DEFAULTS.latencyBudgetMs,
     enabled: DEFAULTS.enabled
   });
+  console.log(`  ${GREEN}\u2713${RESET} Configuration saved to ${DIM}${CONFIG_FILE}${RESET}`);
   console.log();
-  console.log(`  Configuration saved to ${CONFIG_FILE}`);
-  console.log();
-  const exportLines = getExportLines(tools, port);
-  const hasCursor = tools.includes("cursor");
-  if (exportLines.length > 0) {
-    const profile = detectShellProfile();
-    if (profile) {
-      const allExist = exportLines.every((line) => lineExistsInFile(profile.path, line));
-      if (allExist) {
-        console.log(`  Shell already configured in ${profile.name}`);
+  const connectors = getConnectors(selectedIds);
+  const allShellExports = [];
+  const profile = detectShellProfile();
+  console.log(`  ${BOLD}Configuring ${connectors.length} tool${connectors.length > 1 ? "s" : ""}...${RESET}`);
+  for (const connector of connectors) {
+    const result = await connector.setup(port);
+    const protocol = connector.info.protocol === "anthropic-messages" ? "Anthropic Messages API" : connector.info.protocol === "openai-responses" ? "Responses API" : "Chat Completions API";
+    console.log();
+    console.log(`  ${CYAN}\u2500\u2500 ${connector.info.label} ${RESET}${DIM}(${protocol})${RESET}`);
+    if (connector.info.automatable && result.shellExports.length > 0) {
+      for (const line of result.shellExports) {
+        console.log(`     ${GREEN}\u2713${RESET} ${line}`);
+      }
+      allShellExports.push(...result.shellExports);
+    }
+    for (const line of result.postSetupInstructions) {
+      if (line === "") {
+        console.log();
       } else {
-        const autoResult = await selectPrompt({
-          message: "Configure shell automatically?",
-          options: [
-            { label: "Yes", value: true, description: `Add to ${profile.name}` },
-            { label: "No", value: false, description: "I'll set it up manually" }
-          ],
-          defaultIndex: 0
-        });
-        if (autoResult === true) {
-          const newLines = exportLines.filter((line) => !lineExistsInFile(profile.path, line));
-          if (newLines.length > 0) {
-            appendToShellProfile(profile, newLines);
-          }
-          console.log();
-          console.log(`  Added to ${profile.name}:`);
-          for (const line of exportLines) {
-            console.log(`    ${line}`);
-          }
-          console.log();
-          console.log(`  Run \x1B[1msource ${profile.name}\x1B[0m or restart your terminal to apply.`);
+        if (line.includes("source your shell profile") || line.includes("restart your terminal")) continue;
+        if (line.includes("will automatically route through Liminal")) {
+          console.log(`     ${DIM}${line}${RESET}`);
+        } else if (line.startsWith("  ")) {
+          console.log(`   ${line}`);
         } else {
-          console.log();
-          console.log("  Add these to your shell profile:");
-          console.log();
-          for (const line of exportLines) {
-            console.log(`    ${line}`);
-          }
+          console.log(`     ${line}`);
         }
       }
+    }
+    if (!connector.info.automatable) {
+      console.log(`     ${YELLOW}\u26A0 Requires manual configuration (see steps above)${RESET}`);
+    }
+  }
+  const uniqueExports = [...new Set(allShellExports)];
+  if (uniqueExports.length > 0 && profile) {
+    const allExist = uniqueExports.every((line) => lineExistsInFile(profile.path, line));
+    console.log();
+    if (allExist) {
+      console.log(`  ${GREEN}\u2713${RESET} Shell already configured in ${profile.name}`);
     } else {
-      console.log("  Add these to your shell profile:");
-      console.log();
-      for (const line of exportLines) {
-        console.log(`    ${line}`);
+      const autoResult = await selectPrompt({
+        message: `Add proxy exports to ${profile.name}?`,
+        options: [
+          { label: "Yes", value: true, description: "Automatic shell configuration" },
+          { label: "No", value: false, description: "I'll set it up manually" }
+        ],
+        defaultIndex: 0
+      });
+      if (autoResult === true) {
+        const added = appendToShellProfile(profile, uniqueExports);
+        if (added.length > 0) {
+          console.log();
+          console.log(`  ${GREEN}\u2713${RESET} Added to ${profile.name}`);
+          console.log();
+          console.log(`  Run ${BOLD}source ${profile.name}${RESET} or restart your terminal.`);
+        }
+      } else {
+        console.log();
+        console.log("  Add these to your shell profile:");
+        console.log();
+        for (const line of uniqueExports) {
+          console.log(`    ${CYAN}${line}${RESET}`);
+        }
       }
     }
-  }
-  if (hasCursor) {
+  } else if (uniqueExports.length > 0) {
+    console.log();
+    console.log("  Add these to your shell profile:");
     console.log();
-    console.log("  Cursor setup (manual):");
-    console.log(`    Settings > Models > OpenAI API Base URL: http://127.0.0.1:${port}/v1`);
+    for (const line of uniqueExports) {
+      console.log(`    ${CYAN}${line}${RESET}`);
+    }
   }
   console.log();
+  console.log(`  ${BOLD}Setup complete!${RESET}`);
+  console.log();
   console.log("  Next step:");
-  console.log("    liminal start");
+  console.log(`    ${BOLD}liminal start${RESET}`);
   console.log();
 }
 
@@ -1061,7 +1445,7 @@ function createStreamLearningBuffer(pipeline) {
 }
 
 // src/proxy/streaming.ts
-async function pipeSSEResponse(upstreamResponse, clientRes, onContentDelta, onComplete) {
+async function pipeSSEResponse(upstreamResponse, clientRes, onContentDelta, onComplete, totalTokensSaved = 0) {
   clientRes.writeHead(200, {
     "Content-Type": "text/event-stream",
     "Cache-Control": "no-cache",
@@ -1071,27 +1455,67 @@ async function pipeSSEResponse(upstreamResponse, clientRes, onContentDelta, onCo
   const reader = upstreamResponse.body.getReader();
   const decoder = new TextDecoder();
   let lineBuf = "";
+  const needsAdjustment = totalTokensSaved > 0;
   try {
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
       const chunk = decoder.decode(value, { stream: true });
-      clientRes.write(chunk);
+      if (!needsAdjustment) {
+        clientRes.write(chunk);
+        lineBuf += chunk;
+        const lines2 = lineBuf.split("\n");
+        lineBuf = lines2.pop() || "";
+        for (const line of lines2) {
+          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 {
+            }
+          }
+        }
+        continue;
+      }
       lineBuf += chunk;
       const lines = lineBuf.split("\n");
       lineBuf = lines.pop() || "";
+      let adjusted = false;
+      const outputLines = [];
       for (const line of lines) {
         if (line.startsWith("data: ") && line !== "data: [DONE]") {
           try {
             const json = JSON.parse(line.slice(6));
+            if (json?.usage?.prompt_tokens != null) {
+              json.usage.prompt_tokens += totalTokensSaved;
+              if (json.usage.total_tokens != null) {
+                json.usage.total_tokens += totalTokensSaved;
+              }
+              outputLines.push(`data: ${JSON.stringify(json)}`);
+              adjusted = true;
+            } else {
+              outputLines.push(line);
+            }
             const content = json?.choices?.[0]?.delta?.content;
             if (typeof content === "string") {
               onContentDelta(content);
             }
           } catch {
+            outputLines.push(line);
           }
+        } else {
+          outputLines.push(line);
         }
       }
+      if (adjusted) {
+        const reconstructed = outputLines.join("\n") + "\n";
+        clientRes.write(reconstructed);
+      } else {
+        clientRes.write(chunk);
+      }
     }
   } finally {
     clientRes.end();
@@ -1132,6 +1556,7 @@ async function handleChatCompletions(req, res, body, pipeline, config, logger) {
   }
   let messages = request.messages;
   let anyCompressed = false;
+  let totalTokensSaved = 0;
   if (config.enabled && !pipeline.isCircuitOpen()) {
     try {
       const compressRoles = new Set(config.compressRoles);
@@ -1143,6 +1568,7 @@ async function handleChatCompletions(req, res, body, pipeline, config, logger) {
       );
       messages = result.messages;
       anyCompressed = result.anyCompressed;
+      totalTokensSaved = result.totalTokensSaved;
       if (result.totalTokensSaved > 0) {
         logger.log(`[COMPRESS] Saved ${result.totalTokensSaved} tokens`);
       }
@@ -1185,14 +1611,30 @@ async function handleChatCompletions(req, res, body, pipeline, config, logger) {
         upstreamResponse,
         res,
         (text) => learningBuffer?.append(text),
-        () => learningBuffer?.flush()
+        () => learningBuffer?.flush(),
+        totalTokensSaved
       );
       return;
     }
     const responseBody = await upstreamResponse.text();
+    let finalBody = responseBody;
+    if (totalTokensSaved > 0) {
+      try {
+        const parsed = JSON.parse(responseBody);
+        if (parsed?.usage?.prompt_tokens != null) {
+          parsed.usage.prompt_tokens += totalTokensSaved;
+          if (parsed.usage.total_tokens != null) {
+            parsed.usage.total_tokens += totalTokensSaved;
+          }
+          finalBody = JSON.stringify(parsed);
+          logger.log(`[TOKENS] Adjusted prompt_tokens by +${totalTokensSaved}`);
+        }
+      } catch {
+      }
+    }
     setCORSHeaders(res);
     res.writeHead(200, { "Content-Type": "application/json" });
-    res.end(responseBody);
+    res.end(finalBody);
     if (anyCompressed) {
       try {
         const parsed = JSON.parse(responseBody);
@@ -1218,7 +1660,18 @@ async function handleChatCompletions(req, res, body, pipeline, config, logger) {
 import { RSCCircuitOpenError as RSCCircuitOpenError3 } from "@cognisos/rsc-sdk";
 
 // src/proxy/anthropic-streaming.ts
-async function pipeAnthropicSSEResponse(upstreamResponse, clientRes, onContentDelta, onComplete) {
+function adjustMessageStartLine(dataLine, tokensSaved) {
+  try {
+    const json = JSON.parse(dataLine.slice(6));
+    if (json?.message?.usage?.input_tokens != null) {
+      json.message.usage.input_tokens += tokensSaved;
+      return `data: ${JSON.stringify(json)}`;
+    }
+  } catch {
+  }
+  return null;
+}
+async function pipeAnthropicSSEResponse(upstreamResponse, clientRes, onContentDelta, onComplete, totalTokensSaved = 0) {
   clientRes.writeHead(200, {
     "Content-Type": "text/event-stream",
     "Cache-Control": "no-cache",
@@ -1229,28 +1682,70 @@ async function pipeAnthropicSSEResponse(upstreamResponse, clientRes, onContentDe
   const decoder = new TextDecoder();
   let lineBuf = "";
   let currentEvent = "";
+  let usageAdjusted = false;
+  const needsAdjustment = totalTokensSaved > 0;
   try {
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
       const chunk = decoder.decode(value, { stream: true });
-      clientRes.write(chunk);
+      if (!needsAdjustment || usageAdjusted) {
+        clientRes.write(chunk);
+        lineBuf += chunk;
+        const lines2 = lineBuf.split("\n");
+        lineBuf = lines2.pop() || "";
+        for (const line of lines2) {
+          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 {
+            }
+          }
+        }
+        continue;
+      }
       lineBuf += chunk;
       const lines = lineBuf.split("\n");
       lineBuf = lines.pop() || "";
+      let adjusted = false;
+      const outputLines = [];
       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);
+          outputLines.push(line);
+        } else if (line.startsWith("data: ") && currentEvent === "message_start" && !usageAdjusted) {
+          const adjustedLine = adjustMessageStartLine(line, totalTokensSaved);
+          if (adjustedLine) {
+            outputLines.push(adjustedLine);
+            usageAdjusted = true;
+            adjusted = true;
+          } else {
+            outputLines.push(line);
+          }
+        } else {
+          outputLines.push(line);
+          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 {
             }
-          } catch {
           }
         }
       }
+      if (adjusted) {
+        const reconstructed = outputLines.join("\n") + "\n" + (lineBuf ? "" : "");
+        clientRes.write(reconstructed);
+      } else {
+        clientRes.write(chunk);
+      }
     }
   } finally {
     clientRes.end();
@@ -1310,6 +1805,7 @@ async function handleAnthropicMessages(req, res, body, pipeline, config, logger)
   }
   let messages = request.messages;
   let anyCompressed = false;
+  let totalTokensSaved = 0;
   if (config.enabled && !pipeline.isCircuitOpen()) {
     try {
       const compressRoles = new Set(config.compressRoles);
@@ -1322,6 +1818,7 @@ async function handleAnthropicMessages(req, res, body, pipeline, config, logger)
       );
       messages = convertCompressedToAnthropic(result.messages);
       anyCompressed = result.anyCompressed;
+      totalTokensSaved = result.totalTokensSaved;
       if (result.totalTokensSaved > 0) {
         logger.log(`[COMPRESS] Saved ${result.totalTokensSaved} tokens`);
       }
@@ -1369,14 +1866,27 @@ async function handleAnthropicMessages(req, res, body, pipeline, config, logger)
         upstreamResponse,
         res,
         (text) => learningBuffer?.append(text),
-        () => learningBuffer?.flush()
+        () => learningBuffer?.flush(),
+        totalTokensSaved
       );
       return;
     }
     const responseBody = await upstreamResponse.text();
+    let finalBody = responseBody;
+    if (totalTokensSaved > 0) {
+      try {
+        const parsed = JSON.parse(responseBody);
+        if (parsed?.usage?.input_tokens != null) {
+          parsed.usage.input_tokens += totalTokensSaved;
+          finalBody = JSON.stringify(parsed);
+          logger.log(`[TOKENS] Adjusted input_tokens by +${totalTokensSaved}`);
+        }
+      } catch {
+      }
+    }
     setCORSHeaders2(res);
     res.writeHead(200, { "Content-Type": "application/json" });
-    res.end(responseBody);
+    res.end(finalBody);
     if (anyCompressed) {
       try {
         const parsed = JSON.parse(responseBody);
@@ -1399,58 +1909,426 @@ async function handleAnthropicMessages(req, res, body, pipeline, config, logger)
   }
 }
 
-// src/proxy/handler.ts
+// src/proxy/responses.ts
+import { RSCCircuitOpenError as RSCCircuitOpenError4 } from "@cognisos/rsc-sdk";
+
+// src/proxy/responses-streaming.ts
+async function pipeResponsesSSE(upstreamResponse, clientRes, onContentDelta, onComplete, totalTokensSaved = 0) {
+  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 = "";
+  let usageAdjusted = false;
+  const needsAdjustment = totalTokensSaved > 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = decoder.decode(value, { stream: true });
+      if (!needsAdjustment || usageAdjusted) {
+        clientRes.write(chunk);
+        lineBuf += chunk;
+        const lines2 = lineBuf.split("\n");
+        lineBuf = lines2.pop() || "";
+        for (const line of lines2) {
+          if (line.startsWith("event: ")) {
+            currentEvent = line.slice(7).trim();
+          } else if (line.startsWith("data: ") && currentEvent === "response.output_text.delta") {
+            try {
+              const json = JSON.parse(line.slice(6));
+              if (typeof json?.delta === "string") {
+                onContentDelta(json.delta);
+              }
+            } catch {
+            }
+          }
+        }
+        continue;
+      }
+      lineBuf += chunk;
+      const lines = lineBuf.split("\n");
+      lineBuf = lines.pop() || "";
+      let adjusted = false;
+      const outputLines = [];
+      for (const line of lines) {
+        if (line.startsWith("event: ")) {
+          currentEvent = line.slice(7).trim();
+          outputLines.push(line);
+        } else if (line.startsWith("data: ") && currentEvent === "response.completed" && !usageAdjusted) {
+          try {
+            const json = JSON.parse(line.slice(6));
+            if (json?.response?.usage?.input_tokens != null) {
+              json.response.usage.input_tokens += totalTokensSaved;
+              if (json.response.usage.total_tokens != null) {
+                json.response.usage.total_tokens += totalTokensSaved;
+              }
+              outputLines.push(`data: ${JSON.stringify(json)}`);
+              usageAdjusted = true;
+              adjusted = true;
+            } else {
+              outputLines.push(line);
+            }
+          } catch {
+            outputLines.push(line);
+          }
+        } else {
+          outputLines.push(line);
+          if (line.startsWith("data: ") && currentEvent === "response.output_text.delta") {
+            try {
+              const json = JSON.parse(line.slice(6));
+              if (typeof json?.delta === "string") {
+                onContentDelta(json.delta);
+              }
+            } catch {
+            }
+          }
+        }
+      }
+      if (adjusted) {
+        const reconstructed = outputLines.join("\n") + "\n";
+        clientRes.write(reconstructed);
+      } else {
+        clientRes.write(chunk);
+      }
+    }
+  } finally {
+    clientRes.end();
+    onComplete();
+  }
+}
+
+// src/proxy/responses.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");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
 }
 function sendJSON2(res, status, body) {
   setCORSHeaders3(res);
   res.writeHead(status, { "Content-Type": "application/json" });
   res.end(JSON.stringify(body));
 }
+function extractBearerToken2(req) {
+  const auth = req.headers.authorization;
+  if (!auth || !auth.startsWith("Bearer ")) return null;
+  return auth.slice(7);
+}
+function isMessageItem(item) {
+  return item.type === "message";
+}
+function inputToCompressibleMessages(input) {
+  if (typeof input === "string") {
+    return [{ role: "user", content: input }];
+  }
+  const messages = [];
+  for (const item of input) {
+    if (!isMessageItem(item)) continue;
+    if (typeof item.content === "string") {
+      const role = item.role === "developer" ? "system" : item.role;
+      messages.push({ role, content: item.content });
+    } else if (Array.isArray(item.content)) {
+      const role = item.role === "developer" ? "system" : item.role;
+      const parts = item.content.map((c) => {
+        if (c.type === "input_text") {
+          return { type: "text", text: c.text };
+        }
+        return c;
+      });
+      messages.push({ role, content: parts });
+    }
+  }
+  return messages;
+}
+function applyCompressedToInput(originalInput, compressedMessages) {
+  if (typeof originalInput === "string") {
+    const first = compressedMessages[0];
+    if (first && typeof first.content === "string") {
+      return first.content;
+    }
+    return originalInput;
+  }
+  let msgIdx = 0;
+  const result = [];
+  for (const item of originalInput) {
+    if (!isMessageItem(item)) {
+      result.push(item);
+      continue;
+    }
+    const compressed = compressedMessages[msgIdx];
+    msgIdx++;
+    if (!compressed) {
+      result.push(item);
+      continue;
+    }
+    if (typeof compressed.content === "string") {
+      result.push({
+        ...item,
+        content: compressed.content
+      });
+    } else if (Array.isArray(compressed.content)) {
+      const content = compressed.content.map((part) => {
+        if (part.type === "text" && "text" in part) {
+          return { type: "input_text", text: part.text };
+        }
+        return part;
+      });
+      result.push({
+        ...item,
+        content
+      });
+    } else {
+      result.push(item);
+    }
+  }
+  return result;
+}
+function extractOutputText(output) {
+  const texts = [];
+  for (const item of output) {
+    if (item.type === "message") {
+      const msg = item;
+      for (const block of msg.content) {
+        if (block.type === "output_text" && typeof block.text === "string") {
+          texts.push(block.text);
+        }
+      }
+    }
+  }
+  return texts.join("");
+}
+async function handleResponses(req, res, body, pipeline, config, logger) {
+  const request = body;
+  if (request.input === void 0 || request.input === null) {
+    sendJSON2(res, 400, {
+      error: { message: "input is required", type: "invalid_request_error" }
+    });
+    return;
+  }
+  const llmApiKey = extractBearerToken2(req);
+  if (!llmApiKey) {
+    sendJSON2(res, 401, {
+      error: { message: "Authorization header with Bearer token is required", type: "authentication_error" }
+    });
+    return;
+  }
+  let compressedInput = request.input;
+  let anyCompressed = false;
+  let totalTokensSaved = 0;
+  if (config.enabled && !pipeline.isCircuitOpen()) {
+    try {
+      const compressRoles = new Set(config.compressRoles);
+      const compressible = inputToCompressibleMessages(request.input);
+      if (compressible.length > 0) {
+        const result = await compressMessages(
+          compressible,
+          pipeline.pipeline,
+          pipeline.session,
+          compressRoles
+        );
+        compressedInput = applyCompressedToInput(request.input, result.messages);
+        anyCompressed = result.anyCompressed;
+        totalTokensSaved = result.totalTokensSaved;
+        if (result.totalTokensSaved > 0) {
+          logger.log(`[COMPRESS] Responses API: saved ${result.totalTokensSaved} tokens`);
+        }
+      }
+    } catch (err) {
+      if (err instanceof RSCCircuitOpenError4) {
+        logger.log("[DEGRADE] Circuit breaker open \u2014 passing through directly");
+      } else {
+        logger.log(`[ERROR] Compression failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      compressedInput = request.input;
+    }
+  }
+  const upstreamUrl = `${config.upstreamBaseUrl}/v1/responses`;
+  const upstreamBody = { ...request, input: compressedInput };
+  const upstreamHeaders = {
+    "Authorization": `Bearer ${llmApiKey}`,
+    "Content-Type": "application/json"
+  };
+  if (request.stream) {
+    upstreamHeaders["Accept"] = "text/event-stream";
+  }
+  logger.log(`[RESPONSES] ${request.model} \u2192 ${upstreamUrl}`);
+  try {
+    const upstreamResponse = await fetch(upstreamUrl, {
+      method: "POST",
+      headers: upstreamHeaders,
+      body: JSON.stringify(upstreamBody)
+    });
+    if (!upstreamResponse.ok) {
+      const errorBody = await upstreamResponse.text();
+      logger.log(`[RESPONSES] Upstream error ${upstreamResponse.status}: ${errorBody.slice(0, 500)}`);
+      setCORSHeaders3(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 pipeResponsesSSE(
+        upstreamResponse,
+        res,
+        (text) => learningBuffer?.append(text),
+        () => learningBuffer?.flush(),
+        totalTokensSaved
+      );
+      return;
+    }
+    const responseBody = await upstreamResponse.text();
+    let finalBody = responseBody;
+    if (totalTokensSaved > 0) {
+      try {
+        const parsed = JSON.parse(responseBody);
+        if (parsed?.usage?.input_tokens != null) {
+          parsed.usage.input_tokens += totalTokensSaved;
+          if (parsed.usage.total_tokens != null) {
+            parsed.usage.total_tokens += totalTokensSaved;
+          }
+          finalBody = JSON.stringify(parsed);
+          logger.log(`[TOKENS] Adjusted input_tokens by +${totalTokensSaved}`);
+        }
+      } catch {
+      }
+    }
+    setCORSHeaders3(res);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(finalBody);
+    if (anyCompressed) {
+      try {
+        const parsed = JSON.parse(responseBody);
+        if (parsed?.output) {
+          const text = extractOutputText(parsed.output);
+          if (text.length > 0) {
+            pipeline.pipeline.triggerLearning(text);
+          }
+        }
+      } catch {
+      }
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.log(`[ERROR] Upstream request failed: ${message}`);
+    if (!res.headersSent) {
+      sendJSON2(res, 502, {
+        error: { message: `Failed to reach upstream LLM: ${message}`, type: "server_error" }
+      });
+    }
+  }
+}
+
+// src/proxy/handler.ts
+function setCORSHeaders4(res) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE, PATCH");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, x-api-key, anthropic-version, anthropic-beta, anthropic-dangerous-direct-browser-access");
+  res.setHeader("Access-Control-Max-Age", "86400");
+}
+function sendJSON3(res, status, body) {
+  setCORSHeaders4(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("end", () => resolve(Buffer.concat(chunks)));
     req.on("error", reject);
   });
 }
-async function passthroughAnthropic(req, res, fullUrl, config, logger) {
-  const upstreamUrl = `${config.anthropicUpstreamUrl}${fullUrl}`;
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  const xApiKey = req.headers["x-api-key"];
-  if (typeof xApiKey === "string") headers["x-api-key"] = xApiKey;
-  const auth = req.headers["authorization"];
-  if (typeof auth === "string") headers["Authorization"] = auth;
-  const version = req.headers["anthropic-version"];
-  if (typeof version === "string") headers["anthropic-version"] = version;
-  const beta = req.headers["anthropic-beta"];
-  if (typeof beta === "string") headers["anthropic-beta"] = beta;
+function detectUpstream(req, url) {
+  if (req.headers["x-api-key"]) return "anthropic";
+  if (req.headers["anthropic-version"]) return "anthropic";
+  if (url.startsWith("/v1/messages") || url.startsWith("/messages")) return "anthropic";
+  return "anthropic";
+}
+function getUpstreamBaseUrl(target, config) {
+  return target === "anthropic" ? config.anthropicUpstreamUrl : config.upstreamBaseUrl;
+}
+var HOP_BY_HOP = /* @__PURE__ */ new Set([
+  "host",
+  "connection",
+  "keep-alive",
+  "transfer-encoding",
+  "te",
+  "trailer",
+  "upgrade",
+  "proxy-authorization",
+  "proxy-authenticate"
+]);
+function buildUpstreamHeaders(req) {
+  const headers = {};
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (HOP_BY_HOP.has(key)) continue;
+    if (value === void 0) continue;
+    headers[key] = Array.isArray(value) ? value.join(", ") : value;
+  }
+  return headers;
+}
+async function passthroughToUpstream(req, res, fullUrl, config, logger) {
+  const target = detectUpstream(req, fullUrl);
+  const upstreamBase = getUpstreamBaseUrl(target, config);
+  const upstreamUrl = `${upstreamBase}${fullUrl}`;
+  const method = req.method?.toUpperCase() ?? "GET";
+  logger.log(`[PASSTHROUGH] ${method} ${fullUrl} \u2192 ${target} (${upstreamUrl})`);
+  const headers = buildUpstreamHeaders(req);
   try {
-    const body = await readBody(req);
+    const hasBody = method !== "GET" && method !== "HEAD";
+    const body = hasBody ? await readBody(req) : void 0;
     const upstreamRes = await fetch(upstreamUrl, {
-      method: "POST",
+      method,
       headers,
       body
     });
-    const responseBody = await upstreamRes.text();
-    setCORSHeaders3(res);
-    res.writeHead(upstreamRes.status, {
-      "Content-Type": upstreamRes.headers.get("Content-Type") || "application/json"
-    });
-    res.end(responseBody);
+    const contentType = upstreamRes.headers.get("Content-Type") || "application/json";
+    const isStreaming = contentType.includes("text/event-stream");
+    if (isStreaming && upstreamRes.body) {
+      setCORSHeaders4(res);
+      res.writeHead(upstreamRes.status, {
+        "Content-Type": contentType,
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      });
+      const reader = upstreamRes.body.getReader();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          res.write(value);
+        }
+      } finally {
+        res.end();
+      }
+    } else {
+      const responseBody = await upstreamRes.arrayBuffer();
+      setCORSHeaders4(res);
+      const responseHeaders = { "Content-Type": contentType };
+      const reqId = upstreamRes.headers.get("request-id");
+      if (reqId) responseHeaders["request-id"] = reqId;
+      res.writeHead(upstreamRes.status, responseHeaders);
+      res.end(Buffer.from(responseBody));
+    }
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    logger.log(`[ERROR] Passthrough failed: ${message}`);
-    setCORSHeaders3(res);
-    res.writeHead(502, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ type: "error", error: { type: "api_error", message: `Failed to reach upstream: ${message}` } }));
+    logger.log(`[ERROR] Passthrough to ${target} failed: ${message}`);
+    if (!res.headersSent) {
+      setCORSHeaders4(res);
+      res.writeHead(502, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        type: "error",
+        error: { type: "api_error", message: `Liminal proxy: failed to reach ${target} upstream: ${message}` }
+      }));
+    }
   }
 }
 function createRequestHandler(pipeline, config, logger) {
@@ -1463,14 +2341,14 @@ function createRequestHandler(pipeline, config, logger) {
       const authType = req.headers["x-api-key"] ? "x-api-key" : req.headers["authorization"] ? "bearer" : "none";
       logger.log(`[REQUEST] ${method} ${fullUrl} (auth: ${authType})`);
       if (method === "OPTIONS") {
-        setCORSHeaders3(res);
+        setCORSHeaders4(res);
         res.writeHead(204);
         res.end();
         return;
       }
       if (method === "GET" && (url === "/health" || url === "/")) {
         const summary = pipeline.getSessionSummary();
-        sendJSON2(res, 200, {
+        sendJSON3(res, 200, {
           status: "ok",
           version: config.rscApiKey ? "connected" : "no-api-key",
           rsc_connected: !pipeline.isCircuitOpen(),
@@ -1490,53 +2368,41 @@ function createRequestHandler(pipeline, config, logger) {
         });
         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;
-        }
+      if (method === "POST" && (url === "/v1/chat/completions" || url === "/chat/completions")) {
+        const body = await readBody(req);
+        let parsed;
         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" }
+          parsed = JSON.parse(body.toString("utf-8"));
+        } catch {
+          sendJSON3(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/chat/completions" || url === "/chat/completions")) {
+      if (method === "POST" && (url === "/v1/responses" || url === "/responses")) {
         const body = await readBody(req);
         let parsed;
         try {
-          parsed = JSON.parse(body);
+          parsed = JSON.parse(body.toString("utf-8"));
         } catch {
-          sendJSON2(res, 400, {
+          sendJSON3(res, 400, {
             error: { message: "Invalid JSON body", type: "invalid_request_error" }
           });
           return;
         }
-        await handleChatCompletions(req, res, parsed, pipeline, config, logger);
+        await handleResponses(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);
+          parsed = JSON.parse(body.toString("utf-8"));
         } catch {
-          sendJSON2(res, 400, {
+          sendJSON3(res, 400, {
             type: "error",
             error: { type: "invalid_request_error", message: "Invalid JSON body" }
           });
@@ -1545,18 +2411,12 @@ function createRequestHandler(pipeline, config, logger) {
         await handleAnthropicMessages(req, res, parsed, pipeline, config, logger);
         return;
       }
-      if (method === "POST" && url.startsWith("/v1/messages/")) {
-        await passthroughAnthropic(req, res, fullUrl, config, logger);
-        return;
-      }
-      sendJSON2(res, 404, {
-        error: { message: `Not found: ${method} ${url}`, type: "invalid_request_error" }
-      });
+      await passthroughToUpstream(req, res, fullUrl, config, logger);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       logger.log(`[ERROR] Proxy handler error: ${message}`);
       if (!res.headersSent) {
-        sendJSON2(res, 500, {
+        sendJSON3(res, 500, {
           error: { message: "Internal proxy error", type: "server_error" }
         });
       }
@@ -1623,7 +2483,7 @@ var ProxyServer = class {
 };
 
 // src/daemon/logger.ts
-import { appendFileSync as appendFileSync2, statSync, renameSync, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
+import { appendFileSync as appendFileSync2, statSync, renameSync, mkdirSync as mkdirSync2, existsSync as existsSync5 } from "fs";
 import { dirname as dirname2 } from "path";
 var MAX_LOG_SIZE = 10 * 1024 * 1024;
 var MAX_BACKUPS = 2;
@@ -1634,7 +2494,7 @@ var FileLogger = class {
     this.logFile = options?.logFile ?? LOG_FILE;
     this.mirrorStdout = options?.mirrorStdout ?? false;
     const logDir = dirname2(this.logFile);
-    if (!existsSync3(logDir)) {
+    if (!existsSync5(logDir)) {
       mkdirSync2(logDir, { recursive: true });
     }
   }
@@ -1659,7 +2519,7 @@ var FileLogger = class {
       for (let i = MAX_BACKUPS - 1; i >= 1; i--) {
         const from = `${this.logFile}.${i}`;
         const to = `${this.logFile}.${i + 1}`;
-        if (existsSync3(from)) renameSync(from, to);
+        if (existsSync5(from)) renameSync(from, to);
       }
       renameSync(this.logFile, `${this.logFile}.1`);
     } catch {
@@ -1671,16 +2531,16 @@ var FileLogger = class {
 };
 
 // src/daemon/lifecycle.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, unlinkSync, existsSync as existsSync4 } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, unlinkSync, existsSync as existsSync6 } from "fs";
 import { fork } from "child_process";
 import { fileURLToPath } from "url";
 function writePidFile(pid) {
-  writeFileSync2(PID_FILE, String(pid), "utf-8");
+  writeFileSync3(PID_FILE, String(pid), "utf-8");
 }
 function readPidFile() {
-  if (!existsSync4(PID_FILE)) return null;
+  if (!existsSync6(PID_FILE)) return null;
   try {
-    const content = readFileSync3(PID_FILE, "utf-8").trim();
+    const content = readFileSync4(PID_FILE, "utf-8").trim();
     const pid = parseInt(content, 10);
     return isNaN(pid) ? null : pid;
   } catch {
@@ -1689,7 +2549,7 @@ function readPidFile() {
 }
 function removePidFile() {
   try {
-    if (existsSync4(PID_FILE)) unlinkSync(PID_FILE);
+    if (existsSync6(PID_FILE)) unlinkSync(PID_FILE);
   } catch {
   }
 }
@@ -2070,17 +2930,17 @@ async function configCommand(flags) {
 }
 
 // src/commands/logs.ts
-import { readFileSync as readFileSync4, existsSync as existsSync5, statSync as statSync2, createReadStream } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync7, 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 (!existsSync5(LOG_FILE)) {
+  if (!existsSync7(LOG_FILE)) {
     console.log('No log file found. Start the daemon with "liminal start" to generate logs.');
     return;
   }
-  const content = readFileSync4(LOG_FILE, "utf-8");
+  const content = readFileSync5(LOG_FILE, "utf-8");
   const allLines = content.split("\n");
   const tail = allLines.slice(-lines - 1);
   process.stdout.write(tail.join("\n"));
@@ -2105,6 +2965,135 @@ async function logsCommand(flags) {
   });
 }
 
+// src/commands/uninstall.ts
+import { existsSync as existsSync8, rmSync, readFileSync as readFileSync6 } from "fs";
+var BOLD2 = "\x1B[1m";
+var DIM2 = "\x1B[2m";
+var GREEN2 = "\x1B[32m";
+var YELLOW2 = "\x1B[33m";
+var RESET2 = "\x1B[0m";
+function loadConfiguredTools() {
+  if (!existsSync8(CONFIG_FILE)) return [];
+  try {
+    const raw = readFileSync6(CONFIG_FILE, "utf-8");
+    const config = JSON.parse(raw);
+    if (Array.isArray(config.tools)) return config.tools;
+  } catch {
+  }
+  return [];
+}
+async function uninstallCommand() {
+  console.log();
+  console.log(`  ${BOLD2}Liminal Uninstall${RESET2}`);
+  console.log();
+  const confirm = await selectPrompt({
+    message: "Remove Liminal configuration and restore tool settings?",
+    options: [
+      { label: "Yes", value: true, description: "Undo all Liminal setup" },
+      { label: "No", value: false, description: "Cancel" }
+    ],
+    defaultIndex: 1
+    // Default to No for safety
+  });
+  if (confirm !== true) {
+    console.log();
+    console.log("  Cancelled.");
+    console.log();
+    return;
+  }
+  console.log();
+  const state = isDaemonRunning();
+  if (state.running && state.pid) {
+    console.log(`  Stopping Liminal daemon (PID ${state.pid})...`);
+    try {
+      process.kill(state.pid, "SIGTERM");
+      for (let i = 0; i < 15; i++) {
+        await sleep(200);
+        if (!isProcessAlive(state.pid)) break;
+      }
+      if (isProcessAlive(state.pid)) {
+        process.kill(state.pid, "SIGKILL");
+      }
+    } catch {
+    }
+    removePidFile();
+    console.log(`  ${GREEN2}\u2713${RESET2} Daemon stopped`);
+  } else {
+    console.log(`  ${DIM2}\xB7${RESET2} Daemon not running`);
+  }
+  const profile = detectShellProfile();
+  if (profile) {
+    const existing = findLiminalExportsInProfile(profile);
+    if (existing.length > 0) {
+      const removed = removeLiminalFromShellProfile(profile);
+      if (removed.length > 0) {
+        console.log(`  ${GREEN2}\u2713${RESET2} Removed ${removed.length} line${removed.length > 1 ? "s" : ""} from ${profile.name}:`);
+        for (const line of removed) {
+          const trimmed = line.trim();
+          if (trimmed && trimmed !== "# Liminal \u2014 route AI tools through compression proxy") {
+            console.log(`    ${DIM2}${trimmed}${RESET2}`);
+          }
+        }
+      }
+    } else {
+      console.log(`  ${DIM2}\xB7${RESET2} No Liminal exports found in ${profile.name}`);
+    }
+  }
+  const configuredTools = loadConfiguredTools();
+  const allTools = configuredTools.length > 0 ? configuredTools : CONNECTORS.map((c) => c.info.id);
+  const connectors = getConnectors(allTools);
+  const manualSteps = [];
+  for (const connector of connectors) {
+    const result = await connector.teardown();
+    if (result.manualSteps.length > 0 && !connector.info.automatable) {
+      manualSteps.push({
+        label: connector.info.label,
+        steps: result.manualSteps
+      });
+    }
+  }
+  if (manualSteps.length > 0) {
+    console.log();
+    console.log(`  ${YELLOW2}Manual steps needed:${RESET2}`);
+    for (const { label, steps } of manualSteps) {
+      console.log();
+      console.log(`  ${BOLD2}${label}:${RESET2}`);
+      for (const step of steps) {
+        console.log(`    ${step}`);
+      }
+    }
+  }
+  if (existsSync8(LIMINAL_DIR)) {
+    console.log();
+    const removeData = await selectPrompt({
+      message: "Remove ~/.liminal/ directory? (config, logs, PID file)",
+      options: [
+        { label: "Yes", value: true, description: "Delete all Liminal data" },
+        { label: "No", value: false, description: "Keep config and logs" }
+      ],
+      defaultIndex: 1
+      // Default to keep
+    });
+    if (removeData === true) {
+      rmSync(LIMINAL_DIR, { recursive: true, force: true });
+      console.log(`  ${GREEN2}\u2713${RESET2} Removed ~/.liminal/`);
+    } else {
+      console.log(`  ${DIM2}\xB7${RESET2} Kept ~/.liminal/`);
+    }
+  }
+  console.log();
+  console.log(`  ${GREEN2}Liminal has been uninstalled.${RESET2}`);
+  console.log();
+  console.log(`  ${DIM2}Your AI tools will connect directly to their APIs.${RESET2}`);
+  console.log(`  ${DIM2}Restart your terminal for shell changes to take effect.${RESET2}`);
+  if (manualSteps.length > 0) {
+    console.log(`  ${YELLOW2}Don't forget the manual steps above for ${manualSteps.map((s) => s.label).join(", ")}.${RESET2}`);
+  }
+  console.log();
+  console.log(`  ${DIM2}To reinstall: npx @cognisos/liminal init${RESET2}`);
+  console.log();
+}
+
 // src/bin.ts
 var USAGE = `
   liminal v${VERSION} \u2014 Transparent LLM context compression proxy
@@ -2119,6 +3108,7 @@ var USAGE = `
     liminal summary                       Detailed session metrics
     liminal config [--set k=v] [--get k]  View or edit configuration
     liminal logs [--follow] [--lines N]   View proxy logs
+    liminal uninstall                     Remove Liminal configuration
 
   Options:
     -h, --help       Show this help message
@@ -2196,6 +3186,9 @@ async function main() {
       case "logs":
         await logsCommand(flags);
         break;
+      case "uninstall":
+        await uninstallCommand();
+        break;
       case "":
         console.log(USAGE);
         process.exit(0);