mobbdev 1.2.53 → 1.2.55

package/dist/index.mjs

@@ -9918,7 +9918,7 @@ var _contextLogger = null;
 var createContextLogger = async () => {
   if (_contextLogger) return _contextLogger;
   try {
-    let logger2;
+    let logger3;
     try {
       let module;
       try {
@@ -9928,15 +9928,15 @@ var createContextLogger = async () => {
         const sourcePath = "../../../../../tscommon/backend/src/utils/logger";
         module = await import(sourcePath);
       }
-      logger2 = module.logger;
+      logger3 = module.logger;
     } catch {
     }
-    if (logger2) {
+    if (logger3) {
       _contextLogger = {
-        info: (message, data) => data ? logger2.info(data, message) : logger2.info(message),
-        warn: (message, data) => data ? logger2.warn(data, message) : logger2.warn(message),
-        debug: (message, data) => data ? logger2.debug(data, message) : logger2.debug(message),
-        error: (message, data) => data ? logger2.error(data, message) : logger2.error(message)
+        info: (message, data) => data ? logger3.info(data, message) : logger3.info(message),
+        warn: (message, data) => data ? logger3.warn(data, message) : logger3.warn(message),
+        debug: (message, data) => data ? logger3.debug(data, message) : logger3.debug(message),
+        error: (message, data) => data ? logger3.error(data, message) : logger3.error(message)
       };
       return _contextLogger;
     }
@@ -9952,20 +9952,20 @@ var createContextLogger = async () => {
 };
 var contextLogger = {
   info: async (message, data) => {
-    const logger2 = await createContextLogger();
-    return logger2.info(message, data);
+    const logger3 = await createContextLogger();
+    return logger3.info(message, data);
   },
   debug: async (message, data) => {
-    const logger2 = await createContextLogger();
-    return logger2.debug(message, data);
+    const logger3 = await createContextLogger();
+    return logger3.debug(message, data);
   },
   warn: async (message, data) => {
-    const logger2 = await createContextLogger();
-    return logger2.warn(message, data);
+    const logger3 = await createContextLogger();
+    return logger3.warn(message, data);
   },
   error: async (message, data) => {
-    const logger2 = await createContextLogger();
-    return logger2.error(message, data);
+    const logger3 = await createContextLogger();
+    return logger3.error(message, data);
   }
 };
 
@@ -11313,12 +11313,12 @@ var defaultLogger = {
     }
   }
 };
-function createGitWithLogging(dirName, logger2 = defaultLogger) {
+function createGitWithLogging(dirName, logger3 = defaultLogger) {
   return simpleGit2(dirName, {
     maxConcurrentProcesses: 6
   }).outputHandler((bin, stdout2, stderr2) => {
     const callID = Math.random();
-    logger2.info({ callID, bin }, "Start git CLI call");
+    logger3.info({ callID, bin }, "Start git CLI call");
     let errChunks = [];
     let outChunks = [];
     let isStdoutDone = false;
@@ -11339,25 +11339,25 @@ function createGitWithLogging(dirName, logger2 = defaultLogger) {
         err: `${errChunks.join("").slice(0, 200)}...`,
         out: `${outChunks.join("").slice(0, 200)}...`
       };
-      logger2.info(logObj, "git log output");
+      logger3.info(logObj, "git log output");
       stderr2.removeListener("data", onStderrData);
       stdout2.removeListener("data", onStdoutData);
       errChunks = [];
       outChunks = [];
     }
-    function markDone(stream) {
-      if (stream === "stderr") isStderrDone = true;
+    function markDone(stream3) {
+      if (stream3 === "stderr") isStderrDone = true;
       else isStdoutDone = true;
       finalizeAndCleanup();
     }
     stderr2.on("close", () => markDone("stderr"));
     stdout2.on("close", () => markDone("stdout"));
     stderr2.on("error", (error) => {
-      logger2.info({ callID, error: String(error) }, "git stderr stream error");
+      logger3.info({ callID, error: String(error) }, "git stderr stream error");
       markDone("stderr");
     });
     stdout2.on("error", (error) => {
-      logger2.info({ callID, error: String(error) }, "git stdout stream error");
+      logger3.info({ callID, error: String(error) }, "git stdout stream error");
       markDone("stdout");
     });
   });
@@ -13014,9 +13014,9 @@ async function uploadFile({
   url,
   uploadKey,
   uploadFields,
-  logger: logger2
+  logger: logger3
 }) {
-  const logInfo2 = logger2 || ((_message, _data) => {
+  const logInfo2 = logger3 || ((_message, _data) => {
   });
   logInfo2(`FileUpload: upload file start ${url}`);
   logInfo2(`FileUpload: upload fields`, uploadFields);
@@ -13059,22 +13059,27 @@ import os from "os";
 
 // src/utils/ConfigStoreService.ts
 import Configstore from "configstore";
-function createConfigStore(defaultValues = { apiToken: "" }) {
+function getSanitizedDomain() {
   const API_URL2 = process.env["API_URL"] || DEFAULT_API_URL;
   let domain = "";
   try {
     const url = new URL(API_URL2);
     domain = url.hostname;
-  } catch (e) {
+  } catch {
     domain = API_URL2.replace(/^https?:\/\//, "").replace(/\/.*$/, "").replace(/:\d+$/, "");
   }
-  const sanitizedDomain = domain.replace(/\./g, "_");
-  return new Configstore(`mobbdev-${sanitizedDomain}`, defaultValues);
+  return domain.replace(/\./g, "_");
+}
+function createConfigStore(defaultValues = { apiToken: "" }) {
+  return new Configstore(`mobbdev-${getSanitizedDomain()}`, defaultValues);
 }
-function getConfigStore() {
-  return createConfigStore();
+function createSessionConfigStore(sessionId) {
+  return new Configstore(`mobbdev-${getSanitizedDomain()}-session-${sessionId}`);
 }
-var configStore = getConfigStore();
+function getSessionFilePrefix() {
+  return `mobbdev-${getSanitizedDomain()}-session-`;
+}
+var configStore = createConfigStore();
 
 // src/utils/computerName.ts
 var STABLE_COMPUTER_NAME_CONFIG_KEY = "stableComputerName";
@@ -13305,6 +13310,10 @@ async function sanitizeDataWithCounts(obj) {
   const sanitizedData = await sanitizeRecursive(obj);
   return { sanitizedData, counts };
 }
+async function sanitizeData(obj) {
+  const result = await sanitizeDataWithCounts(obj);
+  return result.sanitizedData;
+}
 
 // src/args/commands/upload_ai_blame.ts
 var defaultLogger2 = {
@@ -13358,9 +13367,9 @@ var PromptItemZ = z27.object({
   }).optional()
 });
 var PromptItemArrayZ = z27.array(PromptItemZ);
-async function getRepositoryUrl() {
+async function getRepositoryUrl(workingDir) {
   try {
-    const gitService = new GitService(process.cwd());
+    const gitService = new GitService(workingDir ?? process.cwd());
     const isRepo = await gitService.isGitRepository();
     if (!isRepo) {
       return null;
@@ -13421,6 +13430,7 @@ function uploadAiBlameBuilder(args) {
   }).strict();
 }
 async function uploadAiBlameHandlerFromExtension(args) {
+  const shouldSanitize = args.sanitize ?? true;
   const uploadArgs = {
     prompt: [],
     inference: [],
@@ -13434,28 +13444,50 @@ async function uploadAiBlameHandlerFromExtension(args) {
   let inferenceCounts;
   let promptsUUID;
   let inferenceUUID;
+  const zeroCounts = {
+    detections: { total: 0, high: 0, medium: 0, low: 0 }
+  };
+  let sanitizationDurationMs;
   await withFile(async (promptFile) => {
-    const promptsResult = await sanitizeDataWithCounts(args.prompts);
-    promptsCounts = promptsResult.counts;
     promptsUUID = path7.basename(promptFile.path, path7.extname(promptFile.path));
-    await fsPromises2.writeFile(
-      promptFile.path,
-      JSON.stringify(promptsResult.sanitizedData, null, 2),
-      "utf-8"
-    );
+    if (shouldSanitize) {
+      const sanitizeStart = performance.now();
+      const promptsResult = await sanitizeDataWithCounts(args.prompts);
+      promptsCounts = promptsResult.counts;
+      await fsPromises2.writeFile(
+        promptFile.path,
+        JSON.stringify(promptsResult.sanitizedData, null, 2),
+        "utf-8"
+      );
+      sanitizationDurationMs = performance.now() - sanitizeStart;
+    } else {
+      promptsCounts = zeroCounts;
+      await fsPromises2.writeFile(
+        promptFile.path,
+        JSON.stringify(args.prompts, null, 2),
+        "utf-8"
+      );
+    }
     uploadArgs.prompt.push(promptFile.path);
     await withFile(async (inferenceFile) => {
-      const inferenceResult = await sanitizeDataWithCounts(args.inference);
-      inferenceCounts = inferenceResult.counts;
       inferenceUUID = path7.basename(
         inferenceFile.path,
         path7.extname(inferenceFile.path)
       );
-      await fsPromises2.writeFile(
-        inferenceFile.path,
-        inferenceResult.sanitizedData,
-        "utf-8"
-      );
+      if (shouldSanitize) {
+        const inferenceStart = performance.now();
+        const inferenceResult = await sanitizeDataWithCounts(args.inference);
+        inferenceCounts = inferenceResult.counts;
+        await fsPromises2.writeFile(
+          inferenceFile.path,
+          inferenceResult.sanitizedData,
+          "utf-8"
+        );
+        sanitizationDurationMs = (sanitizationDurationMs ?? 0) + (performance.now() - inferenceStart);
+      } else {
+        inferenceCounts = zeroCounts;
+        await fsPromises2.writeFile(inferenceFile.path, args.inference, "utf-8");
+      }
       uploadArgs.inference.push(inferenceFile.path);
       uploadArgs.model.push(args.model);
       uploadArgs.toolName.push(args.tool);
@@ -13477,7 +13509,8 @@ async function uploadAiBlameHandlerFromExtension(args) {
     promptsCounts,
     inferenceCounts,
     promptsUUID,
-    inferenceUUID
+    inferenceUUID,
+    sanitizationDurationMs
   };
 }
 async function uploadAiBlameHandler(options) {
@@ -13486,7 +13519,7 @@ async function uploadAiBlameHandler(options) {
     exitOnError = true,
     apiUrl,
     webAppUrl,
-    logger: logger2 = defaultLogger2
+    logger: logger3 = defaultLogger2
   } = options;
   const prompts = args.prompt || [];
   const inferences = args.inference || [];
@@ -13497,7 +13530,7 @@ async function uploadAiBlameHandler(options) {
   const sessionIds = args.sessionId || args["session-id"] || [];
   if (prompts.length !== inferences.length) {
     const errorMsg = "prompt and inference must have the same number of entries";
-    logger2.error(chalk4.red(errorMsg));
+    logger3.error(chalk4.red(errorMsg));
     if (exitOnError) {
       process.exit(1);
     }
@@ -13517,7 +13550,7 @@ async function uploadAiBlameHandler(options) {
       ]);
     } catch {
       const errorMsg = `File not found for session ${i + 1}`;
-      logger2.error(chalk4.red(errorMsg));
+      logger3.error(chalk4.red(errorMsg));
       if (exitOnError) {
         process.exit(1);
       }
@@ -13550,7 +13583,7 @@ async function uploadAiBlameHandler(options) {
   const uploadSessions = initRes.uploadAIBlameInferencesInit?.uploadSessions ?? [];
   if (uploadSessions.length !== sessions.length) {
     const errorMsg = "Init failed to return expected number of sessions";
-    logger2.error(chalk4.red(errorMsg));
+    logger3.error(chalk4.red(errorMsg));
     if (exitOnError) {
       process.exit(1);
     }
@@ -13594,7 +13627,7 @@ async function uploadAiBlameHandler(options) {
     };
   });
   try {
-    logger2.info(
+    logger3.info(
       `[UPLOAD] Calling finalizeAIBlameInferencesUploadRaw with ${finalizeSessions.length} sessions`
     );
     const finRes = await authenticatedClient.finalizeAIBlameInferencesUploadRaw(
@@ -13602,11 +13635,11 @@ async function uploadAiBlameHandler(options) {
         sessions: finalizeSessions
       }
     );
-    logger2.info("[UPLOAD] Finalize response:", JSON.stringify(finRes, null, 2));
+    logger3.info("[UPLOAD] Finalize response:", JSON.stringify(finRes, null, 2));
     const status = finRes?.finalizeAIBlameInferencesUpload?.status;
     if (status !== "OK") {
       const errorMsg = finRes?.finalizeAIBlameInferencesUpload?.error || "unknown error";
-      logger2.error(
+      logger3.error(
         chalk4.red(
           `[UPLOAD] Finalize failed with status: ${status}, error: ${errorMsg}`
         )
@@ -13616,9 +13649,9 @@ async function uploadAiBlameHandler(options) {
       }
       throw new Error(errorMsg);
     }
-    logger2.info(chalk4.green("[UPLOAD] AI Blame uploads finalized successfully"));
+    logger3.info(chalk4.green("[UPLOAD] AI Blame uploads finalized successfully"));
   } catch (error) {
-    logger2.error("[UPLOAD] Finalize threw error:", error);
+    logger3.error("[UPLOAD] Finalize threw error:", error);
     throw error;
   }
 }
@@ -13628,6 +13661,110 @@ async function uploadAiBlameCommandHandler(args) {
 
 // src/features/analysis/graphql/tracy-batch-upload.ts
 var debug10 = Debug9("mobbdev:tracy-batch-upload");
+async function sanitizeRawData(rawData) {
+  try {
+    const sanitized = await sanitizeData(rawData);
+    return JSON.stringify(sanitized);
+  } catch (err) {
+    console.warn(
+      "[tracy] sanitizeRawData failed, falling back to unsanitized:",
+      err.message
+    );
+    return JSON.stringify(rawData);
+  }
+}
+async function prepareAndSendTracyRecords(client, rawRecords, workingDir) {
+  const repositoryUrl = await getRepositoryUrl(workingDir);
+  const { computerName, userName } = getSystemInfo();
+  const clientVersion = packageJson.version;
+  const serializedRawDataByIndex = /* @__PURE__ */ new Map();
+  const records = await Promise.all(
+    rawRecords.map(async (record, index) => {
+      if (record.rawData != null) {
+        const serialized = await sanitizeRawData(record.rawData);
+        serializedRawDataByIndex.set(index, serialized);
+      }
+      const { rawData: _rawData, ...rest } = record;
+      return {
+        ...rest,
+        repositoryUrl: repositoryUrl ?? void 0,
+        computerName,
+        userName,
+        clientVersion
+      };
+    })
+  );
+  const recordsWithRawData = rawRecords.map((r, i) => ({ recordId: r.recordId, index: i })).filter((entry) => serializedRawDataByIndex.has(entry.index));
+  if (recordsWithRawData.length > 0) {
+    debug10("Uploading %d rawData files to S3...", recordsWithRawData.length);
+    const uploadUrlResult = await client.getTracyRawDataUploadUrl();
+    const { url, uploadFieldsJSON, keyPrefix } = uploadUrlResult.getTracyRawDataUploadUrl;
+    if (!url || !uploadFieldsJSON || !keyPrefix) {
+      return {
+        ok: false,
+        errors: ["Failed to get S3 upload URL for rawData"]
+      };
+    }
+    let uploadFields;
+    try {
+      uploadFields = JSON.parse(uploadFieldsJSON);
+    } catch {
+      return { ok: false, errors: ["Malformed uploadFieldsJSON from server"] };
+    }
+    const uploadResults = await Promise.allSettled(
+      recordsWithRawData.map(async (entry) => {
+        const rawDataJson = serializedRawDataByIndex.get(entry.index);
+        if (!rawDataJson) {
+          debug10("No serialized rawData for recordId=%s", entry.recordId);
+          return;
+        }
+        const uploadKey = `${keyPrefix}${entry.recordId}.json`;
+        await uploadFile({
+          file: Buffer.from(rawDataJson, "utf-8"),
+          url,
+          uploadKey,
+          uploadFields
+        });
+        records[entry.index].rawDataS3Key = uploadKey;
+      })
+    );
+    const uploadErrors = uploadResults.filter((r) => r.status === "rejected").map((r) => r.reason.message);
+    if (uploadErrors.length > 0) {
+      debug10("S3 upload errors: %O", uploadErrors);
+    }
+    const missingS3Keys = recordsWithRawData.filter(
+      (entry) => !records[entry.index].rawDataS3Key
+    );
+    if (missingS3Keys.length > 0) {
+      const missingIds = missingS3Keys.map((e) => e.recordId);
+      debug10("Records missing S3 keys after upload: %O", missingIds);
+      return {
+        ok: false,
+        errors: [
+          `Failed to upload rawData to S3 for ${missingS3Keys.length} record(s): ${missingIds.join(", ")}`,
+          ...uploadErrors
+        ]
+      };
+    }
+    debug10("S3 uploads complete");
+  }
+  try {
+    const result = await client.uploadTracyRecords({ records });
+    if (result.uploadTracyRecords.status !== "OK") {
+      return {
+        ok: false,
+        errors: [result.uploadTracyRecords.error ?? "Unknown server error"]
+      };
+    }
+  } catch (err) {
+    debug10("Upload failed: %s", err.message);
+    return {
+      ok: false,
+      errors: [err.message]
+    };
+  }
+  return { ok: true, errors: null };
+}
 
 // src/mcp/services/types.ts
 function detectIDE() {
@@ -14845,8 +14982,8 @@ if (typeof __filename !== "undefined") {
 }
 var costumeRequire = createRequire(moduleUrl);
 var getCheckmarxPath = () => {
-  const os13 = type();
-  const cxFileName = os13 === "Windows_NT" ? "cx.exe" : "cx";
+  const os14 = type();
+  const cxFileName = os14 === "Windows_NT" ? "cx.exe" : "cx";
   try {
     return costumeRequire.resolve(`.bin/${cxFileName}`);
   } catch (e) {
@@ -16159,229 +16296,383 @@ async function analyzeHandler(args) {
 }
 
 // src/features/claude_code/data_collector.ts
+import { createHash as createHash2 } from "crypto";
+import { open as open4, readdir, readFile, unlink } from "fs/promises";
+import path13 from "path";
 import { z as z33 } from "zod";
 init_client_generates();
-init_GitService();
-init_urlParser2();
 
-// src/utils/computeGitDiffAdditions.ts
-import { mkdtemp, rm, writeFile } from "fs/promises";
-import { tmpdir } from "os";
-import path13 from "path";
-import { simpleGit as simpleGit4 } from "simple-git";
-async function computeGitDiffAdditions(oldStr, newStr) {
-  const tmpDir = await mkdtemp(path13.join(tmpdir(), "diff-"));
-  const oldFile = path13.join(tmpDir, "old");
-  const newFile = path13.join(tmpDir, "new");
-  try {
-    await writeFile(oldFile, oldStr);
-    await writeFile(newFile, newStr);
-    const git = simpleGit4();
-    let result;
+// src/utils/shared-logger/create-logger.ts
+import Configstore2 from "configstore";
+import pino from "pino";
+
+// src/utils/shared-logger/configstore-stream.ts
+import { writeFileSync } from "fs";
+import * as stream from "stream";
+var DEFAULT_MAX_LOGS = 1e3;
+var DEFAULT_MAX_HEARTBEAT = 100;
+var LOGS_KEY = "logs";
+var HEARTBEAT_KEY = "heartbeat";
+function createConfigstoreStream(store, opts) {
+  const maxLogs = opts.maxLogs ?? DEFAULT_MAX_LOGS;
+  const maxHeartbeat = opts.maxHeartbeat ?? DEFAULT_MAX_HEARTBEAT;
+  const buffer = [];
+  const heartbeatBuffer = [];
+  let scopePath = opts.scopePath;
+  function storeKey(base) {
+    return scopePath ? `${base}:${scopePath}` : base;
+  }
+  function writeToDisk(entries, key, max) {
     try {
-      result = await git.raw([
-        "diff",
-        "--no-index",
-        "--unified=0",
-        oldFile,
-        newFile
-      ]);
-    } catch (err) {
-      if (err instanceof Error && "stdOut" in err) {
-        result = err.stdOut;
-      } else {
-        throw err;
+      const existing = store.get(key) ?? [];
+      existing.push(...entries);
+      const trimmed = existing.length > max ? existing.slice(-max) : existing;
+      store.set(key, trimmed);
+    } catch {
+      try {
+        const lines = `${entries.map((e) => JSON.stringify(e)).join("\n")}
+`;
+        writeFileSync(`${store.path}.fallback`, lines, { flag: "a" });
+      } catch {
       }
     }
-    const additions = [];
-    for (const line of result.split("\n")) {
-      if (line.startsWith("+") && !line.startsWith("+++")) {
-        additions.push(line.slice(1));
+  }
+  const writable = new stream.Writable({
+    write(chunk, _encoding, callback) {
+      callback();
+      try {
+        const parsed = JSON.parse(chunk.toString());
+        const entry = {
+          timestamp: parsed.time ? new Date(parsed.time).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+          level: parsed.level ?? "info",
+          message: parsed.msg ?? "",
+          ...parsed.durationMs !== void 0 && {
+            durationMs: parsed.durationMs
+          },
+          ...parsed.data !== void 0 && { data: parsed.data }
+        };
+        const isHeartbeat = parsed.heartbeat === true;
+        if (opts.buffered) {
+          if (isHeartbeat) {
+            heartbeatBuffer.push(entry);
+          } else {
+            buffer.push(entry);
+          }
+        } else {
+          if (isHeartbeat) {
+            writeToDisk([entry], storeKey(HEARTBEAT_KEY), maxHeartbeat);
+          } else {
+            writeToDisk([entry], storeKey(LOGS_KEY), maxLogs);
+          }
+        }
+      } catch {
       }
     }
-    return additions.join("\n");
-  } finally {
-    await rm(tmpDir, { recursive: true, force: true });
+  });
+  function flush() {
+    if (buffer.length > 0) {
+      writeToDisk(buffer, storeKey(LOGS_KEY), maxLogs);
+      buffer.length = 0;
+    }
+    if (heartbeatBuffer.length > 0) {
+      writeToDisk(heartbeatBuffer, storeKey(HEARTBEAT_KEY), maxHeartbeat);
+      heartbeatBuffer.length = 0;
+    }
+  }
+  function setScopePath(path27) {
+    scopePath = path27;
+  }
+  return { writable, flush, setScopePath };
+}
+
+// src/utils/shared-logger/dd-batch.ts
+import * as stream2 from "stream";
+import * as util from "util";
+import fetch5 from "cross-fetch";
+var DD_BATCH_INTERVAL_MS = 5e3;
+var DD_BATCH_MAX_SIZE = 50;
+function createDdBatch(config2) {
+  let batch = [];
+  let flushTimer = null;
+  let pendingFlush = null;
+  let errorLogged = false;
+  function flush() {
+    if (batch.length === 0) return;
+    const toSend = batch;
+    batch = [];
+    pendingFlush = fetch5("https://http-intake.logs.datadoghq.com/api/v2/logs", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "DD-API-KEY": config2.apiKey
+      },
+      body: JSON.stringify(toSend)
+    }).then(() => void 0).catch((error) => {
+      if (!errorLogged) {
+        errorLogged = true;
+        config2.onError?.(
+          `Error sending log to Datadog (further errors suppressed): ${util.inspect(error)}`
+        );
+      }
+    });
+  }
+  function enqueue(message) {
+    if (!config2.apiKey) return;
+    batch.push({
+      hostname: config2.hostname,
+      ddsource: config2.ddsource,
+      service: config2.service,
+      ddtags: config2.ddtags,
+      message
+    });
+    if (!flushTimer) {
+      flushTimer = setInterval(flush, DD_BATCH_INTERVAL_MS);
+      if (config2.unrefTimer) {
+        flushTimer.unref();
+      }
+    }
+    if (batch.length >= DD_BATCH_MAX_SIZE) {
+      flush();
+    }
+  }
+  async function flushAsync() {
+    flush();
+    await pendingFlush;
   }
+  function dispose() {
+    flush();
+    if (flushTimer) {
+      clearInterval(flushTimer);
+      flushTimer = null;
+    }
+  }
+  function createPinoStream() {
+    return new stream2.Writable({
+      write(chunk, _encoding, callback) {
+        callback();
+        enqueue(chunk.toString());
+      }
+    });
+  }
+  return { enqueue, flush, flushAsync, dispose, createPinoStream };
 }
 
-// src/features/claude_code/transcript_parser.ts
-import fsPromises4 from "fs/promises";
-function processTranscriptLine(entry) {
-  const prompts = [];
-  let model;
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let date;
-  if (entry.message?.model) {
-    model = entry.message.model;
-  }
-  if (entry.message?.usage) {
-    inputTokens = entry.message.usage.input_tokens || 0;
-    outputTokens = entry.message.usage.output_tokens || 0;
-  }
-  if (entry.timestamp) {
-    date = new Date(entry.timestamp);
-  }
-  if (entry.type === "user" && entry.message?.role === "user") {
-    if (typeof entry.message.content === "string") {
-      prompts.push({
-        type: "USER_PROMPT",
-        text: entry.message.content,
-        date: date || /* @__PURE__ */ new Date(),
-        tokens: inputTokens > 0 ? {
-          inputCount: inputTokens,
-          outputCount: 0
-        } : void 0
-      });
-    }
-  } else if (entry.type === "assistant" && entry.message?.role === "assistant") {
-    if (Array.isArray(entry.message.content)) {
-      for (const item of entry.message.content) {
-        if (item.type === "text" && item.text) {
-          prompts.push({
-            type: "AI_RESPONSE",
-            text: item.text,
-            date: date || /* @__PURE__ */ new Date(),
-            tokens: outputTokens > 0 ? {
-              inputCount: 0,
-              outputCount: outputTokens
-            } : void 0
-          });
-        } else if (item.type === "thinking" && item.thinking) {
-          prompts.push({
-            type: "AI_THINKING",
-            text: item.thinking,
-            date: date || /* @__PURE__ */ new Date()
-          });
-        }
+// src/utils/shared-logger/hostname.ts
+import { createHash } from "crypto";
+import os4 from "os";
+function hashString(input) {
+  return createHash("sha256").update(input).digest("hex").slice(0, 16);
+}
+function getPlainHostname() {
+  try {
+    return `${os4.userInfo().username}@${os4.hostname()}`;
+  } catch {
+    return `unknown@${os4.hostname()}`;
+  }
+}
+function getHashedHostname() {
+  try {
+    return `${hashString(os4.userInfo().username)}@${hashString(os4.hostname())}`;
+  } catch {
+    return `unknown@${hashString(os4.hostname())}`;
+  }
+}
+
+// src/utils/shared-logger/create-logger.ts
+function createLogger(config2) {
+  const {
+    namespace,
+    scopePath,
+    buffered = true,
+    maxLogs,
+    maxHeartbeat,
+    dd,
+    additionalStreams = []
+  } = config2;
+  const store = new Configstore2(namespace, {});
+  const csStream = createConfigstoreStream(store, {
+    buffered,
+    scopePath,
+    maxLogs,
+    maxHeartbeat
+  });
+  let ddBatch = null;
+  if (dd) {
+    const hostname = dd.hostnameMode === "hashed" ? getHashedHostname() : getPlainHostname();
+    const ddConfig = {
+      apiKey: dd.apiKey,
+      ddsource: dd.ddsource,
+      service: dd.service,
+      ddtags: dd.ddtags,
+      hostname,
+      unrefTimer: dd.unrefTimer,
+      onError: dd.onError
+    };
+    ddBatch = createDdBatch(ddConfig);
+  }
+  const streams = [
+    { stream: csStream.writable, level: "info" }
+  ];
+  if (ddBatch) {
+    streams.push({ stream: ddBatch.createPinoStream(), level: "info" });
+  }
+  for (const extra of additionalStreams) {
+    streams.push({
+      stream: extra.stream,
+      level: extra.level
+    });
+  }
+  const pinoLogger = pino(
+    {
+      formatters: {
+        level: (label) => ({ level: label })
       }
+    },
+    pino.multistream(streams)
+  );
+  const info = pinoLogger.info.bind(pinoLogger);
+  const warn = pinoLogger.warn.bind(pinoLogger);
+  const error = pinoLogger.error.bind(pinoLogger);
+  const debug23 = pinoLogger.debug.bind(pinoLogger);
+  function heartbeat(message, data) {
+    pinoLogger.info({ data, heartbeat: true }, message);
+  }
+  async function timed(label, fn) {
+    const start = Date.now();
+    try {
+      const result = await fn();
+      pinoLogger.info({ durationMs: Date.now() - start }, label);
+      return result;
+    } catch (err) {
+      pinoLogger.error(
+        {
+          durationMs: Date.now() - start,
+          data: err instanceof Error ? err.message : String(err)
+        },
+        `${label} [FAILED]`
+      );
+      throw err;
     }
   }
-  return {
-    prompts,
-    model,
-    inputTokens,
-    outputTokens,
-    date
-  };
-}
-async function parseTranscriptAndCreateTrace(transcriptPath, hookData, inference) {
-  const content = await fsPromises4.readFile(transcriptPath, "utf-8");
-  const lines = content.trim().split("\n");
-  let currentToolIndex = -1;
-  for (let i = lines.length - 1; i >= 0; i--) {
-    const line = lines[i]?.trim() ?? "";
-    if (!line.includes('"type":"tool_use"')) continue;
-    const isEditTool = line.includes('"name":"Edit"');
-    const isWriteTool = line.includes('"name":"Write"');
-    if (isEditTool || isWriteTool) {
-      currentToolIndex = i;
-      break;
+  function flushLogs2() {
+    csStream.flush();
+  }
+  async function flushDdAsync() {
+    if (ddBatch) {
+      await ddBatch.flushAsync();
     }
   }
-  const startIndex = 0;
-  const endIndex = currentToolIndex === -1 ? lines.length - 1 : currentToolIndex - 1;
-  const prompts = [];
-  let model;
-  let latestDate;
-  for (let i = startIndex; i <= endIndex; i++) {
-    const line = lines[i]?.trim() ?? "";
-    const entry = JSON.parse(line);
-    const lineResult = processTranscriptLine(entry);
-    prompts.push(...lineResult.prompts);
-    if (lineResult.model && !model) {
-      model = lineResult.model;
-    }
-    if (lineResult.date) {
-      if (!latestDate || lineResult.date > latestDate) {
-        latestDate = lineResult.date;
-      }
-    }
-  }
-  prompts.push({
-    type: "TOOL_EXECUTION",
-    date: latestDate || /* @__PURE__ */ new Date(),
-    tool: {
-      name: hookData.tool_name,
-      parameters: JSON.stringify(hookData.tool_input, null, 2),
-      result: JSON.stringify(hookData.tool_response, null, 2),
-      rawArguments: JSON.stringify(hookData.tool_input),
-      accepted: true
+  function disposeDd() {
+    if (ddBatch) {
+      ddBatch.dispose();
     }
-  });
+  }
   return {
-    prompts,
-    inference,
-    model: model || "claude-sonnet-4",
-    // Use extracted model or fallback
-    tool: "Claude Code",
-    responseTime: (latestDate || /* @__PURE__ */ new Date()).toISOString()
+    info,
+    warn,
+    error,
+    debug: debug23,
+    heartbeat,
+    timed,
+    flushLogs: flushLogs2,
+    flushDdAsync,
+    disposeDd,
+    setScopePath: csStream.setScopePath
   };
 }
 
+// src/features/claude_code/hook_logger.ts
+var DD_RUM_TOKEN = true ? "" : "";
+var CLI_VERSION = true ? "1.2.55" : "unknown";
+var NAMESPACE = "mobbdev-claude-code-hook-logs";
+function createHookLogger(scopePath) {
+  return createLogger({
+    namespace: NAMESPACE,
+    scopePath,
+    dd: {
+      apiKey: DD_RUM_TOKEN,
+      ddsource: "mobbdev-cli",
+      service: "mobbdev-cli-hook",
+      ddtags: `version:${CLI_VERSION}`,
+      hostnameMode: "hashed",
+      unrefTimer: true
+    }
+  });
+}
+var logger = createHookLogger();
+var activeScopedLoggers = [];
+var hookLog = logger;
+function flushLogs() {
+  logger.flushLogs();
+  for (const scoped of activeScopedLoggers) {
+    scoped.flushLogs();
+  }
+  activeScopedLoggers.length = 0;
+}
+async function flushDdLogs() {
+  await logger.flushDdAsync();
+  for (const scoped of activeScopedLoggers) {
+    await scoped.flushDdAsync();
+  }
+}
+function createScopedHookLog(scopePath) {
+  const scoped = createHookLogger(scopePath);
+  activeScopedLoggers.push(scoped);
+  return scoped;
+}
+
 // src/features/claude_code/data_collector.ts
-var StructuredPatchItemSchema = z33.object({
-  oldStart: z33.number(),
-  oldLines: z33.number(),
-  newStart: z33.number(),
-  newLines: z33.number(),
-  lines: z33.array(z33.string())
-});
-var EditToolInputSchema = z33.object({
-  file_path: z33.string(),
-  old_string: z33.string(),
-  new_string: z33.string()
-});
-var WriteToolInputSchema = z33.object({
-  file_path: z33.string(),
-  content: z33.string()
-});
-var EditToolResponseSchema = z33.object({
-  filePath: z33.string(),
-  oldString: z33.string().optional(),
-  newString: z33.string().optional(),
-  originalFile: z33.string().optional(),
-  structuredPatch: z33.array(StructuredPatchItemSchema),
-  userModified: z33.boolean().optional(),
-  replaceAll: z33.boolean().optional()
-});
-var WriteToolResponseSchema = z33.object({
-  type: z33.string().optional(),
-  filePath: z33.string(),
-  content: z33.string().optional(),
-  structuredPatch: z33.array(z33.any()).optional()
-});
+var HOOK_COOLDOWN_MS = 1e4;
+var STALE_KEY_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
+var CLEANUP_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var COOLDOWN_KEY = "lastHookRunAt";
 var HookDataSchema = z33.object({
   session_id: z33.string(),
   transcript_path: z33.string(),
   cwd: z33.string(),
-  permission_mode: z33.string().optional(),
-  hook_event_name: z33.literal("PostToolUse"),
-  tool_name: z33.enum(["Edit", "Write"]),
-  tool_input: z33.union([EditToolInputSchema, WriteToolInputSchema]),
-  tool_response: z33.union([EditToolResponseSchema, WriteToolResponseSchema])
+  hook_event_name: z33.string(),
+  tool_name: z33.string(),
+  tool_input: z33.unknown(),
+  tool_response: z33.unknown()
 });
+var STDIN_TIMEOUT_MS = 1e4;
 async function readStdinData() {
+  hookLog.debug("Reading stdin data");
   return new Promise((resolve, reject) => {
     let inputData = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        process.stdin.destroy();
+        reject(new Error("Timed out reading from stdin"));
+      }
+    }, STDIN_TIMEOUT_MS);
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
       inputData += chunk;
     });
     process.stdin.on("end", () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
       try {
         const parsedData = JSON.parse(inputData);
+        hookLog.debug("Parsed stdin data", {
+          keys: Object.keys(parsedData)
+        });
         resolve(parsedData);
       } catch (error) {
-        reject(
-          new Error(
-            `Failed to parse JSON from stdin: ${error.message}`
-          )
-        );
+        const msg = `Failed to parse JSON from stdin: ${error.message}`;
+        hookLog.error(msg);
+        reject(new Error(msg));
       }
     });
     process.stdin.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      hookLog.error("Error reading from stdin", { error: error.message });
       reject(new Error(`Error reading from stdin: ${error.message}`));
     });
   });
@@ -16389,144 +16680,329 @@ async function readStdinData() {
 function validateHookData(data) {
   return HookDataSchema.parse(data);
 }
-function extractStructuredPatchAdditions(hookData) {
-  const editResponse = hookData.tool_response;
-  const additions = [];
-  for (const patch of editResponse.structuredPatch) {
-    for (const line of patch.lines) {
-      if (line.startsWith("+")) {
-        additions.push(line.slice(1));
-      }
-    }
-  }
-  return additions.join("\n");
-}
-async function extractInference(hookData) {
-  if (hookData.tool_name === "Write") {
-    const writeInput = hookData.tool_input;
-    return writeInput.content || "";
-  }
-  if (hookData.tool_name === "Edit") {
-    const editInput = hookData.tool_input;
+function generateSyntheticId(sessionId, timestamp, type2, lineIndex) {
+  const input = `${sessionId ?? ""}:${timestamp ?? ""}:${type2 ?? ""}:${lineIndex}`;
+  const hash = createHash2("sha256").update(input).digest("hex").slice(0, 16);
+  return `synth:${hash}`;
+}
+function getCursorKey(transcriptPath) {
+  const hash = createHash2("sha256").update(transcriptPath).digest("hex").slice(0, 12);
+  return `cursor.${hash}`;
+}
+async function readNewTranscriptEntries(transcriptPath, sessionId, sessionStore) {
+  const cursor = sessionStore.get(getCursorKey(transcriptPath));
+  let content;
+  let fileSize;
+  let lineIndexOffset;
+  if (cursor?.byteOffset) {
+    const fh = await open4(transcriptPath, "r");
     try {
-      return await computeGitDiffAdditions(
-        editInput.old_string,
-        editInput.new_string
+      const stat = await fh.stat();
+      fileSize = stat.size;
+      if (cursor.byteOffset >= stat.size) {
+        hookLog.info("No new data in transcript file", { sessionId });
+        return { entries: [], fileSize };
+      }
+      const buf = Buffer.alloc(stat.size - cursor.byteOffset);
+      await fh.read(buf, 0, buf.length, cursor.byteOffset);
+      content = buf.toString("utf-8");
+    } finally {
+      await fh.close();
+    }
+    lineIndexOffset = cursor.byteOffset;
+    hookLog.debug("Read transcript file from offset", {
+      transcriptPath,
+      byteOffset: cursor.byteOffset,
+      bytesRead: content.length
+    });
+  } else {
+    content = await readFile(transcriptPath, "utf-8");
+    fileSize = Buffer.byteLength(content, "utf-8");
+    lineIndexOffset = 0;
+    hookLog.debug("Read full transcript file", {
+      transcriptPath,
+      totalBytes: fileSize
+    });
+  }
+  const lines = content.split("\n").filter((line) => line.trim().length > 0);
+  const parsed = [];
+  let malformedLines = 0;
+  for (let i = 0; i < lines.length; i++) {
+    try {
+      const entry = JSON.parse(lines[i]);
+      const recordId = entry.uuid ?? generateSyntheticId(
+        entry.sessionId,
+        entry.timestamp,
+        entry.type,
+        lineIndexOffset + i
       );
+      parsed.push({ ...entry, _recordId: recordId });
     } catch {
-      return extractStructuredPatchAdditions(hookData);
+      malformedLines++;
     }
   }
-  return "";
+  if (malformedLines > 0) {
+    hookLog.warn("Skipped malformed lines", { malformedLines, transcriptPath });
+  }
+  if (!cursor) {
+    hookLog.info("First invocation for session \u2014 uploading all entries", {
+      sessionId,
+      totalEntries: parsed.length
+    });
+  } else {
+    hookLog.info("Resuming from byte offset", {
+      sessionId,
+      byteOffset: cursor.byteOffset,
+      newEntries: parsed.length
+    });
+  }
+  return { entries: parsed, fileSize };
+}
+var FILTERED_PROGRESS_SUBTYPES = /* @__PURE__ */ new Set([
+  // Incremental streaming output from running bash commands, emitted every
+  // ~1 second. The final complete output is already captured in the "user"
+  // tool_result entry when the command finishes.
+  "bash_progress",
+  // Records that the hook itself fired. Pure meta-noise — the hook
+  // recording the fact that the hook ran.
+  "hook_progress",
+  // UI-only "waiting" indicator for background tasks (TaskOutput polling).
+  // Contains only a task description and type — no session-relevant data.
+  "waiting_for_task",
+  // MCP tool start/completed timing events. Only unique data is elapsedTimeMs
+  // which can be derived from tool_use/tool_result timestamps.
+  "mcp_progress"
+]);
+var FILTERED_ENTRY_TYPES = /* @__PURE__ */ new Set([
+  // Claude Code's internal undo/restore bookkeeping — tracks which files
+  // have backups. No sessionId, no message, no model or tool data.
+  "file-history-snapshot",
+  // Internal task queue management (enqueue/remove/popAll). Duplicates data
+  // already captured in user messages, agent_progress, and Task tool_use entries.
+  "queue-operation",
+  // Records the last user prompt text before a compaction or session restart.
+  // Redundant — the actual user prompt is already captured in the 'user' entry.
+  "last-prompt"
+]);
+var FILTERED_ASSISTANT_TOOLS = /* @__PURE__ */ new Set([
+  // Polls for a sub-agent result. The input is just task_id + boilerplate
+  // (block, timeout). The actual result is captured in the user:tool_result.
+  "TaskOutput",
+  // Discovers available deferred/MCP tools. The input is just a search query.
+  // The discovered tools are captured in the user:tool_result.
+  "ToolSearch"
+]);
+function filterEntries(entries) {
+  const filtered = entries.filter((entry) => {
+    const entryType = entry.type ?? "";
+    if (FILTERED_ENTRY_TYPES.has(entryType)) {
+      return false;
+    }
+    if (entryType === "progress") {
+      const data = entry["data"];
+      const subtype = typeof data?.["type"] === "string" ? data["type"] : "";
+      return !FILTERED_PROGRESS_SUBTYPES.has(subtype);
+    }
+    if (entryType === "assistant") {
+      const message = entry["message"];
+      const content = message?.["content"];
+      if (Array.isArray(content) && content.length > 0) {
+        const block = content[0];
+        if (block["type"] === "tool_use" && typeof block["name"] === "string" && FILTERED_ASSISTANT_TOOLS.has(block["name"])) {
+          return false;
+        }
+      }
+    }
+    return true;
+  });
+  return { filtered, filteredOut: entries.length - filtered.length };
 }
-async function collectHookData() {
-  const rawData = await readStdinData();
-  const hookData = validateHookData(rawData);
-  const inference = await extractInference(hookData);
-  let tracePayload;
+async function cleanupStaleSessions(sessionStore) {
+  const lastCleanup = configStore.get("claudeCode.lastCleanupAt");
+  if (lastCleanup && Date.now() - lastCleanup < CLEANUP_INTERVAL_MS) {
+    return;
+  }
+  const now = Date.now();
+  const prefix = getSessionFilePrefix();
+  const configDir = path13.dirname(sessionStore.path);
   try {
-    tracePayload = await parseTranscriptAndCreateTrace(
-      hookData.transcript_path,
-      hookData,
-      inference
-    );
-  } catch (error) {
-    console.warn(
-      "Warning: Could not parse transcript:",
-      error.message
-    );
-    tracePayload = {
-      prompts: [
-        {
-          type: "TOOL_EXECUTION",
-          date: /* @__PURE__ */ new Date(),
-          tool: {
-            name: hookData.tool_name,
-            parameters: JSON.stringify(hookData.tool_input, null, 2),
-            result: JSON.stringify(hookData.tool_response, null, 2),
-            rawArguments: JSON.stringify(hookData.tool_input),
-            accepted: true
+    const files = await readdir(configDir);
+    let deletedCount = 0;
+    for (const file of files) {
+      if (!file.startsWith(prefix) || !file.endsWith(".json")) continue;
+      const filePath = path13.join(configDir, file);
+      try {
+        const content = JSON.parse(await readFile(filePath, "utf-8"));
+        let newest = 0;
+        const cooldown = content[COOLDOWN_KEY];
+        if (cooldown && cooldown > newest) newest = cooldown;
+        const cursors = content["cursor"];
+        if (cursors && typeof cursors === "object") {
+          for (const val of Object.values(cursors)) {
+            const c = val;
+            if (c?.updatedAt && c.updatedAt > newest) newest = c.updatedAt;
           }
         }
-      ],
-      inference,
-      model: "claude-sonnet-4",
-      tool: "Claude Code",
-      responseTime: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  return {
-    hookData,
-    inference,
-    tracePayload
-  };
-}
-async function getRepositoryUrl2(cwd) {
-  try {
-    const gitService = new GitService(cwd);
-    const isRepo = await gitService.isGitRepository();
-    if (!isRepo) {
-      return null;
+        if (newest > 0 && now - newest > STALE_KEY_MAX_AGE_MS) {
+          await unlink(filePath);
+          deletedCount++;
+        }
+      } catch {
+      }
+    }
+    if (deletedCount > 0) {
+      hookLog.info("Cleaned up stale session files", { deletedCount });
     }
-    const remoteUrl = await gitService.getRemoteUrl();
-    const parsed = parseScmURL(remoteUrl);
-    return parsed?.scmType === "GitHub" /* GitHub */ || parsed?.scmType === "GitLab" /* GitLab */ ? remoteUrl : null;
   } catch {
-    return null;
   }
+  configStore.set("claudeCode.lastCleanupAt", now);
 }
-async function processAndUploadHookData() {
-  const result = await collectHookData();
-  const repositoryUrl = await getRepositoryUrl2(result.hookData.cwd);
-  let uploadSuccess;
+async function processAndUploadTranscriptEntries() {
+  hookLog.info("Hook invoked");
+  const rawData = await readStdinData();
+  const hookData = validateHookData(rawData);
+  const sessionStore = createSessionConfigStore(hookData.session_id);
+  await cleanupStaleSessions(sessionStore);
+  const lastRunAt = sessionStore.get(COOLDOWN_KEY);
+  if (lastRunAt && Date.now() - lastRunAt < HOOK_COOLDOWN_MS) {
+    return { entriesUploaded: 0, entriesSkipped: 0, errors: 0 };
+  }
+  sessionStore.set(COOLDOWN_KEY, Date.now());
+  const log2 = createScopedHookLog(hookData.cwd);
+  log2.info("Hook data validated", {
+    sessionId: hookData.session_id,
+    toolName: hookData.tool_name,
+    hookEvent: hookData.hook_event_name,
+    cwd: hookData.cwd
+  });
   try {
-    await uploadAiBlameHandlerFromExtension({
-      prompts: result.tracePayload.prompts,
-      inference: result.tracePayload.inference,
-      model: result.tracePayload.model,
-      tool: result.tracePayload.tool,
-      responseTime: result.tracePayload.responseTime,
+    return await processTranscript(hookData, sessionStore, log2);
+  } finally {
+    log2.flushLogs();
+  }
+}
+async function processTranscript(hookData, sessionStore, log2) {
+  const cursorKey = getCursorKey(hookData.transcript_path);
+  const { entries: rawEntries, fileSize } = await readNewTranscriptEntries(
+    hookData.transcript_path,
+    hookData.session_id,
+    sessionStore
+  );
+  if (rawEntries.length === 0) {
+    log2.info("No new entries to upload");
+    return { entriesUploaded: 0, entriesSkipped: 0, errors: 0 };
+  }
+  const { filtered: entries, filteredOut } = filterEntries(rawEntries);
+  if (filteredOut > 0) {
+    log2.info("Filtered out noise entries", {
+      filteredOut,
+      remaining: entries.length
+    });
+  }
+  if (entries.length === 0) {
+    log2.info("All entries filtered out, nothing to upload");
+    const lastEntry = rawEntries[rawEntries.length - 1];
+    const prevCursor = sessionStore.get(cursorKey);
+    const cursor = {
+      id: lastEntry._recordId,
+      byteOffset: fileSize,
+      updatedAt: Date.now(),
+      lastModel: prevCursor?.lastModel
+    };
+    sessionStore.set(cursorKey, cursor);
+    return {
+      entriesUploaded: 0,
+      entriesSkipped: filteredOut,
+      errors: 0
+    };
+  }
+  const gqlClient = await log2.timed(
+    "GQL auth",
+    () => getAuthenticatedGQLClient({ isSkipPrompts: true })
+  );
+  const cursorForModel = sessionStore.get(cursorKey);
+  let lastSeenModel = cursorForModel?.lastModel ?? null;
+  const records = entries.map((entry) => {
+    const { _recordId, ...rawEntry } = entry;
+    const message = rawEntry["message"];
+    const currentModel = message?.["model"] ?? null;
+    if (currentModel && currentModel !== "<synthetic>") {
+      lastSeenModel = currentModel;
+    } else if (lastSeenModel && !currentModel) {
+      if (message) {
+        message["model"] = lastSeenModel;
+      } else {
+        rawEntry["message"] = { model: lastSeenModel };
+      }
+    }
+    return {
+      platform: "CLAUDE_CODE" /* ClaudeCode */,
+      recordId: _recordId,
+      recordTimestamp: entry.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
       blameType: "CHAT" /* Chat */,
-      sessionId: result.hookData.session_id,
-      repositoryUrl
+      rawData: rawEntry
+    };
+  });
+  log2.info("Uploading batch", {
+    count: records.length,
+    skipped: filteredOut,
+    firstRecordId: records[0]?.recordId,
+    lastRecordId: records[records.length - 1]?.recordId
+  });
+  const result = await log2.timed(
+    "Batch upload",
+    () => prepareAndSendTracyRecords(gqlClient, records, hookData.cwd)
+  );
+  if (result.ok) {
+    const lastRawEntry = rawEntries[rawEntries.length - 1];
+    const cursor = {
+      id: lastRawEntry._recordId,
+      byteOffset: fileSize,
+      updatedAt: Date.now(),
+      lastModel: lastSeenModel ?? void 0
+    };
+    sessionStore.set(cursorKey, cursor);
+    log2.heartbeat("Upload ok", {
+      entriesUploaded: entries.length,
+      entriesSkipped: filteredOut
     });
-    uploadSuccess = true;
-  } catch (error) {
-    console.warn(
-      "Warning: Failed to upload trace data:",
-      error.message
-    );
-    uploadSuccess = false;
+    return {
+      entriesUploaded: entries.length,
+      entriesSkipped: filteredOut,
+      errors: 0
+    };
   }
+  log2.error("Batch upload had errors", { errors: result.errors });
   return {
-    ...result,
-    uploadSuccess
+    entriesUploaded: 0,
+    entriesSkipped: filteredOut,
+    errors: entries.length
   };
 }
 
 // src/features/claude_code/install_hook.ts
-import fsPromises5 from "fs/promises";
-import os4 from "os";
+import fsPromises4 from "fs/promises";
+import os5 from "os";
 import path14 from "path";
 import chalk11 from "chalk";
-var CLAUDE_SETTINGS_PATH = path14.join(os4.homedir(), ".claude", "settings.json");
+var CLAUDE_SETTINGS_PATH = path14.join(os5.homedir(), ".claude", "settings.json");
 async function claudeSettingsExists() {
   try {
-    await fsPromises5.access(CLAUDE_SETTINGS_PATH);
+    await fsPromises4.access(CLAUDE_SETTINGS_PATH);
     return true;
   } catch {
     return false;
   }
 }
 async function readClaudeSettings() {
-  const settingsContent = await fsPromises5.readFile(
+  const settingsContent = await fsPromises4.readFile(
     CLAUDE_SETTINGS_PATH,
     "utf-8"
   );
   return JSON.parse(settingsContent);
 }
 async function writeClaudeSettings(settings) {
-  await fsPromises5.writeFile(
+  await fsPromises4.writeFile(
     CLAUDE_SETTINGS_PATH,
     JSON.stringify(settings, null, 2),
     "utf-8"
@@ -16569,7 +17045,8 @@ async function installMobbHooks(options = {}) {
     }
   }
   const mobbHookConfig = {
-    matcher: "Edit|Write",
+    // Empty matcher = match all tools (Claude Code hook spec: empty string matches every PostToolUse event)
+    matcher: "",
     hooks: [
       {
         type: "command",
@@ -16578,7 +17055,7 @@ async function installMobbHooks(options = {}) {
     ]
   };
   const existingHookIndex = settings.hooks.PostToolUse.findIndex(
-    (hook) => hook.matcher === "Edit|Write" && hook.hooks.some(
+    (hook) => hook.hooks.some(
       (h) => h.command?.includes("mobbdev@latest claude-code-process-hook")
     )
   );
@@ -16628,51 +17105,45 @@ var claudeCodeInstallHookHandler = async (argv) => {
   }
 };
 var claudeCodeProcessHookHandler = async () => {
-  try {
-    const { hookData, inference, tracePayload, uploadSuccess } = await processAndUploadHookData();
-    console.log("Successfully processed Claude Code hook:");
-    console.log("Session ID:", hookData.session_id);
-    console.log("Tool:", hookData.tool_name);
-    console.log("Transcript path:", hookData.transcript_path);
-    console.log("Inference length:", inference.length);
-    const userPrompts = tracePayload.prompts.filter(
-      (p) => p.type === "USER_PROMPT"
-    );
-    const assistantResponses = tracePayload.prompts.filter(
-      (p) => p.type === "AI_RESPONSE"
-    );
-    const aiThinking = tracePayload.prompts.filter(
-      (p) => p.type === "AI_THINKING"
-    );
-    console.log("Conversation context extracted:");
-    console.log("- User prompts:", userPrompts.length);
-    console.log("- Assistant responses:", assistantResponses.length);
-    console.log("- AI thinking entries:", aiThinking.length);
-    console.log("- Model:", tracePayload.model);
-    const totalInputTokens = tracePayload.prompts.reduce(
-      (sum, p) => sum + (p.tokens?.inputCount || 0),
-      0
-    );
-    const totalOutputTokens = tracePayload.prompts.reduce(
-      (sum, p) => sum + (p.tokens?.outputCount || 0),
-      0
-    );
-    console.log("- Input tokens:", totalInputTokens);
-    console.log("- Output tokens:", totalOutputTokens);
-    console.log("Trace data formatted:");
-    console.log("- Prompt items:", tracePayload.prompts.length);
-    console.log("- Model:", tracePayload.model);
-    console.log("- Tool:", tracePayload.tool);
-    console.log("- Response time:", tracePayload.responseTime);
-    console.log("- Upload success:", uploadSuccess ? "\u2705" : "\u274C");
-    if (uploadSuccess) {
-      console.log("\u2705 Claude Code trace uploaded successfully to Mobb backend");
+  async function flushAndExit(code) {
+    try {
+      flushLogs();
+      await flushDdLogs();
+    } catch {
+    } finally {
+      process.exit(code);
     }
-    process.exit(0);
+  }
+  process.on("uncaughtException", (error) => {
+    hookLog.error("Uncaught exception in hook", {
+      error: String(error),
+      stack: error.stack
+    });
+    void flushAndExit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    hookLog.error("Unhandled rejection in hook", {
+      error: String(reason),
+      stack: reason instanceof Error ? reason.stack : void 0
+    });
+    void flushAndExit(1);
+  });
+  let exitCode = 0;
+  try {
+    const result = await processAndUploadTranscriptEntries();
+    hookLog.info("Claude Code upload complete", {
+      entriesUploaded: result.entriesUploaded,
+      entriesSkipped: result.entriesSkipped,
+      errors: result.errors
+    });
   } catch (error) {
-    console.error("Failed to process Claude Code hook data:", error);
-    process.exit(1);
+    exitCode = 1;
+    hookLog.error("Failed to process Claude Code hook", {
+      error: String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
   }
+  await flushAndExit(exitCode);
 };
 
 // src/mcp/core/McpServer.ts
@@ -16686,7 +17157,7 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 
 // src/mcp/Logger.ts
-import Configstore2 from "configstore";
+import Configstore3 from "configstore";
 
 // src/mcp/services/WorkspaceService.ts
 var WorkspaceService = class {
@@ -16772,7 +17243,7 @@ var Logger = class {
     __publicField(this, "lastKnownPath", null);
     this.host = WorkspaceService.getHost();
     this.unknownPathSuffix = Math.floor(1e3 + Math.random() * 9e3).toString();
-    this.mobbConfigStore = new Configstore2("mobb-logs", {});
+    this.mobbConfigStore = new Configstore3("mobb-logs", {});
     this.mobbConfigStore.set("version", packageJson.version);
   }
   /**
@@ -16828,12 +17299,12 @@ var Logger = class {
     this.mobbConfigStore.set(currentPath, [...logs, logMessage]);
   }
 };
-var logger = new Logger();
-var logInfo = (message, data) => logger.log(message, "info", data);
-var logError = (message, data) => logger.log(message, "error", data);
-var logWarn = (message, data) => logger.log(message, "warn", data);
-var logDebug = (message, data) => logger.log(message, "debug", data);
-var log = logger.log.bind(logger);
+var logger2 = new Logger();
+var logInfo = (message, data) => logger2.log(message, "info", data);
+var logError = (message, data) => logger2.log(message, "error", data);
+var logWarn = (message, data) => logger2.log(message, "warn", data);
+var logDebug = (message, data) => logger2.log(message, "debug", data);
+var log = logger2.log.bind(logger2);
 
 // src/mcp/services/McpGQLClient.ts
 import crypto2 from "crypto";
@@ -17555,7 +18026,7 @@ async function createAuthenticatedMcpGQLClient({
 // src/mcp/services/McpUsageService/host.ts
 import { execSync as execSync2 } from "child_process";
 import fs13 from "fs";
-import os5 from "os";
+import os6 from "os";
 import path15 from "path";
 var IDEs = ["cursor", "windsurf", "webstorm", "vscode", "claude"];
 var runCommand = (cmd) => {
@@ -17570,7 +18041,7 @@ var gitInfo = {
   email: runCommand("git config user.email")
 };
 var getClaudeWorkspacePaths = () => {
-  const home = os5.homedir();
+  const home = os6.homedir();
   const claudeIdePath = path15.join(home, ".claude", "ide");
   const workspacePaths = [];
   if (!fs13.existsSync(claudeIdePath)) {
@@ -17599,7 +18070,7 @@ var getClaudeWorkspacePaths = () => {
   return workspacePaths;
 };
 var getMCPConfigPaths = (hostName) => {
-  const home = os5.homedir();
+  const home = os6.homedir();
   const currentDir = process.env["WORKSPACE_FOLDER_PATHS"] || process.env["PWD"] || process.cwd();
   switch (hostName.toLowerCase()) {
     case "cursor":
@@ -17689,7 +18160,7 @@ var readMCPConfig = (hostName) => {
 };
 var getRunningProcesses = () => {
   try {
-    return os5.platform() === "win32" ? execSync2("tasklist", { encoding: "utf8" }) : execSync2("ps aux", { encoding: "utf8" });
+    return os6.platform() === "win32" ? execSync2("tasklist", { encoding: "utf8" }) : execSync2("ps aux", { encoding: "utf8" });
   } catch {
     return "";
   }
@@ -17764,7 +18235,7 @@ var versionCommands = {
   }
 };
 var getProcessInfo = (pid) => {
-  const platform2 = os5.platform();
+  const platform2 = os6.platform();
   try {
     if (platform2 === "linux" || platform2 === "darwin") {
       const output = execSync2(`ps -o pid=,ppid=,comm= -p ${pid}`, {
@@ -17883,7 +18354,7 @@ var getHostInfo = (additionalMcpList) => {
     const config2 = allConfigs[ide] || null;
     const ideName = ide.charAt(0).toUpperCase() + ide.slice(1) || "Unknown";
     let ideVersion = "Unknown";
-    const platform2 = os5.platform();
+    const platform2 = os6.platform();
     const cmds = versionCommands[ideName]?.[platform2] ?? [];
     for (const cmd of cmds) {
       try {
@@ -17915,15 +18386,15 @@ var getHostInfo = (additionalMcpList) => {
 };
 
 // src/mcp/services/McpUsageService/McpUsageService.ts
-import fetch5 from "node-fetch";
-import os7 from "os";
+import fetch6 from "node-fetch";
+import os8 from "os";
 import { v4 as uuidv42, v5 as uuidv5 } from "uuid";
 init_configs();
 
 // src/mcp/services/McpUsageService/system.ts
 init_configs();
 import fs14 from "fs";
-import os6 from "os";
+import os7 from "os";
 import path16 from "path";
 var MAX_DEPTH = 2;
 var patterns = ["mcp", "claude"];
@@ -17958,8 +18429,8 @@ var searchDir = async (dir, depth = 0) => {
 };
 var findSystemMCPConfigs = async () => {
   try {
-    const home = os6.homedir();
-    const platform2 = os6.platform();
+    const home = os7.homedir();
+    const platform2 = os7.platform();
     const knownDirs = platform2 === "win32" ? [
       path16.join(home, ".cursor"),
       path16.join(home, "Documents"),
@@ -18031,7 +18502,7 @@ var McpUsageService = class {
   generateHostId() {
     const stored = configStore.get(this.configKey);
     if (stored?.mcpHostId) return stored.mcpHostId;
-    const interfaces = os7.networkInterfaces();
+    const interfaces = os8.networkInterfaces();
     const macs = [];
     for (const iface of Object.values(interfaces)) {
       if (!iface) continue;
@@ -18039,7 +18510,7 @@ var McpUsageService = class {
         if (net.mac && net.mac !== "00:00:00:00:00:00") macs.push(net.mac);
       }
     }
-    const macString = macs.length ? macs.sort().join(",") : `${os7.hostname()}-${uuidv42()}`;
+    const macString = macs.length ? macs.sort().join(",") : `${os8.hostname()}-${uuidv42()}`;
     const hostId = uuidv5(macString, uuidv5.DNS);
     logDebug("[UsageService] Generated new host ID", { hostId });
     return hostId;
@@ -18062,7 +18533,7 @@ var McpUsageService = class {
       mcpHostId,
       organizationId,
       mcpVersion: packageJson.version,
-      mcpOsName: os7.platform(),
+      mcpOsName: os8.platform(),
       mcps: JSON.stringify(mcps),
       status,
       userName: user.name,
@@ -18102,7 +18573,7 @@ var McpUsageService = class {
       }
       logDebug("[UsageService] Before", { usageData });
       try {
-        const res = await fetch5(this.REST_API_URL, {
+        const res = await fetch6(this.REST_API_URL, {
           method: "POST",
           headers: {
             Accept: "application/json"
@@ -20383,22 +20854,22 @@ For a complete security audit workflow, use the \`full-security-audit\` prompt.
 
 // src/mcp/services/McpDetectionService/CursorMcpDetectionService.ts
 import * as fs17 from "fs";
-import * as os9 from "os";
+import * as os10 from "os";
 import * as path18 from "path";
 
 // src/mcp/services/McpDetectionService/BaseMcpDetectionService.ts
 init_configs();
 import * as fs16 from "fs";
-import fetch6 from "node-fetch";
+import fetch7 from "node-fetch";
 import * as path17 from "path";
 
 // src/mcp/services/McpDetectionService/McpDetectionServiceUtils.ts
 import * as fs15 from "fs";
-import * as os8 from "os";
+import * as os9 from "os";
 
 // src/mcp/services/McpDetectionService/VscodeMcpDetectionService.ts
 import * as fs18 from "fs";
-import * as os10 from "os";
+import * as os11 from "os";
 import * as path19 from "path";
 
 // src/mcp/tools/checkForNewAvailableFixes/CheckForNewAvailableFixesTool.ts
@@ -21956,7 +22427,7 @@ import {
   mkdirSync,
   readFileSync as readFileSync3,
   unlinkSync,
-  writeFileSync
+  writeFileSync as writeFileSync2
 } from "fs";
 import fs22 from "fs/promises";
 import parseDiff2 from "parse-diff";
@@ -22177,7 +22648,7 @@ var PatchApplicationService = class {
     }
     const dirPath = path22.dirname(normalizedFilePath);
     mkdirSync(dirPath, { recursive: true });
-    writeFileSync(normalizedFilePath, finalContent, "utf8");
+    writeFileSync2(normalizedFilePath, finalContent, "utf8");
     return normalizedFilePath;
   }
   static resolvePathWithinRepo({
@@ -24843,18 +25314,18 @@ async function getGrpcClient(port, csrf3) {
 
 // src/features/codeium_intellij/parse_intellij_logs.ts
 import fs25 from "fs";
-import os11 from "os";
+import os12 from "os";
 import path25 from "path";
 function getLogsDir() {
   if (process.platform === "darwin") {
-    return path25.join(os11.homedir(), "Library/Logs/JetBrains");
+    return path25.join(os12.homedir(), "Library/Logs/JetBrains");
   } else if (process.platform === "win32") {
     return path25.join(
-      process.env["LOCALAPPDATA"] || path25.join(os11.homedir(), "AppData/Local"),
+      process.env["LOCALAPPDATA"] || path25.join(os12.homedir(), "AppData/Local"),
       "JetBrains"
     );
   } else {
-    return path25.join(os11.homedir(), ".cache/JetBrains");
+    return path25.join(os12.homedir(), ".cache/JetBrains");
   }
 }
 function parseIdeLogDir(ideLogDir) {
@@ -24912,7 +25383,7 @@ function findRunningCodeiumLanguageServers() {
 var HookDataSchema2 = z47.object({
   trajectory_id: z47.string()
 });
-async function processAndUploadHookData2() {
+async function processAndUploadHookData() {
   const tracePayload = await getTraceDataForHook();
   if (!tracePayload) {
     console.warn("Warning: Failed to retrieve chat data.");
@@ -25076,17 +25547,17 @@ function processChatStepCodeAction(step) {
 }
 
 // src/features/codeium_intellij/install_hook.ts
-import fsPromises6 from "fs/promises";
-import os12 from "os";
+import fsPromises5 from "fs/promises";
+import os13 from "os";
 import path26 from "path";
 import chalk14 from "chalk";
 function getCodeiumHooksPath() {
-  return path26.join(os12.homedir(), ".codeium", "hooks.json");
+  return path26.join(os13.homedir(), ".codeium", "hooks.json");
 }
 async function readCodeiumHooks() {
   const hooksPath = getCodeiumHooksPath();
   try {
-    const content = await fsPromises6.readFile(hooksPath, "utf-8");
+    const content = await fsPromises5.readFile(hooksPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -25095,8 +25566,8 @@ async function readCodeiumHooks() {
 async function writeCodeiumHooks(config2) {
   const hooksPath = getCodeiumHooksPath();
   const dir = path26.dirname(hooksPath);
-  await fsPromises6.mkdir(dir, { recursive: true });
-  await fsPromises6.writeFile(
+  await fsPromises5.mkdir(dir, { recursive: true });
+  await fsPromises5.writeFile(
     hooksPath,
     JSON.stringify(config2, null, 2),
     "utf-8"
@@ -25184,7 +25655,7 @@ var windsurfIntellijInstallHookHandler = async (argv) => {
 };
 var windsurfIntellijProcessHookHandler = async () => {
   try {
-    await processAndUploadHookData2();
+    await processAndUploadHookData();
     process.exit(0);
   } catch (error) {
     console.error("Failed to process Windsurf IntelliJ hook data:", error);