haansi 0.1.2 → 0.1.4

package/dist/haansi.js

@@ -44,10 +44,10 @@ function prompt(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve5) => {
+  return new Promise((resolve4) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve5(answer.trim());
+      resolve4(answer.trim());
     });
   });
 }
@@ -380,7 +380,7 @@ var require_main = __commonJS({
         return { parsed: parsedAll };
       }
     }
-    function config6(options) {
+    function config5(options) {
       if (_dotenvKey(options).length === 0) {
         return DotenvModule.configDotenv(options);
       }
@@ -447,7 +447,7 @@ var require_main = __commonJS({
       configDotenv,
       _configVault,
       _parseVault,
-      config: config6,
+      config: config5,
       decrypt,
       parse: parse4,
       populate
@@ -515,506 +515,6 @@ var init_logger = __esm({
   }
 });
 
-// ../service-capture/claude-sessions/reader.ts
-var import_fs, import_fs2, import_path, import_os, logger, CLAUDE_DIR, PROJECTS_DIR, ClaudeSessionReader;
-var init_reader = __esm({
-  "../service-capture/claude-sessions/reader.ts"() {
-    "use strict";
-    import_fs = require("fs");
-    import_fs2 = require("fs");
-    import_path = require("path");
-    import_os = require("os");
-    init_logger();
-    logger = createLogger("claude-session-reader");
-    CLAUDE_DIR = (0, import_path.join)((0, import_os.homedir)(), ".claude");
-    PROJECTS_DIR = (0, import_path.join)(CLAUDE_DIR, "projects");
-    ClaudeSessionReader = class {
-      /**
-       * Convert a filesystem path to the ~/.claude/projects/ directory name format.
-       * Claude Code replaces both '/' and '_' with '-'.
-       * e.g. /Users/foo/git_repos/haansi-platform → -Users-foo-git-repos-haansi-platform
-       */
-      static projectDirName(absolutePath) {
-        return absolutePath.replace(/[/_]/g, "-");
-      }
-      /**
-       * Returns the ~/.claude/projects/[encoded-path]/ directory for a given project.
-       */
-      static getProjectSessionsDir(projectAbsolutePath) {
-        return (0, import_path.join)(PROJECTS_DIR, this.projectDirName(projectAbsolutePath));
-      }
-      /**
-       * List all project directories in ~/.claude/projects/.
-       */
-      listProjectDirs() {
-        if (!(0, import_fs.existsSync)(PROJECTS_DIR)) return [];
-        return (0, import_fs2.readdirSync)(PROJECTS_DIR).map((name) => (0, import_path.join)(PROJECTS_DIR, name)).filter((p) => (0, import_fs2.statSync)(p).isDirectory());
-      }
-      /**
-       * Read and parse sessions-index.json for a given project sessions directory.
-       * Returns null if the file doesn't exist or can't be parsed.
-       */
-      readSessionsIndex(sessionsDir) {
-        const indexPath = (0, import_path.join)(sessionsDir, "sessions-index.json");
-        if (!(0, import_fs.existsSync)(indexPath)) return null;
-        try {
-          const raw = (0, import_fs.readFileSync)(indexPath, "utf-8");
-          return JSON.parse(raw);
-        } catch (err) {
-          logger.warn("Failed to parse sessions-index.json", {
-            sessionsDir,
-            err: String(err)
-          });
-          return null;
-        }
-      }
-      /**
-       * Parse all JSONL entries from a session file. Returns raw entries in file order.
-       * Lines that fail to parse are skipped with a warning.
-       */
-      parseSessionFile(filePath) {
-        if (!(0, import_fs.existsSync)(filePath)) {
-          logger.warn("Session file not found", { filePath });
-          return [];
-        }
-        const entries = [];
-        const lines = (0, import_fs.readFileSync)(filePath, "utf-8").split("\n");
-        for (let i = 0; i < lines.length; i++) {
-          const line = lines[i].trim();
-          if (!line) continue;
-          try {
-            entries.push(JSON.parse(line));
-          } catch {
-          }
-        }
-        return entries;
-      }
-      /**
-       * Extract plain text from a message content value.
-       * Handles both legacy string content and structured block arrays.
-       */
-      extractText(content) {
-        if (typeof content === "string") return content;
-        return content.filter(
-          (b) => b.type === "text" || b.type === "thinking"
-        ).map((b) => "text" in b ? b.text : b.thinking ?? "").join("\n").trim();
-      }
-      /**
-       * Extract tool_use blocks from a message content array (assistant turns).
-       */
-      extractToolCalls(content) {
-        if (typeof content === "string") return [];
-        return content.filter(
-          (b) => b.type === "tool_use"
-        ).map((b) => ({
-          id: b.id,
-          name: b.name,
-          input: b.input
-        }));
-      }
-      /**
-       * Extract tool_result blocks from a message content array (user turns).
-       */
-      extractToolResults(content) {
-        if (typeof content === "string") return [];
-        return content.filter(
-          (b) => b.type === "tool_result"
-        ).map((b) => {
-          const rawContent = b.content;
-          let text;
-          if (typeof rawContent === "string") {
-            text = rawContent;
-          } else if (Array.isArray(rawContent)) {
-            text = rawContent.map((item) => "text" in item ? item.text ?? "" : "").join("\n");
-          } else {
-            text = "";
-          }
-          return {
-            toolUseId: b.tool_use_id,
-            content: text,
-            isError: b.is_error ?? false
-          };
-        });
-      }
-      /**
-       * Convert raw JSONL entries into ordered ClauseTurns.
-       * Reconstruction order: build a parentUuid → child map, then walk from roots.
-       * Falls back to file order if the graph has cycles or disconnected nodes.
-       */
-      reconstructThread(entries) {
-        const messageEntries = entries.filter(
-          (e) => (e.type === "user" || e.type === "assistant") && e.message
-        );
-        if (messageEntries.length === 0) return [];
-        const byUuid = /* @__PURE__ */ new Map();
-        const childrenOf = /* @__PURE__ */ new Map();
-        for (const entry of messageEntries) {
-          byUuid.set(entry.uuid, entry);
-          const parent = entry.parentUuid ?? "__root__";
-          if (!childrenOf.has(parent)) childrenOf.set(parent, []);
-          childrenOf.get(parent).push(entry.uuid);
-        }
-        const ordered = [];
-        const visited = /* @__PURE__ */ new Set();
-        const queue = childrenOf.get("__root__") ?? [];
-        while (queue.length > 0) {
-          const uuid3 = queue.shift();
-          if (visited.has(uuid3)) continue;
-          visited.add(uuid3);
-          const entry = byUuid.get(uuid3);
-          if (entry) {
-            ordered.push(entry);
-            const children = childrenOf.get(uuid3) ?? [];
-            queue.push(...children);
-          }
-        }
-        for (const entry of messageEntries) {
-          if (!visited.has(entry.uuid)) {
-            ordered.push(entry);
-          }
-        }
-        return ordered.map((entry) => {
-          const content = entry.message.content;
-          return {
-            uuid: entry.uuid,
-            parentUuid: entry.parentUuid,
-            role: entry.message.role,
-            text: this.extractText(content),
-            toolCalls: this.extractToolCalls(content),
-            toolResults: this.extractToolResults(content),
-            timestamp: entry.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-            isSidechain: entry.isSidechain ?? false,
-            agentId: entry.agentId,
-            gitBranch: entry.gitBranch
-          };
-        });
-      }
-      /**
-       * Read a single session JSONL file and return a ClaudeSession.
-       * Uses index metadata when provided for faster startup (avoids full parse for summary/firstPrompt).
-       */
-      readSession(filePath, indexEntry) {
-        const entries = this.parseSessionFile(filePath);
-        const turns = this.reconstructThread(entries);
-        const stat = (0, import_fs2.statSync)(filePath);
-        const sessionId = indexEntry?.sessionId ?? (0, import_path.basename)(filePath, ".jsonl");
-        const summaryEntry = entries.find((e) => e.type === "summary");
-        const summary = indexEntry?.summary ?? summaryEntry?.summary;
-        const firstUserTurn = turns.find(
-          (t) => t.role === "user" && !t.isSidechain
-        );
-        const firstPrompt = indexEntry?.firstPrompt ?? firstUserTurn?.text?.slice(0, 500) ?? "";
-        return {
-          sessionId,
-          projectPath: indexEntry?.projectPath ?? "",
-          filePath,
-          fileMtime: stat.mtimeMs,
-          gitBranch: indexEntry?.gitBranch ?? turns[0]?.gitBranch,
-          firstPrompt,
-          summary,
-          created: indexEntry?.created ?? turns[0]?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
-          modified: indexEntry?.modified ?? turns[turns.length - 1]?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
-          turns,
-          subagentSessions: [],
-          // populated separately by ingester if needed
-          messageCount: turns.length
-        };
-      }
-      /**
-       * Read all sessions for a project directory using the sessions-index for efficiency.
-       * Only reads JSONL files that are present and parseable.
-       */
-      readAllSessions(sessionsDir) {
-        const index = this.readSessionsIndex(sessionsDir);
-        const sessions = [];
-        if (!index) {
-          logger.warn(
-            "No sessions-index.json found, falling back to directory scan",
-            { sessionsDir }
-          );
-          return this.scanSessionFiles(sessionsDir);
-        }
-        const mainEntries = index.entries.filter((e) => !e.isSidechain);
-        for (const entry of mainEntries) {
-          if (!(0, import_fs.existsSync)(entry.fullPath)) continue;
-          try {
-            const session = this.readSession(entry.fullPath, entry);
-            sessions.push(session);
-          } catch (err) {
-            logger.warn("Failed to read session", {
-              sessionId: entry.sessionId,
-              err: String(err)
-            });
-          }
-        }
-        logger.info(`Read ${sessions.length} sessions from index`, { sessionsDir });
-        return sessions;
-      }
-      /**
-       * Fallback: scan a directory for *.jsonl files and parse each one.
-       * Skips the subagents/ subdirectory (handled separately).
-       */
-      scanSessionFiles(sessionsDir) {
-        if (!(0, import_fs.existsSync)(sessionsDir)) return [];
-        const sessions = [];
-        const entries = (0, import_fs2.readdirSync)(sessionsDir);
-        for (const name of entries) {
-          if (!name.endsWith(".jsonl")) continue;
-          const filePath = (0, import_path.join)(sessionsDir, name);
-          try {
-            sessions.push(this.readSession(filePath));
-          } catch (err) {
-            logger.warn("Failed to parse session file", { name, err: String(err) });
-          }
-        }
-        return sessions;
-      }
-    };
-  }
-});
-
-// ../service-capture/claude-sessions/ingester.ts
-async function main() {
-  const projectPath = process.env.CLAUDE_PROJECT_PATH ?? process.cwd();
-  const forceAll = process.argv.includes("--force-all");
-  logger2.info("Claude Session Ingester starting", { projectPath, forceAll });
-  const ingester = new ClaudeSessionIngester({ projectPath });
-  const result = await ingester.scan({ forceAll });
-  console.log("\n=== Scan Results ===");
-  console.log(`Total sessions scanned : ${result.totalScanned}`);
-  console.log(`New sessions           : ${result.newSessions.length}`);
-  console.log(`Updated sessions       : ${result.updatedSessions.length}`);
-  console.log(`Unchanged (skipped)    : ${result.unchangedCount}`);
-  const toProcess = [...result.newSessions, ...result.updatedSessions];
-  if (toProcess.length === 0) {
-    console.log("\nNo new sessions to process.");
-    return;
-  }
-  console.log("\n=== Sessions to Process ===");
-  for (const session of toProcess) {
-    const preview = session.firstPrompt.slice(0, 100).replace(/\n/g, " ");
-    console.log(
-      `
-[${session.sessionId.slice(0, 8)}] ${session.gitBranch ?? "unknown-branch"}`
-    );
-    console.log(`  Turns    : ${session.messageCount}`);
-    console.log(`  Created  : ${session.created.slice(0, 19)}`);
-    console.log(`  Modified : ${session.modified.slice(0, 19)}`);
-    console.log(`  Preview  : ${preview}${preview.length === 100 ? "\u2026" : ""}`);
-  }
-  console.log(
-    "\n\u2713 Reader and ingester working. Next step: resolution detection."
-  );
-}
-var import_dotenv, import_path2, import_fs3, import_os2, logger2, DEFAULT_STATE_FILE, STATE_VERSION, ClaudeSessionIngester;
-var init_ingester = __esm({
-  "../service-capture/claude-sessions/ingester.ts"() {
-    "use strict";
-    import_dotenv = __toESM(require_main());
-    import_path2 = require("path");
-    import_fs3 = require("fs");
-    import_os2 = require("os");
-    init_reader();
-    init_logger();
-    (0, import_dotenv.config)({ path: (0, import_path2.resolve)(__dirname, "../../../.env") });
-    logger2 = createLogger("claude-session-ingester");
-    DEFAULT_STATE_FILE = (0, import_path2.join)(
-      (0, import_os2.homedir)(),
-      ".claude",
-      "haansi-mining-state.json"
-    );
-    STATE_VERSION = 1;
-    ClaudeSessionIngester = class {
-      reader;
-      stateFile;
-      projectPath;
-      constructor(options) {
-        this.reader = new ClaudeSessionReader();
-        this.projectPath = options?.projectPath ?? process.env.CLAUDE_PROJECT_PATH ?? process.cwd();
-        this.stateFile = options?.stateFile ?? process.env.CLAUDE_STATE_FILE ?? DEFAULT_STATE_FILE;
-      }
-      // ---------------------------------------------------------------------------
-      // State management
-      // ---------------------------------------------------------------------------
-      loadState() {
-        if (!(0, import_fs3.existsSync)(this.stateFile)) {
-          return {
-            version: STATE_VERSION,
-            lastRunAt: (/* @__PURE__ */ new Date(0)).toISOString(),
-            projectPath: this.projectPath,
-            processed: {}
-          };
-        }
-        try {
-          return JSON.parse((0, import_fs3.readFileSync)(this.stateFile, "utf-8"));
-        } catch {
-          logger2.warn("Could not parse state file, starting fresh", {
-            stateFile: this.stateFile
-          });
-          return {
-            version: STATE_VERSION,
-            lastRunAt: (/* @__PURE__ */ new Date(0)).toISOString(),
-            projectPath: this.projectPath,
-            processed: {}
-          };
-        }
-      }
-      saveState(state) {
-        (0, import_fs3.writeFileSync)(this.stateFile, JSON.stringify(state, null, 2), "utf-8");
-        logger2.debug("State saved", { stateFile: this.stateFile });
-      }
-      // ---------------------------------------------------------------------------
-      // Core scan logic
-      // ---------------------------------------------------------------------------
-      /**
-       * Scan for new or changed sessions relative to the persisted state.
-       * Returns only sessions that need processing (new or mtime changed).
-       */
-      async scan(options) {
-        const sessionsDir = ClaudeSessionReader.getProjectSessionsDir(
-          this.projectPath
-        );
-        if (!(0, import_fs3.existsSync)(sessionsDir)) {
-          logger2.warn("No Claude sessions directory found for project", {
-            projectPath: this.projectPath,
-            sessionsDir
-          });
-          return {
-            newSessions: [],
-            updatedSessions: [],
-            unchangedCount: 0,
-            totalScanned: 0
-          };
-        }
-        logger2.info("Scanning for Claude sessions", { sessionsDir });
-        return this.scanDirs([sessionsDir], options);
-      }
-      /**
-       * Scan ALL project directories under ~/.claude/projects/ regardless of project path.
-       * Returns combined results across every project.
-       */
-      async scanAll(options) {
-        const dirs = this.reader.listProjectDirs();
-        logger2.info("Scanning all Claude project directories", {
-          count: dirs.length
-        });
-        return this.scanDirs(dirs, options);
-      }
-      async scanDirs(sessionsDirs, options) {
-        const state = this.loadState();
-        const newSessions = [];
-        const updatedSessions = [];
-        let unchangedCount = 0;
-        let totalScanned = 0;
-        for (const sessionsDir of sessionsDirs) {
-          const allSessions = this.reader.readAllSessions(sessionsDir);
-          totalScanned += allSessions.length;
-          for (const session of allSessions) {
-            if (session.turns.length < 2) {
-              unchangedCount++;
-              continue;
-            }
-            const record2 = state.processed[session.sessionId];
-            if (options?.forceAll) {
-              newSessions.push(session);
-              continue;
-            }
-            if (!record2) {
-              newSessions.push(session);
-            } else if (session.fileMtime > record2.fileMtime) {
-              updatedSessions.push(session);
-            } else {
-              unchangedCount++;
-            }
-          }
-        }
-        logger2.info("Scan complete", {
-          dirs: sessionsDirs.length,
-          total: totalScanned,
-          new: newSessions.length,
-          updated: updatedSessions.length,
-          unchanged: unchangedCount
-        });
-        return { newSessions, updatedSessions, unchangedCount, totalScanned };
-      }
-      /**
-       * Mark a session as processed and persist state.
-       */
-      /**
-       * Return the number of lines already uploaded for this session (0 if unknown).
-       */
-      getUploadedLineCount(sessionId) {
-        const state = this.loadState();
-        return state.processed[sessionId]?.uploadedLineCount ?? 0;
-      }
-      /**
-       * Return whether this session was previously finalized.
-       */
-      isFinalized(sessionId) {
-        const state = this.loadState();
-        return state.processed[sessionId]?.finalized ?? false;
-      }
-      /**
-       * Return all session IDs that are tracked but not yet finalized.
-       * These are sessions that were previously uploaded as open and may
-       * need finalization if they no longer appear in the scan results.
-       */
-      getOpenSessionIds() {
-        const state = this.loadState();
-        return Object.values(state.processed).filter((r) => r.finalized === false).map((r) => r.sessionId);
-      }
-      /**
-       * Mark a session as finalized without re-reading its file.
-       * Used when a previously-open session is no longer receiving new lines.
-       */
-      markFinalized(sessionId) {
-        const state = this.loadState();
-        const record2 = state.processed[sessionId];
-        if (record2) {
-          record2.finalized = true;
-          record2.processedAt = (/* @__PURE__ */ new Date()).toISOString();
-          state.lastRunAt = (/* @__PURE__ */ new Date()).toISOString();
-          this.saveState(state);
-        }
-      }
-      markProcessed(session, status, extras) {
-        const state = this.loadState();
-        state.processed[session.sessionId] = {
-          sessionId: session.sessionId,
-          filePath: session.filePath,
-          fileMtime: session.fileMtime,
-          processedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          status,
-          ...extras
-        };
-        state.lastRunAt = (/* @__PURE__ */ new Date()).toISOString();
-        this.saveState(state);
-      }
-      /**
-       * Return persisted processing records (useful for reporting).
-       */
-      getState() {
-        return this.loadState();
-      }
-      /**
-       * Reset state for a specific session (forces re-processing on next scan).
-       */
-      resetSession(sessionId) {
-        const state = this.loadState();
-        delete state.processed[sessionId];
-        this.saveState(state);
-        logger2.info("Reset session state", { sessionId });
-      }
-    };
-    if (require.main === module) {
-      main().catch((err) => {
-        logger2.error("Ingester failed", err);
-        process.exit(1);
-      });
-    }
-  }
-});
-
 // ../service-capture/claude-sessions/collector.ts
 var collector_exports = {};
 __export(collector_exports, {
@@ -1029,34 +529,85 @@ function edgeScrub(content) {
 }
 function resolveToken() {
   if (process.env.HAANSI_TOKEN) return process.env.HAANSI_TOKEN;
-  if ((0, import_fs4.existsSync)(CREDENTIALS_FILE2)) {
+  if ((0, import_fs.existsSync)(CREDENTIALS_FILE2)) {
     try {
-      const creds = JSON.parse((0, import_fs4.readFileSync)(CREDENTIALS_FILE2, "utf-8"));
+      const creds = JSON.parse((0, import_fs.readFileSync)(CREDENTIALS_FILE2, "utf-8"));
       if (creds.token) return creds.token;
     } catch {
-      logger3.warn("Could not parse credentials file", {
+      logger.warn("Could not parse credentials file", {
         file: CREDENTIALS_FILE2
       });
     }
   }
   return null;
 }
-async function uploadSession(sessionId, jsonlContent, apiUrl, token, isOpen) {
-  const headers = {
-    Authorization: `Bearer ${token}`,
-    "Content-Type": "application/x-ndjson",
-    "x-session-id": sessionId,
-    "x-session-open": isOpen ? "true" : "false"
-  };
-  let body;
-  if (jsonlContent.length > 0) {
-    body = (0, import_zlib.gzipSync)(Buffer.from(jsonlContent, "utf-8"));
-    headers["Content-Encoding"] = "gzip";
+function discoverSessions() {
+  if (!(0, import_fs.existsSync)(CLAUDE_PROJECTS_DIR)) return [];
+  const sessions = [];
+  const projectDirs = (0, import_fs.readdirSync)(CLAUDE_PROJECTS_DIR).map((name) => (0, import_path.join)(CLAUDE_PROJECTS_DIR, name)).filter((p) => {
+    try {
+      return (0, import_fs.statSync)(p).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  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 {
+      }
+    }
+  }
+  return sessions;
+}
+async function apiGet(path, apiUrl, token) {
+  const response = await fetch(`${apiUrl}/api/v1${path}`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`API ${response.status}: ${text.slice(0, 200)}`);
   }
+  return response.json();
+}
+async function getUploadedSessions(apiUrl, token) {
+  try {
+    const data = await apiGet("/sessions/uploaded", apiUrl, token);
+    const map2 = /* @__PURE__ */ new Map();
+    for (const s of data.sessions) {
+      map2.set(s.sessionId, s.lineCount);
+    }
+    return map2;
+  } catch {
+    logger.warn("Could not fetch uploaded sessions list, will upload all");
+    return /* @__PURE__ */ new Map();
+  }
+}
+async function uploadSession(sessionId, content, apiUrl, token) {
+  const body = (0, import_zlib.gzipSync)(Buffer.from(content, "utf-8"));
   const response = await fetch(`${apiUrl}/api/v1/sessions/raw`, {
     method: "POST",
-    headers,
-    body: body ? new Uint8Array(body) : void 0
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/x-ndjson",
+      "Content-Encoding": "gzip",
+      "x-session-id": sessionId
+    },
+    body: new Uint8Array(body)
   });
   if (!response.ok) {
     const text = await response.text().catch(() => "");
@@ -1073,119 +624,61 @@ async function collect(options) {
       "HAANSI_TOKEN is required. Set it as env var or in ~/.haansi/credentials.json"
     );
   }
-  const ingester = new ClaudeSessionIngester({
-    projectPath: options.projectPath
-  });
-  const scanResult = options.projectPath ? await ingester.scan({ forceAll: options.forceAll }) : await ingester.scanAll({ forceAll: options.forceAll });
-  const activeSessions = [
-    ...scanResult.newSessions,
-    ...scanResult.updatedSessions
-  ];
-  const activeSessionIds = new Set(activeSessions.map((s) => s.sessionId));
-  const sessions = options.limit ? activeSessions.slice(0, options.limit) : activeSessions;
+  const localSessions = discoverSessions();
+  logger.info(`Found ${localSessions.length} session files on disk`);
+  if (localSessions.length === 0) {
+    return { uploaded: 0, skipped: 0, errors: 0 };
+  }
   let uploaded = 0;
+  let skipped = 0;
   let errors = 0;
-  if (sessions.length > 0) {
-    logger3.info(`Uploading ${sessions.length} active session(s)`, {
-      apiUrl,
-      dryRun: options.dryRun ?? false
-    });
-    for (const session of sessions) {
-      const shortId = session.sessionId.slice(0, 8);
-      try {
-        const rawContent = (0, import_fs4.readFileSync)(session.filePath, "utf-8");
-        const allLines = rawContent.split("\n").filter((l) => l.trim().length > 0);
-        const totalLines = allLines.length;
-        let uploadedLineCount = ingester.getUploadedLineCount(
-          session.sessionId
-        );
-        const wasPreviouslyFinalized = ingester.isFinalized(session.sessionId);
-        if (wasPreviouslyFinalized && totalLines > uploadedLineCount) {
-          uploadedLineCount = 0;
-        }
-        if (totalLines < uploadedLineCount) {
-          uploadedLineCount = 0;
-        }
-        const deltaLines = allLines.slice(uploadedLineCount);
-        if (deltaLines.length === 0) {
-          continue;
-        }
-        const deltaContent = edgeScrub(deltaLines.join("\n") + "\n");
-        if (options.dryRun) {
-          logger3.info(
-            `[dry-run] Would upload delta for session ${shortId} (${deltaLines.length} new lines, open)`
-          );
-          uploaded++;
-          continue;
-        }
-        await uploadSession(
-          session.sessionId,
-          deltaContent,
-          apiUrl,
-          token,
-          true
-        );
-        ingester.markProcessed(session, "pending", {
-          uploadedLineCount: totalLines,
-          finalized: false
-        });
-        uploaded++;
-        logger3.info(
-          `delta uploaded session ${shortId} (${deltaLines.length} new lines, open)`
-        );
-      } catch (err) {
-        errors++;
-        logger3.error(`Failed to upload session ${shortId}`, {
-          err: err.message
-        });
-      }
+  const remoteMap = options.forceAll ? /* @__PURE__ */ new Map() : await getUploadedSessions(apiUrl, token);
+  const toUpload = [];
+  for (const session of localSessions) {
+    const remoteLine = remoteMap.get(session.sessionId);
+    if (remoteLine !== void 0 && remoteLine >= session.lineCount) {
+      skipped++;
+    } else {
+      toUpload.push(session);
     }
   }
-  const openSessionIds = ingester.getOpenSessionIds();
-  const toFinalize = openSessionIds.filter((id) => !activeSessionIds.has(id));
-  if (toFinalize.length > 0) {
-    logger3.info(`Finalizing ${toFinalize.length} idle session(s)`);
-    for (const sessionId of toFinalize) {
-      const shortId = sessionId.slice(0, 8);
-      try {
-        if (options.dryRun) {
-          logger3.info(`[dry-run] Would finalize session ${shortId}`);
-          uploaded++;
-          continue;
-        }
-        await uploadSession(sessionId, "", apiUrl, token, false);
-        ingester.markFinalized(sessionId);
+  const batch = options.limit ? toUpload.slice(0, options.limit) : toUpload;
+  skipped += toUpload.length - batch.length;
+  logger.info(
+    `Uploading ${batch.length} session(s), skipping ${skipped} unchanged`
+  );
+  for (const session of batch) {
+    const shortId = session.sessionId.slice(0, 8);
+    try {
+      const rawContent = (0, import_fs.readFileSync)(session.filePath, "utf-8");
+      const scrubbed = edgeScrub(rawContent);
+      if (options.dryRun) {
+        logger.info(
+          `[dry-run] Would upload ${shortId} (${session.lineCount} lines)`
+        );
         uploaded++;
-        logger3.info(`finalized session ${shortId}`);
-      } catch (err) {
-        errors++;
-        logger3.error(`Failed to finalize session ${shortId}`, {
-          err: err.message
-        });
+        continue;
       }
+      await uploadSession(session.sessionId, scrubbed, apiUrl, token);
+      uploaded++;
+      logger.info(`Uploaded ${shortId} (${session.lineCount} lines)`);
+    } catch (err) {
+      errors++;
+      logger.error(`Failed to upload ${shortId}`, { err: err.message });
     }
   }
-  if (sessions.length === 0 && toFinalize.length === 0) {
-    logger3.info("No new sessions to upload");
-  }
-  return { uploaded, skipped: scanResult.unchangedCount, errors };
+  return { uploaded, skipped, errors };
 }
-async function main2() {
+async function main() {
   const forceAll = process.argv.includes("--force-all");
   const dryRun = process.argv.includes("--dry-run");
-  const projectPath = process.env.CLAUDE_PROJECT_PATH || void 0;
   const limitIdx = process.argv.indexOf("--limit");
   const limit = limitIdx !== -1 ? parseInt(process.argv[limitIdx + 1], 10) : void 0;
-  logger3.info("Collector starting", {
-    forceAll,
-    dryRun,
-    projectPath: projectPath ?? "all"
-  });
+  logger.info("Collector starting", { forceAll, dryRun });
   const { uploaded, skipped, errors } = await collect({
     forceAll,
     dryRun,
-    limit,
-    projectPath
+    limit
   });
   console.log(
     `
@@ -1193,21 +686,22 @@ Collector done: ${uploaded} uploaded, ${skipped} unchanged, ${errors} errors`
   );
   if (errors > 0) process.exit(1);
 }
-var import_dotenv2, import_path3, import_fs4, import_os3, import_zlib, logger3, DEFAULT_API_URL2, CREDENTIALS_FILE2, EDGE_SCRUB_PATTERNS;
+var import_dotenv, import_path, import_fs, import_os, import_zlib, logger, DEFAULT_API_URL2, CREDENTIALS_FILE2, CLAUDE_PROJECTS_DIR, MIN_LINES, EDGE_SCRUB_PATTERNS;
 var init_collector = __esm({
   "../service-capture/claude-sessions/collector.ts"() {
     "use strict";
-    import_dotenv2 = __toESM(require_main());
-    import_path3 = require("path");
-    import_fs4 = require("fs");
-    import_os3 = require("os");
+    import_dotenv = __toESM(require_main());
+    import_path = require("path");
+    import_fs = require("fs");
+    import_os = require("os");
     import_zlib = require("zlib");
-    init_ingester();
     init_logger();
-    (0, import_dotenv2.config)({ path: (0, import_path3.resolve)(__dirname, "../../../.env") });
-    logger3 = createLogger("claude-collector");
+    (0, import_dotenv.config)({ path: (0, import_path.resolve)(__dirname, "../../../.env") });
+    logger = createLogger("claude-collector");
     DEFAULT_API_URL2 = "https://api.haansi.co";
-    CREDENTIALS_FILE2 = (0, import_path3.join)((0, import_os3.homedir)(), ".haansi", "credentials.json");
+    CREDENTIALS_FILE2 = (0, import_path.join)((0, import_os.homedir)(), ".haansi", "credentials.json");
+    CLAUDE_PROJECTS_DIR = (0, import_path.join)((0, import_os.homedir)(), ".claude", "projects");
+    MIN_LINES = 4;
     EDGE_SCRUB_PATTERNS = [
       {
         pattern: /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/g,
@@ -1248,8 +742,8 @@ var init_collector = __esm({
       }
     ];
     if (require.main === module) {
-      main2().catch((err) => {
-        logger3.error("Collector failed", err);
+      main().catch((err) => {
+        logger.error("Collector failed", err);
         process.exit(1);
       });
     }
@@ -2170,49 +1664,49 @@ var require_node_cron = __commonJS({
 var collector_daemon_exports = {};
 async function run() {
   const projectPath = process.env.CLAUDE_PROJECT_PATH || void 0;
-  logger4.info("Collect run starting", { projectPath: projectPath ?? "all" });
+  logger2.info("Collect run starting", { projectPath: projectPath ?? "all" });
   const start = Date.now();
   try {
     const { uploaded, skipped, errors } = await collect({ projectPath });
     const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
-    logger4.info(`Collect run complete in ${elapsed}s`, {
+    logger2.info(`Collect run complete in ${elapsed}s`, {
       uploaded,
       skipped,
       errors
     });
   } catch (err) {
-    logger4.error("Collect run failed", { err: err.message });
+    logger2.error("Collect run failed", { err: err.message });
   }
 }
-async function main3() {
-  logger4.info("Collector daemon starting", { schedule: SCHEDULE });
+async function main2() {
+  logger2.info("Collector daemon starting", { schedule: SCHEDULE });
   await run();
   import_node_cron.default.schedule(SCHEDULE, async () => {
-    logger4.info("Scheduled collect run triggered");
+    logger2.info("Scheduled collect run triggered");
     await run();
   });
-  logger4.info(`Daemon running. Next run scheduled per cron: "${SCHEDULE}"`);
+  logger2.info(`Daemon running. Next run scheduled per cron: "${SCHEDULE}"`);
   const shutdown = async (signal) => {
-    logger4.info(`Received ${signal}, shutting down`);
+    logger2.info(`Received ${signal}, shutting down`);
     process.exit(0);
   };
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("SIGINT", () => shutdown("SIGINT"));
 }
-var import_dotenv3, import_path4, import_node_cron, logger4, SCHEDULE;
+var import_dotenv2, import_path2, import_node_cron, logger2, SCHEDULE;
 var init_collector_daemon = __esm({
   "../service-capture/claude-sessions/collector-daemon.ts"() {
     "use strict";
-    import_dotenv3 = __toESM(require_main());
-    import_path4 = require("path");
+    import_dotenv2 = __toESM(require_main());
+    import_path2 = require("path");
     import_node_cron = __toESM(require_node_cron());
     init_collector();
     init_logger();
-    (0, import_dotenv3.config)({ path: (0, import_path4.resolve)(__dirname, "../../../.env") });
-    logger4 = createLogger("collector-daemon");
+    (0, import_dotenv2.config)({ path: (0, import_path2.resolve)(__dirname, "../../../.env") });
+    logger2 = createLogger("collector-daemon");
     SCHEDULE = process.env.CLAUDE_COLLECT_SCHEDULE ?? "*/30 * * * *";
-    main3().catch((err) => {
-      logger4.error("Daemon failed to start", err);
+    main2().catch((err) => {
+      logger2.error("Daemon failed to start", err);
       process.exit(1);
     });
   }
@@ -6215,7 +5709,7 @@ function $constructor(name, initializer3, params) {
   Object.defineProperty(_, "name", { value: name });
   return _;
 }
-function config4(newConfig) {
+function config3(newConfig) {
   if (newConfig)
     Object.assign(globalConfig, newConfig);
   return globalConfig;
@@ -6740,10 +6234,10 @@ function prefixIssues(path, issues) {
 function unwrapMessage(message) {
   return typeof message === "string" ? message : message?.message;
 }
-function finalizeIssue(iss, ctx, config6) {
+function finalizeIssue(iss, ctx, config5) {
   const full = { ...iss, path: iss.path ?? [] };
   if (!iss.message) {
-    const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config6.customError?.(iss)) ?? unwrapMessage(config6.localeError?.(iss)) ?? "Invalid input";
+    const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config5.customError?.(iss)) ?? unwrapMessage(config5.localeError?.(iss)) ?? "Invalid input";
     full.message = message;
   }
   delete full.inst;
@@ -7013,7 +6507,7 @@ var init_parse2 = __esm({
         throw new $ZodAsyncError();
       }
       if (result.issues.length) {
-        const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config4())));
+        const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config3())));
         captureStackTrace(e, _params?.callee);
         throw e;
       }
@@ -7026,7 +6520,7 @@ var init_parse2 = __esm({
       if (result instanceof Promise)
         result = await result;
       if (result.issues.length) {
-        const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config4())));
+        const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config3())));
         captureStackTrace(e, params?.callee);
         throw e;
       }
@@ -7041,7 +6535,7 @@ var init_parse2 = __esm({
       }
       return result.issues.length ? {
         success: false,
-        error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config4())))
+        error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config3())))
       } : { success: true, data: result.value };
     };
     safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
@@ -7052,7 +6546,7 @@ var init_parse2 = __esm({
         result = await result;
       return result.issues.length ? {
         success: false,
-        error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config4())))
+        error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config3())))
       } : { success: true, data: result.value };
     };
     safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
@@ -7986,7 +7480,7 @@ function handleUnionResults(results, final, inst, ctx) {
     code: "invalid_union",
     input: final.value,
     inst,
-    errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config4())))
+    errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config3())))
   });
   return final;
 }
@@ -8001,7 +7495,7 @@ function handleExclusiveUnionResults(results, final, inst, ctx) {
       code: "invalid_union",
       input: final.value,
       inst,
-      errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config4())))
+      errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config3())))
     });
   } else {
     final.issues.push({
@@ -8113,7 +7607,7 @@ function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
         origin: "map",
         input,
         inst,
-        issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config4()))
+        issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config3()))
       });
     }
   }
