haansi 0.1.29 → 0.1.31

package/dist/haansi.js

@@ -34,12 +34,68 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../packages/@company/config/src/service-urls.ts
+var SERVICE_URL_DEFAULTS, HAANSI_API_V1_BASE_URL;
+var init_service_urls = __esm({
+  "../../packages/@company/config/src/service-urls.ts"() {
+    SERVICE_URL_DEFAULTS = Object.freeze({
+      haansiApiBaseUrl: "https://api.haansi.co",
+      localApiBaseUrl: "http://localhost:3000",
+      localWebAppUrl: "http://localhost:3001",
+      localDeliveryServiceUrl: "http://localhost:3200",
+      platformKnowledgeMcpUrl: "http://localhost:3300/mcp",
+      sessionSolutionsMcpUrl: "http://localhost:3301/mcp",
+      codeContextMcpUrl: "http://localhost:3302/mcp"
+    });
+    HAANSI_API_V1_BASE_URL = `${SERVICE_URL_DEFAULTS.haansiApiBaseUrl}/api/v1`;
+  }
+});
+
+// src/lib/paths.ts
+function apiUrl() {
+  return process.env.HAANSI_API_URL ?? DEFAULT_API_URL;
+}
+function resolveToken() {
+  if (process.env.HAANSI_TOKEN) return process.env.HAANSI_TOKEN;
+  if ((0, import_node_fs.existsSync)(CREDENTIALS_FILE)) {
+    try {
+      const creds = JSON.parse((0, import_node_fs.readFileSync)(CREDENTIALS_FILE, "utf-8"));
+      if (typeof creds.token === "string" && creds.token) return creds.token;
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveHaansiBin() {
+  try {
+    const binPath = (0, import_node_child_process.execSync)("which haansi", { encoding: "utf-8" }).trim();
+    if (binPath) return binPath;
+  } catch {
+  }
+  return "haansi";
+}
+var import_node_fs, import_node_path, import_node_os, import_node_child_process, DEFAULT_API_URL, HAANSI_DIR, CREDENTIALS_FILE, CONFIG_FILE;
+var init_paths = __esm({
+  "src/lib/paths.ts"() {
+    "use strict";
+    import_node_fs = require("node:fs");
+    import_node_path = require("node:path");
+    import_node_os = require("node:os");
+    import_node_child_process = require("node:child_process");
+    init_service_urls();
+    DEFAULT_API_URL = SERVICE_URL_DEFAULTS.haansiApiBaseUrl;
+    HAANSI_DIR = (0, import_node_path.join)((0, import_node_os.homedir)(), ".haansi");
+    CREDENTIALS_FILE = (0, import_node_path.join)(HAANSI_DIR, "credentials.json");
+    CONFIG_FILE = (0, import_node_path.join)(HAANSI_DIR, "config.json");
+  }
+});
+
 // package.json
 var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "haansi",
-      version: "0.1.29",
+      version: "0.1.31",
       description: "Haansi CLI - Session collector and MCP server for Claude Code & OpenAI Codex",
       bin: {
         haansi: "./dist/haansi.js"
@@ -70,9 +126,9 @@ __export(auth_login_exports, {
   authLogin: () => authLogin
 });
 function openBrowser(url2) {
-  const cmd = (0, import_node_os.platform)() === "darwin" ? "open" : (0, import_node_os.platform)() === "win32" ? "start" : "xdg-open";
+  const cmd = (0, import_node_os2.platform)() === "darwin" ? "open" : (0, import_node_os2.platform)() === "win32" ? "start" : "xdg-open";
   try {
-    (0, import_node_child_process.exec)(`${cmd} ${JSON.stringify(url2)}`);
+    (0, import_node_child_process2.exec)(`${cmd} ${JSON.stringify(url2)}`);
     return true;
   } catch {
     return false;
@@ -82,7 +138,7 @@ function sleep(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 async function authLogin() {
-  const apiUrl2 = process.env.HAANSI_API_URL ?? DEFAULT_API_URL;
+  const apiUrl2 = apiUrl();
   console.log("Haansi CLI \u2014 Browser Login\n");
   const initiateRes = await fetch(`${apiUrl2}/api/v1/auth/extension/initiate`, {
     method: "POST",
@@ -156,9 +212,9 @@ If the browser didn't open, visit this URL:
     );
   }
   const { token: hskToken } = await tokenRes.json();
-  (0, import_node_fs.mkdirSync)(HAANSI_DIR, { recursive: true });
-  (0, import_node_fs.writeFileSync)(
-    CREDENTIALS_FILE,
+  (0, import_node_fs2.mkdirSync)(HAANSI_DIR2, { recursive: true });
+  (0, import_node_fs2.writeFileSync)(
+    CREDENTIALS_FILE2,
     JSON.stringify({ token: hskToken }, null, 2),
     {
       encoding: "utf-8",
@@ -167,22 +223,22 @@ If the browser didn't open, visit this URL:
   );
   console.log(`
 Authenticated successfully${orgName ? ` (${orgName})` : ""}!`);
-  console.log(`Token saved to ${CREDENTIALS_FILE}`);
+  console.log(`Token saved to ${CREDENTIALS_FILE2}`);
   console.log(
     "Run `haansi collect` to upload sessions or `haansi setup-mcp` to configure Claude Code."
   );
 }
-var import_node_child_process, import_node_fs, import_node_path, import_node_os, DEFAULT_API_URL, HAANSI_DIR, CREDENTIALS_FILE, POLL_INTERVAL_MS, TIMEOUT_MS;
+var import_node_child_process2, import_node_fs2, import_node_path2, import_node_os2, HAANSI_DIR2, CREDENTIALS_FILE2, POLL_INTERVAL_MS, TIMEOUT_MS;
 var init_auth_login = __esm({
   "src/commands/auth-login.ts"() {
     "use strict";
-    import_node_child_process = require("node:child_process");
-    import_node_fs = require("node:fs");
-    import_node_path = require("node:path");
-    import_node_os = require("node:os");
-    DEFAULT_API_URL = "https://api.haansi.co";
-    HAANSI_DIR = (0, import_node_path.join)((0, import_node_os.homedir)(), ".haansi");
-    CREDENTIALS_FILE = (0, import_node_path.join)(HAANSI_DIR, "credentials.json");
+    import_node_child_process2 = require("node:child_process");
+    import_node_fs2 = require("node:fs");
+    import_node_path2 = require("node:path");
+    import_node_os2 = require("node:os");
+    init_paths();
+    HAANSI_DIR2 = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".haansi");
+    CREDENTIALS_FILE2 = (0, import_node_path2.join)(HAANSI_DIR2, "credentials.json");
     POLL_INTERVAL_MS = 2e3;
     TIMEOUT_MS = 5 * 60 * 1e3;
   }
@@ -220,7 +276,7 @@ async function validateToken(token, apiUrl2) {
   }
 }
 async function init() {
-  const apiUrl2 = process.env.HAANSI_API_URL ?? DEFAULT_API_URL2;
+  const apiUrl2 = apiUrl();
   console.log("Haansi CLI \u2014 Setup\n");
   console.log(
     "Tip: For interactive login, run `haansi auth login` to authenticate via browser.\n"
@@ -240,28 +296,28 @@ async function init() {
   }
   console.log("\nValidating token...");
   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), {
+  (0, import_node_fs3.mkdirSync)(HAANSI_DIR3, { recursive: true });
+  (0, import_node_fs3.writeFileSync)(CREDENTIALS_FILE3, JSON.stringify({ token }, null, 2), {
     encoding: "utf-8",
     mode: 384
   });
   console.log(`
-Token saved to ${CREDENTIALS_FILE2}`);
+Token saved to ${CREDENTIALS_FILE3}`);
   console.log(
     "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;
+var readline, import_node_fs3, import_node_path3, import_node_os3, HAANSI_DIR3, CREDENTIALS_FILE3;
 var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
     readline = __toESM(require("node:readline"));
-    import_node_fs2 = require("node:fs");
-    import_node_path2 = require("node:path");
-    import_node_os2 = require("node:os");
-    DEFAULT_API_URL2 = "https://api.haansi.co";
-    HAANSI_DIR2 = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".haansi");
-    CREDENTIALS_FILE2 = (0, import_node_path2.join)(HAANSI_DIR2, "credentials.json");
+    import_node_fs3 = require("node:fs");
+    import_node_path3 = require("node:path");
+    import_node_os3 = require("node:os");
+    init_paths();
+    HAANSI_DIR3 = (0, import_node_path3.join)((0, import_node_os3.homedir)(), ".haansi");
+    CREDENTIALS_FILE3 = (0, import_node_path3.join)(HAANSI_DIR3, "credentials.json");
   }
 });
 
@@ -339,7 +395,7 @@ var require_main = __commonJS({
     var fs = require("fs");
     var path = require("path");
     var os = require("os");
-    var crypto6 = require("crypto");
+    var crypto8 = require("crypto");
     var packageJson = require_package2();
     var version3 = packageJson.version;
     var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
@@ -558,7 +614,7 @@ var require_main = __commonJS({
       const authTag = ciphertext.subarray(-16);
       ciphertext = ciphertext.subarray(12, -16);
       try {
-        const aesgcm = crypto6.createDecipheriv("aes-256-gcm", key, nonce);
+        const aesgcm = crypto8.createDecipheriv("aes-256-gcm", key, nonce);
         aesgcm.setAuthTag(authTag);
         return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
       } catch (error2) {
@@ -623,61 +679,1039 @@ var require_main = __commonJS({
   }
 });
 
-// ../service-capture/common/logger.ts
-function createLogger(service, level) {
-  const logLevel = level ?? (process.env.LOG_LEVEL === "debug" ? 0 /* DEBUG */ : 1 /* INFO */);
-  return new Logger(service, logLevel);
+// ../../packages/@company/observability/node_modules/uuid/dist/esm-node/rng.js
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    import_crypto.default.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+var import_crypto, rnds8Pool, poolPtr;
+var init_rng = __esm({
+  "../../packages/@company/observability/node_modules/uuid/dist/esm-node/rng.js"() {
+    import_crypto = __toESM(require("crypto"));
+    rnds8Pool = new Uint8Array(256);
+    poolPtr = rnds8Pool.length;
+  }
+});
+
+// ../../packages/@company/observability/node_modules/uuid/dist/esm-node/stringify.js
+function unsafeStringify(arr, offset = 0) {
+  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+}
+var byteToHex;
+var init_stringify = __esm({
+  "../../packages/@company/observability/node_modules/uuid/dist/esm-node/stringify.js"() {
+    byteToHex = [];
+    for (let i = 0; i < 256; ++i) {
+      byteToHex.push((i + 256).toString(16).slice(1));
+    }
+  }
+});
+
+// ../../packages/@company/observability/node_modules/uuid/dist/esm-node/native.js
+var import_crypto2, native_default;
+var init_native = __esm({
+  "../../packages/@company/observability/node_modules/uuid/dist/esm-node/native.js"() {
+    import_crypto2 = __toESM(require("crypto"));
+    native_default = {
+      randomUUID: import_crypto2.default.randomUUID
+    };
+  }
+});
+
+// ../../packages/@company/observability/node_modules/uuid/dist/esm-node/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
 }
-var Logger;
+var v4_default;
+var init_v4 = __esm({
+  "../../packages/@company/observability/node_modules/uuid/dist/esm-node/v4.js"() {
+    init_native();
+    init_rng();
+    init_stringify();
+    v4_default = v4;
+  }
+});
+
+// ../../packages/@company/observability/node_modules/uuid/dist/esm-node/index.js
+var init_esm_node = __esm({
+  "../../packages/@company/observability/node_modules/uuid/dist/esm-node/index.js"() {
+    init_v4();
+  }
+});
+
+// ../../packages/@company/observability/src/types.ts
+var init_types = __esm({
+  "../../packages/@company/observability/src/types.ts"() {
+    "use strict";
+  }
+});
+
+// ../../packages/@company/cloud/src/provider-registry.ts
+var ProviderRegistry, cloudRegistry;
+var init_provider_registry = __esm({
+  "../../packages/@company/cloud/src/provider-registry.ts"() {
+    "use strict";
+    ProviderRegistry = class {
+      _provider = null;
+      _config = null;
+      _storage = null;
+      _loggerBackend = null;
+      _metricsBackend = null;
+      _messageQueueParser = null;
+      _secretsManager = null;
+      _databaseSslResolver = null;
+      get provider() {
+        return this._provider;
+      }
+      get config() {
+        return this._config;
+      }
+      register(config6) {
+        this._provider = config6.provider;
+        this._config = config6;
+      }
+      // ── Setters (called by cloud-gcp / cloud-aws register functions) ──────────
+      setStorage(client) {
+        this._storage = client;
+      }
+      setLoggerBackend(backend) {
+        this._loggerBackend = backend;
+      }
+      setMetricsBackend(backend) {
+        this._metricsBackend = backend;
+      }
+      setMessageQueueParser(parser) {
+        this._messageQueueParser = parser;
+      }
+      setSecretsManager(manager) {
+        this._secretsManager = manager;
+      }
+      setDatabaseSslResolver(resolver) {
+        this._databaseSslResolver = resolver;
+      }
+      // ── Getters (called by consumers) ─────────────────────────────────────────
+      getStorage() {
+        if (!this._storage) {
+          throw new Error(
+            "No storage client registered. Call bootstrapCloudProvider() at startup."
+          );
+        }
+        return this._storage;
+      }
+      getLoggerBackend() {
+        return this._loggerBackend;
+      }
+      getMetricsBackend() {
+        return this._metricsBackend;
+      }
+      getMessageQueueParser() {
+        return this._messageQueueParser;
+      }
+      getSecretsManager() {
+        if (!this._secretsManager) {
+          throw new Error(
+            "No secrets manager registered. Call bootstrapCloudProvider() at startup."
+          );
+        }
+        return this._secretsManager;
+      }
+      getDatabaseSslConfig(connectionString) {
+        if (!this._databaseSslResolver) {
+          return {
+            ssl: process.env.NODE_ENV === "production" ? { rejectUnauthorized: true } : false
+          };
+        }
+        return this._databaseSslResolver(connectionString);
+      }
+      /**
+       * Reset all registrations. Primarily for testing.
+       */
+      reset() {
+        this._provider = null;
+        this._config = null;
+        this._storage = null;
+        this._loggerBackend = null;
+        this._metricsBackend = null;
+        this._messageQueueParser = null;
+        this._secretsManager = null;
+        this._databaseSslResolver = null;
+      }
+    };
+    cloudRegistry = new ProviderRegistry();
+  }
+});
+
+// ../../packages/@company/cloud/src/bootstrap.ts
+function bootstrapCloudProvider(override) {
+  const provider = override ?? process.env.CLOUD_PROVIDER;
+  if (!provider || provider === "local") {
+    return;
+  }
+  const pkg = PROVIDER_PACKAGES[provider];
+  if (!pkg) {
+    throw new Error(
+      `Unknown CLOUD_PROVIDER "${provider}". Supported: ${Object.keys(PROVIDER_PACKAGES).join(", ")}, local`
+    );
+  }
+  try {
+    const mod = _require(pkg);
+    const registerFnName = `register${provider.charAt(0).toUpperCase() + provider.slice(1)}Provider`;
+    const registerFn = mod[registerFnName] ?? mod.default;
+    if (typeof registerFn !== "function") {
+      throw new Error(
+        `${pkg} does not export ${registerFnName}() or a default registration function`
+      );
+    }
+    registerFn();
+  } catch (err) {
+    if (err.code === "ERR_MODULE_NOT_FOUND" || err.code === "MODULE_NOT_FOUND") {
+      throw new Error(
+        `CLOUD_PROVIDER is "${provider}" but ${pkg} is not installed. Add it to your service's package.json dependencies.`
+      );
+    }
+    throw err;
+  }
+}
+var PROVIDER_PACKAGES, _require;
+var init_bootstrap = __esm({
+  "../../packages/@company/cloud/src/bootstrap.ts"() {
+    "use strict";
+    PROVIDER_PACKAGES = {
+      gcp: "@company/cloud-gcp",
+      aws: "@company/cloud-aws"
+    };
+    _require = require;
+  }
+});
+
+// ../../packages/@company/cloud/src/storage-uri.ts
+function storageUri(bucket, path) {
+  const provider = cloudRegistry.provider;
+  const scheme = provider === "aws" ? "s3" : provider === "gcp" ? "gs" : "file";
+  return `${scheme}://${bucket}/${path}`;
+}
+var init_storage_uri = __esm({
+  "../../packages/@company/cloud/src/storage-uri.ts"() {
+    "use strict";
+    init_provider_registry();
+  }
+});
+
+// ../../packages/@company/cloud/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ProviderRegistry: () => ProviderRegistry,
+  bootstrapCloudProvider: () => bootstrapCloudProvider,
+  cloudRegistry: () => cloudRegistry,
+  storageUri: () => storageUri
+});
+var init_src = __esm({
+  "../../packages/@company/cloud/src/index.ts"() {
+    init_provider_registry();
+    init_bootstrap();
+    init_storage_uri();
+  }
+});
+
+// ../../packages/@company/observability/src/logger.ts
+function getCloudBackend() {
+  if (_cloudBackend === void 0) {
+    try {
+      const { cloudRegistry: cloudRegistry2 } = (
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        (init_src(), __toCommonJS(src_exports))
+      );
+      _cloudBackend = cloudRegistry2.getLoggerBackend();
+    } catch {
+      _cloudBackend = null;
+    }
+  }
+  return _cloudBackend;
+}
+function normKey(key) {
+  return key.toLowerCase().replace(/[_\-]/g, "");
+}
+function isSensitiveKey(key) {
+  return SENSITIVE_KEY_RE.test(normKey(key));
+}
+function sanitizeMetadata(obj, depth = 0) {
+  if (depth > 5) return obj;
+  const result = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (isSensitiveKey(k)) {
+      result[k] = "[REDACTED]";
+    } else if (v !== null && typeof v === "object" && !Array.isArray(v) && !(v instanceof Date)) {
+      result[k] = sanitizeMetadata(v, depth + 1);
+    } else {
+      result[k] = v;
+    }
+  }
+  return result;
+}
+function normalizeErrorMetadata(error2, metadata) {
+  if (!error2) return metadata;
+  if (error2 instanceof Error) {
+    return {
+      error: {
+        message: error2.message,
+        name: error2.name,
+        // Omit stack in production — it exposes internal file paths and code structure
+        ...process.env.NODE_ENV !== "production" && {
+          stack: error2.stack
+        }
+      },
+      ...metadata
+    };
+  }
+  if (typeof error2 === "object" && error2 !== null && !Array.isArray(error2)) {
+    return { ...error2, ...metadata };
+  }
+  return { error: String(error2), ...metadata };
+}
+function createLogger(serviceName, projectId) {
+  return new StructuredLogger(
+    serviceName,
+    projectId === null ? void 0 : projectId || process.env.GCP_PROJECT_ID
+  );
+}
+var import_async_hooks, _cloudBackend, SENSITIVE_KEY_RE, traceStorage, StructuredLogger, TraceContext;
 var init_logger = __esm({
-  "../service-capture/common/logger.ts"() {
+  "../../packages/@company/observability/src/logger.ts"() {
     "use strict";
-    Logger = class {
-      level;
-      service;
-      constructor(service, level = 1 /* INFO */) {
-        this.service = service;
-        this.level = level;
+    import_async_hooks = require("async_hooks");
+    init_esm_node();
+    init_types();
+    SENSITIVE_KEY_RE = /^(password|passwd|secret|token|apikey|authorization|auth|authtoken|authkey|credentials?|connectionstring|privatekey)$/;
+    traceStorage = new import_async_hooks.AsyncLocalStorage();
+    StructuredLogger = class {
+      serviceName;
+      isLocal;
+      projectId;
+      constructor(serviceName, projectId) {
+        this.serviceName = serviceName;
+        this.projectId = projectId ?? void 0;
+        this.isLocal = process.env.NODE_ENV === "development" || !this.projectId;
+        if (!this.isLocal && !getCloudBackend()) {
+          console.error(
+            `[StructuredLogger] WARNING: No cloud logger backend registered for service "${serviceName}". Falling back to console logging. Register a cloud provider to enable cloud logging.`
+          );
+        }
       }
-      formatMessage(level, message, context) {
-        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-        const contextStr = context ? ` ${JSON.stringify(context)}` : "";
-        return `[${timestamp}] [${this.service}] [${level}] ${message}${contextStr}`;
+      /**
+       * Write a structured log entry.  Sanitises metadata before writing so that
+       * PII / secrets never reach cloud logging.
+       */
+      async write(entry) {
+        const logEntry = {
+          ...entry,
+          serviceName: this.serviceName,
+          timestamp: entry.timestamp || /* @__PURE__ */ new Date(),
+          metadata: entry.metadata ? sanitizeMetadata(entry.metadata) : void 0
+        };
+        const backend = getCloudBackend();
+        if (this.isLocal || !backend) {
+          this.consoleLog(logEntry);
+        } else {
+          try {
+            await backend.writeLog({
+              severity: logEntry.severity,
+              message: logEntry.message,
+              timestamp: logEntry.timestamp,
+              traceId: logEntry.traceId,
+              spanId: logEntry.spanId,
+              userId: logEntry.userId,
+              organizationId: logEntry.organizationId,
+              serviceName: logEntry.serviceName,
+              metadata: logEntry.metadata
+            });
+          } catch (e) {
+            console.error("[StructuredLogger] Cloud Logging write failed:", e);
+          }
+        }
       }
-      debug(message, context) {
-        if (this.level <= 0 /* DEBUG */) {
-          console.error(this.formatMessage("DEBUG", message, context));
+      /**
+       * Console logging for local development
+       */
+      consoleLog(entry) {
+        const timestamp = entry.timestamp?.toISOString() || (/* @__PURE__ */ new Date()).toISOString();
+        const traceInfo = entry.traceId ? ` [trace: ${entry.traceId.slice(0, 8)}]` : "";
+        const orgInfo = entry.organizationId ? ` [org: ${entry.organizationId.slice(0, 8)}]` : "";
+        const prefix = `[${timestamp}] [${entry.severity}] [${this.serviceName}]${traceInfo}${orgInfo}`;
+        const message = `${prefix} ${entry.message}`;
+        const metadata = entry.metadata ? `
+${JSON.stringify(entry.metadata, null, 2)}` : "";
+        switch (entry.severity) {
+          case "ERROR" /* ERROR */:
+          case "CRITICAL" /* CRITICAL */:
+          case "ALERT" /* ALERT */:
+          case "EMERGENCY" /* EMERGENCY */:
+            console.error(message + metadata);
+            break;
+          case "WARNING" /* WARNING */:
+            console.warn(message + metadata);
+            break;
+          default:
+            console.log(message + metadata);
         }
       }
-      info(message, context) {
-        if (this.level <= 1 /* INFO */) {
-          console.error(this.formatMessage("INFO", message, context));
+      // ─── Convenience level methods ──────────────────────────────────────────────
+      async debug(message, metadata, context) {
+        await this.write({
+          severity: "DEBUG" /* DEBUG */,
+          message,
+          metadata,
+          ...context
+        });
+      }
+      async info(message, metadata, context) {
+        await this.write({
+          severity: "INFO" /* INFO */,
+          message,
+          metadata,
+          ...context
+        });
+      }
+      async notice(message, metadata, context) {
+        await this.write({
+          severity: "NOTICE" /* NOTICE */,
+          message,
+          metadata,
+          ...context
+        });
+      }
+      async warning(message, metadata, context) {
+        await this.write({
+          severity: "WARNING" /* WARNING */,
+          message,
+          metadata,
+          ...context
+        });
+      }
+      async warn(message, metadata, context) {
+        await this.warning(message, metadata, context);
+      }
+      async error(message, error2, metadata, context) {
+        const errorMetadata = normalizeErrorMetadata(error2, metadata);
+        await this.write({
+          severity: "ERROR" /* ERROR */,
+          message,
+          metadata: errorMetadata,
+          ...context
+        });
+      }
+      async critical(message, error2, metadata, context) {
+        const errorMetadata = normalizeErrorMetadata(error2, metadata);
+        await this.write({
+          severity: "CRITICAL" /* CRITICAL */,
+          message,
+          metadata: errorMetadata,
+          ...context
+        });
+      }
+    };
+    TraceContext = class {
+      static generateTraceId() {
+        return v4_default();
+      }
+      static generateSpanId() {
+        return v4_default().slice(0, 16);
+      }
+      /**
+       * Return the trace IDs for the current async execution context.
+       * Returns { traceId: null, spanId: null } when called outside any trace context.
+       */
+      static getTrace() {
+        const store = traceStorage.getStore();
+        return {
+          traceId: store?.traceId ?? null,
+          spanId: store?.spanId ?? null
+        };
+      }
+      /**
+       * Run fn inside a scoped trace context.  All async continuations started
+       * within fn (awaits, Promise chains, timer callbacks) automatically inherit
+       * this context — this is the correct way to scope a single HTTP request.
+       *
+       * Used by traceMiddleware:  TraceContext.runInContext(traceId, spanId, next)
+       */
+      static runInContext(traceId, spanId, fn) {
+        return traceStorage.run({ traceId, spanId }, fn);
+      }
+      /**
+       * Run an async function with a new (or supplied) trace context.
+       * Preferred API for background jobs, workers, and test isolation.
+       */
+      static async runWithTrace(fn, traceId) {
+        const id = traceId || this.generateTraceId();
+        const spanId = this.generateSpanId();
+        return traceStorage.run({ traceId: id, spanId }, fn);
+      }
+      /**
+       * @deprecated No-op.  AsyncLocalStorage replaced process-global static fields.
+       * Use `TraceContext.runWithTrace(fn)` for background jobs or rely on the
+       * traceMiddleware (which calls runInContext automatically) for HTTP requests.
+       */
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      static setTrace(_traceId, _spanId) {
+      }
+      /**
+       * @deprecated No-op — AsyncLocalStorage context is automatically scoped.
+       */
+      static clear() {
+      }
+    };
+  }
+});
+
+// ../../packages/@company/observability/src/metrics.ts
+function getCloudBackend2() {
+  if (_cloudBackend2 === void 0) {
+    try {
+      const { cloudRegistry: cloudRegistry2 } = (
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        (init_src(), __toCommonJS(src_exports))
+      );
+      _cloudBackend2 = cloudRegistry2.getMetricsBackend();
+    } catch {
+      _cloudBackend2 = null;
+    }
+  }
+  return _cloudBackend2;
+}
+var _cloudBackend2, MetricsService;
+var init_metrics = __esm({
+  "../../packages/@company/observability/src/metrics.ts"() {
+    "use strict";
+    init_types();
+    MetricsService = class {
+      projectId;
+      serviceName;
+      isLocal;
+      constructor(serviceName, projectId) {
+        this.serviceName = serviceName;
+        this.projectId = projectId === null ? "" : projectId || process.env.GCP_PROJECT_ID || "";
+        this.isLocal = process.env.NODE_ENV === "development" || !this.projectId;
+        if (!this.isLocal && !getCloudBackend2()) {
+          console.error(
+            `[MetricsService] WARNING: No cloud metrics backend registered for service "${serviceName}". Metrics will be logged to console only. Register a cloud provider to enable cloud metrics.`
+          );
         }
       }
-      warn(message, context) {
-        if (this.level <= 2 /* WARN */) {
-          console.warn(this.formatMessage("WARN", message, context));
+      /**
+       * Record a custom metric
+       */
+      async recordMetric(metric) {
+        if (this.isLocal) {
+          console.log("[METRIC]", {
+            name: metric.name,
+            value: metric.value,
+            type: metric.type,
+            labels: metric.labels,
+            unit: metric.unit
+          });
+          return;
+        }
+        const backend = getCloudBackend2();
+        if (!backend) {
+          console.warn("Metrics backend not initialized");
+          return;
+        }
+        try {
+          await backend.writeMetric({
+            name: metric.name,
+            value: metric.value,
+            type: metric.type,
+            labels: metric.labels,
+            timestamp: metric.timestamp,
+            unit: metric.unit,
+            serviceName: this.serviceName
+          });
+        } catch (error2) {
+          console.error("Failed to record metric:", error2);
         }
       }
-      error(message, error2, context) {
-        if (this.level <= 3 /* ERROR */) {
-          const errorContext = {
-            ...context,
-            ...error2 instanceof Error ? { error: error2.message, stack: error2.stack } : { error: String(error2) }
-          };
-          console.error(this.formatMessage("ERROR", message, errorContext));
+      /**
+       * Record API request metrics
+       */
+      async recordAPICall(metrics) {
+        await this.recordMetric({
+          name: "api/requests_total",
+          value: 1,
+          type: "COUNTER" /* COUNTER */,
+          labels: {
+            endpoint: metrics.endpoint,
+            method: metrics.method,
+            status_code: metrics.statusCode.toString(),
+            organization_id: metrics.organizationId || "unknown"
+          }
+        });
+        await this.recordMetric({
+          name: "api/request_duration_ms",
+          value: metrics.duration,
+          type: "HISTOGRAM" /* HISTOGRAM */,
+          labels: {
+            endpoint: metrics.endpoint,
+            method: metrics.method
+          },
+          unit: "ms"
+        });
+        if (metrics.statusCode >= 400) {
+          await this.recordMetric({
+            name: "api/errors_total",
+            value: 1,
+            type: "COUNTER" /* COUNTER */,
+            labels: {
+              endpoint: metrics.endpoint,
+              method: metrics.method,
+              status_code: metrics.statusCode.toString(),
+              organization_id: metrics.organizationId || "unknown"
+            }
+          });
+        }
+      }
+      /**
+       * Record LLM usage metrics
+       */
+      async recordLLMCall(metrics) {
+        await this.recordMetric({
+          name: "llm/calls_total",
+          value: 1,
+          type: "COUNTER" /* COUNTER */,
+          labels: {
+            model: metrics.model,
+            success: metrics.success.toString(),
+            organization_id: metrics.organizationId || "unknown"
+          }
+        });
+        await this.recordMetric({
+          name: "llm/tokens_total",
+          value: metrics.totalTokens,
+          type: "COUNTER" /* COUNTER */,
+          labels: {
+            model: metrics.model,
+            type: "total",
+            organization_id: metrics.organizationId || "unknown"
+          }
+        });
+        await this.recordMetric({
+          name: "llm/tokens_total",
+          value: metrics.inputTokens,
+          type: "COUNTER" /* COUNTER */,
+          labels: {
+            model: metrics.model,
+            type: "input",
+            organization_id: metrics.organizationId || "unknown"
+          }
+        });
+        await this.recordMetric({
+          name: "llm/tokens_total",
+          value: metrics.outputTokens,
+          type: "COUNTER" /* COUNTER */,
+          labels: {
+            model: metrics.model,
+            type: "output",
+            organization_id: metrics.organizationId || "unknown"
+          }
+        });
+        await this.recordMetric({
+          name: "llm/request_duration_ms",
+          value: metrics.duration,
+          type: "HISTOGRAM" /* HISTOGRAM */,
+          labels: {
+            model: metrics.model
+          },
+          unit: "ms"
+        });
+        if (!metrics.success) {
+          await this.recordMetric({
+            name: "llm/errors_total",
+            value: 1,
+            type: "COUNTER" /* COUNTER */,
+            labels: {
+              model: metrics.model,
+              error_type: metrics.error || "unknown"
+            }
+          });
         }
       }
-      setLevel(level) {
-        this.level = level;
+      /**
+       * Record data capture metrics
+       */
+      async recordDataCapture(metrics) {
+        await this.recordMetric({
+          name: "data_capture/operations_total",
+          value: 1,
+          type: "COUNTER" /* COUNTER */,
+          labels: {
+            integration: metrics.integration,
+            operation: metrics.operation,
+            success: metrics.success.toString()
+          }
+        });
+        await this.recordMetric({
+          name: "data_capture/records_processed",
+          value: metrics.recordsProcessed,
+          type: "COUNTER" /* COUNTER */,
+          labels: {
+            integration: metrics.integration,
+            operation: metrics.operation
+          }
+        });
+        await this.recordMetric({
+          name: "data_capture/duration_ms",
+          value: metrics.duration,
+          type: "HISTOGRAM" /* HISTOGRAM */,
+          labels: {
+            integration: metrics.integration,
+            operation: metrics.operation
+          },
+          unit: "ms"
+        });
+        if (!metrics.success) {
+          await this.recordMetric({
+            name: "data_capture/errors_total",
+            value: 1,
+            type: "COUNTER" /* COUNTER */,
+            labels: {
+              integration: metrics.integration,
+              operation: metrics.operation,
+              error_type: metrics.error || "unknown"
+            }
+          });
+        }
+      }
+      /**
+       * Record usage metrics for billing/quota tracking
+       */
+      async recordUsage(metrics) {
+        await this.recordMetric({
+          name: "usage/api_calls",
+          value: metrics.apiCalls,
+          type: "GAUGE" /* GAUGE */,
+          labels: {
+            organization_id: metrics.organizationId
+          },
+          timestamp: metrics.timestamp
+        });
+        await this.recordMetric({
+          name: "usage/llm_tokens",
+          value: metrics.llmTokens,
+          type: "GAUGE" /* GAUGE */,
+          labels: {
+            organization_id: metrics.organizationId
+          },
+          timestamp: metrics.timestamp
+        });
+        await this.recordMetric({
+          name: "usage/storage_bytes",
+          value: metrics.storageBytes,
+          type: "GAUGE" /* GAUGE */,
+          labels: {
+            organization_id: metrics.organizationId
+          },
+          unit: "bytes",
+          timestamp: metrics.timestamp
+        });
+      }
+      /**
+       * Record custom business metric
+       */
+      async recordCounter(name, value = 1, labels) {
+        await this.recordMetric({
+          name,
+          value,
+          type: "COUNTER" /* COUNTER */,
+          labels
+        });
+      }
+      async recordGauge(name, value, labels) {
+        await this.recordMetric({
+          name,
+          value,
+          type: "GAUGE" /* GAUGE */,
+          labels
+        });
+      }
+      async recordHistogram(name, value, labels, unit) {
+        await this.recordMetric({
+          name,
+          value,
+          type: "HISTOGRAM" /* HISTOGRAM */,
+          labels,
+          unit
+        });
+      }
+    };
+  }
+});
+
+// ../../packages/@company/observability/src/observability-service.ts
+function createObservabilityService(serviceName, projectId) {
+  return new ObservabilityService(serviceName, projectId);
+}
+var ObservabilityService;
+var init_observability_service = __esm({
+  "../../packages/@company/observability/src/observability-service.ts"() {
+    "use strict";
+    init_logger();
+    init_metrics();
+    init_types();
+    ObservabilityService = class {
+      logger;
+      metrics;
+      serviceName;
+      constructor(serviceName, projectId) {
+        this.serviceName = serviceName;
+        this.logger = new StructuredLogger(serviceName, projectId);
+        this.metrics = new MetricsService(serviceName, projectId);
+      }
+      /**
+       * Track API request with both logging and metrics
+       */
+      async trackAPIRequest(metrics, error2) {
+        await this.metrics.recordAPICall(metrics);
+        const { traceId, spanId } = TraceContext.getTrace();
+        const severity = metrics.statusCode >= 500 ? "ERROR" /* ERROR */ : metrics.statusCode >= 400 ? "WARNING" /* WARNING */ : "INFO" /* INFO */;
+        await this.logger.write({
+          severity,
+          message: `${metrics.method} ${metrics.endpoint} ${metrics.statusCode} ${metrics.duration}ms`,
+          traceId: traceId || void 0,
+          spanId: spanId || void 0,
+          organizationId: metrics.organizationId,
+          userId: metrics.userId,
+          metadata: {
+            endpoint: metrics.endpoint,
+            method: metrics.method,
+            statusCode: metrics.statusCode,
+            duration: metrics.duration,
+            error: error2 ? {
+              message: error2.message,
+              ...process.env.NODE_ENV !== "production" && {
+                stack: error2.stack
+              }
+            } : void 0
+          }
+        });
+      }
+      /**
+       * Track LLM call with both logging and metrics
+       */
+      async trackLLMCall(metrics, error2) {
+        await this.metrics.recordLLMCall(metrics);
+        const { traceId, spanId } = TraceContext.getTrace();
+        const severity = metrics.success ? "INFO" /* INFO */ : "ERROR" /* ERROR */;
+        await this.logger.write({
+          severity,
+          message: `LLM call to ${metrics.model}: ${metrics.totalTokens} tokens in ${metrics.duration}ms`,
+          traceId: traceId || void 0,
+          spanId: spanId || void 0,
+          organizationId: metrics.organizationId,
+          metadata: {
+            model: metrics.model,
+            inputTokens: metrics.inputTokens,
+            outputTokens: metrics.outputTokens,
+            totalTokens: metrics.totalTokens,
+            duration: metrics.duration,
+            success: metrics.success,
+            error: error2 ? {
+              message: error2.message,
+              ...process.env.NODE_ENV !== "production" && {
+                stack: error2.stack
+              }
+            } : void 0
+          }
+        });
+      }
+      /**
+       * Track data capture operation
+       */
+      async trackDataCapture(metrics, error2) {
+        await this.metrics.recordDataCapture(metrics);
+        const { traceId, spanId } = TraceContext.getTrace();
+        const severity = metrics.success ? "INFO" /* INFO */ : "ERROR" /* ERROR */;
+        await this.logger.write({
+          severity,
+          message: `${metrics.integration} ${metrics.operation}: ${metrics.recordsProcessed} records in ${metrics.duration}ms`,
+          traceId: traceId || void 0,
+          spanId: spanId || void 0,
+          metadata: {
+            integration: metrics.integration,
+            operation: metrics.operation,
+            recordsProcessed: metrics.recordsProcessed,
+            duration: metrics.duration,
+            success: metrics.success,
+            error: error2 ? {
+              message: error2.message,
+              ...process.env.NODE_ENV !== "production" && {
+                stack: error2.stack
+              }
+            } : void 0
+          }
+        });
+      }
+      /**
+       * Track organization usage
+       */
+      async trackUsage(metrics) {
+        await this.metrics.recordUsage(metrics);
+        await this.logger.info(
+          `Usage recorded for organization ${metrics.organizationId}`,
+          {
+            apiCalls: metrics.apiCalls,
+            llmTokens: metrics.llmTokens,
+            storageBytes: metrics.storageBytes
+          },
+          {
+            organizationId: metrics.organizationId
+          }
+        );
+      }
+      /**
+       * Convenience methods for logging
+       */
+      async debug(message, metadata) {
+        const { traceId, spanId } = TraceContext.getTrace();
+        await this.logger.debug(message, metadata, {
+          traceId: traceId || void 0,
+          spanId: spanId || void 0
+        });
+      }
+      async info(message, metadata) {
+        const { traceId, spanId } = TraceContext.getTrace();
+        await this.logger.info(message, metadata, {
+          traceId: traceId || void 0,
+          spanId: spanId || void 0
+        });
+      }
+      async warning(message, metadata) {
+        const { traceId, spanId } = TraceContext.getTrace();
+        await this.logger.warning(message, metadata, {
+          traceId: traceId || void 0,
+          spanId: spanId || void 0
+        });
+      }
+      /**
+       * Alias for warning() to match console.warn() convention
+       */
+      async warn(message, metadata) {
+        return this.warning(message, metadata);
+      }
+      async error(message, error2, metadata) {
+        const { traceId, spanId } = TraceContext.getTrace();
+        await this.logger.error(message, error2, metadata, {
+          traceId: traceId || void 0,
+          spanId: spanId || void 0
+        });
+      }
+      async critical(message, error2, metadata) {
+        const { traceId, spanId } = TraceContext.getTrace();
+        await this.logger.critical(message, error2, metadata, {
+          traceId: traceId || void 0,
+          spanId: spanId || void 0
+        });
+      }
+      /**
+       * @deprecated No-op.  Use `withTrace(fn)` instead.
+       * Direct setTrace/endTrace are not safe under concurrency and have no effect
+       * with the AsyncLocalStorage-based TraceContext.
+       */
+      startTrace(traceId) {
+        return traceId || TraceContext.generateTraceId();
+      }
+      /**
+       * @deprecated No-op — AsyncLocalStorage context is automatically scoped.
+       */
+      endTrace() {
+      }
+      /**
+       * Run a function with automatic trace context.
+       * Preferred API for background jobs and standalone traces.
+       */
+      async withTrace(fn, traceId) {
+        return TraceContext.runWithTrace(fn, traceId);
       }
     };
   }
 });
 
+// ../../packages/@company/observability/src/middleware.ts
+var init_middleware = __esm({
+  "../../packages/@company/observability/src/middleware.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// ../../packages/@company/observability/src/health.ts
+var init_health = __esm({
+  "../../packages/@company/observability/src/health.ts"() {
+    "use strict";
+  }
+});
+
+// ../../packages/@company/observability/src/degradation.ts
+var init_degradation = __esm({
+  "../../packages/@company/observability/src/degradation.ts"() {
+    "use strict";
+    init_types();
+    init_observability_service();
+  }
+});
+
+// ../../packages/@company/observability/src/index.ts
+var defaultObservability, getDefaultObservability, observability;
+var init_src2 = __esm({
+  "../../packages/@company/observability/src/index.ts"() {
+    init_observability_service();
+    init_observability_service();
+    init_logger();
+    init_metrics();
+    init_middleware();
+    init_health();
+    init_degradation();
+    init_types();
+    defaultObservability = null;
+    getDefaultObservability = () => {
+      if (!defaultObservability) {
+        defaultObservability = createObservabilityService(
+          process.env.SERVICE_NAME || "haansi-platform"
+        );
+      }
+      return defaultObservability;
+    };
+    observability = new Proxy(
+      {},
+      {
+        get(_target, prop) {
+          const instance = getDefaultObservability();
+          const value = instance[prop];
+          return typeof value === "function" ? value.bind(instance) : value;
+        }
+      }
+    );
+  }
+});
+
 // ../service-capture/common/agents/types.ts
 var AGENT_IDS;
-var init_types = __esm({
+var init_types2 = __esm({
   "../service-capture/common/agents/types.ts"() {
     "use strict";
     AGENT_IDS = ["claude-code", "codex"];
@@ -926,7 +1960,7 @@ __export(agents_exports, {
 var init_agents = __esm({
   "../service-capture/common/agents/index.ts"() {
     "use strict";
-    init_types();
+    init_types2();
     init_claude_code();
     init_codex();
     init_registry();
@@ -936,7 +1970,8 @@ var init_agents = __esm({
 // ../service-capture/claude-sessions/collector.ts
 var collector_exports = {};
 __export(collector_exports, {
-  collect: () => collect
+  collect: () => collect,
+  uploadSession: () => uploadSession
 });
 function edgeScrub(content) {
   let result = content;
@@ -1031,15 +2066,15 @@ function extractGitInfo(projectDir, sessionTimestamp, sessionBranch) {
   }
   return result;
 }
-function resolveToken() {
+function resolveToken2() {
   if (process.env.HAANSI_TOKEN) return process.env.HAANSI_TOKEN;
-  if ((0, import_fs3.existsSync)(CREDENTIALS_FILE3)) {
+  if ((0, import_fs3.existsSync)(CREDENTIALS_FILE4)) {
     try {
-      const creds = JSON.parse((0, import_fs3.readFileSync)(CREDENTIALS_FILE3, "utf-8"));
+      const creds = JSON.parse((0, import_fs3.readFileSync)(CREDENTIALS_FILE4, "utf-8"));
       if (creds.token) return creds.token;
     } catch {
       logger.warn("Could not parse credentials file", {
-        file: CREDENTIALS_FILE3
+        file: CREDENTIALS_FILE4
       });
     }
   }
@@ -1050,6 +2085,11 @@ function resolveAgentIds(agents) {
   const installed = detectInstalled().map((a) => a.id);
   return installed.length > 0 ? installed : ["claude-code"];
 }
+function canResolveGit(session) {
+  if (session.gitRemoteUrl || session.gitCommit) return true;
+  if (!session.cwd) return false;
+  return (0, import_fs3.existsSync)(effectiveGitDir(session.cwd));
+}
 function discoverSessions(agentIds) {
   const sessions = [];
   for (const id of agentIds) {
@@ -1111,21 +2151,32 @@ async function uploadSession(sessionId, content, apiUrl2, token, agentSource, gi
   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(`${apiUrl2}/api/v1/capture/sessions/raw`, {
-    method: "POST",
-    headers,
-    body: new Uint8Array(body)
-  });
-  if (!response.ok) {
+  for (let attempt = 0; ; attempt += 1) {
+    const response = await fetch(`${apiUrl2}/api/v1/capture/sessions/raw`, {
+      method: "POST",
+      headers,
+      body: new Uint8Array(body)
+    });
+    if (response.ok) return;
+    if (response.status === 429 && attempt < UPLOAD_RATE_LIMIT_RETRIES) {
+      const retryAfter = Number(response.headers.get("Retry-After"));
+      const waitMs = Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter * 1e3 : DEFAULT_RATE_LIMIT_WAIT_MS;
+      await new Promise((resolve4) => setTimeout(resolve4, waitMs));
+      continue;
+    }
     const text = await response.text().catch(() => "");
-    throw new Error(
+    const err = new Error(
       `Upload failed (${response.status}): ${text.slice(0, 200)}`
     );
+    if (response.status === 429) {
+      err.rateLimited = true;
+    }
+    throw err;
   }
 }
 async function collect(options) {
-  const apiUrl2 = process.env.HAANSI_API_URL ?? DEFAULT_API_URL3;
-  const token = resolveToken();
+  const apiUrl2 = process.env.HAANSI_API_URL ?? DEFAULT_API_URL2;
+  const token = resolveToken2();
   if (!token && !options.dryRun) {
     throw new Error(
       "HAANSI_TOKEN is required. Set it as env var or in ~/.haansi/credentials.json"
@@ -1142,11 +2193,14 @@ async function collect(options) {
   let uploaded = 0;
   let skipped = 0;
   let errors = 0;
+  let deferred = 0;
   const remoteMap = options.forceAll ? /* @__PURE__ */ new Map() : await getUploadedSessions(apiUrl2, token);
   const toUpload = [];
   for (const session of localSessions) {
     const remote = remoteMap.get(session.sessionId);
-    if (remote && remote.lineCount >= session.lineCount && remote.hasGitMeta) {
+    const contentUnchanged = !!remote && remote.lineCount >= session.lineCount;
+    const worthRetryingForGit = !remote?.hasGitMeta && canResolveGit(session);
+    if (contentUnchanged && !worthRetryingForGit) {
       skipped++;
     } else {
       toUpload.push(session);
@@ -1216,11 +2270,22 @@ async function collect(options) {
         }
       );
     } catch (err) {
-      errors++;
-      logger.error(`Failed to upload ${shortId}`, { err: err.message });
+      if (err?.rateLimited) {
+        deferred++;
+        void logger.info(`Rate limited, will retry next run: ${shortId}`);
+      } else {
+        errors++;
+        logger.error(`Failed to upload ${shortId}`, { err: err.message });
+      }
     }
   }
-  return { uploaded, skipped, errors };
+  if (deferred > 0) {
+    void logger.info(
+      `${deferred} session(s) deferred by the upload rate limit \u2014 they remain queued`,
+      { deferred, uploaded }
+    );
+  }
+  return { uploaded, skipped, errors, deferred };
 }
 async function main() {
   const forceAll = process.argv.includes("--force-all");
@@ -1228,14 +2293,18 @@ async function main() {
   const limitIdx = process.argv.indexOf("--limit");
   const limit = limitIdx !== -1 ? parseInt(process.argv[limitIdx + 1], 10) : void 0;
   logger.info("Collector starting", { forceAll, dryRun });
-  const { uploaded, skipped, errors } = await collect({
+  const {
+    uploaded: _uploaded,
+    skipped: _skipped,
+    errors
+  } = await collect({
     forceAll,
     dryRun,
     limit
   });
   if (errors > 0) process.exit(1);
 }
-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, GIT_BIN_CANDIDATES, resolvedGitBin;
+var import_dotenv, import_path3, import_fs3, import_os3, import_zlib, import_child_process, logger, DEFAULT_API_URL2, CREDENTIALS_FILE4, MIN_LINES, EDGE_SCRUB_PATTERNS, GIT_BIN_CANDIDATES, resolvedGitBin, UPLOAD_RATE_LIMIT_RETRIES, DEFAULT_RATE_LIMIT_WAIT_MS;
 var init_collector = __esm({
   "../service-capture/claude-sessions/collector.ts"() {
     "use strict";
@@ -1245,12 +2314,13 @@ var init_collector = __esm({
     import_os3 = require("os");
     import_zlib = require("zlib");
     import_child_process = require("child_process");
-    init_logger();
+    init_src2();
+    init_service_urls();
     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_path3.join)((0, import_os3.homedir)(), ".haansi", "credentials.json");
+    DEFAULT_API_URL2 = SERVICE_URL_DEFAULTS.haansiApiBaseUrl;
+    CREDENTIALS_FILE4 = (0, import_path3.join)((0, import_os3.homedir)(), ".haansi", "credentials.json");
     MIN_LINES = 4;
     EDGE_SCRUB_PATTERNS = [
       {
@@ -1297,6 +2367,8 @@ var init_collector = __esm({
       "/usr/local/bin/git",
       "/usr/bin/git"
     ];
+    UPLOAD_RATE_LIMIT_RETRIES = 2;
+    DEFAULT_RATE_LIMIT_WAIT_MS = 6e4;
     if (require.main === module) {
       main().catch((err) => {
         logger.error("Collector failed", err);
@@ -1306,44 +2378,6 @@ 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, {
@@ -1391,7 +2425,7 @@ function saveAgents(agents) {
     }
   }
   cfg.agents = agents;
-  (0, import_node_fs4.mkdirSync)(HAANSI_DIR3, { recursive: true });
+  (0, import_node_fs4.mkdirSync)(HAANSI_DIR, { recursive: true });
   (0, import_node_fs4.writeFileSync)(CONFIG_FILE, JSON.stringify(cfg, null, 2) + "\n", {
     encoding: "utf-8",
     mode: 384
@@ -1864,19 +2898,19 @@ var require_scheduler = __commonJS({
 });
 
 // ../../node_modules/node-cron/node_modules/uuid/dist/esm-node/rng.js
-function rng() {
-  if (poolPtr > rnds8Pool.length - 16) {
-    import_crypto.default.randomFillSync(rnds8Pool);
-    poolPtr = 0;
+function rng2() {
+  if (poolPtr2 > rnds8Pool2.length - 16) {
+    import_crypto3.default.randomFillSync(rnds8Pool2);
+    poolPtr2 = 0;
   }
-  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+  return rnds8Pool2.slice(poolPtr2, poolPtr2 += 16);
 }
-var import_crypto, rnds8Pool, poolPtr;
-var init_rng = __esm({
+var import_crypto3, rnds8Pool2, poolPtr2;
+var init_rng2 = __esm({
   "../../node_modules/node-cron/node_modules/uuid/dist/esm-node/rng.js"() {
-    import_crypto = __toESM(require("crypto"));
-    rnds8Pool = new Uint8Array(256);
-    poolPtr = rnds8Pool.length;
+    import_crypto3 = __toESM(require("crypto"));
+    rnds8Pool2 = new Uint8Array(256);
+    poolPtr2 = rnds8Pool2.length;
   }
 });
 
@@ -1902,19 +2936,19 @@ var init_validate = __esm({
 
 // ../../node_modules/node-cron/node_modules/uuid/dist/esm-node/stringify.js
 function stringify(arr, offset = 0) {
-  const uuid3 = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+  const uuid3 = (byteToHex2[arr[offset + 0]] + byteToHex2[arr[offset + 1]] + byteToHex2[arr[offset + 2]] + byteToHex2[arr[offset + 3]] + "-" + byteToHex2[arr[offset + 4]] + byteToHex2[arr[offset + 5]] + "-" + byteToHex2[arr[offset + 6]] + byteToHex2[arr[offset + 7]] + "-" + byteToHex2[arr[offset + 8]] + byteToHex2[arr[offset + 9]] + "-" + byteToHex2[arr[offset + 10]] + byteToHex2[arr[offset + 11]] + byteToHex2[arr[offset + 12]] + byteToHex2[arr[offset + 13]] + byteToHex2[arr[offset + 14]] + byteToHex2[arr[offset + 15]]).toLowerCase();
   if (!validate_default(uuid3)) {
     throw TypeError("Stringified UUID is invalid");
   }
   return uuid3;
 }
-var byteToHex, stringify_default;
-var init_stringify = __esm({
+var byteToHex2, stringify_default;
+var init_stringify2 = __esm({
   "../../node_modules/node-cron/node_modules/uuid/dist/esm-node/stringify.js"() {
     init_validate();
-    byteToHex = [];
+    byteToHex2 = [];
     for (let i = 0; i < 256; ++i) {
-      byteToHex.push((i + 256).toString(16).substr(1));
+      byteToHex2.push((i + 256).toString(16).substr(1));
     }
     stringify_default = stringify;
   }
@@ -1928,7 +2962,7 @@ function v1(options, buf, offset) {
   let node = options.node || _nodeId;
   let clockseq = options.clockseq !== void 0 ? options.clockseq : _clockseq;
   if (node == null || clockseq == null) {
-    const seedBytes = options.random || (options.rng || rng)();
+    const seedBytes = options.random || (options.rng || rng2)();
     if (node == null) {
       node = _nodeId = [seedBytes[0] | 1, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];
     }
@@ -1972,8 +3006,8 @@ function v1(options, buf, offset) {
 var _nodeId, _clockseq, _lastMSecs, _lastNSecs, v1_default;
 var init_v1 = __esm({
   "../../node_modules/node-cron/node_modules/uuid/dist/esm-node/v1.js"() {
-    init_rng();
-    init_stringify();
+    init_rng2();
+    init_stringify2();
     _lastMSecs = 0;
     _lastNSecs = 0;
     v1_default = v1;
@@ -2059,7 +3093,7 @@ function v35_default(name, version3, hashfunc) {
 var DNS, URL2;
 var init_v35 = __esm({
   "../../node_modules/node-cron/node_modules/uuid/dist/esm-node/v35.js"() {
-    init_stringify();
+    init_stringify2();
     init_parse();
     DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
     URL2 = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
@@ -2073,12 +3107,12 @@ function md5(bytes) {
   } else if (typeof bytes === "string") {
     bytes = Buffer.from(bytes, "utf8");
   }
-  return import_crypto2.default.createHash("md5").update(bytes).digest();
+  return import_crypto4.default.createHash("md5").update(bytes).digest();
 }
-var import_crypto2, md5_default;
+var import_crypto4, md5_default;
 var init_md5 = __esm({
   "../../node_modules/node-cron/node_modules/uuid/dist/esm-node/md5.js"() {
-    import_crypto2 = __toESM(require("crypto"));
+    import_crypto4 = __toESM(require("crypto"));
     md5_default = md5;
   }
 });
@@ -2095,9 +3129,9 @@ var init_v3 = __esm({
 });
 
 // ../../node_modules/node-cron/node_modules/uuid/dist/esm-node/v4.js
-function v4(options, buf, offset) {
+function v42(options, buf, offset) {
   options = options || {};
-  const rnds = options.random || (options.rng || rng)();
+  const rnds = options.random || (options.rng || rng2)();
   rnds[6] = rnds[6] & 15 | 64;
   rnds[8] = rnds[8] & 63 | 128;
   if (buf) {
@@ -2109,12 +3143,12 @@ function v4(options, buf, offset) {
   }
   return stringify_default(rnds);
 }
-var v4_default;
-var init_v4 = __esm({
+var v4_default2;
+var init_v42 = __esm({
   "../../node_modules/node-cron/node_modules/uuid/dist/esm-node/v4.js"() {
-    init_rng();
-    init_stringify();
-    v4_default = v4;
+    init_rng2();
+    init_stringify2();
+    v4_default2 = v42;
   }
 });
 
@@ -2125,12 +3159,12 @@ function sha1(bytes) {
   } else if (typeof bytes === "string") {
     bytes = Buffer.from(bytes, "utf8");
   }
-  return import_crypto3.default.createHash("sha1").update(bytes).digest();
+  return import_crypto5.default.createHash("sha1").update(bytes).digest();
 }
-var import_crypto3, sha1_default;
+var import_crypto5, sha1_default;
 var init_sha1 = __esm({
   "../../node_modules/node-cron/node_modules/uuid/dist/esm-node/sha1.js"() {
-    import_crypto3 = __toESM(require("crypto"));
+    import_crypto5 = __toESM(require("crypto"));
     sha1_default = sha1;
   }
 });
@@ -2177,21 +3211,21 @@ __export(esm_node_exports, {
   stringify: () => stringify_default,
   v1: () => v1_default,
   v3: () => v3_default,
-  v4: () => v4_default,
+  v4: () => v4_default2,
   v5: () => v5_default,
   validate: () => validate_default,
   version: () => version_default
 });
-var init_esm_node = __esm({
+var init_esm_node2 = __esm({
   "../../node_modules/node-cron/node_modules/uuid/dist/esm-node/index.js"() {
     init_v1();
     init_v3();
-    init_v4();
+    init_v42();
     init_v5();
     init_nil();
     init_version();
     init_validate();
-    init_stringify();
+    init_stringify2();
     init_parse();
   }
 });
@@ -2203,7 +3237,7 @@ var require_scheduled_task = __commonJS({
     var EventEmitter = require("events");
     var Task = require_task();
     var Scheduler = require_scheduler();
-    var uuid3 = (init_esm_node(), __toCommonJS(esm_node_exports));
+    var uuid3 = (init_esm_node2(), __toCommonJS(esm_node_exports));
     var ScheduledTask = class extends EventEmitter {
       constructor(cronExpression, func, options) {
         super();
@@ -2248,7 +3282,7 @@ var require_background_scheduled_task = __commonJS({
     var EventEmitter = require("events");
     var path = require("path");
     var { fork } = require("child_process");
-    var uuid3 = (init_esm_node(), __toCommonJS(esm_node_exports));
+    var uuid3 = (init_esm_node2(), __toCommonJS(esm_node_exports));
     var daemonPath = `${__dirname}/daemon.js`;
     var BackgroundScheduledTask = class extends EventEmitter {
       constructor(cronExpression, taskPath, options) {
@@ -2314,7 +3348,7 @@ var require_storage = __commonJS({
       return {
         save: (task) => {
           if (!task.options) {
-            const uuid3 = (init_esm_node(), __toCommonJS(esm_node_exports));
+            const uuid3 = (init_esm_node2(), __toCommonJS(esm_node_exports));
             task.options = {};
             task.options.name = uuid3.v4();
           }
@@ -2432,10 +3466,11 @@ var init_collector_daemon = __esm({
     import_path4 = require("path");
     import_node_cron = __toESM(require_node_cron());
     init_collector();
-    init_logger();
+    init_src2();
     (0, import_dotenv2.config)({ path: (0, import_path4.resolve)(__dirname, "../../../.env") });
     logger2 = createLogger("collector-daemon");
-    IN_MEMORY_VERSION = require_package().version;
+    IN_MEMORY_VERSION = // eslint-disable-next-line @typescript-eslint/no-require-imports
+    require_package().version;
     SCHEDULE = process.env.HAANSI_COLLECT_SCHEDULE ?? process.env.CLAUDE_COLLECT_SCHEDULE ?? "*/30 * * * *";
     main2().catch((err) => {
       logger2.error("Daemon failed to start", err);
@@ -2659,14 +3694,39 @@ var init_taxonomy = __esm({
 });
 
 // ../../packages/@company/types/src/embedding.ts
+var EMBEDDING_DEFAULTS, EMBEDDING_COLUMN, SUMMARY_EMBEDDING_COLUMN;
 var init_embedding = __esm({
   "../../packages/@company/types/src/embedding.ts"() {
     "use strict";
+    EMBEDDING_DEFAULTS = {
+      // `as const` gives a literal string type for the provider field, which
+      // is assignable to llm-client's LLMProvider union without forcing
+      // @company/types to import that union (which would re-introduce the
+      // dependency edge we want to keep absent).
+      // CUTOVER (2026-07-17): in-house model is now the active config. Reads +
+      // writes + backfills all target the local-768 columns. The old OpenAI 1536
+      // columns (`embedding` / `summary_embedding`) are retained but dormant —
+      // roll back by flipping this whole object back to
+      //   { provider:"openai", model:"text-embedding-3-small", dimensions:1536,
+      //     column:"embedding", summaryColumn:"summary_embedding" }
+      // (a later contract migration drops the dormant columns). Readers alias
+      // `<column> AS embedding` so result-row field names stay stable.
+      provider: "local",
+      model: "Alibaba-NLP/gte-base-en-v1.5",
+      dimensions: 768,
+      // The ACTIVE dense-vector column that every reader + writer + backfill targets.
+      column: "embedding_v2",
+      // The active summary-embedding column (process_registry's second vector,
+      // used by the process matcher).
+      summaryColumn: "summary_embedding_v2"
+    };
+    EMBEDDING_COLUMN = EMBEDDING_DEFAULTS.column;
+    SUMMARY_EMBEDDING_COLUMN = EMBEDDING_DEFAULTS.summaryColumn;
   }
 });
 
 // ../../packages/@company/types/src/index.ts
-var init_src = __esm({
+var init_src3 = __esm({
   "../../packages/@company/types/src/index.ts"() {
     init_timeline();
     init_artifact();
@@ -3353,7 +4413,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_types2 = __esm({
+var init_types3 = __esm({
   "../../node_modules/zod/v3/types.js"() {
     init_ZodError();
     init_errors();
@@ -6606,7 +7666,7 @@ var init_external = __esm({
     init_parseUtil();
     init_typeAliases();
     init_util();
-    init_types2();
+    init_types3();
     init_ZodError();
   }
 });
@@ -14367,7 +15427,7 @@ var init_classic = __esm({
 });
 
 // ../../node_modules/zod/v4/index.js
-var init_v42 = __esm({
+var init_v43 = __esm({
   "../../node_modules/zod/v4/index.js"() {
     init_classic();
     init_classic();
@@ -14388,9 +15448,9 @@ 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_types3 = __esm({
+var init_types4 = __esm({
   "../service-capture/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js"() {
-    init_v42();
+    init_v43();
     LATEST_PROTOCOL_VERSION = "2025-11-25";
     DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26";
     SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
@@ -17554,7 +18614,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_types3();
+    init_types4();
     init_interfaces();
     init_zod_json_schema_compat();
     DEFAULT_REQUEST_TIMEOUT_MSEC = 6e4;
@@ -31136,7 +32196,7 @@ var Server;
 var init_server2 = __esm({
   "../service-capture/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js"() {
     init_protocol();
-    init_types3();
+    init_types4();
     init_ajv_provider();
     init_zod_compat();
     init_server();
@@ -31706,7 +32766,7 @@ var init_mcp = __esm({
     init_server2();
     init_zod_compat();
     init_zod_json_schema_compat();
-    init_types3();
+    init_types4();
     init_completable();
     init_uriTemplate();
     init_toolNameValidation();
@@ -32447,7 +33507,7 @@ function serializeMessage(message) {
 var ReadBuffer;
 var init_stdio = __esm({
   "../service-capture/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js"() {
-    init_types3();
+    init_types4();
     ReadBuffer = class {
       append(chunk) {
         this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
@@ -51347,14 +52407,14 @@ var require_etag = __commonJS({
   "../../node_modules/etag/index.js"(exports2, module2) {
     "use strict";
     module2.exports = etag;
-    var crypto6 = require("crypto");
+    var crypto8 = require("crypto");
     var Stats = require("fs").Stats;
     var toString = Object.prototype.toString;
     function entitytag(entity) {
       if (entity.length === 0) {
         return '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"';
       }
-      var hash2 = crypto6.createHash("sha1").update(entity, "utf8").digest("base64").substring(0, 27);
+      var hash2 = crypto8.createHash("sha1").update(entity, "utf8").digest("base64").substring(0, 27);
       var len = typeof entity === "string" ? Buffer.byteLength(entity, "utf8") : entity.length;
       return '"' + len.toString(16) + "-" + hash2 + '"';
     }
@@ -54769,17 +55829,17 @@ var require_content_disposition = __commonJS({
 // ../service-capture/node_modules/cookie-signature/index.js
 var require_cookie_signature = __commonJS({
   "../service-capture/node_modules/cookie-signature/index.js"(exports2) {
-    var crypto6 = require("crypto");
+    var crypto8 = require("crypto");
     exports2.sign = function(val, secret) {
       if ("string" != typeof val) throw new TypeError("Cookie value must be provided as a string.");
       if (null == secret) throw new TypeError("Secret key must be provided.");
-      return val + "." + crypto6.createHmac("sha256", secret).update(val).digest("base64").replace(/\=+$/, "");
+      return val + "." + crypto8.createHmac("sha256", secret).update(val).digest("base64").replace(/\=+$/, "");
     };
     exports2.unsign = function(input, secret) {
       if ("string" != typeof input) throw new TypeError("Signed cookie string must be provided.");
       if (null == secret) throw new TypeError("Secret key must be provided.");
       var tentativeValue = input.slice(0, input.lastIndexOf(".")), expectedInput = exports2.sign(tentativeValue, secret), expectedBuffer = Buffer.from(expectedInput), inputBuffer = Buffer.from(input);
-      return expectedBuffer.length === inputBuffer.length && crypto6.timingSafeEqual(expectedBuffer, inputBuffer) ? tentativeValue : false;
+      return expectedBuffer.length === inputBuffer.length && crypto8.timingSafeEqual(expectedBuffer, inputBuffer) ? tentativeValue : false;
     };
   }
 });
@@ -56174,13 +57234,13 @@ function writeFromReadableStream(stream, writable) {
   }
   return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
 }
-var import_http2, import_http22, import_stream, import_crypto4, RequestError, toRequestError, GlobalRequest, Request, newHeadersFromIncoming, wrapBodyStream, newRequestFromIncoming, getRequestCache, requestCache, incomingKey, urlKey, headersKey, abortControllerKey, getAbortController, requestPrototype, newRequest, responseCache, getResponseCache, cacheKey, GlobalResponse, Response2, buildOutgoingHttpHeaders, X_ALREADY_SENT, outgoingEnded, handleRequestError, handleFetchError, handleResponseError, flushHeaders, responseViaCache, isPromise, responseViaResponseObject, getRequestListener;
+var import_http2, import_http22, import_stream, import_crypto6, RequestError, toRequestError, GlobalRequest, Request, newHeadersFromIncoming, wrapBodyStream, newRequestFromIncoming, getRequestCache, requestCache, incomingKey, urlKey, headersKey, abortControllerKey, getAbortController, requestPrototype, newRequest, responseCache, getResponseCache, cacheKey, GlobalResponse, Response2, buildOutgoingHttpHeaders, X_ALREADY_SENT, outgoingEnded, handleRequestError, handleFetchError, handleResponseError, flushHeaders, responseViaCache, isPromise, responseViaResponseObject, getRequestListener;
 var init_dist = __esm({
   "../../node_modules/@hono/node-server/dist/index.mjs"() {
     import_http2 = require("http2");
     import_http22 = require("http2");
     import_stream = require("stream");
-    import_crypto4 = __toESM(require("crypto"), 1);
+    import_crypto6 = __toESM(require("crypto"), 1);
     RequestError = class extends Error {
       constructor(message, options) {
         super(message, options);
@@ -56450,7 +57510,7 @@ var init_dist = __esm({
     };
     X_ALREADY_SENT = "x-hono-already-sent";
     if (typeof global.crypto === "undefined") {
-      global.crypto = import_crypto4.default;
+      global.crypto = import_crypto6.default;
     }
     outgoingEnded = Symbol("outgoingEnded");
     handleRequestError = () => new Response(null, {
@@ -56669,7 +57729,7 @@ var init_dist = __esm({
 var WebStandardStreamableHTTPServerTransport;
 var init_webStandardStreamableHttp = __esm({
   "../service-capture/node_modules/@modelcontextprotocol/sdk/dist/esm/server/webStandardStreamableHttp.js"() {
-    init_types3();
+    init_types4();
     WebStandardStreamableHTTPServerTransport = class {
       constructor(options = {}) {
         this._started = false;
@@ -57459,7 +58519,7 @@ async function main3() {
   }
   warmupInBackground();
 }
-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 import_dotenv3, import_path5, import_fs5, import_os4, DEFAULT_API_URL3, CREDENTIALS_FILE5, API_URL, AGENT_SOURCE, DEFAULT_SOURCE_TOOL, TOKEN, contextSchema, isCollecting, lastCollectTime, COLLECT_COOLDOWN_MS, mcpServer, server;
 var init_mcp_server2 = __esm({
   "../service-capture/claude-sessions/mcp-server.ts"() {
     "use strict";
@@ -57469,14 +58529,17 @@ var init_mcp_server2 = __esm({
     import_os4 = require("os");
     init_collector();
     init_http_timeout();
-    init_src();
+    init_service_urls();
+    init_src3();
     init_mcp();
     init_stdio2();
-    init_types3();
+    init_types4();
     (0, import_dotenv3.config)({ path: (0, import_path5.resolve)(__dirname, "../../../.env") });
-    DEFAULT_API_URL5 = "https://api.haansi.co";
+    DEFAULT_API_URL3 = SERVICE_URL_DEFAULTS.haansiApiBaseUrl;
     CREDENTIALS_FILE5 = (0, import_path5.join)((0, import_os4.homedir)(), ".haansi", "credentials.json");
-    API_URL = process.env.HAANSI_API_URL ?? DEFAULT_API_URL5;
+    API_URL = process.env.HAANSI_API_URL ?? DEFAULT_API_URL3;
+    AGENT_SOURCE = process.env.HAANSI_AGENT_SOURCE?.toLowerCase();
+    DEFAULT_SOURCE_TOOL = AGENT_SOURCE === "codex" ? "codex-mcp" : "claude-code-mcp";
     TOKEN = resolveToken3();
     if (!TOKEN) {
       process.exit(1);
@@ -57616,7 +58679,7 @@ var init_mcp_server2 = __esm({
               },
               source_tool: {
                 type: "string",
-                description: 'Tool that saved this (default: "claude-code-mcp")'
+                description: `Tool that saved this (default: "${DEFAULT_SOURCE_TOOL}")`
               },
               _context: contextSchema
             },
@@ -57735,7 +58798,7 @@ var init_mcp_server2 = __esm({
                 git_commit,
                 tags,
                 model,
-                source_tool
+                source_tool: source_tool ?? DEFAULT_SOURCE_TOOL
               },
               { extraHeaders }
             );
@@ -57830,7 +58893,7 @@ function parseTarget(arg) {
   );
 }
 function exchangeUrl() {
-  return `${apiUrl().replace(/\/+$/, "")}/api/v1/access/exchange/mcp`;
+  return `${apiUrl().replace(/\/+$/, "")}/api/v1/memory/exchange/mcp`;
 }
 function setupClaudeMcp(target) {
   let config6 = {};
@@ -57850,12 +58913,13 @@ function setupClaudeMcp(target) {
     const haansiBin = resolveHaansiBin();
     config6.mcpServers["haansi-solutions"] = {
       command: haansiBin,
-      args: ["mcp-server"]
+      args: ["mcp-server"],
+      env: { HAANSI_AGENT_SOURCE: "claude-code" }
     };
     installed.push(`haansi-solutions (stdio \u2192 ${haansiBin} mcp-server)`);
   }
   if (target === "all" || target === "exchange") {
-    const token = resolveToken2();
+    const token = resolveToken();
     if (!token) {
       warnings.push(
         "haansi-exchange not registered: no token found. Run `haansi auth login` first, or set HAANSI_TOKEN."
@@ -57894,12 +58958,13 @@ function setupCodexMcp(target) {
     const haansiBin = resolveHaansiBin();
     content = upsertTomlTable(content, "mcp_servers.haansi-solutions", {
       command: tomlString(haansiBin),
-      args: tomlStringArray(["mcp-server"])
+      args: tomlStringArray(["mcp-server"]),
+      env: tomlInlineTable({ HAANSI_AGENT_SOURCE: "codex" })
     });
     installed.push(`haansi-solutions (stdio \u2192 ${haansiBin} mcp-server)`);
   }
   if (target === "all" || target === "exchange") {
-    const token = resolveToken2();
+    const token = resolveToken();
     if (!token) {
       warnings.push(
         "haansi-exchange not registered: no token found. Run `haansi auth login` first, or set HAANSI_TOKEN."
@@ -58096,7 +59161,7 @@ async function config5(args) {
     process.exit(1);
     return;
   }
-  const apiUrl2 = process.env.HAANSI_API_URL ?? DEFAULT_API_URL6;
+  const apiUrl2 = apiUrl();
   const subcommand = args[0];
   if (subcommand === "get") {
     const key = args[1];
@@ -58177,14 +59242,14 @@ Supported keys:
     if (subcommand !== void 0) process.exit(1);
   }
 }
-var import_node_fs7, import_node_path6, import_node_os6, DEFAULT_API_URL6, CREDENTIALS_FILE6, VALID_SESSION_MODES;
+var import_node_fs7, import_node_path6, import_node_os6, CREDENTIALS_FILE6, VALID_SESSION_MODES;
 var init_config = __esm({
   "src/commands/config.ts"() {
     "use strict";
     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";
+    init_paths();
     CREDENTIALS_FILE6 = (0, import_node_path6.join)((0, import_node_os6.homedir)(), ".haansi", "credentials.json");
     VALID_SESSION_MODES = ["private", "org"];
   }
@@ -58235,7 +59300,7 @@ async function apiPost2(path, body, token, apiUrl2) {
   return response.json();
 }
 async function list(options) {
-  const apiUrl2 = process.env.HAANSI_API_URL ?? DEFAULT_API_URL7;
+  const apiUrl2 = apiUrl();
   const token = resolveToken5();
   let data;
   if (options.search) {
@@ -58261,7 +59326,7 @@ async function list(options) {
 ${data.results.length} result(s)`);
 }
 async function searchKnowledge(options) {
-  const apiUrl2 = process.env.HAANSI_API_URL ?? DEFAULT_API_URL7;
+  const apiUrl2 = apiUrl();
   const token = resolveToken5();
   let url2 = `/memory/solutions/knowledge/search?q=${encodeURIComponent(options.query)}&limit=${options.limit}`;
   if (options.artifactType) {
@@ -58278,7 +59343,7 @@ async function searchKnowledge(options) {
 ${data.results.length} result(s)`);
 }
 async function saveKnowledge(options) {
-  const apiUrl2 = process.env.HAANSI_API_URL ?? DEFAULT_API_URL7;
+  const apiUrl2 = apiUrl();
   const token = resolveToken5();
   const body = {
     problem_description: options.problem,
@@ -58299,19 +59364,20 @@ async function saveKnowledge(options) {
   console.log(`  Solution: ${data.solution_summary}`);
   console.log("\nThis is now searchable via `haansi search-solutions`.");
 }
-var import_node_fs8, import_node_path7, import_node_os7, DEFAULT_API_URL7, CREDENTIALS_FILE7;
+var import_node_fs8, import_node_path7, import_node_os7, CREDENTIALS_FILE7;
 var init_list = __esm({
   "src/commands/list.ts"() {
     "use strict";
     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";
+    init_paths();
     CREDENTIALS_FILE7 = (0, import_node_path7.join)((0, import_node_os7.homedir)(), ".haansi", "credentials.json");
   }
 });
 
 // src/index.ts
+init_paths();
 var { version: VERSION } = require_package();
 var command = process.argv[2];
 function getFlag(flag) {
@@ -58535,7 +59601,7 @@ 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)
+  HAANSI_API_URL             API base URL (default: ${DEFAULT_API_URL})
   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 * * * *)