mobbdev 1.4.43 → 1.4.45

package/dist/args/commands/upload_ai_blame.mjs

@@ -1274,9 +1274,11 @@ var init_shared = __esm({
       z.object({
         scmSubmitFixRequest: z.object({
           submitFixRequest: z.object({
+            // note: nullable at runtime (e.g. deleted or permission-filtered user)
+            // even though the generated schema says otherwise
             createdByUser: z.object({
               email: z.string()
-            }),
+            }).nullable().transform((user) => user ?? { email: "" }),
             targetBranchName: z.string().default("")
           }),
           prUrl: z.string().nullable(),
@@ -4403,6 +4405,8 @@ var ScanContext = {
 };
 
 // src/utils/proxy.ts
+import { Agent as HttpAgent } from "http";
+import { Agent as HttpsAgent } from "https";
 import fetchOrig from "cross-fetch";
 import Debug2 from "debug";
 import { HttpsProxyAgent } from "https-proxy-agent";
@@ -4416,31 +4420,33 @@ function httpToWsUrl(url) {
 
 // src/utils/proxy.ts
 var debug2 = Debug2("mobbdev:proxy");
+var UPLOAD_MAX_SOCKETS = 8;
+var uploadHttpAgent;
+var uploadHttpsAgent;
+var uploadProxyAgents = /* @__PURE__ */ new Map();
 function getHttpProxy() {
   return process.env["HTTPS_PROXY"] || process.env["HTTP_PROXY"] || "";
 }
 function getHttpProxyOnly() {
   return process.env["HTTP_PROXY"] || "";
 }
+function resolveProxyForUrl(url) {
+  const parsedUrl = new URL(url);
+  const hostname = parsedUrl.hostname.toLowerCase();
+  const isHttp = parsedUrl.protocol === "http:";
+  const isHttps = parsedUrl.protocol === "https:";
+  const isLocal = hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
+  const noProxy = process.env["NO_PROXY"] || process.env["no_proxy"];
+  const noProxyMatch = noProxy?.split(",").map((h) => h.trim().toLowerCase()).some((h) => h === hostname || h === "*") ?? false;
+  if (isLocal || noProxyMatch) {
+    return { proxy: "", isHttp, isHttps };
+  }
+  const proxy = isHttps ? getHttpProxy() : isHttp ? getHttpProxyOnly() : "";
+  return { proxy, isHttp, isHttps };
+}
 function getProxyAgent(url) {
   try {
-    const parsedUrl = new URL(url);
-    const hostname = parsedUrl.hostname.toLowerCase();
-    if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]") {
-      debug2("Skipping proxy for localhost URL: %s", url);
-      return void 0;
-    }
-    const noProxy = process.env["NO_PROXY"] || process.env["no_proxy"];
-    if (noProxy) {
-      const noProxyList = noProxy.split(",").map((h) => h.trim().toLowerCase());
-      if (noProxyList.includes(hostname) || noProxyList.includes("*")) {
-        debug2("Skipping proxy due to NO_PROXY for: %s", url);
-        return void 0;
-      }
-    }
-    const isHttp = parsedUrl.protocol === "http:";
-    const isHttps = parsedUrl.protocol === "https:";
-    const proxy = isHttps ? getHttpProxy() : isHttp ? getHttpProxyOnly() : null;
+    const { proxy } = resolveProxyForUrl(url);
     if (proxy) {
       debug2("Using proxy %s for %s", proxy, url);
       return new HttpsProxyAgent(proxy);
@@ -4450,6 +4456,39 @@ function getProxyAgent(url) {
   }
   return void 0;
 }
+function getUploadAgent(url) {
+  try {
+    const { proxy, isHttp, isHttps } = resolveProxyForUrl(url);
+    if (proxy) {
+      let agent = uploadProxyAgents.get(proxy);
+      if (!agent) {
+        agent = new HttpsProxyAgent(proxy, {
+          keepAlive: true,
+          maxSockets: UPLOAD_MAX_SOCKETS
+        });
+        uploadProxyAgents.set(proxy, agent);
+      }
+      return agent;
+    }
+    if (isHttps) {
+      uploadHttpsAgent ?? (uploadHttpsAgent = new HttpsAgent({
+        keepAlive: true,
+        maxSockets: UPLOAD_MAX_SOCKETS
+      }));
+      return uploadHttpsAgent;
+    }
+    if (isHttp) {
+      uploadHttpAgent ?? (uploadHttpAgent = new HttpAgent({
+        keepAlive: true,
+        maxSockets: UPLOAD_MAX_SOCKETS
+      }));
+      return uploadHttpAgent;
+    }
+  } catch (err) {
+    debug2(`No upload agent for ${url}. Reason: ${err.message}`);
+  }
+  return void 0;
+}
 var fetchWithProxy = (url, options = {}) => {
   try {
     const agent = getProxyAgent(url.toString());
@@ -5657,7 +5696,7 @@ async function uploadFile({
       )
     );
   }
-  const agent = getProxyAgent(url);
+  const agent = getUploadAgent(url);
   const effectiveSignal = signal ?? AbortSignal.timeout(computeUploadTimeoutMs(file));
   const response = await fetch3(url, {
     method: "POST",

package/dist/index.mjs

@@ -1376,9 +1376,11 @@ var init_shared = __esm({
       z2.object({
         scmSubmitFixRequest: z2.object({
           submitFixRequest: z2.object({
+            // note: nullable at runtime (e.g. deleted or permission-filtered user)
+            // even though the generated schema says otherwise
             createdByUser: z2.object({
               email: z2.string()
-            }),
+            }).nullable().transform((user) => user ?? { email: "" }),
             targetBranchName: z2.string().default("")
           }),
           prUrl: z2.string().nullable(),
@@ -11369,6 +11371,8 @@ __publicField(_ReportDigestError, "defaultMessage", "\u{1F575}\uFE0F\u200D\u2642
 var ReportDigestError = _ReportDigestError;
 
 // src/utils/proxy.ts
+import { Agent as HttpAgent } from "http";
+import { Agent as HttpsAgent } from "https";
 import fetchOrig from "cross-fetch";
 import Debug5 from "debug";
 import { HttpsProxyAgent } from "https-proxy-agent";
@@ -11382,31 +11386,33 @@ function httpToWsUrl(url) {
 
 // src/utils/proxy.ts
 var debug6 = Debug5("mobbdev:proxy");
+var UPLOAD_MAX_SOCKETS = 8;
+var uploadHttpAgent;
+var uploadHttpsAgent;
+var uploadProxyAgents = /* @__PURE__ */ new Map();
 function getHttpProxy() {
   return process.env["HTTPS_PROXY"] || process.env["HTTP_PROXY"] || "";
 }
 function getHttpProxyOnly() {
   return process.env["HTTP_PROXY"] || "";
 }
+function resolveProxyForUrl(url) {
+  const parsedUrl = new URL(url);
+  const hostname = parsedUrl.hostname.toLowerCase();
+  const isHttp = parsedUrl.protocol === "http:";
+  const isHttps = parsedUrl.protocol === "https:";
+  const isLocal = hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
+  const noProxy = process.env["NO_PROXY"] || process.env["no_proxy"];
+  const noProxyMatch = noProxy?.split(",").map((h) => h.trim().toLowerCase()).some((h) => h === hostname || h === "*") ?? false;
+  if (isLocal || noProxyMatch) {
+    return { proxy: "", isHttp, isHttps };
+  }
+  const proxy = isHttps ? getHttpProxy() : isHttp ? getHttpProxyOnly() : "";
+  return { proxy, isHttp, isHttps };
+}
 function getProxyAgent(url) {
   try {
-    const parsedUrl = new URL(url);
-    const hostname = parsedUrl.hostname.toLowerCase();
-    if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]") {
-      debug6("Skipping proxy for localhost URL: %s", url);
-      return void 0;
-    }
-    const noProxy = process.env["NO_PROXY"] || process.env["no_proxy"];
-    if (noProxy) {
-      const noProxyList = noProxy.split(",").map((h) => h.trim().toLowerCase());
-      if (noProxyList.includes(hostname) || noProxyList.includes("*")) {
-        debug6("Skipping proxy due to NO_PROXY for: %s", url);
-        return void 0;
-      }
-    }
-    const isHttp = parsedUrl.protocol === "http:";
-    const isHttps = parsedUrl.protocol === "https:";
-    const proxy = isHttps ? getHttpProxy() : isHttp ? getHttpProxyOnly() : null;
+    const { proxy } = resolveProxyForUrl(url);
     if (proxy) {
       debug6("Using proxy %s for %s", proxy, url);
       return new HttpsProxyAgent(proxy);
@@ -11416,6 +11422,39 @@ function getProxyAgent(url) {
   }
   return void 0;
 }
+function getUploadAgent(url) {
+  try {
+    const { proxy, isHttp, isHttps } = resolveProxyForUrl(url);
+    if (proxy) {
+      let agent = uploadProxyAgents.get(proxy);
+      if (!agent) {
+        agent = new HttpsProxyAgent(proxy, {
+          keepAlive: true,
+          maxSockets: UPLOAD_MAX_SOCKETS
+        });
+        uploadProxyAgents.set(proxy, agent);
+      }
+      return agent;
+    }
+    if (isHttps) {
+      uploadHttpsAgent ?? (uploadHttpsAgent = new HttpsAgent({
+        keepAlive: true,
+        maxSockets: UPLOAD_MAX_SOCKETS
+      }));
+      return uploadHttpsAgent;
+    }
+    if (isHttp) {
+      uploadHttpAgent ?? (uploadHttpAgent = new HttpAgent({
+        keepAlive: true,
+        maxSockets: UPLOAD_MAX_SOCKETS
+      }));
+      return uploadHttpAgent;
+    }
+  } catch (err) {
+    debug6(`No upload agent for ${url}. Reason: ${err.message}`);
+  }
+  return void 0;
+}
 var fetchWithProxy = (url, options = {}) => {
   try {
     const agent = getProxyAgent(url.toString());
@@ -12299,6 +12338,16 @@ var S3UploadError = class extends Error {
     this.name = "S3UploadError";
   }
 };
+var ACTIONABLE_S3_CODES = /* @__PURE__ */ new Set([
+  "AccessDenied",
+  "ExpiredToken",
+  "InvalidAccessKeyId",
+  "SignatureDoesNotMatch",
+  "TokenRefreshRequired"
+]);
+function isActionableS3Error(err) {
+  return err instanceof S3UploadError && err.s3Code !== void 0 && ACTIONABLE_S3_CODES.has(err.s3Code);
+}
 function parseS3ErrorBody(body) {
   return {
     code: body.match(/<Code>([^<]+)<\/Code>/)?.[1],
@@ -12347,7 +12396,7 @@ async function uploadFile({
       )
     );
   }
-  const agent = getProxyAgent(url);
+  const agent = getUploadAgent(url);
   const effectiveSignal = signal ?? AbortSignal.timeout(computeUploadTimeoutMs(file));
   const response = await fetch3(url, {
     method: "POST",
@@ -15948,7 +15997,179 @@ import { readFileSync, writeFileSync as writeFileSync2 } from "fs";
 import * as os8 from "os";
 import path24 from "path";
 import { setTimeout as sleep4 } from "timers/promises";
-import Configstore3 from "configstore";
+import Configstore4 from "configstore";
+
+// src/features/analysis/context_upload_ledger.ts
+import Configstore2 from "configstore";
+var UPLOADED_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
+var FAILURE_BACKOFF_BASE_MS = 60 * 1e3;
+var FAILURE_BACKOFF_MAX_MS = 60 * 60 * 1e3;
+var FAILURE_LOG_WINDOW_MS = 30 * 60 * 1e3;
+var BREAKER_FAILURE_THRESHOLD = 8;
+var BREAKER_FAILURE_WINDOW_MS = 5 * 60 * 1e3;
+var BREAKER_BASE_COOLDOWN_MS = 30 * 1e3;
+var BREAKER_MAX_COOLDOWN_MS = 10 * 60 * 1e3;
+var MAX_LEDGER_ENTRIES = 5e3;
+var LEDGER_NAMESPACE = "mobbdev-context-upload-ledger";
+var ENTRIES_KEY = "entries";
+var BREAKER_KEY = "breaker";
+var NOOP_UPLOAD_LEDGER = {
+  isUploaded: () => false,
+  isBackedOff: () => false,
+  isBreakerOpen: () => false,
+  onSuccess: () => {
+  },
+  onFailure: () => true,
+  flush: () => {
+  }
+};
+var ConfigstoreUploadLedger = class {
+  constructor(store) {
+    __publicField(this, "store");
+    __publicField(this, "entries");
+    __publicField(this, "breaker");
+    __publicField(this, "dirty", false);
+    this.store = store ?? new Configstore2(LEDGER_NAMESPACE);
+    this.entries = loadEntries(this.store);
+    this.breaker = loadBreaker(this.store);
+  }
+  isUploaded(md5, now) {
+    const entry = this.entries.get(md5);
+    if (!entry?.uploadedAt) {
+      return false;
+    }
+    if (now - entry.uploadedAt > UPLOADED_TTL_MS) {
+      return false;
+    }
+    entry.touchedAt = now;
+    this.dirty = true;
+    return true;
+  }
+  isBackedOff(md5, now) {
+    const entry = this.entries.get(md5);
+    return entry?.nextRetryAt !== void 0 && entry.nextRetryAt > now;
+  }
+  isBreakerOpen(now) {
+    return this.breaker.openUntil > now;
+  }
+  onSuccess(md5, now) {
+    const entry = this.getOrCreate(md5, now);
+    entry.uploadedAt = now;
+    entry.touchedAt = now;
+    delete entry.attempts;
+    delete entry.nextRetryAt;
+    delete entry.lastLoggedAt;
+    this.breaker.consecutiveFailures = 0;
+    this.breaker.lastFailureAt = 0;
+    this.breaker.trips = 0;
+    this.breaker.openUntil = 0;
+    this.dirty = true;
+  }
+  onFailure(md5, now) {
+    const entry = this.getOrCreate(md5, now);
+    const attempts = (entry.attempts ?? 0) + 1;
+    const delay3 = Math.min(
+      FAILURE_BACKOFF_BASE_MS * 2 ** (attempts - 1),
+      FAILURE_BACKOFF_MAX_MS
+    );
+    entry.attempts = attempts;
+    entry.nextRetryAt = now + delay3;
+    entry.touchedAt = now;
+    if (now - this.breaker.lastFailureAt > BREAKER_FAILURE_WINDOW_MS) {
+      this.breaker.consecutiveFailures = 0;
+    }
+    this.breaker.lastFailureAt = now;
+    this.breaker.consecutiveFailures += 1;
+    if (this.breaker.consecutiveFailures >= BREAKER_FAILURE_THRESHOLD && this.breaker.openUntil <= now) {
+      const cooldown = Math.min(
+        BREAKER_BASE_COOLDOWN_MS * 2 ** this.breaker.trips,
+        BREAKER_MAX_COOLDOWN_MS
+      );
+      this.breaker.trips += 1;
+      this.breaker.openUntil = now + cooldown;
+    }
+    const shouldLog = entry.lastLoggedAt === void 0 || now - entry.lastLoggedAt >= FAILURE_LOG_WINDOW_MS;
+    if (shouldLog) {
+      entry.lastLoggedAt = now;
+    }
+    this.dirty = true;
+    return shouldLog;
+  }
+  flush() {
+    if (!this.dirty) {
+      return;
+    }
+    this.evictIfNeeded();
+    try {
+      this.store.set(ENTRIES_KEY, Object.fromEntries(this.entries));
+      this.store.set(BREAKER_KEY, this.breaker);
+      this.dirty = false;
+    } catch {
+    }
+  }
+  getOrCreate(md5, now) {
+    let entry = this.entries.get(md5);
+    if (!entry) {
+      entry = { touchedAt: now };
+      this.entries.set(md5, entry);
+    }
+    return entry;
+  }
+  /** Evict least-recently-touched entries when over the cap. */
+  evictIfNeeded() {
+    if (this.entries.size <= MAX_LEDGER_ENTRIES) {
+      return;
+    }
+    const sorted = [...this.entries.entries()].sort(
+      (a, b) => a[1].touchedAt - b[1].touchedAt
+    );
+    const removeCount = this.entries.size - MAX_LEDGER_ENTRIES;
+    for (let i = 0; i < removeCount; i++) {
+      this.entries.delete(sorted[i][0]);
+    }
+  }
+};
+function finiteOrUndefined(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n >= 0 ? n : void 0;
+}
+function loadEntries(store) {
+  const map = /* @__PURE__ */ new Map();
+  try {
+    const raw = store.get(ENTRIES_KEY);
+    if (raw && typeof raw === "object") {
+      for (const [md5, entry] of Object.entries(raw)) {
+        if (!entry || typeof entry !== "object") {
+          continue;
+        }
+        map.set(md5, {
+          uploadedAt: finiteOrUndefined(entry.uploadedAt),
+          attempts: finiteOrUndefined(entry.attempts),
+          nextRetryAt: finiteOrUndefined(entry.nextRetryAt),
+          lastLoggedAt: finiteOrUndefined(entry.lastLoggedAt),
+          touchedAt: finiteOrUndefined(entry.touchedAt) ?? 0
+        });
+      }
+    }
+  } catch {
+  }
+  return map;
+}
+function loadBreaker(store) {
+  try {
+    const raw = store.get(BREAKER_KEY);
+    if (raw && typeof raw === "object") {
+      return {
+        consecutiveFailures: finiteOrUndefined(raw.consecutiveFailures) ?? 0,
+        lastFailureAt: finiteOrUndefined(raw.lastFailureAt) ?? 0,
+        trips: finiteOrUndefined(raw.trips) ?? 0,
+        openUntil: finiteOrUndefined(raw.openUntil) ?? 0
+      };
+    }
+  } catch {
+  }
+  return { consecutiveFailures: 0, lastFailureAt: 0, trips: 0, openUntil: 0 };
+}
 
 // src/features/analysis/skill_quarantine/runQuarantineCheck.ts
 import { stat as stat3 } from "fs/promises";
@@ -16226,8 +16447,8 @@ var SCAN_PATHS = {
 // src/features/analysis/context_file_scanner.ts
 var MAX_CONTEXT_FILE_SIZE = 20 * 1024 * 1024;
 var SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
-var FAILURE_BACKOFF_BASE_MS = 60 * 1e3;
-var FAILURE_BACKOFF_MAX_MS = 60 * 60 * 1e3;
+var FAILURE_BACKOFF_BASE_MS2 = 60 * 1e3;
+var FAILURE_BACKOFF_MAX_MS2 = 60 * 60 * 1e3;
 var sessionMtimes = /* @__PURE__ */ new Map();
 function markContextFilesUploaded(sessionId, files, skills) {
   const entry = getOrCreateSessionEntry(sessionId);
@@ -16249,8 +16470,8 @@ function markContextUploadFailed(sessionId, files, skills) {
   const recordFailure = (key) => {
     const attempts = (entry.failures.get(key)?.attempts ?? 0) + 1;
     const delay3 = Math.min(
-      FAILURE_BACKOFF_BASE_MS * 2 ** (attempts - 1),
-      FAILURE_BACKOFF_MAX_MS
+      FAILURE_BACKOFF_BASE_MS2 * 2 ** (attempts - 1),
+      FAILURE_BACKOFF_MAX_MS2
     );
     entry.failures.set(key, { attempts, nextRetryAt: now + delay3 });
   };
@@ -17365,7 +17586,12 @@ var DAEMON_POLL_INTERVAL_MS = (() => {
 var HEARTBEAT_STALE_MS = 3e4;
 var TRANSCRIPT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var DAEMON_CHUNK_SIZE = 50;
-var CONTEXT_SCAN_INTERVAL_MS = 5e3;
+var CONTEXT_SCAN_INTERVAL_MS = (() => {
+  const raw = Number(process.env["MOBB_CONTEXT_SCAN_INTERVAL_MS"]);
+  if (!Number.isFinite(raw) || raw <= 0) return 15 * 6e4;
+  return Math.min(Math.max(raw, 1e4), 60 * 6e4);
+})();
+var DAEMON_SHUTDOWN_DRAIN_MS = 6e3;
 
 // src/features/claude_code/daemon_pid_file.ts
 function getMobbdevDir() {
@@ -17449,7 +17675,7 @@ import { promisify } from "util";
 import { setTimeout as sleep3 } from "timers/promises";
 import pLimit6 from "p-limit";
 init_client_generates();
-var UPLOAD_CONCURRENCY = 5;
+var UPLOAD_CONCURRENCY = 1;
 var UPLOAD_MAX_ATTEMPTS = 2;
 var UPLOAD_RETRY_BASE_MS = 250;
 async function uploadWithRetry(args) {
@@ -17467,6 +17693,29 @@ async function uploadWithRetry(args) {
     }
   }
 }
+var uploadLimit = pLimit6(UPLOAD_CONCURRENCY);
+var inFlightUploads = /* @__PURE__ */ new Map();
+async function coalescedUpload(s3Key, run2) {
+  const existing = inFlightUploads.get(s3Key);
+  if (existing) {
+    try {
+      await existing;
+      return { leader: false, ok: true };
+    } catch (err) {
+      return { leader: false, ok: false, err };
+    }
+  }
+  const p = uploadLimit(run2);
+  inFlightUploads.set(s3Key, p);
+  try {
+    await p;
+    return { leader: true, ok: true };
+  } catch (err) {
+    return { leader: true, ok: false, err };
+  } finally {
+    inFlightUploads.delete(s3Key);
+  }
+}
 async function uploadContextRecords(opts) {
   const {
     processedFiles,
@@ -17481,6 +17730,7 @@ async function uploadContextRecords(opts) {
     branch,
     commitSha,
     clientVersion,
+    ledger = NOOP_UPLOAD_LEDGER,
     onFileError,
     onSkillError
   } = opts;
@@ -17489,82 +17739,97 @@ async function uploadContextRecords(opts) {
   const uploadedSkillGroups = [];
   const failedFiles = [];
   const failedSkillGroups = [];
-  const limit = pLimit6(UPLOAD_CONCURRENCY);
+  let dedupedCount = 0;
+  let suppressedCount = 0;
   const extraFields = {
     ...repositoryUrl !== void 0 && { repositoryUrl },
     ...branch !== void 0 && { branch },
     ...commitSha !== void 0 && { commitSha },
     ...clientVersion !== void 0 && { clientVersion }
   };
+  const processItem = async (item) => {
+    const nowMs = Date.now();
+    if (ledger.isUploaded(item.md5, nowMs)) {
+      dedupedCount++;
+    } else if (ledger.isBreakerOpen(nowMs) || ledger.isBackedOff(item.md5, nowMs)) {
+      suppressedCount++;
+      return;
+    } else {
+      const { leader, ok, err } = await coalescedUpload(
+        item.s3Key,
+        () => uploadWithRetry({
+          file: item.getPayload(),
+          url,
+          uploadKey: item.s3Key,
+          uploadFields
+        })
+      );
+      if (!ok) {
+        item.markFailed();
+        if (leader) {
+          const logByWindow = ledger.onFailure(item.md5, Date.now());
+          if (logByWindow || isActionableS3Error(err)) {
+            item.onError?.(item.errorName, err);
+          }
+        }
+        return;
+      }
+      if (leader) {
+        ledger.onSuccess(item.md5, Date.now());
+      }
+    }
+    records.push({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      platform: platform2,
+      recordId: `ctx:${sessionId}:${item.md5}`,
+      recordTimestamp: now,
+      blameType: "CHAT" /* Chat */,
+      rawDataS3Key: item.s3Key,
+      ...extraFields,
+      context: {
+        md5: item.md5,
+        category: item.context.category,
+        name: item.context.name,
+        sizeBytes: item.context.sizeBytes,
+        filePath: item.context.filePath,
+        sessionId
+      }
+    });
+    item.markUploaded();
+  };
   const tasks = [
     ...processedFiles.map(
-      (pf) => limit(async () => {
-        const s3Key = `${keyPrefix}ctx-${pf.md5}.bin`;
-        try {
-          await uploadWithRetry({
-            file: Buffer.from(pf.sanitizedContent, "utf-8"),
-            url,
-            uploadKey: s3Key,
-            uploadFields
-          });
-        } catch (err) {
-          failedFiles.push(pf.entry);
-          onFileError?.(pf.entry.name, err);
-          return;
-        }
-        records.push({
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          platform: platform2,
-          recordId: `ctx:${sessionId}:${pf.md5}`,
-          recordTimestamp: now,
-          blameType: "CHAT" /* Chat */,
-          rawDataS3Key: s3Key,
-          ...extraFields,
-          context: {
-            md5: pf.md5,
-            category: pf.entry.category,
-            name: pf.entry.name,
-            sizeBytes: pf.sizeBytes,
-            filePath: pf.entry.path,
-            sessionId
-          }
-        });
-        uploadedFiles.push(pf.entry);
+      (pf) => processItem({
+        md5: pf.md5,
+        s3Key: `${keyPrefix}ctx-${pf.md5}.bin`,
+        getPayload: () => Buffer.from(pf.sanitizedContent, "utf-8"),
+        context: {
+          category: pf.entry.category,
+          name: pf.entry.name,
+          sizeBytes: pf.sizeBytes,
+          filePath: pf.entry.path
+        },
+        errorName: pf.entry.name,
+        onError: onFileError,
+        markUploaded: () => uploadedFiles.push(pf.entry),
+        markFailed: () => failedFiles.push(pf.entry)
       })
     ),
     ...processedSkills.map(
-      (ps) => limit(async () => {
-        const s3Key = `${keyPrefix}skill-${ps.md5}.zip`;
-        try {
-          await uploadWithRetry({
-            file: ps.zipBuffer,
-            url,
-            uploadKey: s3Key,
-            uploadFields
-          });
-        } catch (err) {
-          failedSkillGroups.push(ps.group);
-          onSkillError?.(ps.group.name, err);
-          return;
-        }
-        records.push({
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          platform: platform2,
-          recordId: `ctx:${sessionId}:${ps.md5}`,
-          recordTimestamp: now,
-          blameType: "CHAT" /* Chat */,
-          rawDataS3Key: s3Key,
-          ...extraFields,
-          context: {
-            md5: ps.md5,
-            category: SKILL_CATEGORY,
-            name: ps.group.name,
-            sizeBytes: ps.sizeBytes,
-            filePath: ps.group.skillPath,
-            sessionId
-          }
-        });
-        uploadedSkillGroups.push(ps.group);
+      (ps) => processItem({
+        md5: ps.md5,
+        s3Key: `${keyPrefix}skill-${ps.md5}.zip`,
+        getPayload: () => ps.zipBuffer,
+        context: {
+          category: SKILL_CATEGORY,
+          name: ps.group.name,
+          sizeBytes: ps.sizeBytes,
+          filePath: ps.group.skillPath
+        },
+        errorName: ps.group.name,
+        onError: onSkillError,
+        markUploaded: () => uploadedSkillGroups.push(ps.group),
+        markFailed: () => failedSkillGroups.push(ps.group)
       })
     )
   ];
@@ -17574,7 +17839,10 @@ async function uploadContextRecords(opts) {
     uploadedFiles,
     uploadedSkillGroups,
     failedFiles,
-    failedSkillGroups
+    failedSkillGroups,
+    dedupedCount,
+    suppressedCount,
+    breakerOpen: ledger.isBreakerOpen(Date.now())
   };
 }
 async function runContextFileUploadPipeline(opts) {
@@ -17590,6 +17858,7 @@ async function runContextFileUploadPipeline(opts) {
     branch,
     commitSha,
     clientVersion,
+    ledger,
     submitRecords,
     onFileError,
     onSkillError
@@ -17606,7 +17875,10 @@ async function runContextFileUploadPipeline(opts) {
     uploadedFiles,
     uploadedSkillGroups,
     failedFiles,
-    failedSkillGroups
+    failedSkillGroups,
+    dedupedCount,
+    suppressedCount,
+    breakerOpen
   } = await uploadContextRecords({
     processedFiles,
     processedSkills,
@@ -17620,20 +17892,28 @@ async function runContextFileUploadPipeline(opts) {
     branch,
     commitSha,
     clientVersion,
+    ledger,
     onFileError,
     onSkillError
   });
   if (failedFiles.length > 0 || failedSkillGroups.length > 0) {
     markContextUploadFailed(sessionId, failedFiles, failedSkillGroups);
   }
+  const summary = {
+    dedupedCount,
+    suppressedCount,
+    failedCount: failedFiles.length + failedSkillGroups.length,
+    breakerOpen
+  };
   if (records.length === 0) {
-    return { fileCount: 0, skillCount: 0 };
+    return { fileCount: 0, skillCount: 0, ...summary };
   }
   await submitRecords(records);
   markContextFilesUploaded(sessionId, uploadedFiles, uploadedSkillGroups);
   return {
     fileCount: uploadedFiles.length,
-    skillCount: uploadedSkillGroups.length
+    skillCount: uploadedSkillGroups.length,
+    ...summary
   };
 }
 
@@ -17641,7 +17921,7 @@ async function runContextFileUploadPipeline(opts) {
 init_client_generates();
 
 // src/utils/shared-logger/create-logger.ts
-import Configstore2 from "configstore";
+import Configstore3 from "configstore";
 import pino from "pino";
 
 // src/utils/shared-logger/configstore-stream.ts
@@ -17868,7 +18148,7 @@ function createLogger(config2) {
   } = config2;
   let csStream = null;
   if (enableConfigstore) {
-    const store = new Configstore2(namespace, {});
+    const store = new Configstore3(namespace, {});
     csStream = createConfigstoreStream(store, {
       buffered,
       scopePath,
@@ -17977,7 +18257,7 @@ function createLogger(config2) {
 
 // src/features/claude_code/hook_logger.ts
 var DD_RUM_TOKEN = true ? "pubf59c0182545bfb4c299175119f1abf9b" : "";
-var CLI_VERSION = true ? "1.4.43" : "unknown";
+var CLI_VERSION = true ? "1.4.45" : "unknown";
 var NAMESPACE = "mobbdev-claude-code-hook-logs";
 var claudeCodeVersion;
 function buildDdTags() {
@@ -18548,7 +18828,7 @@ async function processTranscript(input, sessionStore, log2, maxEntries = DAEMON_
     errors: entries.length
   };
 }
-async function uploadContextFilesIfNeeded(sessionId, cwd, gqlClient, log2) {
+async function uploadContextFilesIfNeeded(sessionId, cwd, gqlClient, log2, ledger) {
   const { regularFiles, skillGroups } = await scanContextFiles(
     cwd,
     "claude-code",
@@ -18570,6 +18850,7 @@ async function uploadContextFilesIfNeeded(sessionId, cwd, gqlClient, log2) {
     );
     return;
   }
+  const uploadFailures = [];
   const pipelineResult = await runContextFileUploadPipeline({
     processedFiles,
     processedSkills,
@@ -18578,20 +18859,15 @@ async function uploadContextFilesIfNeeded(sessionId, cwd, gqlClient, log2) {
     url,
     uploadFieldsJSON,
     keyPrefix,
+    ledger,
     submitRecords: async (records) => {
       const r = await prepareAndSendTracyRecords(gqlClient, records, cwd);
       if (!r.ok) {
         throw new Error(r.errors?.join(", ") ?? "batch upload failed");
       }
     },
-    onFileError: (name, err) => log2.error(
-      { data: { sessionId, name, err } },
-      "Failed to upload context file to S3"
-    ),
-    onSkillError: (name, err) => log2.error(
-      { data: { sessionId, name, err } },
-      "Failed to upload skill zip to S3"
-    )
+    onFileError: (name, err) => uploadFailures.push({ name, err }),
+    onSkillError: (name, err) => uploadFailures.push({ name, err })
   });
   if (pipelineResult === null) {
     log2.error(
@@ -18600,19 +18876,48 @@ async function uploadContextFilesIfNeeded(sessionId, cwd, gqlClient, log2) {
     );
     return;
   }
+  if (uploadFailures.length > 0) {
+    const hasActionableS3Error = uploadFailures.some(
+      (f) => isActionableS3Error(f.err)
+    );
+    const payload = {
+      sessionId,
+      failedCount: pipelineResult.failedCount,
+      suppressedCount: pipelineResult.suppressedCount,
+      dedupedCount: pipelineResult.dedupedCount,
+      breakerOpen: pipelineResult.breakerOpen,
+      errTypes: summarizeUploadErrTypes(uploadFailures.map((f) => f.err)),
+      sample: uploadFailures.slice(0, 3).map((f) => f.name)
+    };
+    if (hasActionableS3Error) {
+      log2.error({ data: payload }, "Context/skill S3 upload failures");
+    } else {
+      log2.warn({ data: payload }, "Context/skill upload failures (transient)");
+    }
+  }
   if (pipelineResult.fileCount > 0 || pipelineResult.skillCount > 0) {
     log2.info(
       {
         data: {
           sessionId,
           fileCount: pipelineResult.fileCount,
-          skillCount: pipelineResult.skillCount
+          skillCount: pipelineResult.skillCount,
+          dedupedCount: pipelineResult.dedupedCount
         }
       },
       "Uploaded context files and skills for session"
     );
   }
 }
+function summarizeUploadErrTypes(errs) {
+  const counts = {};
+  for (const err of errs) {
+    const e = err;
+    const key = e?.type ?? e?.code ?? e?.name ?? "unknown";
+    counts[key] = (counts[key] ?? 0) + 1;
+  }
+  return counts;
+}
 
 // src/features/claude_code/install_hook.ts
 import fs14 from "fs";
@@ -18951,9 +19256,18 @@ async function startDaemon() {
   hookLog.info("Daemon starting");
   pruneHookLogFile();
   const pidFile = await acquirePidFile();
+  const uploadLedger = new ConfigstoreUploadLedger();
+  const inFlightContextUploads = /* @__PURE__ */ new Set();
   async function gracefulExit(code, reason) {
     hookLog.info({ data: { code } }, `Daemon exiting: ${reason}`);
     pidFile.remove();
+    if (inFlightContextUploads.size > 0) {
+      await Promise.race([
+        Promise.allSettled([...inFlightContextUploads]),
+        sleep4(DAEMON_SHUTDOWN_DRAIN_MS)
+      ]);
+    }
+    uploadLedger.flush();
     await flushDdLogs();
     process.exit(code);
   }
@@ -19043,14 +19357,20 @@ async function startDaemon() {
         }
       }
       const now = Date.now();
-      if (now - lastContextScanMs >= CONTEXT_SCAN_INTERVAL_MS) {
+      if (!shuttingDown && now - lastContextScanMs >= CONTEXT_SCAN_INTERVAL_MS) {
         lastContextScanMs = now;
         for (const { sessionId, cwd } of sessionCwdCache.values()) {
           const log2 = createScopedHookLog(cwd, { daemonMode: true });
-          uploadContextFilesIfNeeded(sessionId, cwd, gqlClient, log2).catch(
-            (err) => log2.warn({ err }, "Context file scan failed")
-          );
+          const p = uploadContextFilesIfNeeded(
+            sessionId,
+            cwd,
+            gqlClient,
+            log2,
+            uploadLedger
+          ).catch((err) => log2.warn({ err }, "Context file scan failed")).finally(() => inFlightContextUploads.delete(p));
+          inFlightContextUploads.add(p);
         }
+        uploadLedger.flush();
       }
       if (cleanupConfigDir) {
         await cleanupStaleSessions(cleanupConfigDir);
@@ -19220,7 +19540,7 @@ async function tryAutoUpgradeHooks() {
 var HOOK_LOG_MAX_SCOPE_KEYS = 20;
 var HOOK_LOG_MAX_ENTRIES_PER_KEY = 200;
 function pruneHookLogFile() {
-  const logFilePath = new Configstore3("mobbdev-claude-code-hook-logs").path;
+  const logFilePath = new Configstore4("mobbdev-claude-code-hook-logs").path;
   try {
     const raw = readFileSync(logFilePath, "utf-8");
     const data = JSON.parse(raw);
@@ -19352,7 +19672,7 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 
 // src/mcp/Logger.ts
-import Configstore4 from "configstore";
+import Configstore5 from "configstore";
 
 // src/mcp/services/WorkspaceService.ts
 var WorkspaceService = class {
@@ -19438,7 +19758,7 @@ var Logger = class {
     __publicField(this, "lastKnownPath", null);
     this.host = WorkspaceService.getHost();
     this.unknownPathSuffix = Math.floor(1e3 + Math.random() * 9e3).toString();
-    this.mobbConfigStore = new Configstore4("mobb-logs", {});
+    this.mobbConfigStore = new Configstore5("mobb-logs", {});
     this.mobbConfigStore.set("version", packageJson.version);
   }
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobbdev",
-  "version": "1.4.43",
+  "version": "1.4.45",
   "description": "Automated secure code remediation tool",
   "repository": "git+https://github.com/mobb-dev/bugsy.git",
   "main": "dist/index.mjs",