@@ -8127,7 +7621,7 @@ function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
         input,
         inst,
         key,
-        issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx, config4()))
+        issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx, config3()))
       });
     }
   }
@@ -9289,7 +8783,7 @@ var init_schemas = __esm({
                 payload.issues.push({
                   code: "invalid_key",
                   origin: "record",
-                  issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config4())),
+                  issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config3())),
                   input: key,
                   path: [key],
                   inst
@@ -9585,7 +9079,7 @@ var init_schemas = __esm({
               payload.value = def.catchValue({
                 ...payload,
                 error: {
-                  issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config4()))
+                  issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config3()))
                 },
                 input: payload.value
               });
@@ -9599,7 +9093,7 @@ var init_schemas = __esm({
           payload.value = def.catchValue({
             ...payload,
             error: {
-              issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config4()))
+              issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config3()))
             },
             input: payload.value
           });
@@ -13897,7 +13391,7 @@ var init_external3 = __esm({
     init_iso2();
     init_iso2();
     init_coerce2();
-    config4(en_default2());
+    config3(en_default2());
   }
 });
 
@@ -16924,13 +16418,13 @@ var init_zodToJsonSchema = __esm({
         }, true) ?? parseAnyDef(refs)
       }), {}) : void 0;
       const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
