mobbdev 1.2.68 → 1.3.0

package/dist/index.mjs

@@ -3560,8 +3560,8 @@ var init_FileUtils = __esm({
           const fullPath = path.join(dir, item);
           try {
             await fsPromises.access(fullPath, fs.constants.R_OK);
-            const stat = await fsPromises.stat(fullPath);
-            if (stat.isDirectory()) {
+            const stat2 = await fsPromises.stat(fullPath);
+            if (stat2.isDirectory()) {
               if (isRootLevel && excludedRootDirectories.includes(item)) {
                 continue;
               }
@@ -3573,7 +3573,7 @@ var init_FileUtils = __esm({
                 name: item,
                 fullPath,
                 relativePath: path.relative(rootDir, fullPath),
-                time: stat.mtime.getTime(),
+                time: stat2.mtime.getTime(),
                 isFile: true
               });
             }
@@ -4205,6 +4205,64 @@ import tmp from "tmp";
 // src/features/analysis/scm/ado/ado.ts
 import pLimit from "p-limit";
 
+// src/utils/contextLogger.ts
+import debugModule from "debug";
+var debug = debugModule("mobb:shared");
+var _contextLogger = null;
+var createContextLogger = async () => {
+  if (_contextLogger) return _contextLogger;
+  try {
+    let logger3;
+    try {
+      let module;
+      try {
+        const buildPath = "../../../../../tscommon/backend/build/src/utils/logger";
+        module = await import(buildPath);
+      } catch (e) {
+        const sourcePath = "../../../../../tscommon/backend/src/utils/logger";
+        module = await import(sourcePath);
+      }
+      logger3 = module.logger;
+    } catch {
+    }
+    if (logger3) {
+      _contextLogger = {
+        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;
+    }
+  } catch {
+  }
+  _contextLogger = {
+    info: (message, data) => debug(message, data),
+    warn: (message, data) => debug(message, data),
+    debug: (message, data) => debug(message, data),
+    error: (message, data) => debug(message, data)
+  };
+  return _contextLogger;
+};
+var contextLogger = {
+  info: async (message, data) => {
+    const logger3 = await createContextLogger();
+    return logger3.info(message, data);
+  },
+  debug: async (message, data) => {
+    const logger3 = await createContextLogger();
+    return logger3.debug(message, data);
+  },
+  warn: async (message, data) => {
+    const logger3 = await createContextLogger();
+    return logger3.warn(message, data);
+  },
+  error: async (message, data) => {
+    const logger3 = await createContextLogger();
+    return logger3.error(message, data);
+  }
+};
+
 // src/features/analysis/scm/errors.ts
 var InvalidAccessTokenError = class extends Error {
   constructor(m, scmType) {
@@ -6680,7 +6738,7 @@ var accountsZ = z16.object({
 });
 
 // src/features/analysis/scm/ado/utils.ts
-var debug = Debug("mobbdev:scm:ado");
+var debug2 = Debug("mobbdev:scm:ado");
 function transformVisualStudioUrl(url) {
   const match = url.match(/^https:\/\/([^.]+)\.visualstudio\.com/i);
   if (match) {
@@ -7042,7 +7100,7 @@ async function getAdoSdk(params) {
       const url = new URL(repoUrl);
       const origin = url.origin.toLowerCase().endsWith(".visualstudio.com") ? DEFUALT_ADO_ORIGIN : url.origin.toLowerCase();
       const params2 = `path=/&versionDescriptor[versionOptions]=0&versionDescriptor[versionType]=commit&versionDescriptor[version]=${branch}&resolveLfs=true&$format=zip&api-version=5.0&download=true`;
-      const path27 = [
+      const path30 = [
         prefixPath,
         owner,
         projectName,
@@ -7053,7 +7111,7 @@ async function getAdoSdk(params) {
         "items",
         "items"
       ].filter(Boolean).join("/");
-      return new URL(`${path27}?${params2}`, origin).toString();
+      return new URL(`${path30}?${params2}`, origin).toString();
     },
     async getAdoBranchList({ repoUrl }) {
       try {
@@ -7142,8 +7200,8 @@ async function getAdoSdk(params) {
         const changeType = entry.changeType;
         return changeType !== 16 && entry.item?.path;
       }).map((entry) => {
-        const path27 = entry.item.path;
-        return path27.startsWith("/") ? path27.slice(1) : path27;
+        const path30 = entry.item.path;
+        return path30.startsWith("/") ? path30.slice(1) : path30;
       });
     },
     async searchAdoPullRequests({
@@ -7328,6 +7386,41 @@ async function getAdoSdk(params) {
         return commitRes.value;
       }
       throw new RefNotFoundError(`ref: ${ref} does not exist`);
+    },
+    async listProjectMembers({ repoUrl }) {
+      try {
+        const { projectName } = parseAdoOwnerAndRepo(repoUrl);
+        if (!projectName) return [];
+        const coreApi = await api2.getCoreApi();
+        const teams = await coreApi.getTeams(projectName);
+        const allMembers = [];
+        const seenIds = /* @__PURE__ */ new Set();
+        for (const team of teams) {
+          if (!team.id || !team.projectId) continue;
+          const members = await coreApi.getTeamMembersWithExtendedProperties(
+            team.projectId,
+            team.id
+          );
+          for (const member of members) {
+            const identity = member.identity;
+            if (!identity?.id || seenIds.has(identity.id)) continue;
+            seenIds.add(identity.id);
+            allMembers.push({
+              id: identity.id,
+              displayName: identity.displayName ?? "",
+              uniqueName: identity["uniqueName"] ?? "",
+              imageUrl: identity["imageUrl"] ?? ""
+            });
+          }
+        }
+        return allMembers;
+      } catch (e) {
+        contextLogger.warn(
+          "[listProjectMembers] Failed to list ADO project members \u2014 scope may be insufficient",
+          { error: e instanceof Error ? e.message : String(e), repoUrl }
+        );
+        return [];
+      }
     }
   };
 }
@@ -7932,6 +8025,19 @@ var AdoSCMLib = class extends SCMLib {
       reset: new Date(Date.now() + 36e5)
     };
   }
+  async getRepositoryContributors() {
+    this._validateAccessTokenAndUrl();
+    const adoSdk = await this.getAdoSdk();
+    const members = await adoSdk.listProjectMembers({ repoUrl: this.url });
+    const isLikelyEmail = (v) => !!v && /^[^@\s\\]+@[^@\s\\]+\.[^@\s\\]+$/.test(v);
+    return members.map((m) => ({
+      externalId: m.id,
+      username: m.uniqueName || null,
+      displayName: m.displayName || null,
+      email: isLikelyEmail(m.uniqueName) ? m.uniqueName : null,
+      accessLevel: null
+    }));
+  }
 };
 
 // src/features/analysis/scm/bitbucket/bitbucket.ts
@@ -7950,7 +8056,7 @@ var BitbucketAuthResultZ = z19.object({
 });
 
 // src/features/analysis/scm/bitbucket/bitbucket.ts
-var debug2 = Debug2("scm:bitbucket");
+var debug3 = Debug2("scm:bitbucket");
 var BITBUCKET_HOSTNAME = "bitbucket.org";
 var TokenExpiredErrorZ = z20.object({
   status: z20.number(),
@@ -8195,6 +8301,70 @@ function getBitbucketSdk(params) {
         workspace
       });
       return res.data;
+    },
+    async getWorkspaceMembers(params2) {
+      const allMembers = [];
+      let hasMore = true;
+      let page = 1;
+      while (hasMore) {
+        const res = await bitbucketClient.workspaces.getMembersForWorkspace({
+          workspace: params2.workspace,
+          page: String(page),
+          pagelen: 100
+        });
+        const values = res.data.values ?? [];
+        allMembers.push(...values);
+        hasMore = Boolean(res.data.next) && values.length > 0;
+        page++;
+      }
+      return allMembers;
+    },
+    async getCurrentUserWithEmail() {
+      try {
+        const [userRes, emailsRes] = await Promise.all([
+          bitbucketClient.user.get({}),
+          bitbucketClient.user.listEmails({})
+        ]);
+        const accountId = userRes.data?.["account_id"] ?? null;
+        const emails = emailsRes.data?.values ?? [];
+        const primary = emails.find((e) => e.is_primary && e.is_confirmed);
+        const confirmed = emails.find((e) => e.is_confirmed);
+        const email = primary?.email ?? confirmed?.email ?? emails[0]?.email ?? null;
+        return { accountId, email };
+      } catch {
+        return { accountId: null, email: null };
+      }
+    },
+    async getRepoCommitAuthors(params2) {
+      try {
+        const res = await bitbucketClient.repositories.listCommits({
+          repo_slug: params2.repo_slug,
+          workspace: params2.workspace,
+          pagelen: 100
+        });
+        const commits = res.data?.values ?? [];
+        const authorMap = /* @__PURE__ */ new Map();
+        for (const commit of commits) {
+          const raw = commit?.["author"];
+          if (!raw?.raw) continue;
+          const match = raw.raw.match(/^(.+?)\s*<([^>]+)>/);
+          if (!match) continue;
+          const [, name, email] = match;
+          if (!email) continue;
+          const accountId = raw.user?.account_id ?? null;
+          const dedupeKey = accountId ?? raw.user?.nickname ?? email;
+          if (!authorMap.has(dedupeKey)) {
+            authorMap.set(dedupeKey, {
+              name: name.trim(),
+              email,
+              accountId
+            });
+          }
+        }
+        return Array.from(authorMap.values());
+      } catch {
+        return [];
+      }
     }
   };
 }
@@ -8514,6 +8684,79 @@ var BitbucketSCMLib = class extends SCMLib {
   async getRateLimitStatus() {
     return null;
   }
+  async getRepositoryContributors() {
+    this._validateAccessTokenAndUrl();
+    const { workspace, repo_slug } = parseBitbucketOrganizationAndRepo(this.url);
+    const [members, commitAuthors, currentUser] = await Promise.all([
+      this.bitbucketSdk.getWorkspaceMembers({ workspace }),
+      this.bitbucketSdk.getRepoCommitAuthors({ workspace, repo_slug }),
+      this.bitbucketSdk.getCurrentUserWithEmail()
+    ]);
+    const emailByAccountId = /* @__PURE__ */ new Map();
+    const emailByName = /* @__PURE__ */ new Map();
+    for (const author of commitAuthors) {
+      if (author.accountId) {
+        emailByAccountId.set(author.accountId, author.email);
+      }
+      const nameLower = author.name.toLowerCase();
+      if (!emailByName.has(nameLower)) {
+        emailByName.set(nameLower, author.email);
+      }
+    }
+    contextLogger.info("[Bitbucket] Starting contributor enrichment", {
+      memberCount: members.length,
+      commitAuthorCount: commitAuthors.length,
+      byAccountId: emailByAccountId.size,
+      byName: emailByName.size
+    });
+    const result = members.map((m) => {
+      const user = m["user"];
+      let email = null;
+      let emailSource = "none";
+      if (currentUser.email && currentUser.accountId && user?.account_id === currentUser.accountId) {
+        email = currentUser.email;
+        emailSource = "authenticated_user";
+      }
+      if (!email && user?.account_id) {
+        email = emailByAccountId.get(user.account_id) ?? null;
+        if (email) emailSource = "commit_by_account_id";
+      }
+      if (!email && user?.nickname) {
+        email = emailByName.get(user.nickname.toLowerCase()) ?? null;
+        if (email) emailSource = "commit_by_nickname";
+      }
+      if (!email && user?.display_name) {
+        email = emailByName.get(user.display_name.toLowerCase()) ?? null;
+        if (email) emailSource = "commit_by_displayname";
+      }
+      if (email) {
+        contextLogger.info("[Bitbucket] Resolved contributor email", {
+          nickname: user?.nickname,
+          emailSource
+        });
+      } else {
+        contextLogger.debug("[Bitbucket] No email resolved for member", {
+          nickname: user?.nickname,
+          displayName: user?.display_name,
+          accountId: user?.account_id
+        });
+      }
+      return {
+        externalId: user?.account_id ?? user?.uuid ?? "",
+        username: user?.nickname ?? null,
+        displayName: user?.display_name ?? null,
+        email,
+        accessLevel: null
+      };
+    });
+    const withEmail = result.filter((c) => c.email);
+    contextLogger.info("[Bitbucket] Contributor enrichment summary", {
+      total: result.length,
+      withEmail: withEmail.length,
+      withoutEmail: result.length - withEmail.length
+    });
+    return result;
+  }
 };
 
 // src/features/analysis/scm/constants.ts
@@ -8525,6 +8768,7 @@ var REPORT_DEFAULT_FILE_NAME = "report.json";
 init_env();
 
 // src/features/analysis/scm/github/GithubSCMLib.ts
+import pLimit3 from "p-limit";
 import { z as z22 } from "zod";
 init_client_generates();
 
@@ -9395,6 +9639,104 @@ function getGithubSdk(params = {}) {
         totalCount: response.data.total_count,
         hasMore: page * perPage < response.data.total_count
       };
+    },
+    async listRepositoryCollaborators(params2) {
+      const collaborators = await octokit.paginate(
+        octokit.rest.repos.listCollaborators,
+        {
+          owner: params2.owner,
+          repo: params2.repo,
+          per_page: 100
+        }
+      );
+      return collaborators;
+    },
+    async listOrgMembers(params2) {
+      const members = await octokit.paginate(octokit.rest.orgs.listMembers, {
+        org: params2.org,
+        per_page: 100
+      });
+      return members;
+    },
+    async getUserProfile(params2) {
+      const { data } = await octokit.rest.users.getByUsername({
+        username: params2.username
+      });
+      return data;
+    },
+    async getLatestRepoCommitByAuthor(params2) {
+      try {
+        const { data } = await octokit.rest.repos.listCommits({
+          owner: params2.owner,
+          repo: params2.repo,
+          author: params2.author,
+          per_page: 1
+        });
+        return data[0] ?? null;
+      } catch {
+        return null;
+      }
+    },
+    async getAuthenticatedUser() {
+      try {
+        const { data } = await octokit.rest.users.getAuthenticated();
+        return { id: data.id, login: data.login, email: data.email ?? null };
+      } catch {
+        return null;
+      }
+    },
+    async getAuthenticatedUserEmails() {
+      try {
+        const { data } = await octokit.rest.users.listEmailsForAuthenticatedUser({
+          per_page: 100
+        });
+        return data;
+      } catch {
+        return [];
+      }
+    },
+    async getEmailFromPublicEvents(params2) {
+      try {
+        const { data: events } = await octokit.rest.activity.listPublicEventsForUser({
+          username: params2.username,
+          per_page: 30
+        });
+        let fallback = null;
+        for (const event of events) {
+          if (event.type !== "PushEvent") continue;
+          const payload = event.payload;
+          if (!payload.commits) continue;
+          for (const commit of payload.commits) {
+            const email = commit.author?.email;
+            if (!email) continue;
+            if (!email.includes("noreply")) return email;
+            if (!fallback) fallback = email;
+          }
+        }
+        return fallback;
+      } catch {
+        return null;
+      }
+    },
+    async getEmailFromCommitSearch(params2) {
+      try {
+        const { data } = await octokit.rest.search.commits({
+          q: `author:${params2.username}`,
+          sort: "author-date",
+          order: "desc",
+          per_page: 5
+        });
+        let fallback = null;
+        for (const item of data.items) {
+          const email = item.commit?.author?.email;
+          if (!email) continue;
+          if (!email.includes("noreply")) return email;
+          if (!fallback) fallback = email;
+        }
+        return fallback;
+      } catch {
+        return null;
+      }
     }
   };
 }
@@ -9545,6 +9887,160 @@ var GithubSCMLib = class extends SCMLib {
       limit: result.limit
     };
   }
+  async getRepositoryContributors() {
+    this._validateAccessTokenAndUrl();
+    const { owner, repo } = parseGithubOwnerAndRepo(this.url);
+    const [collaborators, authUser, authEmails] = await Promise.all([
+      this.githubSdk.listRepositoryCollaborators({ owner, repo }),
+      this.githubSdk.getAuthenticatedUser(),
+      this.githubSdk.getAuthenticatedUserEmails()
+    ]);
+    let authUserPrimaryEmail = null;
+    if (authEmails.length > 0) {
+      const primary = authEmails.find((e) => e.primary && e.verified);
+      const verified = authEmails.find((e) => e.verified);
+      authUserPrimaryEmail = primary?.email ?? verified?.email ?? authEmails[0]?.email ?? null;
+    }
+    const enrichLimit = pLimit3(5);
+    const enriched = await Promise.all(
+      collaborators.map(
+        (c) => enrichLimit(async () => {
+          let profileEmail = c.email ?? null;
+          let displayName = c.login ?? null;
+          let emailSource = profileEmail ? "collaborator_api" : "none";
+          if (!profileEmail && authUser && authUserPrimaryEmail && c.id === authUser.id) {
+            profileEmail = authUserPrimaryEmail;
+            emailSource = "authenticated_user";
+          }
+          const isRealEmail = (e) => e && !e.includes("noreply");
+          let noreplyFallback = null;
+          let noreplySource = "";
+          if (c.login) {
+            try {
+              const profile = await this.githubSdk.getUserProfile({
+                username: c.login
+              });
+              if (profile.email) {
+                profileEmail = profile.email;
+                emailSource = "user_profile";
+              }
+              displayName = profile.name ?? displayName;
+            } catch (err) {
+              contextLogger.warn("[GitHub] getUserProfile failed", {
+                username: c.login,
+                error: err instanceof Error ? err.message : String(err)
+              });
+            }
+            if (!isRealEmail(profileEmail)) {
+              if (profileEmail && !noreplyFallback) {
+                noreplyFallback = profileEmail;
+                noreplySource = emailSource;
+              }
+              try {
+                const commit = await this.githubSdk.getLatestRepoCommitByAuthor(
+                  {
+                    owner,
+                    repo,
+                    author: c.login
+                  }
+                );
+                const commitEmail = commit?.commit?.author?.email;
+                if (commitEmail) {
+                  if (isRealEmail(commitEmail)) {
+                    profileEmail = commitEmail;
+                    emailSource = "commit_author";
+                  } else if (!noreplyFallback) {
+                    noreplyFallback = commitEmail;
+                    noreplySource = "commit_noreply";
+                  }
+                }
+              } catch (err) {
+                contextLogger.warn(
+                  "[GitHub] getLatestRepoCommitByAuthor failed",
+                  {
+                    username: c.login,
+                    owner,
+                    repo,
+                    error: err instanceof Error ? err.message : String(err)
+                  }
+                );
+              }
+            }
+            if (!isRealEmail(profileEmail)) {
+              try {
+                const eventEmail = await this.githubSdk.getEmailFromPublicEvents({
+                  username: c.login
+                });
+                if (eventEmail) {
+                  if (isRealEmail(eventEmail)) {
+                    profileEmail = eventEmail;
+                    emailSource = "public_events";
+                  } else if (!noreplyFallback) {
+                    noreplyFallback = eventEmail;
+                    noreplySource = "events_noreply";
+                  }
+                }
+              } catch (err) {
+                contextLogger.warn("[GitHub] getEmailFromPublicEvents failed", {
+                  username: c.login,
+                  error: err instanceof Error ? err.message : String(err)
+                });
+              }
+            }
+            if (!isRealEmail(profileEmail)) {
+              try {
+                const searchEmail = await this.githubSdk.getEmailFromCommitSearch({
+                  username: c.login
+                });
+                if (searchEmail) {
+                  if (isRealEmail(searchEmail)) {
+                    profileEmail = searchEmail;
+                    emailSource = "commit_search";
+                  } else if (!noreplyFallback) {
+                    noreplyFallback = searchEmail;
+                    noreplySource = "search_noreply";
+                  }
+                }
+              } catch (err) {
+                contextLogger.warn("[GitHub] getEmailFromCommitSearch failed", {
+                  username: c.login,
+                  error: err instanceof Error ? err.message : String(err)
+                });
+              }
+            }
+            if (!isRealEmail(profileEmail) && noreplyFallback) {
+              profileEmail = noreplyFallback;
+              emailSource = noreplySource;
+            }
+          }
+          if (profileEmail) {
+            contextLogger.info("[GitHub] Resolved contributor email", {
+              username: c.login,
+              emailSource
+            });
+          } else {
+            contextLogger.debug("[GitHub] No email resolved for contributor", {
+              username: c.login
+            });
+          }
+          return {
+            externalId: String(c.id),
+            username: c.login ?? null,
+            displayName,
+            email: profileEmail,
+            accessLevel: c.role_name ?? null
+          };
+        })
+      )
+    );
+    const withEmail = enriched.filter((c) => c.email);
+    contextLogger.info("[GitHub] Contributor enrichment summary", {
+      total: enriched.length,
+      withEmail: withEmail.length,
+      withoutEmail: enriched.length - withEmail.length
+    });
+    return enriched;
+  }
   get scmLibType() {
     return "GITHUB" /* GITHUB */;
   }
@@ -9907,72 +10403,12 @@ import {
   Gitlab
 } from "@gitbeaker/rest";
 import Debug3 from "debug";
-import pLimit3 from "p-limit";
+import pLimit4 from "p-limit";
 import {
   Agent,
   fetch as undiciFetch,
   ProxyAgent as ProxyAgent2
 } from "undici";
-
-// src/utils/contextLogger.ts
-import debugModule from "debug";
-var debug3 = debugModule("mobb:shared");
-var _contextLogger = null;
-var createContextLogger = async () => {
-  if (_contextLogger) return _contextLogger;
-  try {
-    let logger3;
-    try {
-      let module;
-      try {
-        const buildPath = "../../../../../tscommon/backend/build/src/utils/logger";
-        module = await import(buildPath);
-      } catch (e) {
-        const sourcePath = "../../../../../tscommon/backend/src/utils/logger";
-        module = await import(sourcePath);
-      }
-      logger3 = module.logger;
-    } catch {
-    }
-    if (logger3) {
-      _contextLogger = {
-        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;
-    }
-  } catch {
-  }
-  _contextLogger = {
-    info: (message, data) => debug3(message, data),
-    warn: (message, data) => debug3(message, data),
-    debug: (message, data) => debug3(message, data),
-    error: (message, data) => debug3(message, data)
-  };
-  return _contextLogger;
-};
-var contextLogger = {
-  info: async (message, data) => {
-    const logger3 = await createContextLogger();
-    return logger3.info(message, data);
-  },
-  debug: async (message, data) => {
-    const logger3 = await createContextLogger();
-    return logger3.debug(message, data);
-  },
-  warn: async (message, data) => {
-    const logger3 = await createContextLogger();
-    return logger3.warn(message, data);
-  },
-  error: async (message, data) => {
-    const logger3 = await createContextLogger();
-    return logger3.error(message, data);
-  }
-};
-
-// src/features/analysis/scm/gitlab/gitlab.ts
 init_env();
 
 // src/features/analysis/scm/gitlab/types.ts
@@ -10335,7 +10771,7 @@ async function getGitlabMrCommitsBatch({
     url: repoUrl,
     gitlabAuthToken: accessToken
   });
-  const limit = pLimit3(GITLAB_API_CONCURRENCY);
+  const limit = pLimit4(GITLAB_API_CONCURRENCY);
   const results = await Promise.all(
     mrNumbers.map(
       (mrNumber) => limit(async () => {
@@ -10374,7 +10810,7 @@ async function getGitlabMrDataBatch({
     url: repoUrl,
     gitlabAuthToken: accessToken
   });
-  const limit = pLimit3(GITLAB_API_CONCURRENCY);
+  const limit = pLimit4(GITLAB_API_CONCURRENCY);
   const results = await Promise.all(
     mrNumbers.map(
       (mrNumber) => limit(async () => {
@@ -10651,18 +11087,86 @@ async function brokerRequestHandler(endpoint, options) {
     };
   throw new Error(`gitbeaker: ${response.statusText}`);
 }
-
-// src/features/analysis/scm/gitlab/GitlabSCMLib.ts
-init_client_generates();
-var GitlabSCMLib = class extends SCMLib {
-  constructor(url, accessToken, scmOrg) {
-    super(url, accessToken, scmOrg);
-  }
-  async createSubmitRequest(params) {
-    this._validateAccessTokenAndUrl();
-    const { targetBranchName, sourceBranchName, title, body } = params;
-    return String(
-      await createMergeRequest({
+async function listGitlabProjectMembers({
+  repoUrl,
+  accessToken
+}) {
+  const { owner, projectPath } = parseGitlabOwnerAndRepo(repoUrl);
+  const api2 = getGitBeaker({ url: repoUrl, gitlabAuthToken: accessToken });
+  const projectMembers = await api2.ProjectMembers.all(projectPath, {
+    includeInherited: true
+  });
+  if (projectMembers.length > 1 || !owner) return projectMembers;
+  try {
+    const groupMembers = await api2.GroupMembers.all(owner, {
+      includeInherited: true
+    });
+    if (groupMembers.length > projectMembers.length) {
+      return groupMembers;
+    }
+  } catch {
+  }
+  return projectMembers;
+}
+async function getGitlabUserPublicEmail({
+  repoUrl,
+  accessToken,
+  userId
+}) {
+  try {
+    const api2 = getGitBeaker({ url: repoUrl, gitlabAuthToken: accessToken });
+    const user = await api2.Users.show(userId);
+    return user["public_email"];
+  } catch {
+    return null;
+  }
+}
+async function listGitlabRepoContributors({
+  repoUrl,
+  accessToken
+}) {
+  try {
+    const { projectPath } = parseGitlabOwnerAndRepo(repoUrl);
+    const api2 = getGitBeaker({ url: repoUrl, gitlabAuthToken: accessToken });
+    const contributors = await api2.Repositories.allContributors(projectPath);
+    return contributors.map((c) => ({
+      name: c.name,
+      email: c.email,
+      commits: c.commits
+    }));
+  } catch {
+    return [];
+  }
+}
+async function getGitlabAuthenticatedUser({
+  repoUrl,
+  accessToken
+}) {
+  try {
+    const api2 = getGitBeaker({ url: repoUrl, gitlabAuthToken: accessToken });
+    const user = await api2.Users.showCurrentUser();
+    const record = user;
+    return {
+      id: record["id"],
+      email: record["email"] ?? record["public_email"] ?? null
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/features/analysis/scm/gitlab/GitlabSCMLib.ts
+import pLimit5 from "p-limit";
+init_client_generates();
+var GitlabSCMLib = class extends SCMLib {
+  constructor(url, accessToken, scmOrg) {
+    super(url, accessToken, scmOrg);
+  }
+  async createSubmitRequest(params) {
+    this._validateAccessTokenAndUrl();
+    const { targetBranchName, sourceBranchName, title, body } = params;
+    return String(
+      await createMergeRequest({
         title,
         body,
         targetBranchName,
@@ -11019,6 +11523,93 @@ var GitlabSCMLib = class extends SCMLib {
       accessToken: this.accessToken
     });
   }
+  async getRepositoryContributors() {
+    this._validateAccessTokenAndUrl();
+    const [members, repoContributors, authUser] = await Promise.all([
+      listGitlabProjectMembers({
+        repoUrl: this.url,
+        accessToken: this.accessToken
+      }),
+      listGitlabRepoContributors({
+        repoUrl: this.url,
+        accessToken: this.accessToken
+      }),
+      getGitlabAuthenticatedUser({
+        repoUrl: this.url,
+        accessToken: this.accessToken
+      })
+    ]);
+    contextLogger.info("[GitLab] Starting contributor enrichment", {
+      memberCount: members.length,
+      repoContributorCount: repoContributors.length
+    });
+    const enrichLimit = pLimit5(5);
+    const enriched = await Promise.all(
+      members.map(
+        (m) => enrichLimit(async () => {
+          let email = null;
+          let emailSource = "none";
+          if (authUser?.email && authUser.id === m.id) {
+            email = authUser.email;
+            emailSource = "authenticated_user";
+          }
+          if (!email) {
+            try {
+              email = await getGitlabUserPublicEmail({
+                repoUrl: this.url,
+                accessToken: this.accessToken,
+                userId: m.id
+              });
+              if (email) emailSource = "public_email";
+            } catch (err) {
+              contextLogger.warn("[GitLab] getGitlabUserPublicEmail failed", {
+                username: m.username,
+                userId: m.id,
+                error: err instanceof Error ? err.message : String(err)
+              });
+            }
+          }
+          if (!email && m.username) {
+            const match = repoContributors.find(
+              (rc) => rc.name?.toLowerCase() === m.username?.toLowerCase() || rc.name?.toLowerCase() === m.name?.toLowerCase()
+            );
+            if (match?.email) {
+              email = match.email;
+              emailSource = match.email.includes("noreply") ? "commit_noreply" : "commit_author";
+            } else {
+              contextLogger.debug(
+                "[GitLab] No commit author match for member",
+                {
+                  username: m.username,
+                  displayName: m.name
+                }
+              );
+            }
+          }
+          if (email) {
+            contextLogger.info("[GitLab] Resolved contributor email", {
+              username: m.username,
+              emailSource
+            });
+          }
+          return {
+            externalId: String(m.id),
+            username: m.username ?? null,
+            displayName: m.name ?? null,
+            email,
+            accessLevel: m.access_level != null ? String(m.access_level) : null
+          };
+        })
+      )
+    );
+    const withEmail = enriched.filter((c) => c.email);
+    contextLogger.info("[GitLab] Contributor enrichment summary", {
+      total: enriched.length,
+      withEmail: withEmail.length,
+      withoutEmail: enriched.length - withEmail.length
+    });
+    return enriched;
+  }
 };
 
 // src/features/analysis/scm/scmFactory.ts
@@ -11130,6 +11721,10 @@ var StubSCMLib = class extends SCMLib {
     console.warn("getRateLimitStatus() returning null");
     return null;
   }
+  async getRepositoryContributors() {
+    console.warn("getRepositoryContributors() returning empty array");
+    return [];
+  }
 };
 
 // src/features/analysis/scm/scmFactory.ts
@@ -12041,6 +12636,7 @@ var mobbCliCommand = {
   uploadAiBlame: "upload-ai-blame",
   claudeCodeInstallHook: "claude-code-install-hook",
   claudeCodeProcessHook: "claude-code-process-hook",
+  claudeCodeDaemon: "claude-code-daemon",
   windsurfIntellijInstallHook: "windsurf-intellij-install-hook",
   windsurfIntellijProcessHook: "windsurf-intellij-process-hook",
   scanSkill: "scan-skill"
@@ -12986,7 +13582,7 @@ async function handleMobbLogin({
       });
       throw new CliError("Failed to generate login URL");
     }
-    !skipPrompts && console.log(
+    console.log(
       `If the page does not open automatically, kindly access it through ${loginUrl}.`
     );
     authManager.openUrlInBrowser();
@@ -14415,7 +15011,7 @@ async function postIssueComment(params) {
     fpDescription
   } = params;
   const {
-    path: path27,
+    path: path30,
     startLine,
     vulnerabilityReportIssue: {
       vulnerabilityReportIssueTags,
@@ -14430,7 +15026,7 @@ async function postIssueComment(params) {
 Refresh the page in order to see the changes.`,
     pull_number: pullRequest,
     commit_id: commitSha,
-    path: path27,
+    path: path30,
     line: startLine
   });
   const commentId = commentRes.data.id;
@@ -14464,7 +15060,7 @@ async function postFixComment(params) {
     scanner
   } = params;
   const {
-    path: path27,
+    path: path30,
     startLine,
     vulnerabilityReportIssue: { fixId, vulnerabilityReportIssueTags, category },
     vulnerabilityReportIssueId
@@ -14482,7 +15078,7 @@ async function postFixComment(params) {
 Refresh the page in order to see the changes.`,
     pull_number: pullRequest,
     commit_id: commitSha,
-    path: path27,
+    path: path30,
     line: startLine
   });
   const commentId = commentRes.data.id;
@@ -15086,8 +15682,8 @@ if (typeof __filename !== "undefined") {
 }
 var costumeRequire = createRequire(moduleUrl);
 var getCheckmarxPath = () => {
-  const os14 = type();
-  const cxFileName = os14 === "Windows_NT" ? "cx.exe" : "cx";
+  const os16 = type();
+  const cxFileName = os16 === "Windows_NT" ? "cx.exe" : "cx";
   try {
     return costumeRequire.resolve(`.bin/${cxFileName}`);
   } catch (e) {
@@ -16004,8 +16600,8 @@ async function resolveSkillScanInput(skillInput) {
   if (!fs11.existsSync(resolvedPath)) {
     return skillInput;
   }
-  const stat = fs11.statSync(resolvedPath);
-  if (!stat.isDirectory()) {
+  const stat2 = fs11.statSync(resolvedPath);
+  if (!stat2.isDirectory()) {
     throw new CliError(
       "Local skill input must be a directory containing SKILL.md"
     );
@@ -16399,28 +16995,108 @@ async function analyzeHandler(args) {
   await analyze(args, { skipPrompts: args.yes });
 }
 
-// src/features/claude_code/data_collector.ts
-import { execFile } from "child_process";
-import { createHash as createHash2 } from "crypto";
-import { access, open as open4, readdir, readFile, unlink } from "fs/promises";
-import path14 from "path";
-import { promisify } from "util";
-import { z as z33 } from "zod";
-init_client_generates();
+// src/args/commands/claude_code.ts
+import { spawn } from "child_process";
+
+// src/features/claude_code/daemon.ts
+import path17 from "path";
+import { setTimeout as sleep2 } from "timers/promises";
+
+// src/features/claude_code/daemon_pid_file.ts
+import fs13 from "fs";
+import os4 from "os";
+import path13 from "path";
 
 // src/features/claude_code/data_collector_constants.ts
 var CC_VERSION_CACHE_KEY = "claudeCode.detectedCCVersion";
 var CC_VERSION_CLI_KEY = "claudeCode.detectedCCVersionCli";
-var GLOBAL_COOLDOWN_MS = 5e3;
-var HOOK_COOLDOWN_MS = 15e3;
-var ACTIVE_LOCK_TTL_MS = 6e4;
 var GQL_AUTH_TIMEOUT_MS = 15e3;
 var STALE_KEY_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
 var CLEANUP_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-var MAX_ENTRIES_PER_INVOCATION = 200;
-var COOLDOWN_KEY = "lastHookRunAt";
-var ACTIVE_KEY = "hookActiveAt";
-var STDIN_TIMEOUT_MS = 1e4;
+var DAEMON_TTL_MS = 30 * 60 * 1e3;
+var DAEMON_POLL_INTERVAL_MS = 1e4;
+var HEARTBEAT_STALE_MS = 3e4;
+var TRANSCRIPT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var DAEMON_CHUNK_SIZE = 50;
+
+// src/features/claude_code/daemon_pid_file.ts
+function getMobbdevDir() {
+  return path13.join(os4.homedir(), ".mobbdev");
+}
+function getDaemonCheckScriptPath() {
+  return path13.join(getMobbdevDir(), "daemon-check.js");
+}
+var DaemonPidFile = class {
+  constructor() {
+    __publicField(this, "data", null);
+  }
+  get filePath() {
+    return path13.join(getMobbdevDir(), "daemon.pid");
+  }
+  /** Ensure ~/.mobbdev/ directory exists. */
+  ensureDir() {
+    fs13.mkdirSync(getMobbdevDir(), { recursive: true });
+  }
+  /** Read the PID file from disk. Returns the parsed data or null. */
+  read() {
+    try {
+      const raw = fs13.readFileSync(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.pid !== "number" || typeof parsed.startedAt !== "number" || typeof parsed.heartbeat !== "number") {
+        this.data = null;
+      } else {
+        this.data = parsed;
+      }
+    } catch {
+      this.data = null;
+    }
+    return this.data;
+  }
+  /** Write a new PID file for the given process id. */
+  write(pid, version) {
+    this.data = {
+      pid,
+      startedAt: Date.now(),
+      heartbeat: Date.now(),
+      version
+    };
+    fs13.writeFileSync(this.filePath, JSON.stringify(this.data), "utf8");
+  }
+  /** Update the heartbeat timestamp of the current PID file. */
+  updateHeartbeat() {
+    if (!this.data) this.read();
+    if (!this.data) return;
+    this.data.heartbeat = Date.now();
+    fs13.writeFileSync(this.filePath, JSON.stringify(this.data), "utf8");
+  }
+  /** Check whether the previously read PID data represents a live daemon. */
+  isAlive() {
+    if (!this.data) return false;
+    if (Date.now() - this.data.heartbeat > HEARTBEAT_STALE_MS) return false;
+    try {
+      process.kill(this.data.pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** Remove the PID file from disk (best-effort). */
+  remove() {
+    this.data = null;
+    try {
+      fs13.unlinkSync(this.filePath);
+    } catch {
+    }
+  }
+};
+
+// src/features/claude_code/data_collector.ts
+import { execFile } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { access, open as open4, readdir, readFile, unlink } from "fs/promises";
+import path14 from "path";
+import { promisify } from "util";
+init_client_generates();
 
 // src/utils/shared-logger/create-logger.ts
 import Configstore2 from "configstore";
@@ -16499,8 +17175,8 @@ function createConfigstoreStream(store, opts) {
       heartbeatBuffer.length = 0;
     }
   }
-  function setScopePath(path27) {
-    scopePath = path27;
+  function setScopePath(path30) {
+    scopePath = path30;
   }
   return { writable, flush, setScopePath };
 }
@@ -16582,22 +17258,22 @@ function createDdBatch(config2) {
 
 // src/utils/shared-logger/hostname.ts
 import { createHash } from "crypto";
-import os4 from "os";
+import os5 from "os";
 function hashString(input) {
   return createHash("sha256").update(input).digest("hex").slice(0, 16);
 }
 function getPlainHostname() {
   try {
-    return `${os4.userInfo().username}@${os4.hostname()}`;
+    return `${os5.userInfo().username}@${os5.hostname()}`;
   } catch {
-    return `unknown@${os4.hostname()}`;
+    return `unknown@${os5.hostname()}`;
   }
 }
 function getHashedHostname() {
   try {
-    return `${hashString(os4.userInfo().username)}@${hashString(os4.hostname())}`;
+    return `${hashString(os5.userInfo().username)}@${hashString(os5.hostname())}`;
   } catch {
-    return `unknown@${hashString(os4.hostname())}`;
+    return `unknown@${hashString(os5.hostname())}`;
   }
 }
 
@@ -16610,15 +17286,19 @@ function createLogger(config2) {
     maxLogs,
     maxHeartbeat,
     dd,
-    additionalStreams = []
+    additionalStreams = [],
+    enableConfigstore = true
   } = config2;
-  const store = new Configstore2(namespace, {});
-  const csStream = createConfigstoreStream(store, {
-    buffered,
-    scopePath,
-    maxLogs,
-    maxHeartbeat
-  });
+  let csStream = null;
+  if (enableConfigstore) {
+    const store = new Configstore2(namespace, {});
+    csStream = createConfigstoreStream(store, {
+      buffered,
+      scopePath,
+      maxLogs,
+      maxHeartbeat
+    });
+  }
   let ddBatch = null;
   if (dd) {
     const hostname = dd.hostnameMode === "hashed" ? getHashedHostname() : getPlainHostname();
@@ -16633,9 +17313,10 @@ function createLogger(config2) {
     };
     ddBatch = createDdBatch(ddConfig);
   }
-  const streams = [
-    { stream: csStream.writable, level: "info" }
-  ];
+  const streams = [];
+  if (csStream) {
+    streams.push({ stream: csStream.writable, level: "info" });
+  }
   if (ddBatch) {
     streams.push({ stream: ddBatch.createPinoStream(), level: "info" });
   }
@@ -16647,6 +17328,11 @@ function createLogger(config2) {
   }
   const pinoLogger = pino(
     {
+      serializers: {
+        err: pino.stdSerializers.err,
+        error: pino.stdSerializers.err,
+        e: pino.stdSerializers.err
+      },
       formatters: {
         level: (label) => ({ level: label })
       }
@@ -16677,8 +17363,8 @@ function createLogger(config2) {
       throw err;
     }
   }
-  function flushLogs2() {
-    csStream.flush();
+  function flushLogs() {
+    csStream?.flush();
   }
   async function flushDdAsync() {
     if (ddBatch) {
@@ -16702,17 +17388,19 @@ function createLogger(config2) {
     debug: debug23,
     heartbeat,
     timed,
-    flushLogs: flushLogs2,
+    flushLogs,
     flushDdAsync,
     disposeDd,
-    setScopePath: csStream.setScopePath,
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    setScopePath: csStream?.setScopePath ?? (() => {
+    }),
     updateDdTags
   };
 }
 
 // src/features/claude_code/hook_logger.ts
 var DD_RUM_TOKEN = true ? "pubf59c0182545bfb4c299175119f1abf9b" : "";
-var CLI_VERSION = true ? "1.2.68" : "unknown";
+var CLI_VERSION = true ? "1.3.0" : "unknown";
 var NAMESPACE = "mobbdev-claude-code-hook-logs";
 var claudeCodeVersion;
 function buildDdTags() {
@@ -16722,10 +17410,11 @@ function buildDdTags() {
   }
   return tags.join(",");
 }
-function createHookLogger(scopePath) {
+function createHookLogger(opts) {
   return createLogger({
     namespace: NAMESPACE,
-    scopePath,
+    scopePath: opts?.scopePath,
+    enableConfigstore: opts?.enableConfigstore,
     dd: {
       apiKey: DD_RUM_TOKEN,
       ddsource: "mobbdev-cli",
@@ -16738,6 +17427,7 @@ function createHookLogger(scopePath) {
 }
 var logger = createHookLogger();
 var activeScopedLoggers = [];
+var scopedLoggerCache = /* @__PURE__ */ new Map();
 var hookLog = logger;
 function setClaudeCodeVersion(version) {
   claudeCodeVersion = version;
@@ -16746,289 +17436,82 @@ function setClaudeCodeVersion(version) {
 function getClaudeCodeVersion() {
   return claudeCodeVersion;
 }
-function flushLogs() {
-  logger.flushLogs();
-  for (const scoped of activeScopedLoggers) {
-    scoped.flushLogs();
-  }
-}
 async function flushDdLogs() {
   await logger.flushDdAsync();
   for (const scoped of activeScopedLoggers) {
     await scoped.flushDdAsync();
   }
-  activeScopedLoggers.length = 0;
 }
-function createScopedHookLog(scopePath) {
-  const scoped = createHookLogger(scopePath);
+function createScopedHookLog(scopePath, opts) {
+  const cached = scopedLoggerCache.get(scopePath);
+  if (cached) return cached;
+  const scoped = createHookLogger({
+    scopePath,
+    enableConfigstore: opts?.daemonMode ? false : void 0
+  });
+  scopedLoggerCache.set(scopePath, scoped);
   activeScopedLoggers.push(scoped);
   return scoped;
 }
 
-// src/features/claude_code/install_hook.ts
-import fsPromises4 from "fs/promises";
-import os5 from "os";
-import path13 from "path";
-import chalk11 from "chalk";
-var CLAUDE_SETTINGS_PATH = path13.join(os5.homedir(), ".claude", "settings.json");
-var RECOMMENDED_MATCHER = "Write|Edit";
-async function claudeSettingsExists() {
+// src/features/claude_code/data_collector.ts
+var execFileAsync = promisify(execFile);
+async function detectClaudeCodeVersion() {
+  const cachedCliVersion = configStore.get(CC_VERSION_CLI_KEY);
+  if (cachedCliVersion === packageJson.version) {
+    return configStore.get(CC_VERSION_CACHE_KEY);
+  }
   try {
-    await fsPromises4.access(CLAUDE_SETTINGS_PATH);
-    return true;
+    const { stdout: stdout2 } = await execFileAsync("claude", ["--version"], {
+      timeout: 3e3,
+      encoding: "utf-8"
+    });
+    const version = stdout2.trim().split(/\s/)[0] || stdout2.trim();
+    configStore.set(CC_VERSION_CACHE_KEY, version);
+    configStore.set(CC_VERSION_CLI_KEY, packageJson.version);
+    return version;
   } catch {
-    return false;
+    configStore.set(CC_VERSION_CACHE_KEY, void 0);
+    configStore.set(CC_VERSION_CLI_KEY, packageJson.version);
+    return void 0;
   }
 }
-async function readClaudeSettings() {
-  const settingsContent = await fsPromises4.readFile(
-    CLAUDE_SETTINGS_PATH,
-    "utf-8"
-  );
-  return JSON.parse(settingsContent);
+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}`;
 }
-async function writeClaudeSettings(settings) {
-  await fsPromises4.writeFile(
-    CLAUDE_SETTINGS_PATH,
-    JSON.stringify(settings, null, 2),
-    "utf-8"
-  );
+function getCursorKey(transcriptPath) {
+  const hash = createHash2("sha256").update(transcriptPath).digest("hex").slice(0, 12);
+  return `cursor.${hash}`;
 }
-async function autoUpgradeMatcherIfStale() {
+async function resolveTranscriptPath(transcriptPath, sessionId) {
   try {
-    if (!await claudeSettingsExists()) return false;
-    const settings = await readClaudeSettings();
-    const hooks = settings.hooks?.PostToolUse;
-    if (!hooks) return false;
-    let upgraded = false;
-    for (const hook of hooks) {
-      const isMobbHook = hook.hooks.some(
-        (h) => h.command?.includes("claude-code-process-hook")
+    await access(transcriptPath);
+    return transcriptPath;
+  } catch {
+  }
+  const filename = path14.basename(transcriptPath);
+  const dirName = path14.basename(path14.dirname(transcriptPath));
+  const projectsDir = path14.dirname(path14.dirname(transcriptPath));
+  const baseDirName = dirName.replace(/[-.]claude-worktrees-.+$/, "");
+  if (baseDirName !== dirName) {
+    const candidate = path14.join(projectsDir, baseDirName, filename);
+    try {
+      await access(candidate);
+      hookLog.info(
+        {
+          data: {
+            original: transcriptPath,
+            resolved: candidate,
+            sessionId,
+            method: "worktree-strip"
+          }
+        },
+        "Transcript path resolved via fallback"
       );
-      if (!isMobbHook) continue;
-      if (hook.matcher !== RECOMMENDED_MATCHER) {
-        hook.matcher = RECOMMENDED_MATCHER;
-        upgraded = true;
-      }
-      for (const h of hook.hooks) {
-        if (!h.async) {
-          h.async = true;
-          upgraded = true;
-        }
-      }
-    }
-    if (upgraded) {
-      await writeClaudeSettings(settings);
-    }
-    return upgraded;
-  } catch {
-    return false;
-  }
-}
-async function installMobbHooks(options = {}) {
-  console.log(chalk11.blue("Installing Mobb hooks in Claude Code settings..."));
-  if (!await claudeSettingsExists()) {
-    console.log(chalk11.red("\u274C Claude Code settings file not found"));
-    console.log(chalk11.yellow(`Expected location: ${CLAUDE_SETTINGS_PATH}`));
-    console.log(chalk11.yellow("Is Claude Code installed on your system?"));
-    console.log(chalk11.yellow("Please install Claude Code and try again."));
-    throw new Error(
-      "Claude Code settings file not found. Is Claude Code installed?"
-    );
-  }
-  const settings = await readClaudeSettings();
-  if (!settings.hooks) {
-    settings.hooks = {};
-  }
-  if (!settings.hooks.PostToolUse) {
-    settings.hooks.PostToolUse = [];
-  }
-  let command = "npx --yes mobbdev@latest claude-code-process-hook";
-  if (options.saveEnv) {
-    const envVars = [];
-    if (process.env["WEB_APP_URL"]) {
-      envVars.push(`WEB_APP_URL="${process.env["WEB_APP_URL"]}"`);
-    }
-    if (process.env["API_URL"]) {
-      envVars.push(`API_URL="${process.env["API_URL"]}"`);
-    }
-    if (envVars.length > 0) {
-      command = `${envVars.join(" ")} ${command}`;
-      console.log(
-        chalk11.blue(
-          `Adding environment variables to hook command: ${envVars.join(", ")}`
-        )
-      );
-    }
-  }
-  const mobbHookConfig = {
-    // Only fire on tools that indicate meaningful work — skip high-frequency
-    // read-only tools (Grep, Glob, WebSearch, WebFetch) to reduce CPU overhead
-    // from process startup (~1.7s user CPU per invocation).
-    matcher: RECOMMENDED_MATCHER,
-    hooks: [
-      {
-        type: "command",
-        command,
-        async: true
-      }
-    ]
-  };
-  const existingHookIndex = settings.hooks.PostToolUse.findIndex(
-    (hook) => hook.hooks.some(
-      (h) => h.command?.includes("mobbdev@latest claude-code-process-hook")
-    )
-  );
-  if (existingHookIndex >= 0) {
-    console.log(chalk11.yellow("Mobb hook already exists, updating..."));
-    settings.hooks.PostToolUse[existingHookIndex] = mobbHookConfig;
-  } else {
-    console.log(chalk11.green("Adding new Mobb hook..."));
-    settings.hooks.PostToolUse.push(mobbHookConfig);
-  }
-  await writeClaudeSettings(settings);
-  console.log(
-    chalk11.green(
-      `\u2705 Mobb hooks ${options.saveEnv ? "and environment variables " : ""}installed successfully in ${CLAUDE_SETTINGS_PATH}`
-    )
-  );
-}
-
-// src/features/claude_code/data_collector.ts
-var HookDataSchema = z33.object({
-  session_id: z33.string().nullish(),
-  transcript_path: z33.string().nullish(),
-  cwd: z33.string().nullish(),
-  hook_event_name: z33.string(),
-  tool_name: z33.string(),
-  tool_input: z33.unknown(),
-  tool_response: z33.unknown()
-});
-var execFileAsync = promisify(execFile);
-async function detectClaudeCodeVersion() {
-  const cachedCliVersion = configStore.get(CC_VERSION_CLI_KEY);
-  if (cachedCliVersion === packageJson.version) {
-    return configStore.get(CC_VERSION_CACHE_KEY);
-  }
-  try {
-    const { stdout: stdout2 } = await execFileAsync("claude", ["--version"], {
-      timeout: 3e3,
-      encoding: "utf-8"
-    });
-    const version = stdout2.trim().split(/\s/)[0] || stdout2.trim();
-    configStore.set(CC_VERSION_CACHE_KEY, version);
-    configStore.set(CC_VERSION_CLI_KEY, packageJson.version);
-    return version;
-  } catch {
-    configStore.set(CC_VERSION_CACHE_KEY, void 0);
-    configStore.set(CC_VERSION_CLI_KEY, packageJson.version);
-    return void 0;
-  }
-}
-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(
-          {
-            data: { keys: Object.keys(parsedData) }
-          },
-          "Parsed stdin data"
-        );
-        resolve(parsedData);
-      } catch (error) {
-        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(
-        { data: { error: error.message } },
-        "Error reading from stdin"
-      );
-      reject(new Error(`Error reading from stdin: ${error.message}`));
-    });
-  });
-}
-function validateHookData(data) {
-  return HookDataSchema.parse(data);
-}
-async function extractSessionIdFromTranscript(transcriptPath) {
-  try {
-    const fh = await open4(transcriptPath, "r");
-    try {
-      const buf = Buffer.alloc(4096);
-      const { bytesRead } = await fh.read(buf, 0, 4096, 0);
-      const chunk = buf.toString("utf-8", 0, bytesRead);
-      const firstLine = chunk.split("\n").find((l) => l.trim().length > 0);
-      if (!firstLine) return null;
-      const entry = JSON.parse(firstLine);
-      return entry.sessionId ?? null;
-    } finally {
-      await fh.close();
-    }
-  } catch {
-    return null;
-  }
-}
-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 resolveTranscriptPath(transcriptPath, sessionId) {
-  try {
-    await access(transcriptPath);
-    return transcriptPath;
-  } catch {
-  }
-  const filename = path14.basename(transcriptPath);
-  const dirName = path14.basename(path14.dirname(transcriptPath));
-  const projectsDir = path14.dirname(path14.dirname(transcriptPath));
-  const baseDirName = dirName.replace(/[-.]claude-worktrees-.+$/, "");
-  if (baseDirName !== dirName) {
-    const candidate = path14.join(projectsDir, baseDirName, filename);
-    try {
-      await access(candidate);
-      hookLog.info(
-        {
-          data: {
-            original: transcriptPath,
-            resolved: candidate,
-            sessionId,
-            method: "worktree-strip"
-          }
-        },
-        "Transcript path resolved via fallback"
-      );
-      return candidate;
-    } catch {
+      return candidate;
+    } catch {
     }
   }
   try {
@@ -17057,7 +17540,7 @@ async function resolveTranscriptPath(transcriptPath, sessionId) {
   }
   return transcriptPath;
 }
-async function readNewTranscriptEntries(transcriptPath, sessionId, sessionStore) {
+async function readNewTranscriptEntries(transcriptPath, sessionId, sessionStore, maxEntries = DAEMON_CHUNK_SIZE) {
   transcriptPath = await resolveTranscriptPath(transcriptPath, sessionId);
   const cursor = sessionStore.get(getCursorKey(transcriptPath));
   let content;
@@ -17066,9 +17549,9 @@ async function readNewTranscriptEntries(transcriptPath, sessionId, sessionStore)
   if (cursor?.byteOffset) {
     const fh = await open4(transcriptPath, "r");
     try {
-      const stat = await fh.stat();
-      fileSize = stat.size;
-      if (cursor.byteOffset >= stat.size) {
+      const stat2 = await fh.stat();
+      fileSize = stat2.size;
+      if (cursor.byteOffset >= stat2.size) {
         hookLog.info({ data: { sessionId } }, "No new data in transcript file");
         return {
           entries: [],
@@ -17076,7 +17559,7 @@ async function readNewTranscriptEntries(transcriptPath, sessionId, sessionStore)
           resolvedTranscriptPath: transcriptPath
         };
       }
-      const buf = Buffer.alloc(stat.size - cursor.byteOffset);
+      const buf = Buffer.alloc(stat2.size - cursor.byteOffset);
       await fh.read(buf, 0, buf.length, cursor.byteOffset);
       content = buf.toString("utf-8");
     } finally {
@@ -17111,7 +17594,7 @@ async function readNewTranscriptEntries(transcriptPath, sessionId, sessionStore)
   for (let i = 0; i < allLines.length; i++) {
     const line = allLines[i];
     const lineBytes = Buffer.byteLength(line, "utf-8") + (i < allLines.length - 1 ? 1 : 0);
-    if (parsed.length >= MAX_ENTRIES_PER_INVOCATION) break;
+    if (parsed.length >= maxEntries) break;
     bytesConsumed += lineBytes;
     if (line.trim().length === 0) continue;
     try {
@@ -17129,7 +17612,7 @@ async function readNewTranscriptEntries(transcriptPath, sessionId, sessionStore)
     parsedLineIndex++;
   }
   const endByteOffset = startOffset + bytesConsumed;
-  const capped = parsed.length >= MAX_ENTRIES_PER_INVOCATION;
+  const capped = parsed.length >= maxEntries;
   if (malformedLines > 0) {
     hookLog.warn(
       { data: { malformedLines, transcriptPath } },
@@ -17142,10 +17625,11 @@ async function readNewTranscriptEntries(transcriptPath, sessionId, sessionStore)
         data: {
           sessionId,
           entriesParsed: parsed.length,
-          totalLines: allLines.length
+          totalLines: allLines.length,
+          maxEntries
         }
       },
-      "Capped at MAX_ENTRIES_PER_INVOCATION, remaining entries deferred"
+      "Capped at maxEntries, remaining entries deferred"
     );
   } else if (!cursor) {
     hookLog.info(
@@ -17225,14 +17709,13 @@ function filterEntries(entries) {
   });
   return { filtered, filteredOut: entries.length - filtered.length };
 }
-async function cleanupStaleSessions(sessionStore) {
+async function cleanupStaleSessions(configDir) {
   const lastCleanup = configStore.get("claudeCode.lastCleanupAt");
   if (lastCleanup && Date.now() - lastCleanup < CLEANUP_INTERVAL_MS) {
     return;
   }
   const now = Date.now();
   const prefix = getSessionFilePrefix();
-  const configDir = path14.dirname(sessionStore.path);
   try {
     const files = await readdir(configDir);
     let deletedCount = 0;
@@ -17242,8 +17725,6 @@ async function cleanupStaleSessions(sessionStore) {
       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)) {
@@ -17265,157 +17746,7 @@ async function cleanupStaleSessions(sessionStore) {
   }
   configStore.set("claudeCode.lastCleanupAt", now);
 }
-async function processAndUploadTranscriptEntries() {
-  hookLog.info("Hook invoked");
-  const globalLastRun = configStore.get("claudeCode.globalLastHookRunAt");
-  const globalNow = Date.now();
-  if (globalLastRun && globalNow - globalLastRun < GLOBAL_COOLDOWN_MS) {
-    return { entriesUploaded: 0, entriesSkipped: 0, errors: 0 };
-  }
-  configStore.set("claudeCode.globalLastHookRunAt", globalNow);
-  const lastUpgradeVersion = configStore.get(
-    "claudeCode.matcherUpgradeVersion"
-  );
-  if (lastUpgradeVersion !== packageJson.version) {
-    const upgraded = await autoUpgradeMatcherIfStale();
-    configStore.set("claudeCode.matcherUpgradeVersion", packageJson.version);
-    if (upgraded) {
-      hookLog.info("Auto-upgraded hook matcher to reduce CPU usage");
-    }
-  }
-  try {
-    const ccVersion = await detectClaudeCodeVersion();
-    setClaudeCodeVersion(ccVersion);
-  } catch {
-  }
-  const rawData = await readStdinData();
-  const rawObj = rawData;
-  const hookData = (() => {
-    try {
-      return validateHookData(rawData);
-    } catch (err) {
-      hookLog.error(
-        {
-          data: {
-            hook_event_name: rawObj?.["hook_event_name"],
-            tool_name: rawObj?.["tool_name"],
-            session_id: rawObj?.["session_id"],
-            cwd: rawObj?.["cwd"],
-            keys: rawObj ? Object.keys(rawObj) : []
-          }
-        },
-        `Hook validation failed: ${err.message?.slice(0, 200)}`
-      );
-      throw err;
-    }
-  })();
-  if (!hookData.transcript_path) {
-    hookLog.warn(
-      {
-        data: {
-          hook_event_name: hookData.hook_event_name,
-          tool_name: hookData.tool_name,
-          session_id: hookData.session_id,
-          cwd: hookData.cwd
-        }
-      },
-      "Missing transcript_path \u2014 cannot process hook"
-    );
-    return { entriesUploaded: 0, entriesSkipped: 0, errors: 0 };
-  }
-  let sessionId = hookData.session_id;
-  if (!sessionId) {
-    sessionId = await extractSessionIdFromTranscript(hookData.transcript_path);
-    if (sessionId) {
-      hookLog.warn(
-        {
-          data: {
-            hook_event_name: hookData.hook_event_name,
-            tool_name: hookData.tool_name,
-            cwd: hookData.cwd,
-            extractedSessionId: sessionId
-          }
-        },
-        "Missing session_id in hook data \u2014 extracted from transcript"
-      );
-    } else {
-      hookLog.warn(
-        {
-          data: {
-            hook_event_name: hookData.hook_event_name,
-            tool_name: hookData.tool_name,
-            transcript_path: hookData.transcript_path
-          }
-        },
-        "Missing session_id and could not extract from transcript \u2014 cannot process hook"
-      );
-      return { entriesUploaded: 0, entriesSkipped: 0, errors: 0 };
-    }
-  }
-  if (!hookData.cwd) {
-    hookLog.warn(
-      {
-        data: {
-          hook_event_name: hookData.hook_event_name,
-          tool_name: hookData.tool_name,
-          session_id: sessionId
-        }
-      },
-      "Missing cwd in hook data \u2014 scoped logging and repo URL detection disabled"
-    );
-  }
-  const resolvedHookData = {
-    ...hookData,
-    session_id: sessionId,
-    transcript_path: hookData.transcript_path,
-    cwd: hookData.cwd ?? void 0
-  };
-  const sessionStore = createSessionConfigStore(resolvedHookData.session_id);
-  await cleanupStaleSessions(sessionStore);
-  const now = Date.now();
-  const lastRunAt = sessionStore.get(COOLDOWN_KEY);
-  if (lastRunAt && now - lastRunAt < HOOK_COOLDOWN_MS) {
-    return { entriesUploaded: 0, entriesSkipped: 0, errors: 0 };
-  }
-  const activeAt = sessionStore.get(ACTIVE_KEY);
-  if (activeAt && now - activeAt < ACTIVE_LOCK_TTL_MS) {
-    const activeDuration = now - activeAt;
-    if (activeDuration > HOOK_COOLDOWN_MS) {
-      hookLog.warn(
-        {
-          data: {
-            activeDurationMs: activeDuration,
-            sessionId: resolvedHookData.session_id
-          }
-        },
-        "Hook still active \u2014 possible slow upload or hung process"
-      );
-    }
-    return { entriesUploaded: 0, entriesSkipped: 0, errors: 0 };
-  }
-  sessionStore.set(ACTIVE_KEY, now);
-  sessionStore.set(COOLDOWN_KEY, now);
-  const log2 = createScopedHookLog(resolvedHookData.cwd ?? process.cwd());
-  log2.info(
-    {
-      data: {
-        sessionId: resolvedHookData.session_id,
-        toolName: resolvedHookData.tool_name,
-        hookEvent: resolvedHookData.hook_event_name,
-        cwd: resolvedHookData.cwd,
-        claudeCodeVersion: getClaudeCodeVersion()
-      }
-    },
-    "Hook data validated"
-  );
-  try {
-    return await processTranscript(resolvedHookData, sessionStore, log2);
-  } finally {
-    sessionStore.delete(ACTIVE_KEY);
-    log2.flushLogs();
-  }
-}
-async function processTranscript(hookData, sessionStore, log2) {
+async function processTranscript(input, sessionStore, log2, maxEntries = DAEMON_CHUNK_SIZE, gqlClientOverride) {
   const {
     entries: rawEntries,
     endByteOffset,
@@ -17423,9 +17754,10 @@ async function processTranscript(hookData, sessionStore, log2) {
   } = await log2.timed(
     "Read transcript",
     () => readNewTranscriptEntries(
-      hookData.transcript_path,
-      hookData.session_id,
-      sessionStore
+      input.transcript_path,
+      input.session_id,
+      sessionStore,
+      maxEntries
     )
   );
   const cursorKey = getCursorKey(resolvedTranscriptPath);
@@ -17458,30 +17790,26 @@ async function processTranscript(hookData, sessionStore, log2) {
     };
   }
   let gqlClient;
-  try {
-    gqlClient = await log2.timed(
-      "GQL auth",
-      () => withTimeout(
-        getAuthenticatedGQLClient({ isSkipPrompts: true }),
-        GQL_AUTH_TIMEOUT_MS,
-        "GQL auth"
-      )
-    );
-  } catch (err) {
-    log2.error(
-      {
-        data: {
-          error: String(err),
-          stack: err instanceof Error ? err.stack : void 0
-        }
-      },
-      "GQL auth failed"
-    );
-    return {
-      entriesUploaded: 0,
-      entriesSkipped: filteredOut,
-      errors: entries.length
-    };
+  if (gqlClientOverride) {
+    gqlClient = gqlClientOverride;
+  } else {
+    try {
+      gqlClient = await log2.timed(
+        "GQL auth",
+        () => withTimeout(
+          getAuthenticatedGQLClient({ isSkipPrompts: true }),
+          GQL_AUTH_TIMEOUT_MS,
+          "GQL auth"
+        )
+      );
+    } catch (err) {
+      log2.error({ err }, "GQL auth failed");
+      return {
+        entriesUploaded: 0,
+        entriesSkipped: filteredOut,
+        errors: entries.length
+      };
+    }
   }
   const cursorForModel = sessionStore.get(cursorKey);
   let lastSeenModel = cursorForModel?.lastModel ?? null;
@@ -17498,68 +17826,508 @@ async function processTranscript(hookData, sessionStore, log2) {
         rawEntry["message"] = { model: lastSeenModel };
       }
     }
-    if (!rawEntry["sessionId"]) {
-      rawEntry["sessionId"] = hookData.session_id;
+    if (!rawEntry["sessionId"]) {
+      rawEntry["sessionId"] = input.session_id;
+    }
+    return {
+      platform: "CLAUDE_CODE" /* ClaudeCode */,
+      recordId: _recordId,
+      recordTimestamp: entry.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+      blameType: "CHAT" /* Chat */,
+      rawData: rawEntry
+    };
+  });
+  const totalRawDataBytes = records.reduce((sum, r) => {
+    return sum + (r.rawData ? JSON.stringify(r.rawData).length : 0);
+  }, 0);
+  log2.info(
+    {
+      data: {
+        count: records.length,
+        skipped: filteredOut,
+        rawDataBytes: totalRawDataBytes,
+        firstRecordId: records[0]?.recordId,
+        lastRecordId: records[records.length - 1]?.recordId
+      }
+    },
+    "Uploading batch"
+  );
+  const sanitize = process.env["MOBBDEV_HOOK_SANITIZE"] === "1";
+  const result = await log2.timed(
+    "Batch upload",
+    () => prepareAndSendTracyRecords(gqlClient, records, input.cwd, {
+      sanitize
+    })
+  );
+  if (result.ok) {
+    const lastRawEntry = rawEntries[rawEntries.length - 1];
+    const cursor = {
+      id: lastRawEntry._recordId,
+      byteOffset: endByteOffset,
+      updatedAt: Date.now(),
+      lastModel: lastSeenModel ?? void 0
+    };
+    sessionStore.set(cursorKey, cursor);
+    log2.heartbeat("Upload ok", {
+      entriesUploaded: entries.length,
+      entriesSkipped: filteredOut,
+      claudeCodeVersion: getClaudeCodeVersion()
+    });
+    return {
+      entriesUploaded: entries.length,
+      entriesSkipped: filteredOut,
+      errors: 0
+    };
+  }
+  log2.error(
+    { data: { errors: result.errors, recordCount: entries.length } },
+    "Batch upload had errors"
+  );
+  return {
+    entriesUploaded: 0,
+    entriesSkipped: filteredOut,
+    errors: entries.length
+  };
+}
+
+// src/features/claude_code/install_hook.ts
+import fs14 from "fs";
+import fsPromises4 from "fs/promises";
+import os6 from "os";
+import path15 from "path";
+import chalk11 from "chalk";
+
+// src/features/claude_code/daemon-check-shim.tmpl.js
+var daemon_check_shim_tmpl_default = "// Mobb daemon shim \u2014 checks if daemon is alive, spawns if dead.\n// Auto-generated by mobbdev CLI. Do not edit.\nvar fs = require('fs')\nvar spawn = require('child_process').spawn\nvar path = require('path')\nvar os = require('os')\n\nvar pidFile = path.join(os.homedir(), '.mobbdev', 'daemon.pid')\nvar HEARTBEAT_STALE_MS = __HEARTBEAT_STALE_MS__\n\ntry {\n  var data = JSON.parse(fs.readFileSync(pidFile, 'utf8'))\n  if (Date.now() - data.heartbeat > HEARTBEAT_STALE_MS) throw new Error('stale')\n  process.kill(data.pid, 0) // throws ESRCH if the process is gone\n} catch (e) {\n  var localCli = process.env.MOBBDEV_LOCAL_CLI\n  var child = localCli\n    ? spawn('node', [localCli, 'claude-code-daemon'], { detached: true, stdio: 'ignore', windowsHide: true })\n    : spawn('npx', ['--yes', 'mobbdev@latest', 'claude-code-daemon'], { detached: true, stdio: 'ignore', shell: true, windowsHide: true })\n  child.unref()\n}\n";
+
+// src/features/claude_code/install_hook.ts
+var CLAUDE_SETTINGS_PATH = path15.join(os6.homedir(), ".claude", "settings.json");
+var RECOMMENDED_MATCHER = "*";
+async function claudeSettingsExists() {
+  try {
+    await fsPromises4.access(CLAUDE_SETTINGS_PATH);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readClaudeSettings() {
+  const settingsContent = await fsPromises4.readFile(
+    CLAUDE_SETTINGS_PATH,
+    "utf-8"
+  );
+  return JSON.parse(settingsContent);
+}
+async function writeClaudeSettings(settings) {
+  await fsPromises4.writeFile(
+    CLAUDE_SETTINGS_PATH,
+    JSON.stringify(settings, null, 2),
+    "utf-8"
+  );
+}
+function isMobbHookCommand(command) {
+  if (!command) return false;
+  return command.includes("mobbdev@latest") || command.includes("/.mobbdev/") || command.includes("\\.mobbdev\\");
+}
+function getDaemonCheckScript() {
+  return daemon_check_shim_tmpl_default.replace(
+    "__HEARTBEAT_STALE_MS__",
+    String(HEARTBEAT_STALE_MS)
+  );
+}
+function writeDaemonCheckScript() {
+  fs14.mkdirSync(getMobbdevDir(), { recursive: true });
+  fs14.writeFileSync(getDaemonCheckScriptPath(), getDaemonCheckScript(), "utf8");
+}
+function buildHookCommand(envPrefix) {
+  const nodeBin = process.execPath || "node";
+  const base = `${nodeBin} ${getDaemonCheckScriptPath()}`;
+  return envPrefix ? `${envPrefix} ${base}` : base;
+}
+async function autoUpgradeMatcherIfStale() {
+  try {
+    if (!await claudeSettingsExists()) return false;
+    const settings = await readClaudeSettings();
+    const hooks = settings.hooks?.PostToolUse;
+    if (!hooks) return false;
+    let upgraded = false;
+    for (const hook of hooks) {
+      const isMobbHook = hook.hooks.some((h) => isMobbHookCommand(h.command));
+      if (!isMobbHook) continue;
+      if (hook.matcher !== RECOMMENDED_MATCHER) {
+        hook.matcher = RECOMMENDED_MATCHER;
+        upgraded = true;
+      }
+      for (const h of hook.hooks) {
+        if (h.command && !h.command.includes("daemon-check.js")) {
+          const envMatch = h.command.match(/^((?:\w+="[^"]*"\s*)+)/);
+          const envPrefix = envMatch?.[1]?.trim();
+          h.command = buildHookCommand(envPrefix);
+          upgraded = true;
+        }
+        if (!h.async) {
+          h.async = true;
+          upgraded = true;
+        }
+      }
+    }
+    if (upgraded) {
+      writeDaemonCheckScript();
+      await writeClaudeSettings(settings);
+    }
+    return upgraded;
+  } catch {
+    return false;
+  }
+}
+async function installMobbHooks(options = {}) {
+  console.log(chalk11.blue("Installing Mobb hooks in Claude Code settings..."));
+  if (!await claudeSettingsExists()) {
+    console.log(chalk11.red("\u274C Claude Code settings file not found"));
+    console.log(chalk11.yellow(`Expected location: ${CLAUDE_SETTINGS_PATH}`));
+    console.log(chalk11.yellow("Is Claude Code installed on your system?"));
+    console.log(chalk11.yellow("Please install Claude Code and try again."));
+    throw new Error(
+      "Claude Code settings file not found. Is Claude Code installed?"
+    );
+  }
+  writeDaemonCheckScript();
+  const settings = await readClaudeSettings();
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  if (!settings.hooks.PostToolUse) {
+    settings.hooks.PostToolUse = [];
+  }
+  let envPrefix;
+  if (options.saveEnv) {
+    const envVars = [];
+    if (process.env["WEB_APP_URL"]) {
+      envVars.push(`WEB_APP_URL="${process.env["WEB_APP_URL"]}"`);
+    }
+    if (process.env["API_URL"]) {
+      envVars.push(`API_URL="${process.env["API_URL"]}"`);
+    }
+    if (envVars.length > 0) {
+      envPrefix = envVars.join(" ");
+      console.log(
+        chalk11.blue(
+          `Adding environment variables to hook command: ${envVars.join(", ")}`
+        )
+      );
+    }
+  }
+  const command = buildHookCommand(envPrefix);
+  const mobbHookConfig = {
+    matcher: RECOMMENDED_MATCHER,
+    hooks: [
+      {
+        type: "command",
+        command,
+        async: true
+      }
+    ]
+  };
+  const existingHookIndex = settings.hooks.PostToolUse.findIndex(
+    (hook) => hook.hooks.some((h) => isMobbHookCommand(h.command))
+  );
+  if (existingHookIndex >= 0) {
+    console.log(chalk11.yellow("Mobb hook already exists, updating..."));
+    settings.hooks.PostToolUse[existingHookIndex] = mobbHookConfig;
+  } else {
+    console.log(chalk11.green("Adding new Mobb hook..."));
+    settings.hooks.PostToolUse.push(mobbHookConfig);
+  }
+  await writeClaudeSettings(settings);
+  console.log(
+    chalk11.green(
+      `\u2705 Mobb hooks ${options.saveEnv ? "and environment variables " : ""}installed successfully in ${CLAUDE_SETTINGS_PATH}`
+    )
+  );
+}
+
+// src/features/claude_code/transcript_scanner.ts
+import { open as open5, readdir as readdir2, stat } from "fs/promises";
+import os7 from "os";
+import path16 from "path";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function getClaudeProjectsDirs() {
+  const dirs = [];
+  const configDir = process.env["CLAUDE_CONFIG_DIR"];
+  if (configDir) {
+    dirs.push(path16.join(configDir, "projects"));
+  }
+  dirs.push(path16.join(os7.homedir(), ".config", "claude", "projects"));
+  dirs.push(path16.join(os7.homedir(), ".claude", "projects"));
+  return dirs;
+}
+async function collectJsonlFiles(files, dir, projectDir, seen, now, results) {
+  for (const file of files) {
+    if (!file.endsWith(".jsonl")) continue;
+    const sessionId = file.replace(".jsonl", "");
+    if (!UUID_RE.test(sessionId)) continue;
+    const filePath = path16.join(dir, file);
+    if (seen.has(filePath)) continue;
+    seen.add(filePath);
+    let fileStat;
+    try {
+      fileStat = await stat(filePath);
+    } catch {
+      continue;
+    }
+    if (now - fileStat.mtimeMs > TRANSCRIPT_MAX_AGE_MS) continue;
+    results.push({
+      filePath,
+      sessionId,
+      projectDir,
+      mtimeMs: fileStat.mtimeMs,
+      size: fileStat.size
+    });
+  }
+}
+async function scanForTranscripts(projectsDirs = getClaudeProjectsDirs()) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const now = Date.now();
+  for (const projectsDir of projectsDirs) {
+    let projectDirs;
+    try {
+      projectDirs = await readdir2(projectsDir);
+    } catch {
+      continue;
+    }
+    for (const projName of projectDirs) {
+      const projPath = path16.join(projectsDir, projName);
+      let projStat;
+      try {
+        projStat = await stat(projPath);
+      } catch {
+        continue;
+      }
+      if (!projStat.isDirectory()) continue;
+      let files;
+      try {
+        files = await readdir2(projPath);
+      } catch {
+        continue;
+      }
+      await collectJsonlFiles(files, projPath, projPath, seen, now, results);
+      for (const entry of files) {
+        if (!UUID_RE.test(entry)) continue;
+        const subagentsDir = path16.join(projPath, entry, "subagents");
+        try {
+          const s = await stat(subagentsDir);
+          if (!s.isDirectory()) continue;
+          const subFiles = await readdir2(subagentsDir);
+          await collectJsonlFiles(
+            subFiles,
+            subagentsDir,
+            projPath,
+            seen,
+            now,
+            results
+          );
+        } catch {
+        }
+      }
+    }
+  }
+  return results;
+}
+var CWD_READ_BYTES = 8192;
+var cwdCache = /* @__PURE__ */ new Map();
+async function extractCwdFromTranscript(filePath) {
+  const cached = cwdCache.get(filePath);
+  if (cached !== void 0) return cached;
+  try {
+    const fh = await open5(filePath, "r");
+    try {
+      const buf = Buffer.alloc(CWD_READ_BYTES);
+      const { bytesRead } = await fh.read(buf, 0, CWD_READ_BYTES, 0);
+      const text = buf.toString("utf8", 0, bytesRead);
+      const lines = text.split("\n");
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const entry = JSON.parse(line);
+          if (typeof entry.cwd === "string") {
+            cwdCache.set(filePath, entry.cwd);
+            return entry.cwd;
+          }
+        } catch {
+        }
+      }
+    } finally {
+      await fh.close();
+    }
+  } catch {
+  }
+  return void 0;
+}
+
+// src/features/claude_code/daemon.ts
+async function startDaemon() {
+  hookLog.info("Daemon starting");
+  const pidFile = await acquirePidFile();
+  async function gracefulExit(code, reason) {
+    hookLog.info({ data: { code } }, `Daemon exiting: ${reason}`);
+    pidFile.remove();
+    await flushDdLogs();
+    process.exit(code);
+  }
+  let shuttingDown = false;
+  process.once("SIGTERM", () => {
+    shuttingDown = true;
+  });
+  process.once("SIGINT", () => {
+    shuttingDown = true;
+  });
+  process.on("uncaughtException", (err) => {
+    hookLog.error({ err }, "Daemon uncaughtException");
+    void gracefulExit(1, "uncaughtException");
+  });
+  process.on("unhandledRejection", (reason) => {
+    hookLog.error({ err: reason }, "Daemon unhandledRejection");
+    void gracefulExit(1, "unhandledRejection");
+  });
+  await tryAutoUpgradeHooks();
+  writeDaemonCheckScript();
+  try {
+    const ccVersion = await detectClaudeCodeVersion();
+    setClaudeCodeVersion(ccVersion);
+  } catch {
+  }
+  const gqlClient = await authenticateOrExit(gracefulExit);
+  const startedAt = Date.now();
+  const lastSeen = /* @__PURE__ */ new Map();
+  let cleanupConfigDir;
+  while (true) {
+    if (shuttingDown) {
+      await gracefulExit(0, "signal");
+    }
+    if (Date.now() - startedAt >= DAEMON_TTL_MS) {
+      await gracefulExit(0, "TTL reached");
+    }
+    pidFile.updateHeartbeat();
+    try {
+      const changed = await detectChangedTranscripts(lastSeen);
+      for (const transcript of changed) {
+        const sessionStore = createSessionConfigStore(transcript.sessionId);
+        if (!cleanupConfigDir) {
+          cleanupConfigDir = path17.dirname(sessionStore.path);
+        }
+        await drainTranscript(transcript, sessionStore, gqlClient);
+      }
+      if (cleanupConfigDir) {
+        await cleanupStaleSessions(cleanupConfigDir);
+      }
+    } catch (err) {
+      hookLog.warn({ err }, "Unexpected error in daemon cycle");
     }
-    return {
-      platform: "CLAUDE_CODE" /* ClaudeCode */,
-      recordId: _recordId,
-      recordTimestamp: entry.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
-      blameType: "CHAT" /* Chat */,
-      rawData: rawEntry
-    };
+    await sleep2(DAEMON_POLL_INTERVAL_MS);
+  }
+}
+async function acquirePidFile() {
+  const pidFile = new DaemonPidFile();
+  pidFile.ensureDir();
+  pidFile.read();
+  if (pidFile.isAlive()) {
+    hookLog.info(
+      { data: { existingPid: pidFile.data?.pid } },
+      "Another daemon is alive, exiting"
+    );
+    await flushDdLogs();
+    process.exit(0);
+  }
+  pidFile.write(process.pid, packageJson.version);
+  hookLog.info({ data: { pid: process.pid } }, "Daemon PID file written");
+  return pidFile;
+}
+async function authenticateOrExit(exit) {
+  try {
+    const client = await withTimeout(
+      getAuthenticatedGQLClient({ isSkipPrompts: true }),
+      GQL_AUTH_TIMEOUT_MS,
+      "GQL auth"
+    );
+    hookLog.info("Daemon authenticated");
+    return client;
+  } catch (err) {
+    hookLog.error({ err }, "Daemon auth failed");
+    return exit(1, "auth failed");
+  }
+}
+async function drainTranscript(transcript, sessionStore, gqlClient) {
+  const cwd = await extractCwdFromTranscript(transcript.filePath);
+  const log2 = createScopedHookLog(cwd ?? transcript.projectDir, {
+    daemonMode: true
   });
-  const totalRawDataBytes = records.reduce((sum, r) => {
-    return sum + (r.rawData ? JSON.stringify(r.rawData).length : 0);
-  }, 0);
-  log2.info(
-    {
-      data: {
-        count: records.length,
-        skipped: filteredOut,
-        rawDataBytes: totalRawDataBytes,
-        firstRecordId: records[0]?.recordId,
-        lastRecordId: records[records.length - 1]?.recordId
+  try {
+    let hasMore = true;
+    while (hasMore) {
+      const result = await processTranscript(
+        {
+          session_id: transcript.sessionId,
+          transcript_path: transcript.filePath,
+          cwd
+        },
+        sessionStore,
+        log2,
+        DAEMON_CHUNK_SIZE,
+        gqlClient
+      );
+      hasMore = result.entriesUploaded + result.entriesSkipped >= DAEMON_CHUNK_SIZE;
+      if (result.errors > 0) {
+        hookLog.warn(
+          {
+            data: {
+              sessionId: transcript.sessionId,
+              errors: result.errors
+            }
+          },
+          "Upload error \u2014 will retry next cycle"
+        );
+        break;
       }
-    },
-    "Uploading batch"
-  );
-  const sanitize = process.env["MOBBDEV_HOOK_SANITIZE"] === "1";
-  const result = await log2.timed(
-    "Batch upload",
-    () => prepareAndSendTracyRecords(gqlClient, records, hookData.cwd, {
-      sanitize
-    })
-  );
-  if (result.ok) {
-    const lastRawEntry = rawEntries[rawEntries.length - 1];
-    const cursor = {
-      id: lastRawEntry._recordId,
-      byteOffset: endByteOffset,
-      updatedAt: Date.now(),
-      lastModel: lastSeenModel ?? void 0
-    };
-    sessionStore.set(cursorKey, cursor);
-    log2.heartbeat("Upload ok", {
-      entriesUploaded: entries.length,
-      entriesSkipped: filteredOut,
-      claudeCodeVersion: getClaudeCodeVersion()
-    });
-    return {
-      entriesUploaded: entries.length,
-      entriesSkipped: filteredOut,
-      errors: 0
-    };
+    }
+  } catch (err) {
+    hookLog.warn(
+      { err, data: { sessionId: transcript.sessionId } },
+      "Error processing transcript \u2014 skipping"
+    );
   }
-  log2.error(
-    { data: { errors: result.errors, recordCount: entries.length } },
-    "Batch upload had errors"
+}
+async function detectChangedTranscripts(lastSeen) {
+  const transcripts = await scanForTranscripts();
+  const changed = [];
+  const currentPaths = /* @__PURE__ */ new Set();
+  for (const t of transcripts) {
+    currentPaths.add(t.filePath);
+    const prev = lastSeen.get(t.filePath);
+    if (!prev || t.mtimeMs > prev.mtimeMs || t.size > prev.size) {
+      changed.push(t);
+    }
+    lastSeen.set(t.filePath, { mtimeMs: t.mtimeMs, size: t.size });
+  }
+  for (const p of lastSeen.keys()) {
+    if (!currentPaths.has(p)) lastSeen.delete(p);
+  }
+  return changed;
+}
+async function tryAutoUpgradeHooks() {
+  const lastUpgradeVersion = configStore.get(
+    "claudeCode.matcherUpgradeVersion"
   );
-  return {
-    entriesUploaded: 0,
-    entriesSkipped: filteredOut,
-    errors: entries.length
-  };
+  if (lastUpgradeVersion === packageJson.version) return;
+  try {
+    const upgraded = await autoUpgradeMatcherIfStale();
+    configStore.set("claudeCode.matcherUpgradeVersion", packageJson.version);
+    if (upgraded) {
+      hookLog.info("Auto-upgraded hook matcher");
+    }
+  } catch (err) {
+    hookLog.warn({ err }, "Failed to auto-upgrade hook matcher");
+  }
 }
 
 // src/args/commands/claude_code.ts
@@ -17579,7 +18347,13 @@ var claudeCodeInstallHookBuilder = (yargs2) => {
 var claudeCodeProcessHookBuilder = (yargs2) => {
   return yargs2.example(
     "$0 claude-code-process-hook",
-    "Process Claude Code hook data and upload to backend"
+    "Process Claude Code hook data (legacy \u2014 spawns daemon)"
+  ).strict();
+};
+var claudeCodeDaemonBuilder = (yargs2) => {
+  return yargs2.example(
+    "$0 claude-code-daemon",
+    "Run the background daemon that processes Claude Code transcripts"
   ).strict();
 };
 var claudeCodeInstallHookHandler = async (argv) => {
@@ -17593,69 +18367,43 @@ var claudeCodeInstallHookHandler = async (argv) => {
   }
 };
 var claudeCodeProcessHookHandler = async () => {
-  const startupMs = Math.round(process.uptime() * 1e3);
-  const debugMode = process.env["MOBBDEV_HOOK_DEBUG"] === "1";
-  async function flushAndExit(code) {
-    try {
-      flushLogs();
-      await flushDdLogs();
-    } catch {
-    } finally {
-      process.exit(debugMode ? code : 0);
+  try {
+    await autoUpgradeMatcherIfStale();
+    writeDaemonCheckScript();
+    const pidFile = new DaemonPidFile();
+    pidFile.read();
+    if (!pidFile.isAlive()) {
+      hookLog.info("Daemon not alive \u2014 spawning");
+      const localCli = process.env["MOBBDEV_LOCAL_CLI"];
+      const child = localCli ? spawn("node", [localCli, "claude-code-daemon"], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true
+      }) : spawn("npx", ["--yes", "mobbdev@latest", "claude-code-daemon"], {
+        detached: true,
+        stdio: "ignore",
+        shell: true,
+        windowsHide: true
+      });
+      child.unref();
     }
+  } catch (err) {
+    hookLog.error({ err }, "Error in process-hook shim");
   }
-  process.on("uncaughtException", (error) => {
-    hookLog.error(
-      { data: { error: String(error), stack: error.stack } },
-      "Uncaught exception in hook"
-    );
-    void flushAndExit(1);
-  });
-  process.on("unhandledRejection", (reason) => {
-    hookLog.error(
-      {
-        data: {
-          error: String(reason),
-          stack: reason instanceof Error ? reason.stack : void 0
-        }
-      },
-      "Unhandled rejection in hook"
-    );
-    void flushAndExit(1);
-  });
-  let exitCode = 0;
-  const hookStart = Date.now();
   try {
-    const result = await processAndUploadTranscriptEntries();
-    if (result.errors > 0) {
-      exitCode = 1;
-    }
-    hookLog.info(
-      {
-        data: {
-          entriesUploaded: result.entriesUploaded,
-          entriesSkipped: result.entriesSkipped,
-          errors: result.errors,
-          startupMs,
-          durationMs: Date.now() - hookStart
-        }
-      },
-      "Claude Code upload complete"
-    );
-  } catch (error) {
-    exitCode = 1;
-    hookLog.error(
-      {
-        data: {
-          error: String(error),
-          stack: error instanceof Error ? error.stack : void 0,
-          durationMs: Date.now() - hookStart
-        }
-      },
-      "Failed to process Claude Code hook"
-    );
+    await flushDdLogs();
+  } catch {
+  }
+  process.exit(0);
+};
+var claudeCodeDaemonHandler = async () => {
+  try {
+    await startDaemon();
+  } catch (err) {
+    hookLog.error({ err }, "Daemon crashed");
+    await flushDdLogs();
+    process.exit(1);
   }
-  await flushAndExit(exitCode);
 };
 
 // src/mcp/core/McpServer.ts
@@ -17677,8 +18425,8 @@ var WorkspaceService = class {
    * Sets a known workspace path that was discovered through successful validation
    * @param path The validated workspace path to store
    */
-  static setKnownWorkspacePath(path27) {
-    this.knownWorkspacePath = path27;
+  static setKnownWorkspacePath(path30) {
+    this.knownWorkspacePath = path30;
   }
   /**
    * Gets the known workspace path that was previously validated
@@ -17825,131 +18573,131 @@ init_configs();
 
 // src/mcp/types.ts
 init_client_generates();
-import { z as z34 } from "zod";
-var ScanAndFixVulnerabilitiesToolSchema = z34.object({
-  path: z34.string()
+import { z as z33 } from "zod";
+var ScanAndFixVulnerabilitiesToolSchema = z33.object({
+  path: z33.string()
 });
-var VulnerabilityReportIssueTagSchema = z34.object({
-  vulnerability_report_issue_tag_value: z34.nativeEnum(
+var VulnerabilityReportIssueTagSchema = z33.object({
+  vulnerability_report_issue_tag_value: z33.nativeEnum(
     Vulnerability_Report_Issue_Tag_Enum
   )
 });
-var VulnerabilityReportIssueSchema = z34.object({
-  category: z34.any().optional().nullable(),
-  parsedIssueType: z34.nativeEnum(IssueType_Enum).nullable().optional(),
-  parsedSeverity: z34.nativeEnum(Vulnerability_Severity_Enum).nullable().optional(),
-  vulnerabilityReportIssueTags: z34.array(VulnerabilityReportIssueTagSchema)
+var VulnerabilityReportIssueSchema = z33.object({
+  category: z33.any().optional().nullable(),
+  parsedIssueType: z33.nativeEnum(IssueType_Enum).nullable().optional(),
+  parsedSeverity: z33.nativeEnum(Vulnerability_Severity_Enum).nullable().optional(),
+  vulnerabilityReportIssueTags: z33.array(VulnerabilityReportIssueTagSchema)
 });
-var SharedStateSchema = z34.object({
-  __typename: z34.literal("fix_shared_state").optional(),
-  id: z34.any(),
+var SharedStateSchema = z33.object({
+  __typename: z33.literal("fix_shared_state").optional(),
+  id: z33.any(),
   // GraphQL uses `any` type for UUID
-  downloadedBy: z34.array(z34.any().nullable()).optional().nullable()
+  downloadedBy: z33.array(z33.any().nullable()).optional().nullable()
 });
-var UnstructuredFixExtraContextSchema = z34.object({
-  __typename: z34.literal("UnstructuredFixExtraContext").optional(),
-  key: z34.string(),
-  value: z34.any()
+var UnstructuredFixExtraContextSchema = z33.object({
+  __typename: z33.literal("UnstructuredFixExtraContext").optional(),
+  key: z33.string(),
+  value: z33.any()
   // GraphQL JSON type
 });
-var FixExtraContextResponseSchema = z34.object({
-  __typename: z34.literal("FixExtraContextResponse").optional(),
-  extraContext: z34.array(UnstructuredFixExtraContextSchema),
-  fixDescription: z34.string()
+var FixExtraContextResponseSchema = z33.object({
+  __typename: z33.literal("FixExtraContextResponse").optional(),
+  extraContext: z33.array(UnstructuredFixExtraContextSchema),
+  fixDescription: z33.string()
 });
-var FixDataSchema = z34.object({
-  __typename: z34.literal("FixData"),
-  patch: z34.string(),
-  patchOriginalEncodingBase64: z34.string(),
+var FixDataSchema = z33.object({
+  __typename: z33.literal("FixData"),
+  patch: z33.string(),
+  patchOriginalEncodingBase64: z33.string(),
   extraContext: FixExtraContextResponseSchema
 });
-var GetFixNoFixErrorSchema = z34.object({
-  __typename: z34.literal("GetFixNoFixError")
+var GetFixNoFixErrorSchema = z33.object({
+  __typename: z33.literal("GetFixNoFixError")
 });
-var PatchAndQuestionsSchema = z34.union([FixDataSchema, GetFixNoFixErrorSchema]);
-var McpFixSchema = z34.object({
-  __typename: z34.literal("fix").optional(),
-  id: z34.any(),
+var PatchAndQuestionsSchema = z33.union([FixDataSchema, GetFixNoFixErrorSchema]);
+var McpFixSchema = z33.object({
+  __typename: z33.literal("fix").optional(),
+  id: z33.any(),
   // GraphQL uses `any` type for UUID
-  confidence: z34.number(),
-  safeIssueType: z34.string().nullable(),
-  severityText: z34.string().nullable(),
-  gitBlameLogin: z34.string().nullable().optional(),
+  confidence: z33.number(),
+  safeIssueType: z33.string().nullable(),
+  severityText: z33.string().nullable(),
+  gitBlameLogin: z33.string().nullable().optional(),
   // Optional in GraphQL
-  severityValue: z34.number().nullable(),
-  vulnerabilityReportIssues: z34.array(VulnerabilityReportIssueSchema),
+  severityValue: z33.number().nullable(),
+  vulnerabilityReportIssues: z33.array(VulnerabilityReportIssueSchema),
   sharedState: SharedStateSchema.nullable().optional(),
   // Optional in GraphQL
   patchAndQuestions: PatchAndQuestionsSchema,
   // Additional field added by the client
-  fixUrl: z34.string().optional()
+  fixUrl: z33.string().optional()
 });
-var FixAggregateSchema = z34.object({
-  __typename: z34.literal("fix_aggregate").optional(),
-  aggregate: z34.object({
-    __typename: z34.literal("fix_aggregate_fields").optional(),
-    count: z34.number()
+var FixAggregateSchema = z33.object({
+  __typename: z33.literal("fix_aggregate").optional(),
+  aggregate: z33.object({
+    __typename: z33.literal("fix_aggregate_fields").optional(),
+    count: z33.number()
   }).nullable()
 });
-var VulnerabilityReportIssueAggregateSchema = z34.object({
-  __typename: z34.literal("vulnerability_report_issue_aggregate").optional(),
-  aggregate: z34.object({
-    __typename: z34.literal("vulnerability_report_issue_aggregate_fields").optional(),
-    count: z34.number()
+var VulnerabilityReportIssueAggregateSchema = z33.object({
+  __typename: z33.literal("vulnerability_report_issue_aggregate").optional(),
+  aggregate: z33.object({
+    __typename: z33.literal("vulnerability_report_issue_aggregate_fields").optional(),
+    count: z33.number()
   }).nullable()
 });
-var RepoSchema = z34.object({
-  __typename: z34.literal("repo").optional(),
-  originalUrl: z34.string()
+var RepoSchema = z33.object({
+  __typename: z33.literal("repo").optional(),
+  originalUrl: z33.string()
 });
-var ProjectSchema = z34.object({
-  id: z34.any(),
+var ProjectSchema = z33.object({
+  id: z33.any(),
   // GraphQL uses `any` type for UUID
-  organizationId: z34.any()
+  organizationId: z33.any()
   // GraphQL uses `any` type for UUID
 });
-var VulnerabilityReportSchema = z34.object({
-  scanDate: z34.any().nullable(),
+var VulnerabilityReportSchema = z33.object({
+  scanDate: z33.any().nullable(),
   // GraphQL uses `any` type for timestamp
-  vendor: z34.string(),
+  vendor: z33.string(),
   // GraphQL generates as string, not enum
-  projectId: z34.any().optional(),
+  projectId: z33.any().optional(),
   // GraphQL uses `any` type for UUID
   project: ProjectSchema,
   totalVulnerabilityReportIssuesCount: VulnerabilityReportIssueAggregateSchema,
   notFixableVulnerabilityReportIssuesCount: VulnerabilityReportIssueAggregateSchema
 });
-var FixReportSummarySchema = z34.object({
-  __typename: z34.literal("fixReport").optional(),
-  id: z34.any(),
+var FixReportSummarySchema = z33.object({
+  __typename: z33.literal("fixReport").optional(),
+  id: z33.any(),
   // GraphQL uses `any` type for UUID
-  createdOn: z34.any(),
+  createdOn: z33.any(),
   // GraphQL uses `any` type for timestamp
   repo: RepoSchema.nullable(),
-  issueTypes: z34.any().nullable(),
+  issueTypes: z33.any().nullable(),
   // GraphQL uses `any` type for JSON
   CRITICAL: FixAggregateSchema,
   HIGH: FixAggregateSchema,
   MEDIUM: FixAggregateSchema,
   LOW: FixAggregateSchema,
-  fixes: z34.array(McpFixSchema),
-  userFixes: z34.array(McpFixSchema).optional(),
+  fixes: z33.array(McpFixSchema),
+  userFixes: z33.array(McpFixSchema).optional(),
   // Present in some responses but can be omitted
   filteredFixesCount: FixAggregateSchema,
   totalFixesCount: FixAggregateSchema,
   vulnerabilityReport: VulnerabilityReportSchema
 });
-var ExpiredReportSchema = z34.object({
-  __typename: z34.literal("fixReport").optional(),
-  id: z34.any(),
+var ExpiredReportSchema = z33.object({
+  __typename: z33.literal("fixReport").optional(),
+  id: z33.any(),
   // GraphQL uses `any` type for UUID
-  expirationOn: z34.any().nullable()
+  expirationOn: z33.any().nullable()
   // GraphQL uses `any` type for timestamp
 });
-var GetLatestReportByRepoUrlResponseSchema = z34.object({
-  __typename: z34.literal("query_root").optional(),
-  fixReport: z34.array(FixReportSummarySchema),
-  expiredReport: z34.array(ExpiredReportSchema)
+var GetLatestReportByRepoUrlResponseSchema = z33.object({
+  __typename: z33.literal("query_root").optional(),
+  fixReport: z33.array(FixReportSummarySchema),
+  expiredReport: z33.array(ExpiredReportSchema)
 });
 
 // src/mcp/services/McpGQLClient.ts
@@ -18537,9 +19285,9 @@ async function createAuthenticatedMcpGQLClient({
 
 // src/mcp/services/McpUsageService/host.ts
 import { execSync as execSync2 } from "child_process";
-import fs13 from "fs";
-import os6 from "os";
-import path15 from "path";
+import fs15 from "fs";
+import os8 from "os";
+import path18 from "path";
 var IDEs = ["cursor", "windsurf", "webstorm", "vscode", "claude"];
 var runCommand = (cmd) => {
   try {
@@ -18553,18 +19301,18 @@ var gitInfo = {
   email: runCommand("git config user.email")
 };
 var getClaudeWorkspacePaths = () => {
-  const home = os6.homedir();
-  const claudeIdePath = path15.join(home, ".claude", "ide");
+  const home = os8.homedir();
+  const claudeIdePath = path18.join(home, ".claude", "ide");
   const workspacePaths = [];
-  if (!fs13.existsSync(claudeIdePath)) {
+  if (!fs15.existsSync(claudeIdePath)) {
     return workspacePaths;
   }
   try {
-    const lockFiles = fs13.readdirSync(claudeIdePath).filter((file) => file.endsWith(".lock"));
+    const lockFiles = fs15.readdirSync(claudeIdePath).filter((file) => file.endsWith(".lock"));
     for (const lockFile of lockFiles) {
-      const lockFilePath = path15.join(claudeIdePath, lockFile);
+      const lockFilePath = path18.join(claudeIdePath, lockFile);
       try {
-        const lockContent = JSON.parse(fs13.readFileSync(lockFilePath, "utf8"));
+        const lockContent = JSON.parse(fs15.readFileSync(lockFilePath, "utf8"));
         if (lockContent.workspaceFolders && Array.isArray(lockContent.workspaceFolders)) {
           workspacePaths.push(...lockContent.workspaceFolders);
         }
@@ -18582,29 +19330,29 @@ var getClaudeWorkspacePaths = () => {
   return workspacePaths;
 };
 var getMCPConfigPaths = (hostName) => {
-  const home = os6.homedir();
+  const home = os8.homedir();
   const currentDir = process.env["WORKSPACE_FOLDER_PATHS"] || process.env["PWD"] || process.cwd();
   switch (hostName.toLowerCase()) {
     case "cursor":
       return [
-        path15.join(currentDir, ".cursor", "mcp.json"),
+        path18.join(currentDir, ".cursor", "mcp.json"),
         // local first
-        path15.join(home, ".cursor", "mcp.json")
+        path18.join(home, ".cursor", "mcp.json")
       ];
     case "windsurf":
       return [
-        path15.join(currentDir, ".codeium", "mcp_config.json"),
+        path18.join(currentDir, ".codeium", "mcp_config.json"),
         // local first
-        path15.join(home, ".codeium", "windsurf", "mcp_config.json")
+        path18.join(home, ".codeium", "windsurf", "mcp_config.json")
       ];
     case "webstorm":
       return [];
     case "visualstudiocode":
     case "vscode":
       return [
-        path15.join(currentDir, ".vscode", "mcp.json"),
+        path18.join(currentDir, ".vscode", "mcp.json"),
         // local first
-        process.platform === "win32" ? path15.join(home, "AppData", "Roaming", "Code", "User", "mcp.json") : path15.join(
+        process.platform === "win32" ? path18.join(home, "AppData", "Roaming", "Code", "User", "mcp.json") : path18.join(
           home,
           "Library",
           "Application Support",
@@ -18615,13 +19363,13 @@ var getMCPConfigPaths = (hostName) => {
       ];
     case "claude": {
       const claudePaths = [
-        path15.join(currentDir, ".claude.json"),
+        path18.join(currentDir, ".claude.json"),
         // local first
-        path15.join(home, ".claude.json")
+        path18.join(home, ".claude.json")
       ];
       const workspacePaths = getClaudeWorkspacePaths();
       for (const workspacePath of workspacePaths) {
-        claudePaths.push(path15.join(workspacePath, ".mcp.json"));
+        claudePaths.push(path18.join(workspacePath, ".mcp.json"));
       }
       return claudePaths;
     }
@@ -18630,9 +19378,9 @@ var getMCPConfigPaths = (hostName) => {
   }
 };
 var readConfigFile = (filePath) => {
-  if (!fs13.existsSync(filePath)) return null;
+  if (!fs15.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs13.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs15.readFileSync(filePath, "utf8"));
   } catch (error) {
     logWarn(`[UsageService] Failed to read MCP config: ${filePath}`);
     return null;
@@ -18672,7 +19420,7 @@ var readMCPConfig = (hostName) => {
 };
 var getRunningProcesses = () => {
   try {
-    return os6.platform() === "win32" ? execSync2("tasklist", { encoding: "utf8" }) : execSync2("ps aux", { encoding: "utf8" });
+    return os8.platform() === "win32" ? execSync2("tasklist", { encoding: "utf8" }) : execSync2("ps aux", { encoding: "utf8" });
   } catch {
     return "";
   }
@@ -18747,7 +19495,7 @@ var versionCommands = {
   }
 };
 var getProcessInfo = (pid) => {
-  const platform2 = os6.platform();
+  const platform2 = os8.platform();
   try {
     if (platform2 === "linux" || platform2 === "darwin") {
       const output = execSync2(`ps -o pid=,ppid=,comm= -p ${pid}`, {
@@ -18782,10 +19530,10 @@ var getHostInfo = (additionalMcpList) => {
   const ideConfigPaths = /* @__PURE__ */ new Set();
   for (const ide of IDEs) {
     const configPaths = getMCPConfigPaths(ide);
-    configPaths.forEach((path27) => ideConfigPaths.add(path27));
+    configPaths.forEach((path30) => ideConfigPaths.add(path30));
   }
   const uniqueAdditionalPaths = additionalMcpList.filter(
-    (path27) => !ideConfigPaths.has(path27)
+    (path30) => !ideConfigPaths.has(path30)
   );
   for (const ide of IDEs) {
     const cfg = readMCPConfig(ide);
@@ -18866,7 +19614,7 @@ var getHostInfo = (additionalMcpList) => {
     const config2 = allConfigs[ide] || null;
     const ideName = ide.charAt(0).toUpperCase() + ide.slice(1) || "Unknown";
     let ideVersion = "Unknown";
-    const platform2 = os6.platform();
+    const platform2 = os8.platform();
     const cmds = versionCommands[ideName]?.[platform2] ?? [];
     for (const cmd of cmds) {
       try {
@@ -18899,15 +19647,15 @@ var getHostInfo = (additionalMcpList) => {
 
 // src/mcp/services/McpUsageService/McpUsageService.ts
 import fetch6 from "node-fetch";
-import os8 from "os";
+import os10 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 os7 from "os";
-import path16 from "path";
+import fs16 from "fs";
+import os9 from "os";
+import path19 from "path";
 var MAX_DEPTH = 2;
 var patterns = ["mcp", "claude"];
 var isFileMatch = (fileName) => {
@@ -18916,7 +19664,7 @@ var isFileMatch = (fileName) => {
 };
 var safeAccess = async (filePath) => {
   try {
-    await fs14.promises.access(filePath, fs14.constants.R_OK);
+    await fs16.promises.access(filePath, fs16.constants.R_OK);
     return true;
   } catch {
     return false;
@@ -18925,9 +19673,9 @@ var safeAccess = async (filePath) => {
 var searchDir = async (dir, depth = 0) => {
   const results = [];
   if (depth > MAX_DEPTH) return results;
-  const entries = await fs14.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs16.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
-    const fullPath = path16.join(dir, entry.name);
+    const fullPath = path19.join(dir, entry.name);
     if (entry.isFile() && isFileMatch(entry.name)) {
       results.push(fullPath);
     } else if (entry.isDirectory()) {
@@ -18941,17 +19689,17 @@ var searchDir = async (dir, depth = 0) => {
 };
 var findSystemMCPConfigs = async () => {
   try {
-    const home = os7.homedir();
-    const platform2 = os7.platform();
+    const home = os9.homedir();
+    const platform2 = os9.platform();
     const knownDirs = platform2 === "win32" ? [
-      path16.join(home, ".cursor"),
-      path16.join(home, "Documents"),
-      path16.join(home, "Downloads")
+      path19.join(home, ".cursor"),
+      path19.join(home, "Documents"),
+      path19.join(home, "Downloads")
     ] : [
-      path16.join(home, ".cursor"),
-      process.env["XDG_CONFIG_HOME"] || path16.join(home, ".config"),
-      path16.join(home, "Documents"),
-      path16.join(home, "Downloads")
+      path19.join(home, ".cursor"),
+      process.env["XDG_CONFIG_HOME"] || path19.join(home, ".config"),
+      path19.join(home, "Documents"),
+      path19.join(home, "Downloads")
     ];
     const timeoutPromise = new Promise(
       (resolve) => setTimeout(() => {
@@ -18963,7 +19711,7 @@ var findSystemMCPConfigs = async () => {
     );
     const searchPromise = Promise.all(
       knownDirs.map(
-        (dir) => fs14.existsSync(dir) ? searchDir(dir) : Promise.resolve([])
+        (dir) => fs16.existsSync(dir) ? searchDir(dir) : Promise.resolve([])
       )
     ).then((results) => results.flat());
     return await Promise.race([timeoutPromise, searchPromise]);
@@ -19014,7 +19762,7 @@ var McpUsageService = class {
   generateHostId() {
     const stored = configStore.get(this.configKey);
     if (stored?.mcpHostId) return stored.mcpHostId;
-    const interfaces = os8.networkInterfaces();
+    const interfaces = os10.networkInterfaces();
     const macs = [];
     for (const iface of Object.values(interfaces)) {
       if (!iface) continue;
@@ -19022,7 +19770,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(",") : `${os8.hostname()}-${uuidv42()}`;
+    const macString = macs.length ? macs.sort().join(",") : `${os10.hostname()}-${uuidv42()}`;
     const hostId = uuidv5(macString, uuidv5.DNS);
     logDebug("[UsageService] Generated new host ID", { hostId });
     return hostId;
@@ -19045,7 +19793,7 @@ var McpUsageService = class {
       mcpHostId,
       organizationId,
       mcpVersion: packageJson.version,
-      mcpOsName: os8.platform(),
+      mcpOsName: os10.platform(),
       mcps: JSON.stringify(mcps),
       status,
       userName: user.name,
@@ -19706,10 +20454,10 @@ var McpServer = class {
 };
 
 // src/mcp/prompts/CheckForNewVulnerabilitiesPrompt.ts
-import { z as z36 } from "zod";
+import { z as z35 } from "zod";
 
 // src/mcp/prompts/base/BasePrompt.ts
-import { z as z35 } from "zod";
+import { z as z34 } from "zod";
 var BasePrompt = class {
   getDefinition() {
     return {
@@ -19738,7 +20486,7 @@ var BasePrompt = class {
       const argsToValidate = args === void 0 ? {} : args;
       return this.argumentsValidationSchema.parse(argsToValidate);
     } catch (error) {
-      if (error instanceof z35.ZodError) {
+      if (error instanceof z34.ZodError) {
         const errorDetails = error.errors.map((e) => {
           const fieldPath = e.path.length > 0 ? e.path.join(".") : "root";
           const message = e.message === "Required" ? `Missing required argument '${fieldPath}'` : `Invalid value for '${fieldPath}': ${e.message}`;
@@ -19767,8 +20515,8 @@ var BasePrompt = class {
 };
 
 // src/mcp/prompts/CheckForNewVulnerabilitiesPrompt.ts
-var CheckForNewVulnerabilitiesArgsSchema = z36.object({
-  path: z36.string().optional()
+var CheckForNewVulnerabilitiesArgsSchema = z35.object({
+  path: z35.string().optional()
 });
 var CheckForNewVulnerabilitiesPrompt = class extends BasePrompt {
   constructor() {
@@ -20013,9 +20761,9 @@ Call the \`check_for_new_available_fixes\` tool now${args?.path ? ` for ${args.p
 };
 
 // src/mcp/prompts/FullSecurityAuditPrompt.ts
-import { z as z37 } from "zod";
-var FullSecurityAuditArgsSchema = z37.object({
-  path: z37.string().optional()
+import { z as z36 } from "zod";
+var FullSecurityAuditArgsSchema = z36.object({
+  path: z36.string().optional()
 });
 var FullSecurityAuditPrompt = class extends BasePrompt {
   constructor() {
@@ -20466,9 +21214,9 @@ Begin the audit now${args?.path ? ` for ${args.path}` : ""}.
 };
 
 // src/mcp/prompts/ReviewAndFixCriticalPrompt.ts
-import { z as z38 } from "zod";
-var ReviewAndFixCriticalArgsSchema = z38.object({
-  path: z38.string().optional()
+import { z as z37 } from "zod";
+var ReviewAndFixCriticalArgsSchema = z37.object({
+  path: z37.string().optional()
 });
 var ReviewAndFixCriticalPrompt = class extends BasePrompt {
   constructor() {
@@ -20772,9 +21520,9 @@ Start by scanning${args?.path ? ` ${args.path}` : " the repository"} and priorit
 };
 
 // src/mcp/prompts/ScanRecentChangesPrompt.ts
-import { z as z39 } from "zod";
-var ScanRecentChangesArgsSchema = z39.object({
-  path: z39.string().optional()
+import { z as z38 } from "zod";
+var ScanRecentChangesArgsSchema = z38.object({
+  path: z38.string().optional()
 });
 var ScanRecentChangesPrompt = class extends BasePrompt {
   constructor() {
@@ -20985,9 +21733,9 @@ You now have the guidance needed to perform a fast, targeted security scan of re
 };
 
 // src/mcp/prompts/ScanRepositoryPrompt.ts
-import { z as z40 } from "zod";
-var ScanRepositoryArgsSchema = z40.object({
-  path: z40.string().optional()
+import { z as z39 } from "zod";
+var ScanRepositoryArgsSchema = z39.object({
+  path: z39.string().optional()
 });
 var ScanRepositoryPrompt = class extends BasePrompt {
   constructor() {
@@ -21365,31 +22113,31 @@ 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 os10 from "os";
-import * as path18 from "path";
+import * as fs19 from "fs";
+import * as os12 from "os";
+import * as path21 from "path";
 
 // src/mcp/services/McpDetectionService/BaseMcpDetectionService.ts
 init_configs();
-import * as fs16 from "fs";
+import * as fs18 from "fs";
 import fetch7 from "node-fetch";
-import * as path17 from "path";
+import * as path20 from "path";
 
 // src/mcp/services/McpDetectionService/McpDetectionServiceUtils.ts
-import * as fs15 from "fs";
-import * as os9 from "os";
+import * as fs17 from "fs";
+import * as os11 from "os";
 
 // src/mcp/services/McpDetectionService/VscodeMcpDetectionService.ts
-import * as fs18 from "fs";
-import * as os11 from "os";
-import * as path19 from "path";
+import * as fs20 from "fs";
+import * as os13 from "os";
+import * as path22 from "path";
 
 // src/mcp/tools/checkForNewAvailableFixes/CheckForNewAvailableFixesTool.ts
-import { z as z43 } from "zod";
+import { z as z42 } from "zod";
 
 // src/mcp/services/PathValidation.ts
-import fs19 from "fs";
-import path20 from "path";
+import fs21 from "fs";
+import path23 from "path";
 async function validatePath(inputPath) {
   logDebug("Validating MCP path", { inputPath });
   if (/^\/[a-zA-Z]:\//.test(inputPath)) {
@@ -21421,7 +22169,7 @@ async function validatePath(inputPath) {
     logError(error);
     return { isValid: false, error, path: inputPath };
   }
-  const normalizedPath = path20.normalize(inputPath);
+  const normalizedPath = path23.normalize(inputPath);
   if (normalizedPath.includes("..")) {
     const error = `Normalized path contains path traversal patterns: ${inputPath}`;
     logError(error);
@@ -21448,7 +22196,7 @@ async function validatePath(inputPath) {
   logDebug("Path validation successful", { inputPath });
   logDebug("Checking path existence", { inputPath });
   try {
-    await fs19.promises.access(inputPath);
+    await fs21.promises.access(inputPath);
     logDebug("Path exists and is accessible", { inputPath });
     WorkspaceService.setKnownWorkspacePath(inputPath);
     logDebug("Stored validated path in WorkspaceService", { inputPath });
@@ -21461,7 +22209,7 @@ async function validatePath(inputPath) {
 }
 
 // src/mcp/tools/base/BaseTool.ts
-import { z as z41 } from "zod";
+import { z as z40 } from "zod";
 var BaseTool = class {
   getDefinition() {
     return {
@@ -21488,7 +22236,7 @@ var BaseTool = class {
     try {
       return this.inputValidationSchema.parse(args);
     } catch (error) {
-      if (error instanceof z41.ZodError) {
+      if (error instanceof z40.ZodError) {
         const errorDetails = error.errors.map((e) => {
           const fieldPath = e.path.length > 0 ? e.path.join(".") : "root";
           const message = e.message === "Required" ? `Missing required parameter '${fieldPath}'` : `Invalid value for '${fieldPath}': ${e.message}`;
@@ -22070,10 +22818,10 @@ If you wish to scan files that were recently changed in your git history call th
 init_FileUtils();
 init_GitService();
 init_configs();
-import fs20 from "fs/promises";
+import fs22 from "fs/promises";
 import nodePath from "path";
 var getLocalFiles = async ({
-  path: path27,
+  path: path30,
   maxFileSize = MCP_MAX_FILE_SIZE,
   maxFiles,
   isAllFilesScan,
@@ -22081,17 +22829,17 @@ var getLocalFiles = async ({
   scanRecentlyChangedFiles
 }) => {
   logDebug(`[${scanContext}] Starting getLocalFiles`, {
-    path: path27,
+    path: path30,
     maxFileSize,
     maxFiles,
     isAllFilesScan,
     scanRecentlyChangedFiles
   });
   try {
-    const resolvedRepoPath = await fs20.realpath(path27);
+    const resolvedRepoPath = await fs22.realpath(path30);
     logDebug(`[${scanContext}] Resolved repository path`, {
       resolvedRepoPath,
-      originalPath: path27
+      originalPath: path30
     });
     const gitService = new GitService(resolvedRepoPath, log);
     const gitValidation = await gitService.validateRepository();
@@ -22104,7 +22852,7 @@ var getLocalFiles = async ({
     if (!gitValidation.isValid || isAllFilesScan) {
       try {
         files = await FileUtils.getLastChangedFiles({
-          dir: path27,
+          dir: path30,
           maxFileSize,
           maxFiles,
           isAllFilesScan
@@ -22168,7 +22916,7 @@ var getLocalFiles = async ({
           absoluteFilePath
         );
         try {
-          const fileStat = await fs20.stat(absoluteFilePath);
+          const fileStat = await fs22.stat(absoluteFilePath);
           return {
             filename: nodePath.basename(absoluteFilePath),
             relativePath,
@@ -22196,7 +22944,7 @@ var getLocalFiles = async ({
     logError(`${scanContext}Unexpected error in getLocalFiles`, {
       error: error instanceof Error ? error.message : String(error),
       stack: error instanceof Error ? error.stack : void 0,
-      path: path27
+      path: path30
     });
     throw error;
   }
@@ -22205,15 +22953,15 @@ var getLocalFiles = async ({
 // src/mcp/services/LocalMobbFolderService.ts
 init_client_generates();
 init_GitService();
-import fs21 from "fs";
-import path21 from "path";
-import { z as z42 } from "zod";
+import fs23 from "fs";
+import path24 from "path";
+import { z as z41 } from "zod";
 function extractPathFromPatch(patch) {
   const match = patch?.match(/diff --git a\/([^\s]+) b\//);
   return match?.[1] ?? null;
 }
 function parsedIssueTypeRes(issueType) {
-  return z42.nativeEnum(IssueType_Enum).safeParse(issueType);
+  return z41.nativeEnum(IssueType_Enum).safeParse(issueType);
 }
 var LocalMobbFolderService = class {
   /**
@@ -22292,19 +23040,19 @@ var LocalMobbFolderService = class {
           "[LocalMobbFolderService] Non-git repository detected, skipping .gitignore operations"
         );
       }
-      const mobbFolderPath = path21.join(
+      const mobbFolderPath = path24.join(
         this.repoPath,
         this.defaultMobbFolderName
       );
-      if (!fs21.existsSync(mobbFolderPath)) {
+      if (!fs23.existsSync(mobbFolderPath)) {
         logInfo("[LocalMobbFolderService] Creating .mobb folder", {
           mobbFolderPath
         });
-        fs21.mkdirSync(mobbFolderPath, { recursive: true });
+        fs23.mkdirSync(mobbFolderPath, { recursive: true });
       } else {
         logDebug("[LocalMobbFolderService] .mobb folder already exists");
       }
-      const stats = fs21.statSync(mobbFolderPath);
+      const stats = fs23.statSync(mobbFolderPath);
       if (!stats.isDirectory()) {
         throw new Error(`Path exists but is not a directory: ${mobbFolderPath}`);
       }
@@ -22345,13 +23093,13 @@ var LocalMobbFolderService = class {
       logDebug("[LocalMobbFolderService] Git repository validated successfully");
     } else {
       try {
-        const stats = fs21.statSync(this.repoPath);
+        const stats = fs23.statSync(this.repoPath);
         if (!stats.isDirectory()) {
           throw new Error(
             `Path exists but is not a directory: ${this.repoPath}`
           );
         }
-        fs21.accessSync(this.repoPath, fs21.constants.R_OK | fs21.constants.W_OK);
+        fs23.accessSync(this.repoPath, fs23.constants.R_OK | fs23.constants.W_OK);
         logDebug(
           "[LocalMobbFolderService] Non-git directory validated successfully"
         );
@@ -22464,8 +23212,8 @@ var LocalMobbFolderService = class {
         mobbFolderPath,
         baseFileName
       );
-      const filePath = path21.join(mobbFolderPath, uniqueFileName);
-      await fs21.promises.writeFile(filePath, patch, "utf8");
+      const filePath = path24.join(mobbFolderPath, uniqueFileName);
+      await fs23.promises.writeFile(filePath, patch, "utf8");
       logInfo("[LocalMobbFolderService] Patch saved successfully", {
         filePath,
         fileName: uniqueFileName,
@@ -22522,11 +23270,11 @@ var LocalMobbFolderService = class {
    * @returns Unique filename that doesn't conflict with existing files
    */
   getUniqueFileName(folderPath, baseFileName) {
-    const baseName = path21.parse(baseFileName).name;
-    const extension = path21.parse(baseFileName).ext;
+    const baseName = path24.parse(baseFileName).name;
+    const extension = path24.parse(baseFileName).ext;
     let uniqueFileName = baseFileName;
     let index = 1;
-    while (fs21.existsSync(path21.join(folderPath, uniqueFileName))) {
+    while (fs23.existsSync(path24.join(folderPath, uniqueFileName))) {
       uniqueFileName = `${baseName}-${index}${extension}`;
       index++;
       if (index > 1e3) {
@@ -22557,18 +23305,18 @@ var LocalMobbFolderService = class {
     logDebug("[LocalMobbFolderService] Logging patch info", { fixId: fix.id });
     try {
       const mobbFolderPath = await this.getFolder();
-      const patchInfoPath = path21.join(mobbFolderPath, "patchInfo.md");
+      const patchInfoPath = path24.join(mobbFolderPath, "patchInfo.md");
       const markdownContent = this.generateFixMarkdown(fix, savedPatchFileName);
       let existingContent = "";
-      if (fs21.existsSync(patchInfoPath)) {
-        existingContent = await fs21.promises.readFile(patchInfoPath, "utf8");
+      if (fs23.existsSync(patchInfoPath)) {
+        existingContent = await fs23.promises.readFile(patchInfoPath, "utf8");
         logDebug("[LocalMobbFolderService] Existing patchInfo.md found");
       } else {
         logDebug("[LocalMobbFolderService] Creating new patchInfo.md file");
       }
       const separator = existingContent ? "\n\n================================================================================\n\n" : "";
       const updatedContent = `${markdownContent}${separator}${existingContent}`;
-      await fs21.promises.writeFile(patchInfoPath, updatedContent, "utf8");
+      await fs23.promises.writeFile(patchInfoPath, updatedContent, "utf8");
       logInfo("[LocalMobbFolderService] Patch info logged successfully", {
         patchInfoPath,
         fixId: fix.id,
@@ -22599,7 +23347,7 @@ var LocalMobbFolderService = class {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const patch = this.extractPatchFromFix(fix);
     const relativePatchedFilePath = patch ? extractPathFromPatch(patch) : null;
-    const patchedFilePath = relativePatchedFilePath ? path21.resolve(this.repoPath, relativePatchedFilePath) : null;
+    const patchedFilePath = relativePatchedFilePath ? path24.resolve(this.repoPath, relativePatchedFilePath) : null;
     const fixIdentifier = savedPatchFileName ? savedPatchFileName.replace(".patch", "") : fix.id;
     let markdown = `# Fix ${fixIdentifier}
 
@@ -22941,16 +23689,16 @@ import {
   unlinkSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import fs22 from "fs/promises";
+import fs24 from "fs/promises";
 import parseDiff2 from "parse-diff";
-import path22 from "path";
+import path25 from "path";
 var PatchApplicationService = class {
   /**
    * Gets the appropriate comment syntax for a file based on its extension
    */
   static getCommentSyntax(filePath) {
-    const ext = path22.extname(filePath).toLowerCase();
-    const basename2 = path22.basename(filePath);
+    const ext = path25.extname(filePath).toLowerCase();
+    const basename2 = path25.basename(filePath);
     const commentMap = {
       // C-style languages (single line comments)
       ".js": "//",
@@ -23158,7 +23906,7 @@ var PatchApplicationService = class {
         }
       );
     }
-    const dirPath = path22.dirname(normalizedFilePath);
+    const dirPath = path25.dirname(normalizedFilePath);
     mkdirSync(dirPath, { recursive: true });
     writeFileSync2(normalizedFilePath, finalContent, "utf8");
     return normalizedFilePath;
@@ -23167,9 +23915,9 @@ var PatchApplicationService = class {
     repositoryPath,
     targetPath
   }) {
-    const repoRoot = path22.resolve(repositoryPath);
-    const normalizedPath = path22.resolve(repoRoot, targetPath);
-    const repoRootWithSep = repoRoot.endsWith(path22.sep) ? repoRoot : `${repoRoot}${path22.sep}`;
+    const repoRoot = path25.resolve(repositoryPath);
+    const normalizedPath = path25.resolve(repoRoot, targetPath);
+    const repoRootWithSep = repoRoot.endsWith(path25.sep) ? repoRoot : `${repoRoot}${path25.sep}`;
     if (normalizedPath !== repoRoot && !normalizedPath.startsWith(repoRootWithSep)) {
       throw new Error(
         `Security violation: target path ${targetPath} resolves outside repository`
@@ -23178,7 +23926,7 @@ var PatchApplicationService = class {
     return {
       repoRoot,
       normalizedPath,
-      relativePath: path22.relative(repoRoot, normalizedPath)
+      relativePath: path25.relative(repoRoot, normalizedPath)
     };
   }
   /**
@@ -23460,9 +24208,9 @@ var PatchApplicationService = class {
         continue;
       }
       try {
-        const absolutePath = path22.resolve(repositoryPath, targetFile);
+        const absolutePath = path25.resolve(repositoryPath, targetFile);
         if (existsSync6(absolutePath)) {
-          const stats = await fs22.stat(absolutePath);
+          const stats = await fs24.stat(absolutePath);
           const fileModTime = stats.mtime.getTime();
           if (fileModTime > scanStartTime) {
             logError(
@@ -23503,7 +24251,7 @@ var PatchApplicationService = class {
     const appliedFixes = [];
     const failedFixes = [];
     const skippedFixes = [];
-    const resolvedRepoPath = await fs22.realpath(repositoryPath);
+    const resolvedRepoPath = await fs24.realpath(repositoryPath);
     logInfo(
       `[${scanContext}] Starting patch application for ${fixes.length} fixes`,
       {
@@ -23686,7 +24434,7 @@ var PatchApplicationService = class {
       fix,
       scanContext
     });
-    appliedFiles.push(path22.relative(repositoryPath, actualPath));
+    appliedFiles.push(path25.relative(repositoryPath, actualPath));
     logDebug(`[${scanContext}] Created new file: ${relativePath}`);
   }
   /**
@@ -23735,7 +24483,7 @@ var PatchApplicationService = class {
         fix,
         scanContext
       });
-      appliedFiles.push(path22.relative(repositoryPath, actualPath));
+      appliedFiles.push(path25.relative(repositoryPath, actualPath));
       logDebug(`[${scanContext}] Modified file: ${relativePath}`);
     }
   }
@@ -23931,8 +24679,8 @@ init_configs();
 
 // src/mcp/services/FileOperations.ts
 init_FileUtils();
-import fs23 from "fs";
-import path23 from "path";
+import fs25 from "fs";
+import path26 from "path";
 import AdmZip3 from "adm-zip";
 var FileOperations = class {
   /**
@@ -23952,10 +24700,10 @@ var FileOperations = class {
     let packedFilesCount = 0;
     const packedFiles = [];
     const excludedFiles = [];
-    const resolvedRepoPath = path23.resolve(repositoryPath);
+    const resolvedRepoPath = path26.resolve(repositoryPath);
     for (const filepath of fileList) {
-      const absoluteFilepath = path23.join(repositoryPath, filepath);
-      const resolvedFilePath = path23.resolve(absoluteFilepath);
+      const absoluteFilepath = path26.join(repositoryPath, filepath);
+      const resolvedFilePath = path26.resolve(absoluteFilepath);
       if (!resolvedFilePath.startsWith(resolvedRepoPath)) {
         const reason = "potential path traversal security risk";
         logDebug(`[FileOperations] Skipping ${filepath} due to ${reason}`);
@@ -24002,11 +24750,11 @@ var FileOperations = class {
     fileList,
     repositoryPath
   }) {
-    const resolvedRepoPath = path23.resolve(repositoryPath);
+    const resolvedRepoPath = path26.resolve(repositoryPath);
     const validatedPaths = [];
     for (const filepath of fileList) {
-      const absoluteFilepath = path23.join(repositoryPath, filepath);
-      const resolvedFilePath = path23.resolve(absoluteFilepath);
+      const absoluteFilepath = path26.join(repositoryPath, filepath);
+      const resolvedFilePath = path26.resolve(absoluteFilepath);
       if (!resolvedFilePath.startsWith(resolvedRepoPath)) {
         logDebug(
           `[FileOperations] Rejecting ${filepath} - path traversal attempt detected`
@@ -24014,7 +24762,7 @@ var FileOperations = class {
         continue;
       }
       try {
-        await fs23.promises.access(absoluteFilepath, fs23.constants.R_OK);
+        await fs25.promises.access(absoluteFilepath, fs25.constants.R_OK);
         validatedPaths.push(filepath);
       } catch (error) {
         logDebug(
@@ -24033,8 +24781,8 @@ var FileOperations = class {
     const fileDataArray = [];
     for (const absolutePath of filePaths) {
       try {
-        const content = await fs23.promises.readFile(absolutePath);
-        const relativePath = path23.basename(absolutePath);
+        const content = await fs25.promises.readFile(absolutePath);
+        const relativePath = path26.basename(absolutePath);
         fileDataArray.push({
           relativePath,
           absolutePath,
@@ -24059,7 +24807,7 @@ var FileOperations = class {
     relativeFilepath
   }) {
     try {
-      return await fs23.promises.readFile(absoluteFilepath);
+      return await fs25.promises.readFile(absoluteFilepath);
     } catch (fsError) {
       logError(
         `[FileOperations] Failed to read ${relativeFilepath} from filesystem: ${fsError}`
@@ -24346,14 +25094,14 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
    * since the last scan.
    */
   async scanForSecurityVulnerabilities({
-    path: path27,
+    path: path30,
     isAllDetectionRulesScan,
     isAllFilesScan,
     scanContext
   }) {
     this.hasAuthenticationFailed = false;
     logDebug(`[${scanContext}] Scanning for new security vulnerabilities`, {
-      path: path27
+      path: path30
     });
     if (!this.gqlClient) {
       logInfo(`[${scanContext}] No GQL client found, skipping scan`);
@@ -24369,11 +25117,11 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       }
       logDebug(
         `[${scanContext}] Connected to the API, assembling list of files to scan`,
-        { path: path27 }
+        { path: path30 }
       );
       const isBackgroundScan = scanContext === ScanContext.BACKGROUND_INITIAL || scanContext === ScanContext.BACKGROUND_PERIODIC;
       const files = await getLocalFiles({
-        path: path27,
+        path: path30,
         isAllFilesScan,
         scanContext,
         scanRecentlyChangedFiles: !isBackgroundScan
@@ -24399,13 +25147,13 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       });
       const { fixReportId, projectId } = await scanFiles({
         fileList: filesToScan.map((file) => file.relativePath),
-        repositoryPath: path27,
+        repositoryPath: path30,
         gqlClient: this.gqlClient,
         isAllDetectionRulesScan,
         scanContext
       });
       logInfo(
-        `[${scanContext}] Security scan completed for ${path27} reportId: ${fixReportId} projectId: ${projectId}`
+        `[${scanContext}] Security scan completed for ${path30} reportId: ${fixReportId} projectId: ${projectId}`
       );
       if (isAllFilesScan) {
         return;
@@ -24699,13 +25447,13 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
     });
     return scannedFiles.some((file) => file.relativePath === fixFile);
   }
-  async getFreshFixes({ path: path27 }) {
+  async getFreshFixes({ path: path30 }) {
     const scanContext = ScanContext.USER_REQUEST;
-    logDebug(`[${scanContext}] Getting fresh fixes`, { path: path27 });
-    if (this.path !== path27) {
-      this.path = path27;
+    logDebug(`[${scanContext}] Getting fresh fixes`, { path: path30 });
+    if (this.path !== path30) {
+      this.path = path30;
       this.reset();
-      logInfo(`[${scanContext}] Reset service state for new path`, { path: path27 });
+      logInfo(`[${scanContext}] Reset service state for new path`, { path: path30 });
     }
     try {
       const loginContext = createMcpLoginContext("check_new_fixes");
@@ -24724,7 +25472,7 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       }
       throw error;
     }
-    this.triggerScan({ path: path27, gqlClient: this.gqlClient });
+    this.triggerScan({ path: path30, gqlClient: this.gqlClient });
     let isMvsAutoFixEnabled = null;
     try {
       isMvsAutoFixEnabled = await this.gqlClient.getMvsAutoFixSettings();
@@ -24758,33 +25506,33 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
     return noFreshFixesPrompt;
   }
   triggerScan({
-    path: path27,
+    path: path30,
     gqlClient
   }) {
-    if (this.path !== path27) {
-      this.path = path27;
+    if (this.path !== path30) {
+      this.path = path30;
       this.reset();
-      logInfo(`Reset service state for new path in triggerScan`, { path: path27 });
+      logInfo(`Reset service state for new path in triggerScan`, { path: path30 });
     }
     this.gqlClient = gqlClient;
     if (!this.intervalId) {
-      this.startPeriodicScanning(path27);
-      this.executeInitialScan(path27);
-      void this.executeInitialFullScan(path27);
+      this.startPeriodicScanning(path30);
+      this.executeInitialScan(path30);
+      void this.executeInitialFullScan(path30);
     }
   }
-  startPeriodicScanning(path27) {
+  startPeriodicScanning(path30) {
     const scanContext = ScanContext.BACKGROUND_PERIODIC;
     logDebug(
       `[${scanContext}] Starting periodic scan for new security vulnerabilities`,
       {
-        path: path27
+        path: path30
       }
     );
     this.intervalId = setInterval(() => {
-      logDebug(`[${scanContext}] Triggering periodic security scan`, { path: path27 });
+      logDebug(`[${scanContext}] Triggering periodic security scan`, { path: path30 });
       this.scanForSecurityVulnerabilities({
-        path: path27,
+        path: path30,
         scanContext
       }).catch((error) => {
         logError(`[${scanContext}] Error during periodic security scan`, {
@@ -24793,45 +25541,45 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       });
     }, MCP_PERIODIC_CHECK_INTERVAL);
   }
-  async executeInitialFullScan(path27) {
+  async executeInitialFullScan(path30) {
     const scanContext = ScanContext.FULL_SCAN;
-    logDebug(`[${scanContext}] Triggering initial full security scan`, { path: path27 });
+    logDebug(`[${scanContext}] Triggering initial full security scan`, { path: path30 });
     logDebug(`[${scanContext}] Full scan paths scanned`, {
       fullScanPathsScanned: this.fullScanPathsScanned
     });
-    if (this.fullScanPathsScanned.includes(path27)) {
+    if (this.fullScanPathsScanned.includes(path30)) {
       logDebug(`[${scanContext}] Full scan already executed for this path`, {
-        path: path27
+        path: path30
       });
       return;
     }
     configStore.set("fullScanPathsScanned", [
       ...this.fullScanPathsScanned,
-      path27
+      path30
     ]);
     try {
       await this.scanForSecurityVulnerabilities({
-        path: path27,
+        path: path30,
         isAllFilesScan: true,
         isAllDetectionRulesScan: true,
         scanContext: ScanContext.FULL_SCAN
       });
-      if (!this.fullScanPathsScanned.includes(path27)) {
-        this.fullScanPathsScanned.push(path27);
+      if (!this.fullScanPathsScanned.includes(path30)) {
+        this.fullScanPathsScanned.push(path30);
         configStore.set("fullScanPathsScanned", this.fullScanPathsScanned);
       }
-      logInfo(`[${scanContext}] Full scan completed`, { path: path27 });
+      logInfo(`[${scanContext}] Full scan completed`, { path: path30 });
     } catch (error) {
       logError(`[${scanContext}] Error during initial full security scan`, {
         error
       });
     }
   }
-  executeInitialScan(path27) {
+  executeInitialScan(path30) {
     const scanContext = ScanContext.BACKGROUND_INITIAL;
-    logDebug(`[${scanContext}] Triggering initial security scan`, { path: path27 });
+    logDebug(`[${scanContext}] Triggering initial security scan`, { path: path30 });
     this.scanForSecurityVulnerabilities({
-      path: path27,
+      path: path30,
       scanContext: ScanContext.BACKGROUND_INITIAL
     }).catch((error) => {
       logError(`[${scanContext}] Error during initial security scan`, { error });
@@ -24910,8 +25658,8 @@ Example payload:
       },
       required: ["path"]
     });
-    __publicField(this, "inputValidationSchema", z43.object({
-      path: z43.string().describe(
+    __publicField(this, "inputValidationSchema", z42.object({
+      path: z42.string().describe(
         "Full local path to the cloned git repository to check for new available fixes"
       )
     }));
@@ -24928,9 +25676,9 @@ Example payload:
         `Invalid path: potential security risk detected in path: ${pathValidationResult.error}`
       );
     }
-    const path27 = pathValidationResult.path;
+    const path30 = pathValidationResult.path;
     const resultText = await this.newFixesService.getFreshFixes({
-      path: path27
+      path: path30
     });
     logInfo("CheckForNewAvailableFixesTool execution completed", {
       resultText
@@ -24941,7 +25689,7 @@ Example payload:
 
 // src/mcp/tools/fetchAvailableFixes/FetchAvailableFixesTool.ts
 init_GitService();
-import { z as z44 } from "zod";
+import { z as z43 } from "zod";
 
 // src/mcp/tools/fetchAvailableFixes/FetchAvailableFixesService.ts
 init_configs();
@@ -25084,16 +25832,16 @@ Call this tool instead of ${MCP_TOOL_SCAN_AND_FIX_VULNERABILITIES} when you only
       },
       required: ["path"]
     });
-    __publicField(this, "inputValidationSchema", z44.object({
-      path: z44.string().describe(
+    __publicField(this, "inputValidationSchema", z43.object({
+      path: z43.string().describe(
         "Full local path to the cloned git repository to check for available fixes"
       ),
-      offset: z44.number().optional().describe("Optional offset for pagination"),
-      limit: z44.number().optional().describe("Optional maximum number of fixes to return"),
-      fileFilter: z44.array(z44.string()).optional().describe(
+      offset: z43.number().optional().describe("Optional offset for pagination"),
+      limit: z43.number().optional().describe("Optional maximum number of fixes to return"),
+      fileFilter: z43.array(z43.string()).optional().describe(
         "Optional list of file paths relative to the path parameter to filter fixes by. INCOMPATIBLE with fetchFixesFromAnyFile"
       ),
-      fetchFixesFromAnyFile: z44.boolean().optional().describe(
+      fetchFixesFromAnyFile: z43.boolean().optional().describe(
         "Optional boolean to fetch fixes for all files. INCOMPATIBLE with fileFilter"
       )
     }));
@@ -25108,8 +25856,8 @@ Call this tool instead of ${MCP_TOOL_SCAN_AND_FIX_VULNERABILITIES} when you only
         `Invalid path: potential security risk detected in path: ${pathValidationResult.error}`
       );
     }
-    const path27 = pathValidationResult.path;
-    const gitService = new GitService(path27, log);
+    const path30 = pathValidationResult.path;
+    const gitService = new GitService(path30, log);
     const gitValidation = await gitService.validateRepository();
     if (!gitValidation.isValid) {
       throw new Error(`Invalid git repository: ${gitValidation.error}`);
@@ -25158,7 +25906,7 @@ Call this tool instead of ${MCP_TOOL_SCAN_AND_FIX_VULNERABILITIES} when you only
 };
 
 // src/mcp/tools/mcpChecker/mcpCheckerTool.ts
-import z45 from "zod";
+import z44 from "zod";
 
 // src/mcp/tools/mcpChecker/mcpCheckerService.ts
 var _McpCheckerService = class _McpCheckerService {
@@ -25219,7 +25967,7 @@ var McpCheckerTool = class extends BaseTool {
     __publicField(this, "displayName", "MCP Checker");
     // A detailed description to guide the LLM on when and how to invoke this tool.
     __publicField(this, "description", "Check the MCP servers running on this IDE against organization policies.");
-    __publicField(this, "inputValidationSchema", z45.object({}));
+    __publicField(this, "inputValidationSchema", z44.object({}));
     __publicField(this, "inputSchema", {
       type: "object",
       properties: {},
@@ -25245,7 +25993,7 @@ var McpCheckerTool = class extends BaseTool {
 };
 
 // src/mcp/tools/scanAndFixVulnerabilities/ScanAndFixVulnerabilitiesTool.ts
-import z46 from "zod";
+import z45 from "zod";
 init_configs();
 
 // src/mcp/tools/scanAndFixVulnerabilities/ScanAndFixVulnerabilitiesService.ts
@@ -25433,17 +26181,17 @@ Example payload:
   "rescan": false
 }`);
     __publicField(this, "hasAuthentication", true);
-    __publicField(this, "inputValidationSchema", z46.object({
-      path: z46.string().describe(
+    __publicField(this, "inputValidationSchema", z45.object({
+      path: z45.string().describe(
         "Full local path to repository to scan and fix vulnerabilities"
       ),
-      offset: z46.number().optional().describe("Optional offset for pagination"),
-      limit: z46.number().optional().describe("Optional maximum number of results to return"),
-      maxFiles: z46.number().optional().describe(
+      offset: z45.number().optional().describe("Optional offset for pagination"),
+      limit: z45.number().optional().describe("Optional maximum number of results to return"),
+      maxFiles: z45.number().optional().describe(
         `Optional maximum number of files to scan (default: ${MCP_DEFAULT_MAX_FILES_TO_SCAN}). Increase for comprehensive scans of larger codebases or decrease for faster focused scans.`
       ),
-      rescan: z46.boolean().optional().describe("Optional whether to rescan the repository"),
-      scanRecentlyChangedFiles: z46.boolean().optional().describe(
+      rescan: z45.boolean().optional().describe("Optional whether to rescan the repository"),
+      scanRecentlyChangedFiles: z45.boolean().optional().describe(
         "Optional whether to automatically scan recently changed files when no changed files are found in git status. If false, the tool will prompt the user instead."
       )
     }));
@@ -25494,9 +26242,9 @@ Example payload:
         `Invalid path: potential security risk detected in path: ${pathValidationResult.error}`
       );
     }
-    const path27 = pathValidationResult.path;
+    const path30 = pathValidationResult.path;
     const files = await getLocalFiles({
-      path: path27,
+      path: path30,
       maxFileSize: MCP_MAX_FILE_SIZE,
       maxFiles: args.maxFiles,
       scanContext: ScanContext.USER_REQUEST,
@@ -25516,7 +26264,7 @@ Example payload:
     try {
       const fixResult = await this.vulnerabilityFixService.processVulnerabilities({
         fileList: files.map((file) => file.relativePath),
-        repositoryPath: path27,
+        repositoryPath: path30,
         offset: args.offset,
         limit: args.limit,
         isRescan: args.rescan || !!args.maxFiles
@@ -25620,7 +26368,7 @@ var mcpHandler = async (_args) => {
 };
 
 // src/args/commands/review.ts
-import fs24 from "fs";
+import fs26 from "fs";
 import chalk12 from "chalk";
 function reviewBuilder(yargs2) {
   return yargs2.option("f", {
@@ -25657,7 +26405,7 @@ function reviewBuilder(yargs2) {
   ).help();
 }
 function validateReviewOptions(argv) {
-  if (!fs24.existsSync(argv.f)) {
+  if (!fs26.existsSync(argv.f)) {
     throw new CliError(`
 Can't access ${chalk12.bold(argv.f)}`);
   }
@@ -25751,15 +26499,76 @@ async function addScmTokenHandler(args) {
 }
 
 // src/features/codeium_intellij/data_collector.ts
-import { z as z47 } from "zod";
+import { z as z46 } from "zod";
+
+// src/utils/read-stdin.ts
+import { setTimeout as setTimeout4 } from "timers";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var noop = () => {
+};
+var noopLogger = {
+  debug: noop,
+  error: noop
+};
+async function readStdinData(config2) {
+  const logger3 = config2?.logger ?? noopLogger;
+  const timeoutMs = config2?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  logger3.debug("Reading stdin data");
+  return new Promise((resolve, reject) => {
+    let inputData = "";
+    let settled = false;
+    const timer = setTimeout4(() => {
+      if (!settled) {
+        settled = true;
+        process.stdin.destroy();
+        reject(new Error("Timed out reading from stdin"));
+      }
+    }, timeoutMs);
+    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);
+        logger3.debug(
+          {
+            data: { keys: Object.keys(parsedData) }
+          },
+          "Parsed stdin data"
+        );
+        resolve(parsedData);
+      } catch (error) {
+        const msg = `Failed to parse JSON from stdin: ${error.message}`;
+        logger3.error(msg);
+        reject(new Error(msg));
+      }
+    });
+    process.stdin.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      logger3.error(
+        { data: { error: error.message } },
+        "Error reading from stdin"
+      );
+      reject(new Error(`Error reading from stdin: ${error.message}`));
+    });
+  });
+}
+
+// src/features/codeium_intellij/data_collector.ts
 init_client_generates();
 init_urlParser2();
 
 // src/features/codeium_intellij/codeium_language_server_grpc_client.ts
-import path24 from "path";
+import path27 from "path";
 import * as grpc from "@grpc/grpc-js";
 import * as protoLoader from "@grpc/proto-loader";
-var PROTO_PATH = path24.join(
+var PROTO_PATH = path27.join(
   getModuleRootDir(),
   "src/features/codeium_intellij/proto/exa/language_server_pb/language_server.proto"
 );
@@ -25771,7 +26580,7 @@ function loadProto() {
     defaults: true,
     oneofs: true,
     includeDirs: [
-      path24.join(getModuleRootDir(), "src/features/codeium_intellij/proto")
+      path27.join(getModuleRootDir(), "src/features/codeium_intellij/proto")
     ]
   });
   return grpc.loadPackageDefinition(
@@ -25825,30 +26634,30 @@ async function getGrpcClient(port, csrf3) {
 }
 
 // src/features/codeium_intellij/parse_intellij_logs.ts
-import fs25 from "fs";
-import os12 from "os";
-import path25 from "path";
+import fs27 from "fs";
+import os14 from "os";
+import path28 from "path";
 function getLogsDir() {
   if (process.platform === "darwin") {
-    return path25.join(os12.homedir(), "Library/Logs/JetBrains");
+    return path28.join(os14.homedir(), "Library/Logs/JetBrains");
   } else if (process.platform === "win32") {
-    return path25.join(
-      process.env["LOCALAPPDATA"] || path25.join(os12.homedir(), "AppData/Local"),
+    return path28.join(
+      process.env["LOCALAPPDATA"] || path28.join(os14.homedir(), "AppData/Local"),
       "JetBrains"
     );
   } else {
-    return path25.join(os12.homedir(), ".cache/JetBrains");
+    return path28.join(os14.homedir(), ".cache/JetBrains");
   }
 }
 function parseIdeLogDir(ideLogDir) {
-  const logFiles = fs25.readdirSync(ideLogDir).filter((f) => /^idea(\.\d+)?\.log$/.test(f)).map((f) => ({
+  const logFiles = fs27.readdirSync(ideLogDir).filter((f) => /^idea(\.\d+)?\.log$/.test(f)).map((f) => ({
     name: f,
-    mtime: fs25.statSync(path25.join(ideLogDir, f)).mtimeMs
+    mtime: fs27.statSync(path28.join(ideLogDir, f)).mtimeMs
   })).sort((a, b) => a.mtime - b.mtime).map((f) => f.name);
   let latestCsrf = null;
   let latestPort = null;
   for (const logFile of logFiles) {
-    const lines = fs25.readFileSync(path25.join(ideLogDir, logFile), "utf-8").split("\n");
+    const lines = fs27.readFileSync(path28.join(ideLogDir, logFile), "utf-8").split("\n");
     for (const line of lines) {
       if (!line.includes(
         "com.codeium.intellij.language_server.LanguageServerProcessHandler"
@@ -25874,13 +26683,13 @@ function parseIdeLogDir(ideLogDir) {
 function findRunningCodeiumLanguageServers() {
   const results = [];
   const logsDir = getLogsDir();
-  if (!fs25.existsSync(logsDir)) return results;
-  for (const ide of fs25.readdirSync(logsDir)) {
-    let ideLogDir = path25.join(logsDir, ide);
+  if (!fs27.existsSync(logsDir)) return results;
+  for (const ide of fs27.readdirSync(logsDir)) {
+    let ideLogDir = path28.join(logsDir, ide);
     if (process.platform !== "darwin") {
-      ideLogDir = path25.join(ideLogDir, "log");
+      ideLogDir = path28.join(ideLogDir, "log");
     }
-    if (!fs25.existsSync(ideLogDir) || !fs25.statSync(ideLogDir).isDirectory()) {
+    if (!fs27.existsSync(ideLogDir) || !fs27.statSync(ideLogDir).isDirectory()) {
       continue;
     }
     const result = parseIdeLogDir(ideLogDir);
@@ -25892,8 +26701,8 @@ function findRunningCodeiumLanguageServers() {
 }
 
 // src/features/codeium_intellij/data_collector.ts
-var HookDataSchema2 = z47.object({
-  trajectory_id: z47.string()
+var HookDataSchema = z46.object({
+  trajectory_id: z46.string()
 });
 async function processAndUploadHookData() {
   const tracePayload = await getTraceDataForHook();
@@ -25921,12 +26730,12 @@ async function processAndUploadHookData() {
     console.warn("Failed to upload trace data:", e);
   }
 }
-function validateHookData2(data) {
-  return HookDataSchema2.parse(data);
+function validateHookData(data) {
+  return HookDataSchema.parse(data);
 }
 async function getTraceDataForHook() {
   const rawData = await readStdinData();
-  const hookData = validateHookData2(rawData);
+  const hookData = validateHookData(rawData);
   return await getTraceDataForTrajectory(hookData.trajectory_id);
 }
 async function getTraceDataForTrajectory(trajectoryId) {
@@ -26060,11 +26869,11 @@ function processChatStepCodeAction(step) {
 
 // src/features/codeium_intellij/install_hook.ts
 import fsPromises5 from "fs/promises";
-import os13 from "os";
-import path26 from "path";
+import os15 from "os";
+import path29 from "path";
 import chalk14 from "chalk";
 function getCodeiumHooksPath() {
-  return path26.join(os13.homedir(), ".codeium", "hooks.json");
+  return path29.join(os15.homedir(), ".codeium", "hooks.json");
 }
 async function readCodeiumHooks() {
   const hooksPath = getCodeiumHooksPath();
@@ -26077,7 +26886,7 @@ async function readCodeiumHooks() {
 }
 async function writeCodeiumHooks(config2) {
   const hooksPath = getCodeiumHooksPath();
-  const dir = path26.dirname(hooksPath);
+  const dir = path29.dirname(hooksPath);
   await fsPromises5.mkdir(dir, { recursive: true });
   await fsPromises5.writeFile(
     hooksPath,
@@ -26248,9 +27057,16 @@ var parseArgs = async (args) => {
     claudeCodeInstallHookHandler
   ).command(
     mobbCliCommand.claudeCodeProcessHook,
-    chalk15.bold("Process Claude Code hook data and upload to backend."),
+    chalk15.bold("Process Claude Code hook data (legacy \u2014 spawns daemon)."),
     claudeCodeProcessHookBuilder,
     claudeCodeProcessHookHandler
+  ).command(
+    mobbCliCommand.claudeCodeDaemon,
+    chalk15.bold(
+      "Run the background daemon for Claude Code transcript processing."
+    ),
+    claudeCodeDaemonBuilder,
+    claudeCodeDaemonHandler
   ).command(
     mobbCliCommand.windsurfIntellijInstallHook,
     chalk15.bold("Install Windsurf IntelliJ hooks for data collection."),