mobbdev 1.2.56 → 1.2.58

package/dist/index.mjs

@@ -1660,8 +1660,16 @@ var init_analysis = __esm({
         originalUrl: z8.string(),
         reference: z8.string(),
         commitSha: z8.string(),
-        isKnownBranch: z8.boolean().nullable()
-      }),
+        isKnownBranch: z8.boolean().nullish().default(true)
+      }).nullable().transform(
+        (repo) => repo ?? {
+          name: null,
+          originalUrl: "",
+          reference: "",
+          commitSha: "",
+          isKnownBranch: true
+        }
+      ),
       vulnerabilityReport: z8.object({
         id: z8.string().uuid(),
         vendor: z8.nativeEnum(Vulnerability_Report_Vendor_Enum),
@@ -1982,7 +1990,15 @@ var init_types = __esm({
           reference: z11.string(),
           commitSha: z11.string(),
           isKnownBranch: z11.boolean().nullish().default(true)
-        }),
+        }).nullable().transform(
+          (repo) => repo ?? {
+            name: null,
+            originalUrl: "",
+            reference: "",
+            commitSha: "",
+            isKnownBranch: true
+          }
+        ),
         vulnerabilityReportIssuesFixedCount: z11.object({
           vulnerabilityReportIssues_aggregate: z11.object({
             aggregate: z11.object({ count: z11.number() })
@@ -2003,7 +2019,7 @@ var init_types = __esm({
           file: z11.object({
             id: z11.string().uuid(),
             path: z11.string()
-          }),
+          }).nullable(),
           pending: z11.object({
             aggregate: z11.object({
               count: z11.number()
@@ -2204,7 +2220,13 @@ var init_types = __esm({
           originalUrl: z11.string(),
           reference: z11.string(),
           name: z11.string()
-        }),
+        }).nullable().transform(
+          (repo) => repo ?? {
+            originalUrl: "",
+            reference: "",
+            name: ""
+          }
+        ),
         createdByUser: z11.object({
           email: z11.string()
         }).nullable(),
@@ -2752,7 +2774,7 @@ function parseCommitLine(line) {
     message: parts[6]
   };
 }
-var PrepareGitBlameMessageZ, PrepareGitBlameResponseMessageZ, CommitMetadataZ, LineToCommitMapZ, CommitMetadataMapZ, BlameInfoZ, LineRangeZ, PrContextZ, PrepareCommitBlameMessageZ, BlameLineInfoZ, FileBlameDataZ, ChunkFetchResultZ, FileBlameResponseEntryZ, CommitBlameDataZ, CommitInfoZ, GitIdentityZ, COMMIT_LOG_FORMAT, CommitDataZ, PrDiffDataZ, PrStatsZ, CommitsManifestZ, BlameLineEntryZ, BlameLinesDataZ, PrepareCommitBlameResponseMessageZ;
+var PrepareGitBlameMessageZ, PrepareGitBlameResponseMessageZ, CommitMetadataZ, LineToCommitMapZ, CommitMetadataMapZ, BlameInfoZ, LineRangeZ, PrContextZ, PrepareCommitBlameMessageZ, BlameLineInfoZ, FileBlameDataZ, ChunkFetchResultZ, FileBlameResponseEntryZ, CommitBlameDataZ, CommitInfoZ, GitIdentityZ, COMMIT_LOG_FORMAT, CommitDataZ, PrDiffDataZ, PrStatsZ, CommitsManifestZ, BlameLineEntryZ, BlameLinesDataZ, PrepareCommitBlameResponseMessageZ, VulnerabilityAttributionMessageZ;
 var init_gitBlameTypes = __esm({
   "src/utils/blame/gitBlameTypes.ts"() {
     "use strict";
@@ -2927,6 +2949,11 @@ var init_gitBlameTypes = __esm({
       /** User email passed through from request for single commit blame attribution analysis trigger. */
       userEmail: z18.string().optional()
     });
+    VulnerabilityAttributionMessageZ = z18.object({
+      fixReportId: z18.string().uuid(),
+      vulnerabilityAttributionRequestId: z18.string().uuid(),
+      userEmail: z18.string()
+    });
   }
 });
 
@@ -6695,9 +6722,9 @@ function transformVisualStudioUrl(url) {
 }
 function _getPublicAdoClient({
   orgName,
-  origin: origin2
+  origin
 }) {
-  const orgUrl = `${origin2}/${orgName}`;
+  const orgUrl = `${origin}/${orgName}`;
   const authHandler = api.getPersonalAccessTokenHandler("");
   authHandler.canHandleAuthentication = () => false;
   authHandler.prepareRequest = (_options) => {
@@ -6759,10 +6786,10 @@ async function getAdoConnectData({
         org: tokenOrg
       };
     }
-    const { owner, origin: origin2, prefixPath } = parseAdoOwnerAndRepo(url);
+    const { owner, origin, prefixPath } = parseAdoOwnerAndRepo(url);
     return {
       org: owner,
-      origin: prefixPath ? `${origin2}/${prefixPath}` : origin2
+      origin: prefixPath ? `${origin}/${prefixPath}` : origin
     };
   }
   if (!tokenOrg) {
@@ -6787,17 +6814,17 @@ function isAdoOnCloud(url) {
   return urlObj.origin.toLowerCase() === DEFUALT_ADO_ORIGIN || urlObj.hostname.toLowerCase().endsWith(".visualstudio.com");
 }
 async function getAdoApiClient(params) {
-  const { origin: origin2 = DEFUALT_ADO_ORIGIN, orgName } = params;
+  const { origin = DEFUALT_ADO_ORIGIN, orgName } = params;
   if (params.tokenType === "NONE" /* NONE */ || // note: move to public client if the token is not associated with the PAT org
   // we're only doing it the ado on the cloud
-  params.tokenType === "PAT" /* PAT */ && params.patTokenOrg !== orgName && isAdoOnCloud(origin2)) {
-    return _getPublicAdoClient({ orgName, origin: origin2 });
+  params.tokenType === "PAT" /* PAT */ && params.patTokenOrg !== orgName && isAdoOnCloud(origin)) {
+    return _getPublicAdoClient({ orgName, origin });
   }
-  const orgUrl = `${origin2}/${orgName}`;
+  const orgUrl = `${origin}/${orgName}`;
   if (params.tokenType === "OAUTH" /* OAUTH */) {
-    if (!isAdoOnCloud(origin2)) {
+    if (!isAdoOnCloud(origin)) {
       throw new Error(
-        `Oauth token is not supported for ADO on prem - ${origin2} `
+        `Oauth token is not supported for ADO on prem - ${origin} `
       );
     }
     const connection2 = new api.WebApi(
@@ -6833,7 +6860,7 @@ function getAdoTokenInfo(token) {
 async function getAdoClientParams(params) {
   const { url, accessToken, tokenOrg } = params;
   const adoTokenInfo = getAdoTokenInfo(accessToken);
-  const { org, origin: origin2 } = await getAdoConnectData({
+  const { org, origin } = await getAdoConnectData({
     url,
     tokenOrg,
     adoTokenInfo
@@ -6842,14 +6869,14 @@ async function getAdoClientParams(params) {
     case "NONE" /* NONE */:
       return {
         tokenType: "NONE" /* NONE */,
-        origin: origin2,
+        origin,
         orgName: org.toLowerCase()
       };
     case "OAUTH" /* OAUTH */: {
       return {
         tokenType: "OAUTH" /* OAUTH */,
         accessToken: adoTokenInfo.accessToken,
-        origin: origin2,
+        origin,
         orgName: org.toLowerCase()
       };
     }
@@ -6858,7 +6885,7 @@ async function getAdoClientParams(params) {
         tokenType: "PAT" /* PAT */,
         accessToken: adoTokenInfo.accessToken,
         patTokenOrg: z17.string().parse(tokenOrg).toLowerCase(),
-        origin: origin2,
+        origin,
         orgName: org.toLowerCase()
       };
     }
@@ -7044,7 +7071,7 @@ async function getAdoSdk(params) {
     }) {
       const { owner, repo, projectName, prefixPath } = parseAdoOwnerAndRepo(repoUrl);
       const url = new URL(repoUrl);
-      const origin2 = url.origin.toLowerCase().endsWith(".visualstudio.com") ? DEFUALT_ADO_ORIGIN : url.origin.toLowerCase();
+      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 = [
         prefixPath,
@@ -7057,7 +7084,7 @@ async function getAdoSdk(params) {
         "items",
         "items"
       ].filter(Boolean).join("/");
-      return new URL(`${path27}?${params2}`, origin2).toString();
+      return new URL(`${path27}?${params2}`, origin).toString();
     },
     async getAdoBranchList({ repoUrl }) {
       try {
@@ -7338,7 +7365,8 @@ async function getAdoSdk(params) {
 async function getAdoRepoList({
   orgName,
   tokenOrg,
-  accessToken
+  accessToken,
+  url
 }) {
   let orgs = [];
   const adoTokenInfo = getAdoTokenInfo(accessToken);
@@ -7348,10 +7376,11 @@ async function getAdoRepoList({
   if (adoTokenInfo.type === "OAUTH" /* OAUTH */) {
     orgs = await getOrgsForOauthToken({ oauthToken: accessToken });
   }
-  if (orgs.length === 0 && !orgName) {
+  const effectiveOrgName = orgName || tokenOrg;
+  if (orgs.length === 0 && !effectiveOrgName) {
     throw new Error(`no orgs for ADO`);
-  } else if (orgs.length === 0 && orgName) {
-    orgs = [orgName];
+  } else if (orgs.length === 0 && effectiveOrgName) {
+    orgs = [effectiveOrgName];
   }
   const repos = (await Promise.allSettled(
     orgs.map(async (org) => {
@@ -7359,7 +7388,7 @@ async function getAdoRepoList({
         ...await getAdoClientParams({
           accessToken,
           tokenOrg: tokenOrg || org,
-          url: void 0
+          url
         }),
         orgName: org
       });
@@ -7627,15 +7656,11 @@ var AdoSCMLib = class extends SCMLib {
   }
   async getRepoList(scmOrg) {
     this._validateAccessToken();
-    if (this.url && new URL(this.url).origin !== scmCloudUrl.Ado) {
-      throw new Error(
-        `Oauth token is not supported for ADO on prem - ${origin} `
-      );
-    }
     return getAdoRepoList({
       orgName: scmOrg,
       accessToken: this.accessToken,
-      tokenOrg: this.scmOrg
+      tokenOrg: this.scmOrg,
+      url: this.url
     });
   }
   async getBranchList() {
@@ -7840,15 +7865,11 @@ var AdoSCMLib = class extends SCMLib {
   // getRepositoriesPaged() API per-project for true server-side pagination.
   async searchRepos(params) {
     this._validateAccessToken();
-    if (this.url && new URL(this.url).origin !== scmCloudUrl.Ado) {
-      throw new Error(
-        `Oauth token is not supported for ADO on prem - ${this.url}`
-      );
-    }
     const allRepos = await getAdoRepoList({
       orgName: params.scmOrg,
       accessToken: this.accessToken,
-      tokenOrg: this.scmOrg
+      tokenOrg: this.scmOrg,
+      url: this.url
     });
     allRepos.sort((a, b) => {
       const dateA = a.repoUpdatedAt ? new Date(a.repoUpdatedAt).getTime() : 0;
@@ -8945,17 +8966,30 @@ function getGithubSdk(params = {}) {
     },
     async getGithubRepoList() {
       try {
-        const githubRepos = await octokit.request(GET_USER_REPOS, {
-          sort: "updated"
-        });
-        return githubRepos.data.map((repo) => ({
-          repoName: repo.name,
-          repoUrl: repo.html_url,
-          repoOwner: repo.owner.login,
-          repoLanguages: repo.language ? [repo.language] : [],
-          repoIsPublic: !repo.private,
-          repoUpdatedAt: repo.updated_at
-        }));
+        const allRepos = [];
+        let page = 1;
+        const perPage = 100;
+        let hasMore = true;
+        while (hasMore) {
+          const githubRepos = await octokit.request(GET_USER_REPOS, {
+            sort: "updated",
+            per_page: perPage,
+            page
+          });
+          for (const repo of githubRepos.data) {
+            allRepos.push({
+              repoName: repo.name,
+              repoUrl: repo.html_url,
+              repoOwner: repo.owner.login,
+              repoLanguages: repo.language ? [repo.language] : [],
+              repoIsPublic: !repo.private,
+              repoUpdatedAt: repo.updated_at
+            });
+          }
+          hasMore = githubRepos.data.length >= perPage;
+          page++;
+        }
+        return allRepos;
       } catch (e) {
         if (e instanceof RequestError && e.status === 401) {
           console.warn(
@@ -9378,7 +9412,7 @@ function getGithubSdk(params = {}) {
       if (!org) {
         throw new Error("Organization is required for repository search");
       }
-      const query = `org:${org}`;
+      const query = `org:${org} fork:true`;
       const githubSortField = sort.field === "name" ? void 0 : "updated";
       const response = await octokit.rest.search.repos({
         q: query,
@@ -10139,7 +10173,9 @@ async function searchGitlabProjects({
   url,
   accessToken,
   perPage = 20,
-  page = 1
+  page = 1,
+  orderBy = "created_at",
+  sort = "desc"
 }) {
   if (perPage > GITLAB_MAX_PER_PAGE) {
     throw new Error(
@@ -10147,31 +10183,28 @@ async function searchGitlabProjects({
     );
   }
   const api2 = getGitBeaker({ url, gitlabAuthToken: accessToken });
+  const fetchProjects = (effectiveOrderBy) => api2.Projects.all({
+    membership: true,
+    orderBy: effectiveOrderBy,
+    sort,
+    pagination: "offset",
+    perPage,
+    page,
+    showExpanded: true
+  });
   let response;
-  try {
-    response = await api2.Projects.all({
-      membership: true,
-      orderBy: "last_activity_at",
-      sort: "desc",
-      pagination: "offset",
-      perPage,
-      page,
-      showExpanded: true
-    });
-  } catch (e) {
-    debug4(
-      "[searchGitlabProjects] order_by=last_activity_at failed, falling back to created_at: %s",
-      e instanceof Error ? e.message : String(e)
-    );
-    response = await api2.Projects.all({
-      membership: true,
-      orderBy: "created_at",
-      sort: "desc",
-      pagination: "offset",
-      perPage,
-      page,
-      showExpanded: true
-    });
+  if (orderBy === "last_activity_at") {
+    try {
+      response = await fetchProjects("last_activity_at");
+    } catch (e) {
+      debug4(
+        "[searchGitlabProjects] order_by=last_activity_at failed, falling back to created_at: %s",
+        e instanceof Error ? e.message : String(e)
+      );
+      response = await fetchProjects("created_at");
+    }
+  } else {
+    response = await fetchProjects(orderBy);
   }
   const projects = response.data.map((p) => ({
     id: p.id,
@@ -10933,11 +10966,15 @@ var GitlabSCMLib = class extends SCMLib {
     }
     const page = parseCursorSafe(params.cursor, 1);
     const perPage = params.limit || 10;
+    const sort = params.sort || { field: "updated", order: "desc" };
+    const orderBy = sort.field === "updated" ? "last_activity_at" : "created_at";
     const { projects, hasMore } = await searchGitlabProjects({
       url: this.url,
       accessToken: this.accessToken,
       perPage,
-      page
+      page,
+      orderBy,
+      sort: sort.order
     });
     const includeLanguages = params.includeLanguages !== false;
     const languageMap = /* @__PURE__ */ new Map();
@@ -11127,29 +11164,29 @@ var StubSCMLib = class extends SCMLib {
 };
 
 // src/features/analysis/scm/scmFactory.ts
-async function createScmLib({ url, accessToken, scmType, scmOrg }, { propagateExceptions = false } = {}) {
+async function createScmLib({ url, accessToken, scmType, scmOrg }, { propagateExceptions = false, skipValidation = false } = {}) {
   const trimmedUrl = url ? url.trim().replace(/\/$/, "").replace(/.git$/i, "") : void 0;
   try {
     switch (scmType) {
       case "GITHUB" /* GITHUB */: {
         const scm = new GithubSCMLib(trimmedUrl, accessToken, scmOrg);
-        await scm.validateParams();
+        if (!skipValidation) await scm.validateParams();
         return scm;
       }
       case "GITLAB" /* GITLAB */: {
         const scm = new GitlabSCMLib(trimmedUrl, accessToken, scmOrg);
-        await scm.validateParams();
+        if (!skipValidation) await scm.validateParams();
         return scm;
       }
       case "ADO" /* ADO */: {
         const scm = new AdoSCMLib(trimmedUrl, accessToken, scmOrg);
         await scm.getAdoSdk();
-        await scm.validateParams();
+        if (!skipValidation) await scm.validateParams();
         return scm;
       }
       case "BITBUCKET" /* BITBUCKET */: {
         const scm = new BitbucketSCMLib(trimmedUrl, accessToken, scmOrg);
-        await scm.validateParams();
+        if (!skipValidation) await scm.validateParams();
         return scm;
       }
     }
@@ -13659,12 +13696,47 @@ async function uploadAiBlameCommandHandler(args) {
   await uploadAiBlameHandler({ args });
 }
 
+// src/utils/with-timeout.ts
+import { setTimeout as delay } from "timers/promises";
+function withTimeout(promise, ms, label) {
+  const ac = new AbortController();
+  return Promise.race([
+    promise.finally(() => ac.abort()),
+    delay(ms, void 0, { signal: ac.signal }).then(() => {
+      throw new Error(`${label} timed out after ${ms}ms`);
+    })
+  ]);
+}
+
 // src/features/analysis/graphql/tracy-batch-upload.ts
 var debug10 = Debug9("mobbdev:tracy-batch-upload");
+function timedStep(label, fn) {
+  const start = Date.now();
+  const result = fn();
+  const maybePromise = result instanceof Promise ? result : Promise.resolve(result);
+  return maybePromise.then(
+    (val) => {
+      debug10("[perf] %s: %dms", label, Date.now() - start);
+      return val;
+    },
+    (err) => {
+      debug10("[perf] %s FAILED: %dms", label, Date.now() - start);
+      throw err;
+    }
+  );
+}
+var BATCH_TIMEOUT_MS = 3e4;
 async function sanitizeRawData(rawData) {
+  const start = Date.now();
   try {
     const sanitized = await sanitizeData(rawData);
-    return JSON.stringify(sanitized);
+    const serialized = JSON.stringify(sanitized);
+    debug10(
+      "[perf] sanitizeRawData: %dms (%d bytes)",
+      Date.now() - start,
+      serialized.length
+    );
+    return serialized;
   } catch (err) {
     console.warn(
       "[tracy] sanitizeRawData failed, falling back to unsanitized:",
@@ -13673,44 +13745,80 @@ async function sanitizeRawData(rawData) {
     return JSON.stringify(rawData);
   }
 }
-async function prepareAndSendTracyRecords(client, rawRecords, workingDir) {
-  const repositoryUrl = await getRepositoryUrl(workingDir);
+async function prepareAndSendTracyRecords(client, rawRecords, workingDir, options) {
   const { computerName, userName } = getSystemInfo();
-  const clientVersion = packageJson.version;
+  const defaultClientVersion = packageJson.version;
+  const shouldSanitize = options?.sanitize ?? true;
+  const defaultRepoUrl = rawRecords[0]?.repositoryUrl ? void 0 : await getRepositoryUrl(workingDir) ?? void 0;
+  debug10(
+    "[step:sanitize] %s %d records",
+    shouldSanitize ? "Sanitizing" : "Serializing",
+    rawRecords.length
+  );
   const serializedRawDataByIndex = /* @__PURE__ */ new Map();
-  const records = await Promise.all(
-    rawRecords.map(async (record, index) => {
-      if (record.rawData != null) {
-        const serialized = await sanitizeRawData(record.rawData);
-        serializedRawDataByIndex.set(index, serialized);
-      }
-      const { rawData: _rawData, ...rest } = record;
-      return {
-        ...rest,
-        repositoryUrl: repositoryUrl ?? void 0,
-        computerName,
-        userName,
-        clientVersion
-      };
-    })
+  const records = await timedStep(
+    `${shouldSanitize ? "sanitize" : "serialize"} ${rawRecords.length} records`,
+    () => Promise.all(
+      rawRecords.map(async (record, index) => {
+        if (record.rawData != null) {
+          const serialized = shouldSanitize ? await sanitizeRawData(record.rawData) : JSON.stringify(record.rawData);
+          serializedRawDataByIndex.set(index, serialized);
+        }
+        const { rawData: _rawData, ...rest } = record;
+        return {
+          ...rest,
+          repositoryUrl: record.repositoryUrl ?? defaultRepoUrl,
+          computerName,
+          userName,
+          clientVersion: record.clientVersion ?? defaultClientVersion
+        };
+      })
+    )
   );
   const recordsWithRawData = rawRecords.map((r, i) => ({ recordId: r.recordId, index: i })).filter((entry) => serializedRawDataByIndex.has(entry.index));
   if (recordsWithRawData.length > 0) {
-    debug10("Uploading %d rawData files to S3...", recordsWithRawData.length);
-    const uploadUrlResult = await client.getTracyRawDataUploadUrl();
+    debug10(
+      "[step:s3-url] Requesting presigned URL for %d rawData files",
+      recordsWithRawData.length
+    );
+    let uploadUrlResult;
+    try {
+      uploadUrlResult = await withTimeout(
+        client.getTracyRawDataUploadUrl(),
+        BATCH_TIMEOUT_MS,
+        "[step:s3-url] getTracyRawDataUploadUrl"
+      );
+    } catch (err) {
+      return {
+        ok: false,
+        errors: [
+          `[step:s3-url] Failed to fetch S3 upload URL: ${err.message}`
+        ]
+      };
+    }
     const { url, uploadFieldsJSON, keyPrefix } = uploadUrlResult.getTracyRawDataUploadUrl;
     if (!url || !uploadFieldsJSON || !keyPrefix) {
       return {
         ok: false,
-        errors: ["Failed to get S3 upload URL for rawData"]
+        errors: [
+          `[step:s3-url] Missing S3 upload fields (url=${!!url}, fields=${!!uploadFieldsJSON}, prefix=${!!keyPrefix})`
+        ]
       };
     }
     let uploadFields;
     try {
       uploadFields = JSON.parse(uploadFieldsJSON);
     } catch {
-      return { ok: false, errors: ["Malformed uploadFieldsJSON from server"] };
+      return {
+        ok: false,
+        errors: ["[step:s3-url] Malformed uploadFieldsJSON from server"]
+      };
     }
+    debug10(
+      "[step:s3-upload] Uploading %d files to S3",
+      recordsWithRawData.length
+    );
+    const s3Start = Date.now();
     const uploadResults = await Promise.allSettled(
       recordsWithRawData.map(async (entry) => {
         const rawDataJson = serializedRawDataByIndex.get(entry.index);
@@ -13719,48 +13827,67 @@ async function prepareAndSendTracyRecords(client, rawRecords, workingDir) {
           return;
         }
         const uploadKey = `${keyPrefix}${entry.recordId}.json`;
-        await uploadFile({
-          file: Buffer.from(rawDataJson, "utf-8"),
-          url,
-          uploadKey,
-          uploadFields
-        });
+        await withTimeout(
+          uploadFile({
+            file: Buffer.from(rawDataJson, "utf-8"),
+            url,
+            uploadKey,
+            uploadFields
+          }),
+          BATCH_TIMEOUT_MS,
+          `[step:s3-upload] uploadFile ${entry.recordId}`
+        );
         records[entry.index].rawDataS3Key = uploadKey;
       })
     );
+    debug10(
+      "[perf] s3-upload %d files: %dms",
+      recordsWithRawData.length,
+      Date.now() - s3Start
+    );
     const uploadErrors = uploadResults.filter((r) => r.status === "rejected").map((r) => r.reason.message);
     if (uploadErrors.length > 0) {
-      debug10("S3 upload errors: %O", uploadErrors);
+      debug10("[step:s3-upload] S3 upload errors: %O", uploadErrors);
     }
     const missingS3Keys = recordsWithRawData.filter(
       (entry) => !records[entry.index].rawDataS3Key
     );
     if (missingS3Keys.length > 0) {
       const missingIds = missingS3Keys.map((e) => e.recordId);
-      debug10("Records missing S3 keys after upload: %O", missingIds);
+      debug10("[step:s3-upload] Records missing S3 keys: %O", missingIds);
       return {
         ok: false,
         errors: [
-          `Failed to upload rawData to S3 for ${missingS3Keys.length} record(s): ${missingIds.join(", ")}`,
+          `[step:s3-upload] Failed to upload rawData for ${missingS3Keys.length} record(s): ${missingIds.join(", ")}`,
           ...uploadErrors
         ]
       };
     }
-    debug10("S3 uploads complete");
+    debug10("[step:s3-upload] S3 uploads complete");
   }
+  debug10("[step:gql-submit] Submitting %d records via GraphQL", records.length);
   try {
-    const result = await client.uploadTracyRecords({ records });
+    const result = await timedStep(
+      `gql-submit ${records.length} records`,
+      () => withTimeout(
+        client.uploadTracyRecords({ records }),
+        BATCH_TIMEOUT_MS,
+        "[step:gql-submit] uploadTracyRecords"
+      )
+    );
     if (result.uploadTracyRecords.status !== "OK") {
       return {
         ok: false,
-        errors: [result.uploadTracyRecords.error ?? "Unknown server error"]
+        errors: [
+          `[step:gql-submit] Server rejected: ${result.uploadTracyRecords.error ?? "Unknown server error"}`
+        ]
       };
     }
   } catch (err) {
-    debug10("Upload failed: %s", err.message);
+    debug10("[step:gql-submit] Upload failed: %s", err.message);
     return {
       ok: false,
-      errors: [err.message]
+      errors: [`[step:gql-submit] ${err.message}`]
     };
   }
   return { ok: true, errors: null };
@@ -16297,8 +16424,8 @@ async function analyzeHandler(args) {
 
 // src/features/claude_code/data_collector.ts
 import { createHash as createHash2 } from "crypto";
-import { open as open4, readdir, readFile, unlink } from "fs/promises";
-import path13 from "path";
+import { access, open as open4, readdir, readFile, unlink } from "fs/promises";
+import path14 from "path";
 import { z as z33 } from "zod";
 init_client_generates();
 
@@ -16583,7 +16710,7 @@ function createLogger(config2) {
 
 // src/features/claude_code/hook_logger.ts
 var DD_RUM_TOKEN = true ? "pubf59c0182545bfb4c299175119f1abf9b" : "";
-var CLI_VERSION = true ? "1.2.56" : "unknown";
+var CLI_VERSION = true ? "1.2.58" : "unknown";
 var NAMESPACE = "mobbdev-claude-code-hook-logs";
 function createHookLogger(scopePath) {
   return createLogger({
@@ -16607,13 +16734,13 @@ function flushLogs() {
   for (const scoped of activeScopedLoggers) {
     scoped.flushLogs();
   }
-  activeScopedLoggers.length = 0;
 }
 async function flushDdLogs() {
   await logger.flushDdAsync();
   for (const scoped of activeScopedLoggers) {
     await scoped.flushDdAsync();
   }
+  activeScopedLoggers.length = 0;
 }
 function createScopedHookLog(scopePath) {
   const scoped = createHookLogger(scopePath);
@@ -16621,11 +16748,138 @@ function createScopedHookLog(scopePath) {
   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 = "Bash|Write|Edit|Agent|Read";
+var STALE_MATCHERS = /* @__PURE__ */ new Set(["", "*", "Edit|Write"]);
+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"
+  );
+}
+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) => h.command?.includes("claude-code-process-hook") && (h.command?.includes("mobbdev") || h.command?.includes("mobbdev@"))
+      );
+      if (isMobbHook && STALE_MATCHERS.has(hook.matcher)) {
+        hook.matcher = RECOMMENDED_MATCHER;
+        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
+      }
+    ]
+  };
+  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 HOOK_COOLDOWN_MS = 1e4;
+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 = 50;
 var COOLDOWN_KEY = "lastHookRunAt";
+var ACTIVE_KEY = "hookActiveAt";
 var HookDataSchema = z33.object({
   session_id: z33.string(),
   transcript_path: z33.string(),
@@ -16658,9 +16912,12 @@ async function readStdinData() {
       clearTimeout(timer);
       try {
         const parsedData = JSON.parse(inputData);
-        hookLog.debug("Parsed stdin data", {
-          keys: Object.keys(parsedData)
-        });
+        hookLog.debug(
+          {
+            data: { keys: Object.keys(parsedData) }
+          },
+          "Parsed stdin data"
+        );
         resolve(parsedData);
       } catch (error) {
         const msg = `Failed to parse JSON from stdin: ${error.message}`;
@@ -16672,7 +16929,10 @@ async function readStdinData() {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      hookLog.error("Error reading from stdin", { error: error.message });
+      hookLog.error(
+        { data: { error: error.message } },
+        "Error reading from stdin"
+      );
       reject(new Error(`Error reading from stdin: ${error.message}`));
     });
   });
@@ -16689,7 +16949,63 @@ 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 {
+    }
+  }
+  try {
+    const dirs = await readdir(projectsDir);
+    for (const dir of dirs) {
+      if (dir === dirName) continue;
+      const candidate = path14.join(projectsDir, dir, filename);
+      try {
+        await access(candidate);
+        hookLog.info(
+          {
+            data: {
+              original: transcriptPath,
+              resolved: candidate,
+              sessionId,
+              method: "sibling-scan"
+            }
+          },
+          "Transcript path resolved via fallback"
+        );
+        return candidate;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return transcriptPath;
+}
 async function readNewTranscriptEntries(transcriptPath, sessionId, sessionStore) {
+  transcriptPath = await resolveTranscriptPath(transcriptPath, sessionId);
   const cursor = sessionStore.get(getCursorKey(transcriptPath));
   let content;
   let fileSize;
@@ -16700,8 +17016,12 @@ async function readNewTranscriptEntries(transcriptPath, sessionId, sessionStore)
       const stat = await fh.stat();
       fileSize = stat.size;
       if (cursor.byteOffset >= stat.size) {
-        hookLog.info("No new data in transcript file", { sessionId });
-        return { entries: [], fileSize };
+        hookLog.info({ data: { sessionId } }, "No new data in transcript file");
+        return {
+          entries: [],
+          endByteOffset: fileSize,
+          resolvedTranscriptPath: transcriptPath
+        };
       }
       const buf = Buffer.alloc(stat.size - cursor.byteOffset);
       await fh.read(buf, 0, buf.length, cursor.byteOffset);
@@ -16710,53 +17030,88 @@ async function readNewTranscriptEntries(transcriptPath, sessionId, sessionStore)
       await fh.close();
     }
     lineIndexOffset = cursor.byteOffset;
-    hookLog.debug("Read transcript file from offset", {
-      transcriptPath,
-      byteOffset: cursor.byteOffset,
-      bytesRead: content.length
-    });
+    hookLog.debug(
+      {
+        data: {
+          transcriptPath,
+          byteOffset: cursor.byteOffset,
+          bytesRead: content.length
+        }
+      },
+      "Read transcript file from offset"
+    );
   } else {
     content = await readFile(transcriptPath, "utf-8");
     fileSize = Buffer.byteLength(content, "utf-8");
     lineIndexOffset = 0;
-    hookLog.debug("Read full transcript file", {
-      transcriptPath,
-      totalBytes: fileSize
-    });
+    hookLog.debug(
+      { data: { transcriptPath, totalBytes: fileSize } },
+      "Read full transcript file"
+    );
   }
-  const lines = content.split("\n").filter((line) => line.trim().length > 0);
+  const startOffset = cursor?.byteOffset ?? 0;
+  const allLines = content.split("\n");
   const parsed = [];
   let malformedLines = 0;
-  for (let i = 0; i < lines.length; i++) {
+  let bytesConsumed = 0;
+  let parsedLineIndex = 0;
+  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;
+    bytesConsumed += lineBytes;
+    if (line.trim().length === 0) continue;
     try {
-      const entry = JSON.parse(lines[i]);
+      const entry = JSON.parse(line);
       const recordId = entry.uuid ?? generateSyntheticId(
         entry.sessionId,
         entry.timestamp,
         entry.type,
-        lineIndexOffset + i
+        lineIndexOffset + parsedLineIndex
       );
       parsed.push({ ...entry, _recordId: recordId });
     } catch {
       malformedLines++;
     }
+    parsedLineIndex++;
   }
+  const endByteOffset = startOffset + bytesConsumed;
+  const capped = parsed.length >= MAX_ENTRIES_PER_INVOCATION;
   if (malformedLines > 0) {
-    hookLog.warn("Skipped malformed lines", { malformedLines, transcriptPath });
+    hookLog.warn(
+      { data: { malformedLines, transcriptPath } },
+      "Skipped malformed lines"
+    );
   }
-  if (!cursor) {
-    hookLog.info("First invocation for session \u2014 uploading all entries", {
-      sessionId,
-      totalEntries: parsed.length
-    });
+  if (capped) {
+    hookLog.info(
+      {
+        data: {
+          sessionId,
+          entriesParsed: parsed.length,
+          totalLines: allLines.length
+        }
+      },
+      "Capped at MAX_ENTRIES_PER_INVOCATION, remaining entries deferred"
+    );
+  } else if (!cursor) {
+    hookLog.info(
+      { data: { sessionId, totalEntries: parsed.length } },
+      "First invocation for session \u2014 uploading all entries"
+    );
   } else {
-    hookLog.info("Resuming from byte offset", {
-      sessionId,
-      byteOffset: cursor.byteOffset,
-      newEntries: parsed.length
-    });
+    hookLog.info(
+      {
+        data: { sessionId, byteOffset: startOffset, newEntries: parsed.length }
+      },
+      "Resuming from byte offset"
+    );
   }
-  return { entries: parsed, fileSize };
+  return {
+    entries: parsed,
+    endByteOffset,
+    resolvedTranscriptPath: transcriptPath
+  };
 }
 var FILTERED_PROGRESS_SUBTYPES = /* @__PURE__ */ new Set([
   // Incremental streaming output from running bash commands, emitted every
@@ -16824,13 +17179,13 @@ async function cleanupStaleSessions(sessionStore) {
   }
   const now = Date.now();
   const prefix = getSessionFilePrefix();
-  const configDir = path13.dirname(sessionStore.path);
+  const configDir = path14.dirname(sessionStore.path);
   try {
     const files = await readdir(configDir);
     let deletedCount = 0;
     for (const file of files) {
       if (!file.startsWith(prefix) || !file.endsWith(".json")) continue;
-      const filePath = path13.join(configDir, file);
+      const filePath = path14.join(configDir, file);
       try {
         const content = JSON.parse(await readFile(filePath, "utf-8"));
         let newest = 0;
@@ -16851,7 +17206,7 @@ async function cleanupStaleSessions(sessionStore) {
       }
     }
     if (deletedCount > 0) {
-      hookLog.info("Cleaned up stale session files", { deletedCount });
+      hookLog.info({ data: { deletedCount } }, "Cleaned up stale session files");
     }
   } catch {
   }
@@ -16859,45 +17214,92 @@ async function cleanupStaleSessions(sessionStore) {
 }
 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");
+    }
+  }
   const rawData = await readStdinData();
   const hookData = validateHookData(rawData);
   const sessionStore = createSessionConfigStore(hookData.session_id);
   await cleanupStaleSessions(sessionStore);
+  const now = Date.now();
   const lastRunAt = sessionStore.get(COOLDOWN_KEY);
-  if (lastRunAt && Date.now() - lastRunAt < HOOK_COOLDOWN_MS) {
+  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: hookData.session_id
+          }
+        },
+        "Hook still active \u2014 possible slow upload or hung process"
+      );
+    }
     return { entriesUploaded: 0, entriesSkipped: 0, errors: 0 };
   }
-  sessionStore.set(COOLDOWN_KEY, Date.now());
+  sessionStore.set(ACTIVE_KEY, now);
+  sessionStore.set(COOLDOWN_KEY, now);
   const log2 = createScopedHookLog(hookData.cwd);
-  log2.info("Hook data validated", {
-    sessionId: hookData.session_id,
-    toolName: hookData.tool_name,
-    hookEvent: hookData.hook_event_name,
-    cwd: hookData.cwd
-  });
+  log2.info(
+    {
+      data: {
+        sessionId: hookData.session_id,
+        toolName: hookData.tool_name,
+        hookEvent: hookData.hook_event_name,
+        cwd: hookData.cwd
+      }
+    },
+    "Hook data validated"
+  );
   try {
     return await processTranscript(hookData, sessionStore, log2);
   } finally {
+    sessionStore.delete(ACTIVE_KEY);
     log2.flushLogs();
   }
 }
 async function processTranscript(hookData, sessionStore, log2) {
-  const cursorKey = getCursorKey(hookData.transcript_path);
-  const { entries: rawEntries, fileSize } = await readNewTranscriptEntries(
-    hookData.transcript_path,
-    hookData.session_id,
-    sessionStore
+  const {
+    entries: rawEntries,
+    endByteOffset,
+    resolvedTranscriptPath
+  } = await log2.timed(
+    "Read transcript",
+    () => readNewTranscriptEntries(
+      hookData.transcript_path,
+      hookData.session_id,
+      sessionStore
+    )
   );
+  const cursorKey = getCursorKey(resolvedTranscriptPath);
   if (rawEntries.length === 0) {
     log2.info("No new entries to upload");
     return { entriesUploaded: 0, entriesSkipped: 0, errors: 0 };
   }
   const { filtered: entries, filteredOut } = filterEntries(rawEntries);
   if (filteredOut > 0) {
-    log2.info("Filtered out noise entries", {
-      filteredOut,
-      remaining: entries.length
-    });
+    log2.info(
+      { data: { filteredOut, remaining: entries.length } },
+      "Filtered out noise entries"
+    );
   }
   if (entries.length === 0) {
     log2.info("All entries filtered out, nothing to upload");
@@ -16905,7 +17307,7 @@ async function processTranscript(hookData, sessionStore, log2) {
     const prevCursor = sessionStore.get(cursorKey);
     const cursor = {
       id: lastEntry._recordId,
-      byteOffset: fileSize,
+      byteOffset: endByteOffset,
       updatedAt: Date.now(),
       lastModel: prevCursor?.lastModel
     };
@@ -16916,10 +17318,32 @@ async function processTranscript(hookData, sessionStore, log2) {
       errors: 0
     };
   }
-  const gqlClient = await log2.timed(
-    "GQL auth",
-    () => getAuthenticatedGQLClient({ isSkipPrompts: true })
-  );
+  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
+    };
+  }
   const cursorForModel = sessionStore.get(cursorKey);
   let lastSeenModel = cursorForModel?.lastModel ?? null;
   const records = entries.map((entry) => {
@@ -16943,21 +17367,33 @@ async function processTranscript(hookData, sessionStore, log2) {
       rawData: rawEntry
     };
   });
-  log2.info("Uploading batch", {
-    count: records.length,
-    skipped: filteredOut,
-    firstRecordId: records[0]?.recordId,
-    lastRecordId: records[records.length - 1]?.recordId
-  });
+  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, hookData.cwd)
+    () => prepareAndSendTracyRecords(gqlClient, records, hookData.cwd, {
+      sanitize
+    })
   );
   if (result.ok) {
     const lastRawEntry = rawEntries[rawEntries.length - 1];
     const cursor = {
       id: lastRawEntry._recordId,
-      byteOffset: fileSize,
+      byteOffset: endByteOffset,
       updatedAt: Date.now(),
       lastModel: lastSeenModel ?? void 0
     };
@@ -16972,7 +17408,10 @@ async function processTranscript(hookData, sessionStore, log2) {
       errors: 0
     };
   }
-  log2.error("Batch upload had errors", { errors: result.errors });
+  log2.error(
+    { data: { errors: result.errors, recordCount: entries.length } },
+    "Batch upload had errors"
+  );
   return {
     entriesUploaded: 0,
     entriesSkipped: filteredOut,
@@ -16980,100 +17419,6 @@ async function processTranscript(hookData, sessionStore, log2) {
   };
 }
 
-// src/features/claude_code/install_hook.ts
-import fsPromises4 from "fs/promises";
-import os5 from "os";
-import path14 from "path";
-import chalk11 from "chalk";
-var CLAUDE_SETTINGS_PATH = path14.join(os5.homedir(), ".claude", "settings.json");
-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"
-  );
-}
-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 = {
-    // Empty matcher = match all tools (Claude Code hook spec: empty string matches every PostToolUse event)
-    matcher: "",
-    hooks: [
-      {
-        type: "command",
-        command
-      }
-    ]
-  };
-  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/args/commands/claude_code.ts
 var claudeCodeInstallHookBuilder = (yargs2) => {
   return yargs2.option("save-env", {
@@ -17105,43 +17450,67 @@ 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(code);
+      process.exit(debugMode ? code : 0);
     }
   }
   process.on("uncaughtException", (error) => {
-    hookLog.error("Uncaught exception in hook", {
-      error: String(error),
-      stack: error.stack
-    });
+    hookLog.error(
+      { data: { error: String(error), stack: error.stack } },
+      "Uncaught exception in hook"
+    );
     void flushAndExit(1);
   });
   process.on("unhandledRejection", (reason) => {
-    hookLog.error("Unhandled rejection in hook", {
-      error: String(reason),
-      stack: reason instanceof Error ? reason.stack : void 0
-    });
+    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();
-    hookLog.info("Claude Code upload complete", {
-      entriesUploaded: result.entriesUploaded,
-      entriesSkipped: result.entriesSkipped,
-      errors: result.errors
-    });
+    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("Failed to process Claude Code hook", {
-      error: String(error),
-      stack: error instanceof Error ? error.stack : void 0
-    });
+    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 flushAndExit(exitCode);
 };