-      const main5 = parseDef(schema._def, name === void 0 ? refs : {
+      const main4 = parseDef(schema._def, name === void 0 ? refs : {
         ...refs,
         currentPath: [...refs.basePath, refs.definitionPath, name]
       }, false) ?? parseAnyDef(refs);
       const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
       if (title !== void 0) {
-        main5.title = title;
+        main4.title = title;
       }
       if (refs.flags.hasReferencedOpenAiAnyType) {
         if (!definitions) {
@@ -16951,9 +16445,9 @@ var init_zodToJsonSchema = __esm({
         }
       }
       const combined = name === void 0 ? definitions ? {
-        ...main5,
+        ...main4,
         [refs.definitionPath]: definitions
-      } : main5 : {
+      } : main4 : {
         $ref: [
           ...refs.$refStrategy === "relative" ? [] : refs.basePath,
           refs.definitionPath,
@@ -16961,7 +16455,7 @@ var init_zodToJsonSchema = __esm({
         ].join("/"),
         [refs.definitionPath]: {
           ...definitions,
-          [name]: main5
+          [name]: main4
         }
       };
       if (refs.target === "jsonSchema7") {
@@ -17591,7 +17085,7 @@ var init_protocol = __esm({
               return;
             }
             const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-            await new Promise((resolve5) => setTimeout(resolve5, pollInterval));
+            await new Promise((resolve4) => setTimeout(resolve4, pollInterval));
             options?.signal?.throwIfAborted();
           }
         } catch (error2) {
@@ -17608,7 +17102,7 @@ var init_protocol = __esm({
        */
       request(request, resultSchema, options) {
         const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve4, reject) => {
           const earlyReject = (error2) => {
             reject(error2);
           };
@@ -17686,7 +17180,7 @@ var init_protocol = __esm({
               if (!parseResult.success) {
                 reject(parseResult.error);
               } else {
-                resolve5(parseResult.data);
+                resolve4(parseResult.data);
               }
             } catch (error2) {
               reject(error2);
@@ -17947,12 +17441,12 @@ var init_protocol = __esm({
           }
         } catch {
         }
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve4, reject) => {
           if (signal.aborted) {
             reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
             return;
           }
-          const timeoutId = setTimeout(resolve5, interval);
+          const timeoutId = setTimeout(resolve4, interval);
           signal.addEventListener("abort", () => {
             clearTimeout(timeoutId);
             reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -20979,7 +20473,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve5.call(this, root, ref);
+      let _sch = resolve4.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a2 = root.localRefs) === null || _a2 === void 0 ? void 0 : _a2[ref];
         const { schemaId } = this.opts;
@@ -21006,7 +20500,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve5(root, ref) {
+    function resolve4(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -21581,7 +21075,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve5(baseURI, relativeURI, options) {
+    function resolve4(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse4(baseURI, schemelessOptions), parse4(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -21808,7 +21302,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve5,
+      resolve: resolve4,
       resolveComponent,
       equal,
       serialize,
@@ -22363,13 +21857,13 @@ var require_core = __commonJS({
     }, warn() {
     }, error() {
     } };
-    function getLogger(logger5) {
-      if (logger5 === false)
+    function getLogger(logger3) {
+      if (logger3 === false)
         return noLogs;
-      if (logger5 === void 0)
+      if (logger3 === void 0)
         return console;
-      if (logger5.log && logger5.warn && logger5.error)
-        return logger5;
+      if (logger3.log && logger3.warn && logger3.error)
+        return logger3;
       throw new Error("logger must implement log, warn and error methods");
     }
     var KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
@@ -27599,7 +27093,7 @@ var require_compile2 = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve5.call(this, root, ref);
+      let _sch = resolve4.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a2 = root.localRefs) === null || _a2 === void 0 ? void 0 : _a2[ref];
         const { schemaId } = this.opts;
@@ -27626,7 +27120,7 @@ var require_compile2 = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve5(root, ref) {
+    function resolve4(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -28261,13 +27755,13 @@ var require_core3 = __commonJS({
     }, warn() {
     }, error() {
     } };
-    function getLogger(logger5) {
-      if (logger5 === false)
+    function getLogger(logger3) {
+      if (logger3 === false)
         return noLogs;
-      if (logger5 === void 0)
+      if (logger3 === void 0)
         return console;
-      if (logger5.log && logger5.warn && logger5.error)
-        return logger5;
+      if (logger3.log && logger3.warn && logger3.error)
+        return logger3;
       throw new Error("logger must implement log, warn and error methods");
     }
     var KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
@@ -31158,13 +30652,13 @@ var init_mcp_server = __esm({
       constructor(_mcpServer) {
         this._mcpServer = _mcpServer;
       }
-      registerToolTask(name, config6, handler) {
-        const execution = { taskSupport: "required", ...config6.execution };
+      registerToolTask(name, config5, handler) {
+        const execution = { taskSupport: "required", ...config5.execution };
         if (execution.taskSupport === "forbidden") {
           throw new Error(`Cannot register task-based tool '${name}' with taskSupport 'forbidden'. Use registerTool() instead.`);
         }
         const mcpServerInternal = this._mcpServer;
-        return mcpServerInternal._createRegisteredTool(name, config6.title, config6.description, config6.inputSchema, config6.outputSchema, config6.annotations, execution, config6._meta, handler);
+        return mcpServerInternal._createRegisteredTool(name, config5.title, config5.description, config5.inputSchema, config5.outputSchema, config5.annotations, execution, config5._meta, handler);
       }
     };
   }
@@ -31476,7 +30970,7 @@ var init_mcp = __esm({
         let task = createTaskResult.task;
         const pollInterval = task.pollInterval ?? 5e3;
         while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-          await new Promise((resolve5) => setTimeout(resolve5, pollInterval));
+          await new Promise((resolve4) => setTimeout(resolve4, pollInterval));
           const updatedTask = await extra.taskStore.getTask(taskId);
           if (!updatedTask) {
             throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -31677,12 +31171,12 @@ var init_mcp = __esm({
           return registeredResourceTemplate;
         }
       }
-      registerResource(name, uriOrTemplate, config6, readCallback) {
+      registerResource(name, uriOrTemplate, config5, readCallback) {
         if (typeof uriOrTemplate === "string") {
           if (this._registeredResources[uriOrTemplate]) {
             throw new Error(`Resource ${uriOrTemplate} is already registered`);
           }
-          const registeredResource = this._createRegisteredResource(name, config6.title, uriOrTemplate, config6, readCallback);
+          const registeredResource = this._createRegisteredResource(name, config5.title, uriOrTemplate, config5, readCallback);
           this.setResourceRequestHandlers();
           this.sendResourceListChanged();
           return registeredResource;
@@ -31690,7 +31184,7 @@ var init_mcp = __esm({
           if (this._registeredResourceTemplates[name]) {
             throw new Error(`Resource template ${name} is already registered`);
           }
-          const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, config6.title, uriOrTemplate, config6, readCallback);
+          const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, config5.title, uriOrTemplate, config5, readCallback);
           this.setResourceRequestHandlers();
           this.sendResourceListChanged();
           return registeredResourceTemplate;
@@ -31885,11 +31379,11 @@ var init_mcp = __esm({
       /**
        * Registers a tool with a config object and callback.
        */
-      registerTool(name, config6, cb) {
+      registerTool(name, config5, cb) {
         if (this._registeredTools[name]) {
           throw new Error(`Tool ${name} is already registered`);
         }
-        const { title, description, inputSchema, outputSchema, annotations, _meta } = config6;
+        const { title, description, inputSchema, outputSchema, annotations, _meta } = config5;
         return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, _meta, cb);
       }
       prompt(name, ...rest) {
@@ -31913,11 +31407,11 @@ var init_mcp = __esm({
       /**
        * Registers a prompt with a config object and callback.
        */
-      registerPrompt(name, config6, cb) {
+      registerPrompt(name, config5, cb) {
         if (this._registeredPrompts[name]) {
           throw new Error(`Prompt ${name} is already registered`);
         }
-        const { title, description, argsSchema } = config6;
+        const { title, description, argsSchema } = config5;
         const registeredPrompt = this._createRegisteredPrompt(name, title, description, argsSchema, cb);
         this.setPromptRequestHandlers();
         this.sendPromptListChanged();
@@ -32067,12 +31561,12 @@ var init_stdio2 = __esm({
         this.onclose?.();
       }
       send(message) {
-        return new Promise((resolve5) => {
+        return new Promise((resolve4) => {
           const json2 = serializeMessage(message);
           if (this._stdout.write(json2)) {
-            resolve5();
+            resolve4();
           } else {
-            this._stdout.once("drain", resolve5);
+            this._stdout.once("drain", resolve4);
           }
         });
       }
@@ -32084,9 +31578,9 @@ var init_stdio2 = __esm({
 var mcp_server_exports = {};
 function resolveToken2() {
   if (process.env.HAANSI_TOKEN) return process.env.HAANSI_TOKEN;
-  if ((0, import_fs5.existsSync)(CREDENTIALS_FILE3)) {
+  if ((0, import_fs2.existsSync)(CREDENTIALS_FILE3)) {
     try {
-      const creds = JSON.parse((0, import_fs5.readFileSync)(CREDENTIALS_FILE3, "utf-8"));
+      const creds = JSON.parse((0, import_fs2.readFileSync)(CREDENTIALS_FILE3, "utf-8"));
       if (creds.token) return creds.token;
     } catch {
     }
@@ -32112,7 +31606,7 @@ function maybeCollect() {
     triggerCollectInBackground();
   }
 }
-async function apiGet(path) {
+async function apiGet2(path) {
   const response = await fetch(`${API_URL}/api/v1${path}`, {
     headers: { Authorization: `Bearer ${TOKEN}` }
   });
@@ -32122,9 +31616,9 @@ async function apiGet(path) {
   }
   return response.json();
 }
-async function main4() {
+async function main3() {
   try {
-    await apiGet("/sessions/recent?limit=1");
+    await apiGet2("/sessions/recent?limit=1");
     console.error("[mcp-server] API connection ok");
     triggerCollectInBackground();
   } catch (err) {
@@ -32137,21 +31631,21 @@ async function main4() {
   await mcpServer.connect(transport);
   console.error("[mcp-server] haansi-solutions MCP server running on stdio");
 }
-var import_dotenv4, import_path5, import_fs5, import_os4, DEFAULT_API_URL3, CREDENTIALS_FILE3, API_URL, TOKEN, isCollecting, lastCollectTime, COLLECT_COOLDOWN_MS, mcpServer, server;
+var import_dotenv3, import_path3, import_fs2, import_os2, DEFAULT_API_URL3, CREDENTIALS_FILE3, API_URL, TOKEN, isCollecting, lastCollectTime, COLLECT_COOLDOWN_MS, mcpServer, server;
 var init_mcp_server2 = __esm({
   "../service-capture/claude-sessions/mcp-server.ts"() {
     "use strict";
-    import_dotenv4 = __toESM(require_main());
-    import_path5 = require("path");
-    import_fs5 = require("fs");
-    import_os4 = require("os");
+    import_dotenv3 = __toESM(require_main());
+    import_path3 = require("path");
+    import_fs2 = require("fs");
+    import_os2 = require("os");
     init_collector();
     init_mcp();
     init_stdio2();
     init_types2();
-    (0, import_dotenv4.config)({ path: (0, import_path5.resolve)(__dirname, "../../../.env") });
+    (0, import_dotenv3.config)({ path: (0, import_path3.resolve)(__dirname, "../../../.env") });
     DEFAULT_API_URL3 = "https://api.haansi.co";
-    CREDENTIALS_FILE3 = (0, import_path5.join)((0, import_os4.homedir)(), ".haansi", "credentials.json");
+    CREDENTIALS_FILE3 = (0, import_path3.join)((0, import_os2.homedir)(), ".haansi", "credentials.json");
     API_URL = process.env.HAANSI_API_URL ?? DEFAULT_API_URL3;
     TOKEN = resolveToken2();
     if (!TOKEN) {
@@ -32213,7 +31707,7 @@ var init_mcp_server2 = __esm({
           case "search_solutions": {
             const { query, top_k = 5 } = args;
             const k = Math.min(Math.max(1, top_k), 20);
-            const data = await apiGet(
+            const data = await apiGet2(
               `/sessions/search?q=${encodeURIComponent(query)}&top_k=${k}`
             );
             if (!data.results || data.results.length === 0) {
@@ -32233,7 +31727,7 @@ var init_mcp_server2 = __esm({
           case "list_recent_solutions": {
             const { limit = 10 } = args;
             const n = Math.min(Math.max(1, limit), 50);
-            const data = await apiGet(`/sessions/recent?limit=${n}`);
+            const data = await apiGet2(`/sessions/recent?limit=${n}`);
             if (!data.results || data.results.length === 0) {
               return {
                 content: [
@@ -32259,7 +31753,7 @@ var init_mcp_server2 = __esm({
         };
       }
     });
-    main4().catch((err) => {
+    main3().catch((err) => {
       console.error("[mcp-server] Failed to start:", err);
       process.exit(1);
     });
@@ -32272,24 +31766,24 @@ __export(setup_mcp_exports, {
   setupMcp: () => setupMcp
 });
 async function setupMcp() {
-  let config6 = {};
+  let config5 = {};
   if ((0, import_node_fs2.existsSync)(CLAUDE_JSON)) {
     try {
-      config6 = JSON.parse((0, import_node_fs2.readFileSync)(CLAUDE_JSON, "utf-8"));
+      config5 = JSON.parse((0, import_node_fs2.readFileSync)(CLAUDE_JSON, "utf-8"));
     } catch {
       console.error(
         `Warning: Could not parse ${CLAUDE_JSON} \u2014 will overwrite with new config.`
       );
     }
   }
-  if (!config6.mcpServers) {
-    config6.mcpServers = {};
+  if (!config5.mcpServers) {
+    config5.mcpServers = {};
   }
-  config6.mcpServers["haansi-solutions"] = {
+  config5.mcpServers["haansi-solutions"] = {
     command: "npx",
     args: ["haansi", "mcp-server"]
   };
-  (0, import_node_fs2.writeFileSync)(CLAUDE_JSON, JSON.stringify(config6, null, 2) + "\n", "utf-8");
+  (0, import_node_fs2.writeFileSync)(CLAUDE_JSON, JSON.stringify(config5, null, 2) + "\n", "utf-8");
   console.log(`MCP server configured in ${CLAUDE_JSON}`);
   console.log(
     "Restart Claude Code to activate the haansi-solutions MCP server."
@@ -32414,7 +31908,7 @@ function resolveToken3() {
   }
   throw new Error("No token found. Run `haansi init` first.");
 }
-async function apiGet2(path, token, apiUrl) {
+async function apiGet3(path, token, apiUrl) {
   const response = await fetch(`${apiUrl}/api/v1${path}`, {
     headers: { Authorization: `Bearer ${token}` }
   });
@@ -32429,13 +31923,13 @@ async function list(options) {
   const token = resolveToken3();
   let data;
   if (options.search) {
-    data = await apiGet2(
+    data = await apiGet3(
       `/sessions/search?q=${encodeURIComponent(options.search)}&top_k=${options.limit}`,
       token,
       apiUrl
     );
   } else {
-    data = await apiGet2(
+    data = await apiGet3(
       `/sessions/recent?limit=${options.limit}`,
       token,
       apiUrl