haansi 0.1.24 → 0.1.26

package/dist/haansi.js

@@ -39,8 +39,8 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "haansi",
-      version: "0.1.24",
-      description: "Haansi CLI - Session collector and MCP server for Claude Code",
+      version: "0.1.26",
+      description: "Haansi CLI - Session collector and MCP server for Claude Code & OpenAI Codex",
       bin: {
         haansi: "./dist/haansi.js"
       },
@@ -82,9 +82,9 @@ function sleep(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 async function authLogin() {
-  const apiUrl = process.env.HAANSI_API_URL ?? DEFAULT_API_URL;
+  const apiUrl2 = process.env.HAANSI_API_URL ?? DEFAULT_API_URL;
   console.log("Haansi CLI \u2014 Browser Login\n");
-  const initiateRes = await fetch(`${apiUrl}/api/v1/auth/extension/initiate`, {
+  const initiateRes = await fetch(`${apiUrl2}/api/v1/auth/extension/initiate`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ client_type: "cli" })
@@ -115,7 +115,7 @@ If the browser didn't open, visit this URL:
   while (Date.now() < deadline) {
     await sleep(POLL_INTERVAL_MS);
     const pollRes = await fetch(
-      `${apiUrl}/api/v1/auth/extension/token?session_id=${encodeURIComponent(session_id)}`
+      `${apiUrl2}/api/v1/auth/extension/token?session_id=${encodeURIComponent(session_id)}`
     );
     if (pollRes.status === 410) {
       throw new Error("Session expired or was already used. Please try again.");
@@ -141,7 +141,7 @@ If the browser didn't open, visit this URL:
     );
   }
   console.log("Creating CLI token...");
-  const tokenRes = await fetch(`${apiUrl}/api/v1/access/cli-tokens`, {
+  const tokenRes = await fetch(`${apiUrl2}/api/v1/access/cli-tokens`, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${jwt2}`,
@@ -205,9 +205,9 @@ function prompt(question) {
     });
   });
 }
-async function validateToken(token, apiUrl) {
+async function validateToken(token, apiUrl2) {
   const response = await fetch(
-    `${apiUrl}/api/v1/memory/solutions/recent?limit=1`,
+    `${apiUrl2}/api/v1/memory/solutions/recent?limit=1`,
     {
       headers: { Authorization: `Bearer ${token}` }
     }
@@ -220,7 +220,7 @@ async function validateToken(token, apiUrl) {
   }
 }
 async function init() {
-  const apiUrl = process.env.HAANSI_API_URL ?? DEFAULT_API_URL2;
+  const apiUrl2 = process.env.HAANSI_API_URL ?? DEFAULT_API_URL2;
   console.log("Haansi CLI \u2014 Setup\n");
   console.log(
     "Tip: For interactive login, run `haansi auth login` to authenticate via browser.\n"
@@ -239,7 +239,7 @@ async function init() {
     process.exit(1);
   }
   console.log("\nValidating token...");
-  await validateToken(token, apiUrl);
+  await validateToken(token, apiUrl2);
   (0, import_node_fs2.mkdirSync)(HAANSI_DIR2, { recursive: true });
   (0, import_node_fs2.writeFileSync)(CREDENTIALS_FILE2, JSON.stringify({ token }, null, 2), {
     encoding: "utf-8",
@@ -248,7 +248,7 @@ async function init() {
   console.log(`
 Token saved to ${CREDENTIALS_FILE2}`);
   console.log(
-    "Run `haansi daemon` to start collecting or `haansi setup-mcp` to configure Claude Code."
+    "Run `haansi daemon` to start collecting or `haansi setup-mcp` to configure your coding agent(s) (Claude Code / Codex)."
   );
 }
 var readline, import_node_fs2, import_node_path2, import_node_os2, DEFAULT_API_URL2, HAANSI_DIR2, CREDENTIALS_FILE2;
@@ -675,6 +675,253 @@ var init_logger = __esm({
   }
 });
 
+// ../service-capture/common/agents/types.ts
+var AGENT_IDS;
+var init_types = __esm({
+  "../service-capture/common/agents/types.ts"() {
+    "use strict";
+    AGENT_IDS = ["claude-code", "codex"];
+  }
+});
+
+// ../service-capture/common/agents/claude-code.ts
+function projectsDir() {
+  return (0, import_path.join)((0, import_os.homedir)(), ".claude", "projects");
+}
+function extractMeta(filePath) {
+  const result = {
+    cwd: null,
+    timestamp: null,
+    gitBranch: null
+  };
+  try {
+    const lines = (0, import_fs.readFileSync)(filePath, "utf-8").split("\n").filter((l) => l.trim()).slice(0, 50);
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (!result.cwd && typeof entry.cwd === "string")
+          result.cwd = entry.cwd;
+        if (!result.timestamp && typeof entry.timestamp === "string")
+          result.timestamp = entry.timestamp;
+        if (!result.gitBranch && typeof entry.gitBranch === "string")
+          result.gitBranch = entry.gitBranch;
+        if (result.cwd && result.timestamp && result.gitBranch) break;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+var import_fs, import_path, import_os, claudeCodeAgent;
+var init_claude_code = __esm({
+  "../service-capture/common/agents/claude-code.ts"() {
+    "use strict";
+    import_fs = require("fs");
+    import_path = require("path");
+    import_os = require("os");
+    claudeCodeAgent = {
+      id: "claude-code",
+      displayName: "Claude Code",
+      sessionsRoot() {
+        return projectsDir();
+      },
+      isInstalled() {
+        return (0, import_fs.existsSync)(projectsDir());
+      },
+      discoverSessions() {
+        const root = projectsDir();
+        if (!(0, import_fs.existsSync)(root)) return [];
+        const sessions = [];
+        const projectDirs = (0, import_fs.readdirSync)(root).map((name) => (0, import_path.join)(root, name)).filter((p) => {
+          try {
+            return (0, import_fs.statSync)(p).isDirectory();
+          } catch {
+            return false;
+          }
+        });
+        for (const dir of projectDirs) {
+          let files;
+          try {
+            files = (0, import_fs.readdirSync)(dir).filter((f) => f.endsWith(".jsonl"));
+          } catch {
+            continue;
+          }
+          for (const file2 of files) {
+            const filePath = (0, import_path.join)(dir, file2);
+            const sessionId = (0, import_path.basename)(file2, ".jsonl");
+            try {
+              const stat = (0, import_fs.statSync)(filePath);
+              const content = (0, import_fs.readFileSync)(filePath, "utf-8");
+              const lineCount = content.split("\n").filter((l) => l.trim()).length;
+              const meta3 = extractMeta(filePath);
+              sessions.push({
+                sessionId,
+                filePath,
+                lineCount,
+                sizeBytes: stat.size,
+                ...meta3
+              });
+            } catch {
+            }
+          }
+        }
+        return sessions;
+      }
+    };
+  }
+});
+
+// ../service-capture/common/agents/codex.ts
+function codexHome() {
+  return process.env.CODEX_HOME || (0, import_path2.join)((0, import_os2.homedir)(), ".codex");
+}
+function sessionsDir() {
+  return (0, import_path2.join)(codexHome(), "sessions");
+}
+function walkRollouts(dir, out) {
+  let entries;
+  try {
+    entries = (0, import_fs2.readdirSync)(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    const full = (0, import_path2.join)(dir, name);
+    let isDir = false;
+    try {
+      isDir = (0, import_fs2.statSync)(full).isDirectory();
+    } catch {
+      continue;
+    }
+    if (isDir) {
+      walkRollouts(full, out);
+    } else if (name.startsWith("rollout-") && name.endsWith(".jsonl")) {
+      out.push(full);
+    }
+  }
+}
+function readRolloutMeta(filePath, content) {
+  const fileName = (0, import_path2.basename)(filePath, ".jsonl");
+  const fromName = UUID_RE.exec(fileName)?.[1];
+  let cwd = null;
+  let timestamp = null;
+  let gitBranch = null;
+  let metaId = null;
+  const lines = content.split("\n").filter((l) => l.trim()).slice(0, 50);
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (!timestamp && typeof entry.timestamp === "string") {
+        timestamp = entry.timestamp;
+      }
+      const p = entry.payload ?? {};
+      if (entry.type === "session_meta") {
+        if (typeof p.cwd === "string") cwd = p.cwd;
+        if (typeof p.id === "string") metaId = p.id;
+        const branch = p.git?.branch ?? p.git_branch;
+        if (typeof branch === "string") gitBranch = branch;
+      }
+      if (cwd && gitBranch && timestamp && metaId) break;
+    } catch {
+    }
+  }
+  return {
+    sessionId: fromName ?? metaId ?? fileName,
+    cwd,
+    timestamp,
+    gitBranch
+  };
+}
+var import_fs2, import_path2, import_os2, UUID_RE, codexAgent;
+var init_codex = __esm({
+  "../service-capture/common/agents/codex.ts"() {
+    "use strict";
+    import_fs2 = require("fs");
+    import_path2 = require("path");
+    import_os2 = require("os");
+    UUID_RE = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
+    codexAgent = {
+      id: "codex",
+      displayName: "OpenAI Codex",
+      sessionsRoot() {
+        return sessionsDir();
+      },
+      isInstalled() {
+        return (0, import_fs2.existsSync)(codexHome());
+      },
+      discoverSessions() {
+        const root = sessionsDir();
+        if (!(0, import_fs2.existsSync)(root)) return [];
+        const files = [];
+        walkRollouts(root, files);
+        const sessions = [];
+        for (const filePath of files) {
+          try {
+            const stat = (0, import_fs2.statSync)(filePath);
+            const content = (0, import_fs2.readFileSync)(filePath, "utf-8");
+            const lineCount = content.split("\n").filter((l) => l.trim()).length;
+            const meta3 = readRolloutMeta(filePath, content);
+            sessions.push({
+              sessionId: meta3.sessionId,
+              filePath,
+              lineCount,
+              sizeBytes: stat.size,
+              cwd: meta3.cwd,
+              timestamp: meta3.timestamp,
+              gitBranch: meta3.gitBranch
+            });
+          } catch {
+          }
+        }
+        return sessions;
+      }
+    };
+  }
+});
+
+// ../service-capture/common/agents/registry.ts
+function getAgents() {
+  return AGENTS;
+}
+function getAgent(id) {
+  const agent = AGENTS.find((a) => a.id === id);
+  if (!agent) throw new Error(`Unknown agent: ${id}`);
+  return agent;
+}
+function detectInstalled() {
+  return AGENTS.filter((a) => a.isInstalled());
+}
+var AGENTS;
+var init_registry = __esm({
+  "../service-capture/common/agents/registry.ts"() {
+    "use strict";
+    init_claude_code();
+    init_codex();
+    AGENTS = [claudeCodeAgent, codexAgent];
+  }
+});
+
+// ../service-capture/common/agents/index.ts
+var agents_exports = {};
+__export(agents_exports, {
+  AGENT_IDS: () => AGENT_IDS,
+  claudeCodeAgent: () => claudeCodeAgent,
+  codexAgent: () => codexAgent,
+  detectInstalled: () => detectInstalled,
+  getAgent: () => getAgent,
+  getAgents: () => getAgents
+});
+var init_agents = __esm({
+  "../service-capture/common/agents/index.ts"() {
+    "use strict";
+    init_types();
+    init_claude_code();
+    init_codex();
+    init_registry();
+  }
+});
+
 // ../service-capture/claude-sessions/collector.ts
 var collector_exports = {};
 __export(collector_exports, {
@@ -735,40 +982,11 @@ function extractGitInfo(projectDir, sessionTimestamp, sessionBranch) {
   }
   return result;
 }
-function extractSessionMeta(filePath) {
-  const result = {
-    cwd: null,
-    timestamp: null,
-    gitBranch: null
-  };
-  try {
-    const content = (0, import_fs.readFileSync)(filePath, "utf-8");
-    const lines = content.split("\n").filter((l) => l.trim()).slice(0, 50);
-    for (const line of lines) {
-      try {
-        const entry = JSON.parse(line);
-        if (!result.cwd && entry.cwd && typeof entry.cwd === "string") {
-          result.cwd = entry.cwd;
-        }
-        if (!result.timestamp && entry.timestamp && typeof entry.timestamp === "string") {
-          result.timestamp = entry.timestamp;
-        }
-        if (!result.gitBranch && entry.gitBranch && typeof entry.gitBranch === "string") {
-          result.gitBranch = entry.gitBranch;
-        }
-        if (result.cwd && result.timestamp && result.gitBranch) break;
-      } catch {
-      }
-    }
-  } catch {
-  }
-  return result;
-}
 function resolveToken() {
   if (process.env.HAANSI_TOKEN) return process.env.HAANSI_TOKEN;
-  if ((0, import_fs.existsSync)(CREDENTIALS_FILE3)) {
+  if ((0, import_fs3.existsSync)(CREDENTIALS_FILE3)) {
     try {
-      const creds = JSON.parse((0, import_fs.readFileSync)(CREDENTIALS_FILE3, "utf-8"));
+      const creds = JSON.parse((0, import_fs3.readFileSync)(CREDENTIALS_FILE3, "utf-8"));
       if (creds.token) return creds.token;
     } catch {
       logger.warn("Could not parse credentials file", {
@@ -778,41 +996,32 @@ function resolveToken() {
   }
   return null;
 }
-function discoverSessions() {
-  if (!(0, import_fs.existsSync)(CLAUDE_PROJECTS_DIR)) return [];
+function resolveAgentIds(agents) {
+  if (agents && agents.length > 0) return agents;
+  const installed = detectInstalled().map((a) => a.id);
+  return installed.length > 0 ? installed : ["claude-code"];
+}
+function discoverSessions(agentIds) {
   const sessions = [];
-  const projectDirs = (0, import_fs.readdirSync)(CLAUDE_PROJECTS_DIR).map((name) => (0, import_path.join)(CLAUDE_PROJECTS_DIR, name)).filter((p) => {
+  for (const id of agentIds) {
+    const agent = getAgent(id);
+    let discovered = [];
     try {
-      return (0, import_fs.statSync)(p).isDirectory();
-    } catch {
-      return false;
+      discovered = agent.discoverSessions();
+    } catch (err) {
+      logger.warn(`Discovery failed for ${agent.displayName}`, {
+        err: err?.message
+      });
+      continue;
     }
-  });
-  for (const dir of projectDirs) {
-    const files = (0, import_fs.readdirSync)(dir).filter((f) => f.endsWith(".jsonl"));
-    for (const file2 of files) {
-      const filePath = (0, import_path.join)(dir, file2);
-      const sessionId = (0, import_path.basename)(file2, ".jsonl");
-      try {
-        const stat = (0, import_fs.statSync)(filePath);
-        const content = (0, import_fs.readFileSync)(filePath, "utf-8");
-        const lineCount = content.split("\n").filter((l) => l.trim()).length;
-        if (lineCount >= MIN_LINES) {
-          sessions.push({
-            sessionId,
-            filePath,
-            lineCount,
-            sizeBytes: stat.size
-          });
-        }
-      } catch {
-      }
+    for (const s of discovered) {
+      if (s.lineCount >= MIN_LINES) sessions.push({ ...s, agentId: id });
     }
   }
   return sessions;
 }
-async function apiGet(path, apiUrl, token) {
-  const response = await fetch(`${apiUrl}/api/v1${path}`, {
+async function apiGet(path, apiUrl2, token) {
+  const response = await fetch(`${apiUrl2}/api/v1${path}`, {
     headers: { Authorization: `Bearer ${token}` }
   });
   if (!response.ok) {
@@ -821,11 +1030,11 @@ async function apiGet(path, apiUrl, token) {
   }
   return response.json();
 }
-async function getUploadedSessions(apiUrl, token) {
+async function getUploadedSessions(apiUrl2, token) {
   try {
     const data = await apiGet(
       "/capture/sessions/uploaded",
-      apiUrl,
+      apiUrl2,
       token
     );
     const map2 = /* @__PURE__ */ new Map();
@@ -841,18 +1050,19 @@ async function getUploadedSessions(apiUrl, token) {
     return /* @__PURE__ */ new Map();
   }
 }
-async function uploadSession(sessionId, content, apiUrl, token, gitInfo) {
+async function uploadSession(sessionId, content, apiUrl2, token, agentSource, gitInfo) {
   const body = (0, import_zlib.gzipSync)(Buffer.from(content, "utf-8"));
   const headers = {
     Authorization: `Bearer ${token}`,
     "Content-Type": "application/x-ndjson",
     "Content-Encoding": "gzip",
-    "x-session-id": sessionId
+    "x-session-id": sessionId,
+    "x-haansi-agent-source": agentSource
   };
   if (gitInfo?.gitRemoteUrl) headers["x-git-remote-url"] = gitInfo.gitRemoteUrl;
   if (gitInfo?.gitCommit) headers["x-git-commit"] = gitInfo.gitCommit;
   if (gitInfo?.gitBranch) headers["x-git-branch"] = gitInfo.gitBranch;
-  const response = await fetch(`${apiUrl}/api/v1/capture/sessions/raw`, {
+  const response = await fetch(`${apiUrl2}/api/v1/capture/sessions/raw`, {
     method: "POST",
     headers,
     body: new Uint8Array(body)
@@ -865,22 +1075,25 @@ async function uploadSession(sessionId, content, apiUrl, token, gitInfo) {
   }
 }
 async function collect(options) {
-  const apiUrl = process.env.HAANSI_API_URL ?? DEFAULT_API_URL3;
+  const apiUrl2 = process.env.HAANSI_API_URL ?? DEFAULT_API_URL3;
   const token = resolveToken();
   if (!token && !options.dryRun) {
     throw new Error(
       "HAANSI_TOKEN is required. Set it as env var or in ~/.haansi/credentials.json"
     );
   }
-  const localSessions = discoverSessions();
-  logger.info(`Found ${localSessions.length} session files on disk`);
+  const agentIds = resolveAgentIds(options.agents);
+  const localSessions = discoverSessions(agentIds);
+  logger.info(`Found ${localSessions.length} session files on disk`, {
+    agents: agentIds.join(",")
+  });
   if (localSessions.length === 0) {
     return { uploaded: 0, skipped: 0, errors: 0 };
   }
   let uploaded = 0;
   let skipped = 0;
   let errors = 0;
-  const remoteMap = options.forceAll ? /* @__PURE__ */ new Map() : await getUploadedSessions(apiUrl, token);
+  const remoteMap = options.forceAll ? /* @__PURE__ */ new Map() : await getUploadedSessions(apiUrl2, token);
   const toUpload = [];
   for (const session of localSessions) {
     const remote = remoteMap.get(session.sessionId);
@@ -898,22 +1111,22 @@ async function collect(options) {
   for (const session of batch) {
     const shortId = session.sessionId.slice(0, 8);
     try {
-      const rawContent = (0, import_fs.readFileSync)(session.filePath, "utf-8");
+      const rawContent = (0, import_fs3.readFileSync)(session.filePath, "utf-8");
       const scrubbed = edgeScrub(rawContent);
-      const sessionMeta = extractSessionMeta(session.filePath);
-      const gitInfo = sessionMeta.cwd ? extractGitInfo(
-        sessionMeta.cwd,
-        sessionMeta.timestamp ?? void 0,
-        sessionMeta.gitBranch ?? void 0
+      const gitInfo = session.cwd ? extractGitInfo(
+        session.cwd,
+        session.timestamp ?? void 0,
+        session.gitBranch ?? void 0
       ) : {
         gitRemoteUrl: null,
         gitCommit: null,
-        gitBranch: sessionMeta.gitBranch
+        gitBranch: session.gitBranch
       };
       if (options.dryRun) {
         logger.info(
-          `[dry-run] Would upload ${shortId} (${session.lineCount} lines)`,
+          `[dry-run] Would upload ${shortId} (${session.agentId}, ${session.lineCount} lines)`,
           {
+            agentSource: session.agentId,
             gitRemoteUrl: gitInfo.gitRemoteUrl,
             gitCommit: gitInfo.gitCommit?.slice(0, 8)
           }
@@ -921,12 +1134,23 @@ async function collect(options) {
         uploaded++;
         continue;
       }
-      await uploadSession(session.sessionId, scrubbed, apiUrl, token, gitInfo);
+      await uploadSession(
+        session.sessionId,
+        scrubbed,
+        apiUrl2,
+        token,
+        session.agentId,
+        gitInfo
+      );
       uploaded++;
-      logger.info(`Uploaded ${shortId} (${session.lineCount} lines)`, {
-        gitRemoteUrl: gitInfo.gitRemoteUrl,
-        gitCommit: gitInfo.gitCommit?.slice(0, 8)
-      });
+      logger.info(
+        `Uploaded ${shortId} (${session.agentId}, ${session.lineCount} lines)`,
+        {
+          agentSource: session.agentId,
+          gitRemoteUrl: gitInfo.gitRemoteUrl,
+          gitCommit: gitInfo.gitCommit?.slice(0, 8)
+        }
+      );
     } catch (err) {
       errors++;
       logger.error(`Failed to upload ${shortId}`, { err: err.message });
@@ -947,22 +1171,22 @@ async function main() {
   });
   if (errors > 0) process.exit(1);
 }
-var import_dotenv, import_path, import_fs, import_os, import_zlib, import_child_process, logger, DEFAULT_API_URL3, CREDENTIALS_FILE3, CLAUDE_PROJECTS_DIR, MIN_LINES, EDGE_SCRUB_PATTERNS;
+var import_dotenv, import_path3, import_fs3, import_os3, import_zlib, import_child_process, logger, DEFAULT_API_URL3, CREDENTIALS_FILE3, MIN_LINES, EDGE_SCRUB_PATTERNS;
 var init_collector = __esm({
   "../service-capture/claude-sessions/collector.ts"() {
     "use strict";
     import_dotenv = __toESM(require_main());
-    import_path = require("path");
-    import_fs = require("fs");
-    import_os = require("os");
+    import_path3 = require("path");
+    import_fs3 = require("fs");
+    import_os3 = require("os");
     import_zlib = require("zlib");
     import_child_process = require("child_process");
     init_logger();
-    (0, import_dotenv.config)({ path: (0, import_path.resolve)(__dirname, "../../../.env") });
-    logger = createLogger("claude-collector");
+    init_agents();
+    (0, import_dotenv.config)({ path: (0, import_path3.resolve)(__dirname, "../../../.env") });
+    logger = createLogger("session-collector");
     DEFAULT_API_URL3 = "https://api.haansi.co";
-    CREDENTIALS_FILE3 = (0, import_path.join)((0, import_os.homedir)(), ".haansi", "credentials.json");
-    CLAUDE_PROJECTS_DIR = (0, import_path.join)((0, import_os.homedir)(), ".claude", "projects");
+    CREDENTIALS_FILE3 = (0, import_path3.join)((0, import_os3.homedir)(), ".haansi", "credentials.json");
     MIN_LINES = 4;
     EDGE_SCRUB_PATTERNS = [
       {
@@ -1012,6 +1236,151 @@ var init_collector = __esm({
   }
 });
 
+// src/lib/paths.ts
+function apiUrl() {
+  return process.env.HAANSI_API_URL ?? DEFAULT_API_URL4;
+}
+function resolveToken2() {
+  if (process.env.HAANSI_TOKEN) return process.env.HAANSI_TOKEN;
+  if ((0, import_node_fs3.existsSync)(CREDENTIALS_FILE4)) {
+    try {
+      const creds = JSON.parse((0, import_node_fs3.readFileSync)(CREDENTIALS_FILE4, "utf-8"));
+      if (typeof creds.token === "string" && creds.token) return creds.token;
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveHaansiBin() {
+  try {
+    const binPath = (0, import_node_child_process2.execSync)("which haansi", { encoding: "utf-8" }).trim();
+    if (binPath) return binPath;
+  } catch {
+  }
+  return "haansi";
+}
+var import_node_fs3, import_node_path3, import_node_os3, import_node_child_process2, DEFAULT_API_URL4, HAANSI_DIR3, CREDENTIALS_FILE4, CONFIG_FILE;
+var init_paths = __esm({
+  "src/lib/paths.ts"() {
+    "use strict";
+    import_node_fs3 = require("node:fs");
+    import_node_path3 = require("node:path");
+    import_node_os3 = require("node:os");
+    import_node_child_process2 = require("node:child_process");
+    DEFAULT_API_URL4 = "https://api.haansi.co";
+    HAANSI_DIR3 = (0, import_node_path3.join)((0, import_node_os3.homedir)(), ".haansi");
+    CREDENTIALS_FILE4 = (0, import_node_path3.join)(HAANSI_DIR3, "credentials.json");
+    CONFIG_FILE = (0, import_node_path3.join)(HAANSI_DIR3, "config.json");
+  }
+});
+
+// src/lib/agent-selection.ts
+var agent_selection_exports = {};
+__export(agent_selection_exports, {
+  parseAgentFlag: () => parseAgentFlag,
+  promptForAgents: () => promptForAgents,
+  readSavedAgents: () => readSavedAgents,
+  resolveAgentSelection: () => resolveAgentSelection,
+  saveAgents: () => saveAgents
+});
+function parseAgentFlag(value) {
+  if (!value) return null;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "both" || normalized === "all") return [...VALID];
+  const out = [];
+  for (const part of normalized.split(",").map((s) => s.trim())) {
+    if (part === "claude" || part === "claude-code") {
+      if (!out.includes("claude-code")) out.push("claude-code");
+    } else if (part === "codex") {
+      if (!out.includes("codex")) out.push("codex");
+    }
+  }
+  return out.length > 0 ? out : null;
+}
+function readSavedAgents() {
+  if (!(0, import_node_fs4.existsSync)(CONFIG_FILE)) return null;
+  try {
+    const cfg = JSON.parse((0, import_node_fs4.readFileSync)(CONFIG_FILE, "utf-8"));
+    if (Array.isArray(cfg.agents)) {
+      const agents = cfg.agents.filter(
+        (a) => VALID.includes(a)
+      );
+      return agents.length > 0 ? agents : null;
+    }
+  } catch {
+  }
+  return null;
+}
+function saveAgents(agents) {
+  let cfg = {};
+  if ((0, import_node_fs4.existsSync)(CONFIG_FILE)) {
+    try {
+      cfg = JSON.parse((0, import_node_fs4.readFileSync)(CONFIG_FILE, "utf-8"));
+    } catch {
+      cfg = {};
+    }
+  }
+  cfg.agents = agents;
+  (0, import_node_fs4.mkdirSync)(HAANSI_DIR3, { recursive: true });
+  (0, import_node_fs4.writeFileSync)(CONFIG_FILE, JSON.stringify(cfg, null, 2) + "\n", {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+function resolveAgentSelection(flagValue) {
+  const fromFlag = parseAgentFlag(flagValue);
+  if (fromFlag) return { agents: fromFlag, source: "flag" };
+  const saved = readSavedAgents();
+  if (saved) return { agents: saved, source: "config" };
+  const detected = detectInstalled().map((a) => a.id);
+  if (detected.length > 0) return { agents: detected, source: "detected" };
+  return { agents: ["claude-code"], source: "default" };
+}
+async function promptForAgents() {
+  const installed = new Set(detectInstalled().map((a) => a.id));
+  const agents = getAgents();
+  console.log("\nWhich coding agents should Haansi connect?\n");
+  agents.forEach((a, i) => {
+    const mark = installed.has(a.id) ? "installed" : "not detected";
+    console.log(`  ${i + 1}) ${a.displayName} (${mark})`);
+  });
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const answer = await new Promise((resolve4) => {
+    rl.question(
+      "\nEnter numbers (comma-separated), or press Enter for all installed: ",
+      (a) => {
+        rl.close();
+        resolve4(a.trim());
+      }
+    );
+  });
+  if (!answer) {
+    const detected = agents.filter((a) => installed.has(a.id)).map((a) => a.id);
+    return detected.length > 0 ? detected : [...VALID];
+  }
+  const picked = [];
+  for (const token of answer.split(",").map((s) => s.trim())) {
+    const idx = parseInt(token, 10) - 1;
+    const agent = agents[idx];
+    if (agent && !picked.includes(agent.id)) picked.push(agent.id);
+  }
+  return picked.length > 0 ? picked : [...VALID];
+}
+var import_node_fs4, readline2, VALID;
+var init_agent_selection = __esm({
+  "src/lib/agent-selection.ts"() {
+    "use strict";
+    import_node_fs4 = require("node:fs");
+    readline2 = __toESM(require("node:readline"));
+    init_agents();
+    init_paths();
+    VALID = ["claude-code", "codex"];
+  }
+});
+
 // ../../node_modules/node-cron/src/task.js
 var require_task = __commonJS({
   "../../node_modules/node-cron/src/task.js"(exports2, module2) {
@@ -1924,23 +2293,30 @@ var require_node_cron = __commonJS({
 
 // ../service-capture/claude-sessions/collector-daemon.ts
 var collector_daemon_exports = {};
+function resolveAgentsEnv() {
+  const raw = process.env.HAANSI_AGENTS;
+  if (!raw) return void 0;
+  const valid = ["claude-code", "codex"];
+  const parsed = raw.split(",").map((s) => s.trim().toLowerCase()).filter((s) => valid.includes(s));
+  return parsed.length > 0 ? parsed : void 0;
+}
 function getOnDiskVersion() {
   try {
-    const realEntry = (0, import_fs2.realpathSync)(process.argv[1]);
-    const pkgPath = (0, import_path2.resolve)((0, import_path2.dirname)(realEntry), "..", "package.json");
-    if (!(0, import_fs2.existsSync)(pkgPath)) return null;
-    const pkg = JSON.parse((0, import_fs2.readFileSync)(pkgPath, "utf-8"));
+    const realEntry = (0, import_fs4.realpathSync)(process.argv[1]);
+    const pkgPath = (0, import_path4.resolve)((0, import_path4.dirname)(realEntry), "..", "package.json");
+    if (!(0, import_fs4.existsSync)(pkgPath)) return null;
+    const pkg = JSON.parse((0, import_fs4.readFileSync)(pkgPath, "utf-8"));
     return pkg.version ?? null;
   } catch {
     return null;
   }
 }
 async function run() {
-  const projectPath = process.env.CLAUDE_PROJECT_PATH || void 0;
-  logger2.info("Collect run starting", { projectPath: projectPath ?? "all" });
+  const agents = resolveAgentsEnv();
+  logger2.info("Collect run starting", { agents: agents?.join(",") ?? "all" });
   const start = Date.now();
   try {
-    const { uploaded, skipped, errors } = await collect({ projectPath });
+    const { uploaded, skipped, errors } = await collect({ agents });
     const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
     logger2.info(`Collect run complete in ${elapsed}s`, {
       uploaded,
@@ -1977,20 +2353,20 @@ async function main2() {
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("SIGINT", () => shutdown("SIGINT"));
 }
-var import_dotenv2, import_fs2, import_path2, import_node_cron, logger2, IN_MEMORY_VERSION, SCHEDULE;
+var import_dotenv2, import_fs4, import_path4, import_node_cron, logger2, IN_MEMORY_VERSION, SCHEDULE;
 var init_collector_daemon = __esm({
   "../service-capture/claude-sessions/collector-daemon.ts"() {
     "use strict";
     import_dotenv2 = __toESM(require_main());
-    import_fs2 = require("fs");
-    import_path2 = require("path");
+    import_fs4 = require("fs");
+    import_path4 = require("path");
     import_node_cron = __toESM(require_node_cron());
     init_collector();
     init_logger();
-    (0, import_dotenv2.config)({ path: (0, import_path2.resolve)(__dirname, "../../../.env") });
+    (0, import_dotenv2.config)({ path: (0, import_path4.resolve)(__dirname, "../../../.env") });
     logger2 = createLogger("collector-daemon");
     IN_MEMORY_VERSION = require_package().version;
-    SCHEDULE = process.env.CLAUDE_COLLECT_SCHEDULE ?? "*/30 * * * *";
+    SCHEDULE = process.env.HAANSI_COLLECT_SCHEDULE ?? process.env.CLAUDE_COLLECT_SCHEDULE ?? "*/30 * * * *";
     main2().catch((err) => {
       logger2.error("Daemon failed to start", err);
       process.exit(1);
@@ -2907,7 +3283,7 @@ function createZodEnum(values, params) {
   });
 }
 var ParseInputLazyPath, handleResult, ZodType, cuidRegex, cuid2Regex, ulidRegex, uuidRegex, nanoidRegex, jwtRegex, durationRegex, emailRegex, _emojiRegex, emojiRegex, ipv4Regex, ipv4CidrRegex, ipv6Regex, ipv6CidrRegex, base64Regex, base64urlRegex, dateRegexSource, dateRegex, ZodString, ZodNumber, ZodBigInt, ZodBoolean, ZodDate, ZodSymbol, ZodUndefined, ZodNull, ZodAny, ZodUnknown, ZodNever, ZodVoid, ZodArray, ZodObject, ZodUnion, getDiscriminator, ZodDiscriminatedUnion, ZodIntersection, ZodTuple, ZodRecord, ZodMap, ZodSet, ZodFunction, ZodLazy, ZodLiteral, ZodEnum, ZodNativeEnum, ZodPromise, ZodEffects, ZodOptional, ZodNullable, ZodDefault, ZodCatch, ZodNaN, BRAND, ZodBranded, ZodPipeline, ZodReadonly, late, ZodFirstPartyTypeKind, stringType, numberType, nanType, bigIntType, booleanType, dateType, symbolType, undefinedType, nullType, anyType, unknownType, neverType, voidType, arrayType, objectType, strictObjectType, unionType, discriminatedUnionType, intersectionType, tupleType, recordType, mapType, setType, functionType, lazyType, literalType, enumType, nativeEnumType, promiseType, effectsType, optionalType, nullableType, preprocessType, pipelineType;
-var init_types = __esm({
+var init_types2 = __esm({
   "../../node_modules/zod/v3/types.js"() {
     init_ZodError();
     init_errors();
@@ -6160,7 +6536,7 @@ var init_external = __esm({
     init_parseUtil();
     init_typeAliases();
     init_util();
-    init_types();
+    init_types2();
     init_ZodError();
   }
 });
@@ -13942,7 +14318,7 @@ function assertCompleteRequestResourceTemplate(request) {
   void request;
 }
 var LATEST_PROTOCOL_VERSION, DEFAULT_NEGOTIATED_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS, RELATED_TASK_META_KEY, JSONRPC_VERSION, AssertObjectSchema, ProgressTokenSchema, CursorSchema, TaskCreationParamsSchema, TaskMetadataSchema, RelatedTaskMetadataSchema, RequestMetaSchema, BaseRequestParamsSchema, TaskAugmentedRequestParamsSchema, isTaskAugmentedRequestParams, RequestSchema, NotificationsParamsSchema, NotificationSchema, ResultSchema, RequestIdSchema, JSONRPCRequestSchema, isJSONRPCRequest, JSONRPCNotificationSchema, isJSONRPCNotification, JSONRPCResultResponseSchema, isJSONRPCResultResponse, ErrorCode, JSONRPCErrorResponseSchema, isJSONRPCErrorResponse, JSONRPCMessageSchema, JSONRPCResponseSchema, EmptyResultSchema, CancelledNotificationParamsSchema, CancelledNotificationSchema, IconSchema, IconsSchema, BaseMetadataSchema, ImplementationSchema, FormElicitationCapabilitySchema, ElicitationCapabilitySchema, ClientTasksCapabilitySchema, ServerTasksCapabilitySchema, ClientCapabilitiesSchema, InitializeRequestParamsSchema, InitializeRequestSchema, isInitializeRequest, ServerCapabilitiesSchema, InitializeResultSchema, InitializedNotificationSchema, PingRequestSchema, ProgressSchema, ProgressNotificationParamsSchema, ProgressNotificationSchema, PaginatedRequestParamsSchema, PaginatedRequestSchema, PaginatedResultSchema, TaskStatusSchema, TaskSchema, CreateTaskResultSchema, TaskStatusNotificationParamsSchema, TaskStatusNotificationSchema, GetTaskRequestSchema, GetTaskResultSchema, GetTaskPayloadRequestSchema, GetTaskPayloadResultSchema, ListTasksRequestSchema, ListTasksResultSchema, CancelTaskRequestSchema, CancelTaskResultSchema, ResourceContentsSchema, TextResourceContentsSchema, Base64Schema, BlobResourceContentsSchema, RoleSchema, AnnotationsSchema, ResourceSchema, ResourceTemplateSchema, ListResourcesRequestSchema, ListResourcesResultSchema, ListResourceTemplatesRequestSchema, ListResourceTemplatesResultSchema, ResourceRequestParamsSchema, ReadResourceRequestParamsSchema, ReadResourceRequestSchema, ReadResourceResultSchema, ResourceListChangedNotificationSchema, SubscribeRequestParamsSchema, SubscribeRequestSchema, UnsubscribeRequestParamsSchema, UnsubscribeRequestSchema, ResourceUpdatedNotificationParamsSchema, ResourceUpdatedNotificationSchema, PromptArgumentSchema, PromptSchema, ListPromptsRequestSchema, ListPromptsResultSchema, GetPromptRequestParamsSchema, GetPromptRequestSchema, TextContentSchema, ImageContentSchema, AudioContentSchema, ToolUseContentSchema, EmbeddedResourceSchema, ResourceLinkSchema, ContentBlockSchema, PromptMessageSchema, GetPromptResultSchema, PromptListChangedNotificationSchema, ToolAnnotationsSchema, ToolExecutionSchema, ToolSchema, ListToolsRequestSchema, ListToolsResultSchema, CallToolResultSchema, CompatibilityCallToolResultSchema, CallToolRequestParamsSchema, CallToolRequestSchema, ToolListChangedNotificationSchema, ListChangedOptionsBaseSchema, LoggingLevelSchema, SetLevelRequestParamsSchema, SetLevelRequestSchema, LoggingMessageNotificationParamsSchema, LoggingMessageNotificationSchema, ModelHintSchema, ModelPreferencesSchema, ToolChoiceSchema, ToolResultContentSchema, SamplingContentSchema, SamplingMessageContentBlockSchema, SamplingMessageSchema, CreateMessageRequestParamsSchema, CreateMessageRequestSchema, CreateMessageResultSchema, CreateMessageResultWithToolsSchema, BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema, UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema, LegacyTitledEnumSchemaSchema, SingleSelectEnumSchemaSchema, UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema, MultiSelectEnumSchemaSchema, EnumSchemaSchema, PrimitiveSchemaDefinitionSchema, ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema, ElicitRequestParamsSchema, ElicitRequestSchema, ElicitationCompleteNotificationParamsSchema, ElicitationCompleteNotificationSchema, ElicitResultSchema, ResourceTemplateReferenceSchema, PromptReferenceSchema, CompleteRequestParamsSchema, CompleteRequestSchema, CompleteResultSchema, RootSchema, ListRootsRequestSchema, ListRootsResultSchema, RootsListChangedNotificationSchema, ClientRequestSchema, ClientNotificationSchema, ClientResultSchema, ServerRequestSchema, ServerNotificationSchema, ServerResultSchema, McpError, UrlElicitationRequiredError;
-var init_types2 = __esm({
+var init_types3 = __esm({
   "../service-capture/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js"() {
     init_v42();
     LATEST_PROTOCOL_VERSION = "2025-11-25";
@@ -17108,7 +17484,7 @@ var DEFAULT_REQUEST_TIMEOUT_MSEC, Protocol;
 var init_protocol = __esm({
   "../service-capture/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js"() {
     init_zod_compat();
-    init_types2();
+    init_types3();
     init_interfaces();
     init_zod_json_schema_compat();
     DEFAULT_REQUEST_TIMEOUT_MSEC = 6e4;
@@ -30690,7 +31066,7 @@ var Server;
 var init_server2 = __esm({
   "../service-capture/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js"() {
     init_protocol();
-    init_types2();
+    init_types3();
     init_ajv_provider();
     init_zod_compat();
     init_server();
@@ -31260,7 +31636,7 @@ var init_mcp = __esm({
     init_server2();
     init_zod_compat();
     init_zod_json_schema_compat();
-    init_types2();
+    init_types3();
     init_completable();
     init_uriTemplate();
     init_toolNameValidation();
@@ -32001,7 +32377,7 @@ function serializeMessage(message) {
 var ReadBuffer;
 var init_stdio = __esm({
   "../service-capture/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js"() {
-    init_types2();
+    init_types3();
     ReadBuffer = class {
       append(chunk) {
         this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
@@ -50810,9 +51186,9 @@ var require_view = __commonJS({
     var path = require("node:path");
     var fs = require("node:fs");
     var dirname2 = path.dirname;
-    var basename2 = path.basename;
+    var basename3 = path.basename;
     var extname = path.extname;
-    var join9 = path.join;
+    var join12 = path.join;
     var resolve4 = path.resolve;
     module2.exports = View;
     function View(name, options) {
@@ -50849,7 +51225,7 @@ var require_view = __commonJS({
         var root = roots[i];
         var loc = resolve4(root, name);
         var dir = dirname2(loc);
-        var file2 = basename2(loc);
+        var file2 = basename3(loc);
         path2 = this.resolve(dir, file2);
       }
       return path2;
@@ -50874,12 +51250,12 @@ var require_view = __commonJS({
     };
     View.prototype.resolve = function resolve5(dir, file2) {
       var ext = this.ext;
-      var path2 = join9(dir, file2);
+      var path2 = join12(dir, file2);
       var stat = tryStat(path2);
       if (stat && stat.isFile()) {
         return path2;
       }
-      path2 = join9(dir, basename2(file2, ext), "index" + ext);
+      path2 = join12(dir, basename3(file2, ext), "index" + ext);
       stat = tryStat(path2);
       if (stat && stat.isFile()) {
         return path2;
@@ -54163,7 +54539,7 @@ var require_content_disposition = __commonJS({
     "use strict";
     module2.exports = contentDisposition;
     module2.exports.parse = parse4;
-    var basename2 = require("path").basename;
+    var basename3 = require("path").basename;
     var ENCODE_URL_ATTR_CHAR_REGEXP = /[\x00-\x20"'()*,/:;<=>?@[\\\]{}\x7f]/g;
     var HEX_ESCAPE_REGEXP = /%[0-9A-Fa-f]{2}/;
     var HEX_ESCAPE_REPLACE_REGEXP = /%([0-9A-Fa-f]{2})/g;
@@ -54198,9 +54574,9 @@ var require_content_disposition = __commonJS({
       if (typeof fallback === "string" && NON_LATIN1_REGEXP.test(fallback)) {
         throw new TypeError("fallback must be ISO-8859-1 string");
       }
-      var name = basename2(filename);
+      var name = basename3(filename);
       var isQuotedString = TEXT_REGEXP.test(name);
-      var fallbackName = typeof fallback !== "string" ? fallback && getlatin1(name) : basename2(fallback);
+      var fallbackName = typeof fallback !== "string" ? fallback && getlatin1(name) : basename3(fallback);
       var hasFallback = typeof fallbackName === "string" && fallbackName !== name;
       if (hasFallback || !isQuotedString || HEX_ESCAPE_REGEXP.test(name)) {
         params["filename*"] = name;
@@ -54524,7 +54900,7 @@ var require_send = __commonJS({
     var Stream = require("stream");
     var util2 = require("util");
     var extname = path.extname;
-    var join9 = path.join;
+    var join12 = path.join;
     var normalize = path.normalize;
     var resolve4 = path.resolve;
     var sep = path.sep;
@@ -54696,7 +55072,7 @@ var require_send = __commonJS({
           return res;
         }
         parts = path2.split(sep);
-        path2 = normalize(join9(root, path2));
+        path2 = normalize(join12(root, path2));
       } else {
         if (UP_PATH_REGEXP.test(path2)) {
           debug('malicious path "%s"', path2);
@@ -54829,7 +55205,7 @@ var require_send = __commonJS({
           if (err) return self.onStatError(err);
           return self.error(404);
         }
-        var p = join9(path2, self._index[i]);
+        var p = join12(path2, self._index[i]);
         debug('stat "%s"', p);
         fs.stat(p, function(err2, stat) {
           if (err2) return next(err2);
@@ -56223,7 +56599,7 @@ var init_dist = __esm({
 var WebStandardStreamableHTTPServerTransport;
 var init_webStandardStreamableHttp = __esm({
   "../service-capture/node_modules/@modelcontextprotocol/sdk/dist/esm/server/webStandardStreamableHttp.js"() {
-    init_types2();
+    init_types3();
     WebStandardStreamableHTTPServerTransport = class {
       constructor(options = {}) {
         this._started = false;
@@ -56924,11 +57300,11 @@ var init_streamableHttp = __esm({
 
 // ../service-capture/claude-sessions/mcp-server.ts
 var mcp_server_exports = {};
-function resolveToken2() {
+function resolveToken3() {
   if (process.env.HAANSI_TOKEN) return process.env.HAANSI_TOKEN;
-  if ((0, import_fs3.existsSync)(CREDENTIALS_FILE4)) {
+  if ((0, import_fs5.existsSync)(CREDENTIALS_FILE5)) {
     try {
-      const creds = JSON.parse((0, import_fs3.readFileSync)(CREDENTIALS_FILE4, "utf-8"));
+      const creds = JSON.parse((0, import_fs5.readFileSync)(CREDENTIALS_FILE5, "utf-8"));
       if (creds.token) return creds.token;
     } catch {
     }
@@ -57013,25 +57389,25 @@ async function main3() {
   }
   warmupInBackground();
 }
-var import_dotenv3, import_path3, import_fs3, import_os2, DEFAULT_API_URL4, CREDENTIALS_FILE4, API_URL, TOKEN, contextSchema, isCollecting, lastCollectTime, COLLECT_COOLDOWN_MS, mcpServer, server;
+var import_dotenv3, import_path5, import_fs5, import_os4, DEFAULT_API_URL5, CREDENTIALS_FILE5, API_URL, TOKEN, contextSchema, isCollecting, lastCollectTime, COLLECT_COOLDOWN_MS, mcpServer, server;
 var init_mcp_server2 = __esm({
   "../service-capture/claude-sessions/mcp-server.ts"() {
     "use strict";
     import_dotenv3 = __toESM(require_main());
-    import_path3 = require("path");
-    import_fs3 = require("fs");
-    import_os2 = require("os");
+    import_path5 = require("path");
+    import_fs5 = require("fs");
+    import_os4 = require("os");
     init_collector();
     init_http_timeout();
     init_src();
     init_mcp();
     init_stdio2();
-    init_types2();
-    (0, import_dotenv3.config)({ path: (0, import_path3.resolve)(__dirname, "../../../.env") });
-    DEFAULT_API_URL4 = "https://api.haansi.co";
-    CREDENTIALS_FILE4 = (0, import_path3.join)((0, import_os2.homedir)(), ".haansi", "credentials.json");
-    API_URL = process.env.HAANSI_API_URL ?? DEFAULT_API_URL4;
-    TOKEN = resolveToken2();
+    init_types3();
+    (0, import_dotenv3.config)({ path: (0, import_path5.resolve)(__dirname, "../../../.env") });
+    DEFAULT_API_URL5 = "https://api.haansi.co";
+    CREDENTIALS_FILE5 = (0, import_path5.join)((0, import_os4.homedir)(), ".haansi", "credentials.json");
+    API_URL = process.env.HAANSI_API_URL ?? DEFAULT_API_URL5;
+    TOKEN = resolveToken3();
     if (!TOKEN) {
       process.exit(1);
     }
@@ -57323,30 +57699,59 @@ var init_mcp_server2 = __esm({
   }
 });
 
+// src/lib/codex-config.ts
+function tomlString(value) {
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+  return `"${escaped}"`;
+}
+function tomlStringArray(values) {
+  return `[${values.map(tomlString).join(", ")}]`;
+}
+function tomlInlineTable(entries) {
+  const parts = Object.entries(entries).map(
+    ([k, v]) => `${k} = ${tomlString(v)}`
+  );
+  return `{ ${parts.join(", ")} }`;
+}
+function upsertTomlTable(content, tablePath, entries) {
+  const bodyLines = Object.entries(entries).map(([k, v]) => `${k} = ${v}`);
+  const block = [`[${tablePath}]`, ...bodyLines].join("\n");
+  const lines = content.split("\n");
+  const headerRe = new RegExp(
+    `^\\s*\\[\\s*${tablePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\]\\s*$`
+  );
+  const startIdx = lines.findIndex((l) => headerRe.test(l));
+  if (startIdx === -1) {
+    const trimmed = content.replace(/\s*$/, "");
+    return trimmed.length > 0 ? `${trimmed}
+
+${block}
+` : `${block}
+`;
+  }
+  let endIdx = lines.length;
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    if (/^\s*\[/.test(lines[i])) {
+      endIdx = i;
+      break;
+    }
+  }
+  const before = lines.slice(0, startIdx);
+  const after = lines.slice(endIdx);
+  const rebuilt = [...before, ...block.split("\n"), ...after].join("\n");
+  return rebuilt.replace(/\n{3,}/g, "\n\n");
+}
+var init_codex_config = __esm({
+  "src/lib/codex-config.ts"() {
+    "use strict";
+  }
+});
+
 // src/commands/setup-mcp.ts
 var setup_mcp_exports = {};
 __export(setup_mcp_exports, {
   setupMcp: () => setupMcp
 });
-function resolveHaansiBin() {
-  try {
-    const binPath = (0, import_node_child_process2.execSync)("which haansi", { encoding: "utf-8" }).trim();
-    if (binPath) return binPath;
-  } catch {
-  }
-  return "haansi";
-}
-function resolveToken3() {
-  if (process.env.HAANSI_TOKEN) return process.env.HAANSI_TOKEN;
-  if ((0, import_node_fs3.existsSync)(CREDENTIALS_FILE5)) {
-    try {
-      const creds = JSON.parse((0, import_node_fs3.readFileSync)(CREDENTIALS_FILE5, "utf-8"));
-      if (typeof creds.token === "string" && creds.token) return creds.token;
-    } catch {
-    }
-  }
-  return null;
-}
 function parseTarget(arg) {
   if (!arg || arg === "all") return "all";
   if (arg === "solutions" || arg === "exchange") return arg;
@@ -57354,12 +57759,14 @@ function parseTarget(arg) {
     `Unknown target: ${arg}. Use one of: solutions, exchange, all (default).`
   );
 }
-async function setupMcp(targetArg) {
-  const target = parseTarget(targetArg);
+function exchangeUrl() {
+  return `${apiUrl().replace(/\/+$/, "")}/api/v1/access/exchange/mcp`;
+}
+function setupClaudeMcp(target) {
   let config6 = {};
-  if ((0, import_node_fs3.existsSync)(CLAUDE_JSON)) {
+  if ((0, import_node_fs5.existsSync)(CLAUDE_JSON)) {
     try {
-      config6 = JSON.parse((0, import_node_fs3.readFileSync)(CLAUDE_JSON, "utf-8"));
+      config6 = JSON.parse((0, import_node_fs5.readFileSync)(CLAUDE_JSON, "utf-8"));
     } catch {
       console.error(
         `Warning: Could not parse ${CLAUDE_JSON} \u2014 will overwrite with new config.`
@@ -57378,42 +57785,100 @@ async function setupMcp(targetArg) {
     installed.push(`haansi-solutions (stdio \u2192 ${haansiBin} mcp-server)`);
   }
   if (target === "all" || target === "exchange") {
-    const token = resolveToken3();
+    const token = resolveToken2();
     if (!token) {
-      const msg = "haansi-exchange not registered: no token found. Run `haansi auth login` first, or set HAANSI_TOKEN.";
-      if (target === "exchange") {
-        console.error(msg);
-        process.exit(1);
-      }
-      warnings.push(msg);
+      warnings.push(
+        "haansi-exchange not registered: no token found. Run `haansi auth login` first, or set HAANSI_TOKEN."
+      );
     } else {
-      const apiUrl = process.env.HAANSI_API_URL ?? DEFAULT_API_URL5;
-      const exchangeUrl = `${apiUrl.replace(/\/+$/, "")}/api/v1/access/exchange/mcp`;
+      const url2 = exchangeUrl();
       config6.mcpServers["haansi-exchange"] = {
         type: "http",
-        url: exchangeUrl,
+        url: url2,
         headers: { Authorization: `Bearer ${token}` }
       };
-      installed.push(`haansi-exchange (http \u2192 ${exchangeUrl})`);
+      installed.push(`haansi-exchange (http \u2192 ${url2})`);
+    }
+  }
+  (0, import_node_fs5.writeFileSync)(CLAUDE_JSON, JSON.stringify(config6, null, 2) + "\n", "utf-8");
+  console.log(`
+Claude Code \u2014 configured in ${CLAUDE_JSON}`);
+  for (const entry of installed) console.log(`  \u2022 ${entry}`);
+  for (const w of warnings) console.log(`  ! ${w}`);
+  return { installed, warnings };
+}
+function setupCodexMcp(target) {
+  let content = "";
+  if ((0, import_node_fs5.existsSync)(CODEX_CONFIG)) {
+    try {
+      content = (0, import_node_fs5.readFileSync)(CODEX_CONFIG, "utf-8");
+    } catch {
+      console.error(
+        `Warning: Could not read ${CODEX_CONFIG} \u2014 will create a new file.`
+      );
+    }
+  }
+  const installed = [];
+  const warnings = [];
+  if (target === "all" || target === "solutions") {
+    const haansiBin = resolveHaansiBin();
+    content = upsertTomlTable(content, "mcp_servers.haansi-solutions", {
+      command: tomlString(haansiBin),
+      args: tomlStringArray(["mcp-server"])
+    });
+    installed.push(`haansi-solutions (stdio \u2192 ${haansiBin} mcp-server)`);
+  }
+  if (target === "all" || target === "exchange") {
+    const token = resolveToken2();
+    if (!token) {
+      warnings.push(
+        "haansi-exchange not registered: no token found. Run `haansi auth login` first, or set HAANSI_TOKEN."
+      );
+    } else {
+      const url2 = exchangeUrl();
+      content = upsertTomlTable(content, "mcp_servers.haansi-exchange", {
+        url: tomlString(url2),
+        http_headers: tomlInlineTable({ Authorization: `Bearer ${token}` })
+      });
+      installed.push(`haansi-exchange (http \u2192 ${url2})`);
     }
   }
-  (0, import_node_fs3.writeFileSync)(CLAUDE_JSON, JSON.stringify(config6, null, 2) + "\n", "utf-8");
-  console.log(`MCP servers configured in ${CLAUDE_JSON}`);
+  (0, import_node_fs5.mkdirSync)(CODEX_HOME, { recursive: true });
+  (0, import_node_fs5.writeFileSync)(CODEX_CONFIG, content, "utf-8");
+  console.log(`
+OpenAI Codex \u2014 configured in ${CODEX_CONFIG}`);
   for (const entry of installed) console.log(`  \u2022 ${entry}`);
   for (const w of warnings) console.log(`  ! ${w}`);
-  console.log("\nRestart Claude Code to activate the changes.");
+  return { installed, warnings };
+}
+async function setupMcp(targetArg, agentFlag) {
+  const target = parseTarget(targetArg);
+  const selection = resolveAgentSelection(agentFlag);
+  for (const agentId of selection.agents) {
+    WRITERS[agentId](target);
+  }
+  saveAgents(selection.agents);
+  const restart = selection.agents.map((a) => a === "codex" ? "Codex" : "Claude Code").join(" / ");
+  console.log(`
+Restart ${restart} to activate the changes.`);
 }
-var import_node_fs3, import_node_path3, import_node_os3, import_node_child_process2, CLAUDE_JSON, CREDENTIALS_FILE5, DEFAULT_API_URL5;
+var import_node_fs5, import_node_path4, import_node_os4, CLAUDE_JSON, CODEX_HOME, CODEX_CONFIG, WRITERS;
 var init_setup_mcp = __esm({
   "src/commands/setup-mcp.ts"() {
     "use strict";
-    import_node_fs3 = require("node:fs");
-    import_node_path3 = require("node:path");
-    import_node_os3 = require("node:os");
-    import_node_child_process2 = require("node:child_process");
-    CLAUDE_JSON = (0, import_node_path3.join)((0, import_node_os3.homedir)(), ".claude.json");
-    CREDENTIALS_FILE5 = (0, import_node_path3.join)((0, import_node_os3.homedir)(), ".haansi", "credentials.json");
-    DEFAULT_API_URL5 = "https://api.haansi.co";
+    import_node_fs5 = require("node:fs");
+    import_node_path4 = require("node:path");
+    import_node_os4 = require("node:os");
+    init_paths();
+    init_agent_selection();
+    init_codex_config();
+    CLAUDE_JSON = (0, import_node_path4.join)((0, import_node_os4.homedir)(), ".claude.json");
+    CODEX_HOME = process.env.CODEX_HOME || (0, import_node_path4.join)((0, import_node_os4.homedir)(), ".codex");
+    CODEX_CONFIG = (0, import_node_path4.join)(CODEX_HOME, "config.toml");
+    WRITERS = {
+      "claude-code": setupClaudeMcp,
+      codex: setupCodexMcp
+    };
   }
 });
 
@@ -57463,7 +57928,7 @@ function buildPlist(haansiPath) {
 }
 async function setupDaemon(uninstall) {
   if (uninstall) {
-    if (!(0, import_node_fs4.existsSync)(PLIST_PATH)) {
+    if (!(0, import_node_fs6.existsSync)(PLIST_PATH)) {
       console.log("Daemon is not installed.");
       return;
     }
@@ -57472,13 +57937,13 @@ async function setupDaemon(uninstall) {
     } catch (err) {
       console.error("Failed to unload daemon:", err);
     }
-    (0, import_node_fs4.unlinkSync)(PLIST_PATH);
+    (0, import_node_fs6.unlinkSync)(PLIST_PATH);
     console.log("Daemon stopped and removed.");
     return;
   }
   const haansiPath = findHaansiBin();
-  (0, import_node_fs4.mkdirSync)((0, import_node_path4.join)((0, import_node_os4.homedir)(), ".haansi"), { recursive: true });
-  (0, import_node_fs4.writeFileSync)(PLIST_PATH, buildPlist(haansiPath), "utf-8");
+  (0, import_node_fs6.mkdirSync)((0, import_node_path5.join)((0, import_node_os5.homedir)(), ".haansi"), { recursive: true });
+  (0, import_node_fs6.writeFileSync)(PLIST_PATH, buildPlist(haansiPath), "utf-8");
   try {
     (0, import_node_child_process3.spawnSync)("launchctl", ["unload", PLIST_PATH], { stdio: "pipe" });
   } catch (err) {
@@ -57492,22 +57957,22 @@ async function setupDaemon(uninstall) {
 The daemon will start automatically on every login.`);
   console.log(`To uninstall: haansi setup-daemon --uninstall`);
 }
-var import_node_child_process3, import_node_fs4, import_node_path4, import_node_os4, PLIST_LABEL, PLIST_PATH, LOG_FILE;
+var import_node_child_process3, import_node_fs6, import_node_path5, import_node_os5, PLIST_LABEL, PLIST_PATH, LOG_FILE;
 var init_setup_daemon = __esm({
   "src/commands/setup-daemon.ts"() {
     "use strict";
     import_node_child_process3 = require("node:child_process");
-    import_node_fs4 = require("node:fs");
-    import_node_path4 = require("node:path");
-    import_node_os4 = require("node:os");
+    import_node_fs6 = require("node:fs");
+    import_node_path5 = require("node:path");
+    import_node_os5 = require("node:os");
     PLIST_LABEL = "co.haansi.daemon";
-    PLIST_PATH = (0, import_node_path4.join)(
-      (0, import_node_os4.homedir)(),
+    PLIST_PATH = (0, import_node_path5.join)(
+      (0, import_node_os5.homedir)(),
       "Library",
       "LaunchAgents",
       `${PLIST_LABEL}.plist`
     );
-    LOG_FILE = (0, import_node_path4.join)((0, import_node_os4.homedir)(), ".haansi", "daemon.log");
+    LOG_FILE = (0, import_node_path5.join)((0, import_node_os5.homedir)(), ".haansi", "daemon.log");
   }
 });
 
@@ -57518,9 +57983,9 @@ __export(config_exports, {
 });
 function resolveToken4() {
   if (process.env.HAANSI_TOKEN) return process.env.HAANSI_TOKEN;
-  if ((0, import_node_fs5.existsSync)(CREDENTIALS_FILE6)) {
+  if ((0, import_node_fs7.existsSync)(CREDENTIALS_FILE6)) {
     try {
-      const creds = JSON.parse((0, import_node_fs5.readFileSync)(CREDENTIALS_FILE6, "utf-8"));
+      const creds = JSON.parse((0, import_node_fs7.readFileSync)(CREDENTIALS_FILE6, "utf-8"));
       if (creds.token) return creds.token;
     } catch (err) {
       console.error("Failed to read credentials file:", err);
@@ -57537,12 +58002,12 @@ async function config5(args) {
     process.exit(1);
     return;
   }
-  const apiUrl = process.env.HAANSI_API_URL ?? DEFAULT_API_URL6;
+  const apiUrl2 = process.env.HAANSI_API_URL ?? DEFAULT_API_URL6;
   const subcommand = args[0];
   if (subcommand === "get") {
     const key = args[1];
     const response = await fetch(
-      `${apiUrl}/api/v1/workspace/users/me/preferences`,
+      `${apiUrl2}/api/v1/workspace/users/me/preferences`,
       {
         headers: { Authorization: `Bearer ${token}` }
       }
@@ -57589,7 +58054,7 @@ async function config5(args) {
       return;
     }
     const response = await fetch(
-      `${apiUrl}/api/v1/workspace/users/me/preferences`,
+      `${apiUrl2}/api/v1/workspace/users/me/preferences`,
       {
         method: "PATCH",
         headers: {
@@ -57618,15 +58083,15 @@ Supported keys:
     if (subcommand !== void 0) process.exit(1);
   }
 }
-var import_node_fs5, import_node_path5, import_node_os5, DEFAULT_API_URL6, CREDENTIALS_FILE6, VALID_SESSION_MODES;
+var import_node_fs7, import_node_path6, import_node_os6, DEFAULT_API_URL6, CREDENTIALS_FILE6, VALID_SESSION_MODES;
 var init_config = __esm({
   "src/commands/config.ts"() {
     "use strict";
-    import_node_fs5 = require("node:fs");
-    import_node_path5 = require("node:path");
-    import_node_os5 = require("node:os");
+    import_node_fs7 = require("node:fs");
+    import_node_path6 = require("node:path");
+    import_node_os6 = require("node:os");
     DEFAULT_API_URL6 = "https://api.haansi.co";
-    CREDENTIALS_FILE6 = (0, import_node_path5.join)((0, import_node_os5.homedir)(), ".haansi", "credentials.json");
+    CREDENTIALS_FILE6 = (0, import_node_path6.join)((0, import_node_os6.homedir)(), ".haansi", "credentials.json");
     VALID_SESSION_MODES = ["private", "org"];
   }
 });
@@ -57640,9 +58105,9 @@ __export(list_exports, {
 });
 function resolveToken5() {
   if (process.env.HAANSI_TOKEN) return process.env.HAANSI_TOKEN;
-  if ((0, import_node_fs6.existsSync)(CREDENTIALS_FILE7)) {
+  if ((0, import_node_fs8.existsSync)(CREDENTIALS_FILE7)) {
     try {
-      const creds = JSON.parse((0, import_node_fs6.readFileSync)(CREDENTIALS_FILE7, "utf-8"));
+      const creds = JSON.parse((0, import_node_fs8.readFileSync)(CREDENTIALS_FILE7, "utf-8"));
       if (creds.token) return creds.token;
     } catch (err) {
       console.error("Failed to read credentials file:", err);
@@ -57650,8 +58115,8 @@ function resolveToken5() {
   }
   throw new Error("No token found. Run `haansi init` first.");
 }
-async function apiGet3(path, token, apiUrl) {
-  const response = await fetch(`${apiUrl}/api/v1${path}`, {
+async function apiGet3(path, token, apiUrl2) {
+  const response = await fetch(`${apiUrl2}/api/v1${path}`, {
     headers: { Authorization: `Bearer ${token}` }
   });
   if (!response.ok) {
@@ -57660,8 +58125,8 @@ async function apiGet3(path, token, apiUrl) {
   }
   return response.json();
 }
-async function apiPost2(path, body, token, apiUrl) {
-  const response = await fetch(`${apiUrl}/api/v1${path}`, {
+async function apiPost2(path, body, token, apiUrl2) {
+  const response = await fetch(`${apiUrl2}/api/v1${path}`, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${token}`,
@@ -57676,20 +58141,20 @@ async function apiPost2(path, body, token, apiUrl) {
   return response.json();
 }
 async function list(options) {
-  const apiUrl = process.env.HAANSI_API_URL ?? DEFAULT_API_URL7;
+  const apiUrl2 = process.env.HAANSI_API_URL ?? DEFAULT_API_URL7;
   const token = resolveToken5();
   let data;
   if (options.search) {
     data = await apiGet3(
       `/memory/solutions/search?q=${encodeURIComponent(options.search)}&top_k=${options.limit}`,
       token,
-      apiUrl
+      apiUrl2
     );
   } else {
     data = await apiGet3(
       `/memory/solutions/recent?limit=${options.limit}`,
       token,
-      apiUrl
+      apiUrl2
     );
   }
   if (!data.results || data.results.length === 0) {
@@ -57702,13 +58167,13 @@ async function list(options) {
 ${data.results.length} result(s)`);
 }
 async function searchKnowledge(options) {
-  const apiUrl = process.env.HAANSI_API_URL ?? DEFAULT_API_URL7;
+  const apiUrl2 = process.env.HAANSI_API_URL ?? DEFAULT_API_URL7;
   const token = resolveToken5();
   let url2 = `/memory/solutions/knowledge/search?q=${encodeURIComponent(options.query)}&limit=${options.limit}`;
   if (options.artifactType) {
     url2 += `&artifact_type=${encodeURIComponent(options.artifactType)}`;
   }
-  const data = await apiGet3(url2, token, apiUrl);
+  const data = await apiGet3(url2, token, apiUrl2);
   if (!data.results || data.results.length === 0) {
     console.log("No knowledge artifacts found matching your query.");
     return;
@@ -57719,7 +58184,7 @@ async function searchKnowledge(options) {
 ${data.results.length} result(s)`);
 }
 async function saveKnowledge(options) {
-  const apiUrl = process.env.HAANSI_API_URL ?? DEFAULT_API_URL7;
+  const apiUrl2 = process.env.HAANSI_API_URL ?? DEFAULT_API_URL7;
   const token = resolveToken5();
   const body = {
     problem_description: options.problem,
@@ -57733,28 +58198,32 @@ async function saveKnowledge(options) {
     "/memory/solutions/mined",
     body,
     token,
-    apiUrl
+    apiUrl2
   );
   console.log("Knowledge saved successfully.");
   console.log(`  Problem:  ${data.problem_description}`);
   console.log(`  Solution: ${data.solution_summary}`);
   console.log("\nThis is now searchable via `haansi search-solutions`.");
 }
-var import_node_fs6, import_node_path6, import_node_os6, DEFAULT_API_URL7, CREDENTIALS_FILE7;
+var import_node_fs8, import_node_path7, import_node_os7, DEFAULT_API_URL7, CREDENTIALS_FILE7;
 var init_list = __esm({
   "src/commands/list.ts"() {
     "use strict";
-    import_node_fs6 = require("node:fs");
-    import_node_path6 = require("node:path");
-    import_node_os6 = require("node:os");
+    import_node_fs8 = require("node:fs");
+    import_node_path7 = require("node:path");
+    import_node_os7 = require("node:os");
     DEFAULT_API_URL7 = "https://api.haansi.co";
-    CREDENTIALS_FILE7 = (0, import_node_path6.join)((0, import_node_os6.homedir)(), ".haansi", "credentials.json");
+    CREDENTIALS_FILE7 = (0, import_node_path7.join)((0, import_node_os7.homedir)(), ".haansi", "credentials.json");
   }
 });
 
 // src/index.ts
 var { version: VERSION } = require_package();
 var command = process.argv[2];
+function getFlag(flag) {
+  const idx = process.argv.indexOf(flag);
+  return idx !== -1 ? process.argv[idx + 1] : void 0;
+}
 async function run2() {
   if (command === "--version" || command === "-v") {
     console.log(VERSION);
@@ -57782,24 +58251,47 @@ Usage: haansi auth login`
     }
     case "collect": {
       const { collect: collect2 } = await Promise.resolve().then(() => (init_collector(), collector_exports));
+      const { resolveAgentSelection: resolveAgentSelection2 } = await Promise.resolve().then(() => (init_agent_selection(), agent_selection_exports));
       const forceAll = process.argv.includes("--force-all");
       const dryRun = process.argv.includes("--dry-run");
       const limitIdx = process.argv.indexOf("--limit");
       const limit = limitIdx !== -1 ? parseInt(process.argv[limitIdx + 1], 10) : void 0;
-      const projectPath = process.env.CLAUDE_PROJECT_PATH || void 0;
+      const agents = resolveAgentSelection2(getFlag("--agent")).agents;
       const { uploaded, skipped, errors } = await collect2({
         forceAll,
         dryRun,
         limit,
-        projectPath
+        agents
       });
       console.log(
         `
-Collector done: ${uploaded} uploaded, ${skipped} unchanged, ${errors} errors`
+Collector done (${agents.join(", ")}): ${uploaded} uploaded, ${skipped} unchanged, ${errors} errors`
       );
       if (errors > 0) process.exit(1);
       break;
     }
+    case "agents": {
+      const { detectInstalled: detectInstalled2, getAgents: getAgents2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+      const { resolveAgentSelection: resolveAgentSelection2 } = await Promise.resolve().then(() => (init_agent_selection(), agent_selection_exports));
+      const installed = new Set(detectInstalled2().map((a) => a.id));
+      const selection = resolveAgentSelection2();
+      console.log("Supported coding agents:\n");
+      for (const a of getAgents2()) {
+        const flags = [
+          installed.has(a.id) ? "installed" : "not detected",
+          selection.agents.includes(a.id) ? "selected" : null
+        ].filter(Boolean);
+        console.log(`  \u2022 ${a.displayName} [${a.id}] \u2014 ${flags.join(", ")}`);
+      }
+      console.log(
+        `
+Active selection (${selection.source}): ${selection.agents.join(", ")}`
+      );
+      console.log(
+        "Change with `haansi setup-mcp --agent <claude|codex|both>` or `--agent` on collect."
+      );
+      break;
+    }
     case "daemon": {
       await Promise.resolve().then(() => (init_collector_daemon(), collector_daemon_exports));
       break;
@@ -57810,8 +58302,8 @@ Collector done: ${uploaded} uploaded, ${skipped} unchanged, ${errors} errors`
     }
     case "setup-mcp": {
       const { setupMcp: setupMcp2 } = await Promise.resolve().then(() => (init_setup_mcp(), setup_mcp_exports));
-      const targetArg = process.argv[3];
-      await setupMcp2(targetArg);
+      const targetArg = process.argv[3] && !process.argv[3].startsWith("--") ? process.argv[3] : void 0;
+      await setupMcp2(targetArg, getFlag("--agent"));
       break;
     }
     case "setup-daemon": {
@@ -57896,7 +58388,7 @@ Collector done: ${uploaded} uploaded, ${skipped} unchanged, ${errors} errors`
 }
 function printUsage() {
   console.log(`
-Haansi CLI v${VERSION} \u2014 Session collector and MCP server for Claude Code
+Haansi CLI v${VERSION} \u2014 Session collector and MCP server for Claude Code & OpenAI Codex
 
 Usage:
   haansi <command> [options]
@@ -57904,7 +58396,8 @@ Usage:
 Commands:
   auth login                 Log in via browser (recommended)
   init                       Authenticate with a token (for CI / headless)
-  collect                    Upload new/changed Claude sessions once
+  collect [--agent <sel>]    Upload new/changed sessions once
+  agents                     List supported / installed / selected agents
   config get [key]           Show your preferences (e.g. session_mode)
   config set <key> <val>     Update a preference
 
@@ -57914,8 +58407,11 @@ Commands:
   save-knowledge             Save a problem/solution for future retrieval
 
   daemon                     Run the collector on a schedule (every 30 min)
-  mcp-server                 Start the Haansi MCP server (used by Claude Code)
-  setup-mcp [target]         Register MCP servers in ~/.claude.json
+  mcp-server                 Start the Haansi MCP server (used by the agent)
+  setup-mcp [target] [--agent <sel>]
+                             Register MCP servers with a coding agent.
+                             Claude Code \u2192 ~/.claude.json; Codex \u2192 ~/.codex/config.toml
+                             agent:  claude | codex | both (default: installed)
                              target: solutions | exchange | all (default: all)
                              - solutions: stdio, per-org search/save tools
                              - exchange:  http, cross-org marketplace (read-only)
@@ -57924,6 +58420,7 @@ Commands:
 
 Options:
   --version, -v              Show installed version
+  --agent <sel>              claude | codex | both (collect, setup-mcp)
   --limit <n>                Number of results (default: 5 for search, 10 for list)
 
 Options for search-knowledge:
@@ -57937,6 +58434,7 @@ Options for save-knowledge:
   --tags tag1,tag2           Comma-separated tags
 
 Options for collect:
+  --agent <sel>              claude | codex | both (default: installed agents)
   --force-all                Re-upload all sessions, not just new ones
   --dry-run                  Scan without uploading
   --limit <n>                Upload at most n sessions
@@ -57944,8 +58442,9 @@ Options for collect:
 Environment variables:
   HAANSI_TOKEN               API token (or use \`haansi init\` to save it)
   HAANSI_API_URL             API base URL (default: https://api.haansi.co)
-  CLAUDE_PROJECT_PATH        Collect from a specific project path only
-  CLAUDE_COLLECT_SCHEDULE    Cron expression for daemon (default: */30 * * * *)
+  CODEX_HOME                 Codex home dir (default: ~/.codex)
+  HAANSI_AGENTS              Daemon: comma-separated agents (claude-code,codex)
+  HAANSI_COLLECT_SCHEDULE    Cron expression for daemon (default: */30 * * * *)
 `);
 }
 run2().catch((err) => {