@funnycode/myclaude 0.1.89 → 0.1.90

package/dist/myclaude.js

@@ -4,8 +4,8 @@
 // MACRO - build-time constants (injected by build.ts)
 // MACRO injected by build script
 globalThis.MACRO = {
-  VERSION: "0.1.89",
-  BUILD_TIME: "2026-07-17T12:20:44.184Z",
+  VERSION: "0.1.90",
+  BUILD_TIME: "2026-07-17T18:18:41.746Z",
   PACKAGE_URL: "@funnycode/myclaude",
   NATIVE_PACKAGE_URL: "@funnycode/myclaude",
   VERSION_CHANGELOG: '',
@@ -117484,7 +117484,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@funnycode/myclaude",
-    version: "0.1.89",
+    version: "0.1.90",
     private: false,
     description: "An open-source AI coding assistant in your terminal - powered by Claude",
     license: "MIT",
@@ -117548,6 +117548,7 @@ var init_package = __esm(() => {
       "@opentelemetry/semantic-conventions": "1.40.0",
       ajv: "8.18.0",
       asciichart: "1.5.25",
+      "async-mutex": "^0.5.0",
       "auto-bind": "5.0.1",
       axios: "1.14.0",
       "bidi-js": "1.0.3",
@@ -210289,27 +210290,50 @@ function createDumpPromptsFetch(agentIdOrSessionId) {
             const reader = cloned.body.getReader();
             const decoder = new TextDecoder;
             let buffer = "";
+            const chunks = [];
             try {
               while (true) {
                 const { done, value } = await reader.read();
                 if (done)
                   break;
                 buffer += decoder.decode(value, { stream: true });
+                const lastDoubleNewline = buffer.lastIndexOf(`
+
+`);
+                if (lastDoubleNewline !== -1) {
+                  const completeEvents = buffer.slice(0, lastDoubleNewline);
+                  buffer = buffer.slice(lastDoubleNewline + 2);
+                  for (const event of completeEvents.split(`
+
+`)) {
+                    for (const line of event.split(`
+`)) {
+                      if (line.startsWith("data: ") && line !== "data: [DONE]") {
+                        try {
+                          chunks.push(jsonParse(line.slice(6)));
+                        } catch (err2) {
+                          logForDebugging(`dumpPrompts.SSE parse error: ${err2}`, { level: "error" });
+                        }
+                      }
+                    }
+                  }
+                }
               }
             } finally {
               reader.releaseLock();
             }
-            const chunks = [];
-            for (const event of buffer.split(`
+            if (buffer.trim()) {
+              for (const event of buffer.split(`
 
 `)) {
-              for (const line of event.split(`
+                for (const line of event.split(`
 `)) {
-                if (line.startsWith("data: ") && line !== "data: [DONE]") {
-                  try {
-                    chunks.push(jsonParse(line.slice(6)));
-                  } catch (err2) {
-                    logForDebugging(`dumpPrompts.SSE parse error: ${err2}`, { level: "error" });
+                  if (line.startsWith("data: ") && line !== "data: [DONE]") {
+                    try {
+                      chunks.push(jsonParse(line.slice(6)));
+                    } catch (err2) {
+                      logForDebugging(`dumpPrompts.SSE parse error: ${err2}`, { level: "error" });
+                    }
                   }
                 }
               }
@@ -300876,6 +300900,214 @@ var init_gracefulShutdown = __esm(() => {
   };
 });
 
+// node_modules/async-mutex/index.mjs
+class Semaphore {
+  constructor(_value, _cancelError = E_CANCELED) {
+    this._value = _value;
+    this._cancelError = _cancelError;
+    this._queue = [];
+    this._weightedWaiters = [];
+  }
+  acquire(weight = 1, priority = 0) {
+    if (weight <= 0)
+      throw new Error(`invalid weight ${weight}: must be positive`);
+    return new Promise((resolve28, reject2) => {
+      const task = { resolve: resolve28, reject: reject2, weight, priority };
+      const i3 = findIndexFromEnd(this._queue, (other) => priority <= other.priority);
+      if (i3 === -1 && weight <= this._value) {
+        this._dispatchItem(task);
+      } else {
+        this._queue.splice(i3 + 1, 0, task);
+      }
+    });
+  }
+  runExclusive(callback_1) {
+    return __awaiter$2(this, arguments, undefined, function* (callback, weight = 1, priority = 0) {
+      const [value, release] = yield this.acquire(weight, priority);
+      try {
+        return yield callback(value);
+      } finally {
+        release();
+      }
+    });
+  }
+  waitForUnlock(weight = 1, priority = 0) {
+    if (weight <= 0)
+      throw new Error(`invalid weight ${weight}: must be positive`);
+    if (this._couldLockImmediately(weight, priority)) {
+      return Promise.resolve();
+    } else {
+      return new Promise((resolve28) => {
+        if (!this._weightedWaiters[weight - 1])
+          this._weightedWaiters[weight - 1] = [];
+        insertSorted(this._weightedWaiters[weight - 1], { resolve: resolve28, priority });
+      });
+    }
+  }
+  isLocked() {
+    return this._value <= 0;
+  }
+  getValue() {
+    return this._value;
+  }
+  setValue(value) {
+    this._value = value;
+    this._dispatchQueue();
+  }
+  release(weight = 1) {
+    if (weight <= 0)
+      throw new Error(`invalid weight ${weight}: must be positive`);
+    this._value += weight;
+    this._dispatchQueue();
+  }
+  cancel() {
+    this._queue.forEach((entry) => entry.reject(this._cancelError));
+    this._queue = [];
+  }
+  _dispatchQueue() {
+    this._drainUnlockWaiters();
+    while (this._queue.length > 0 && this._queue[0].weight <= this._value) {
+      this._dispatchItem(this._queue.shift());
+      this._drainUnlockWaiters();
+    }
+  }
+  _dispatchItem(item) {
+    const previousValue = this._value;
+    this._value -= item.weight;
+    item.resolve([previousValue, this._newReleaser(item.weight)]);
+  }
+  _newReleaser(weight) {
+    let called = false;
+    return () => {
+      if (called)
+        return;
+      called = true;
+      this.release(weight);
+    };
+  }
+  _drainUnlockWaiters() {
+    if (this._queue.length === 0) {
+      for (let weight = this._value;weight > 0; weight--) {
+        const waiters = this._weightedWaiters[weight - 1];
+        if (!waiters)
+          continue;
+        waiters.forEach((waiter) => waiter.resolve());
+        this._weightedWaiters[weight - 1] = [];
+      }
+    } else {
+      const queuedPriority = this._queue[0].priority;
+      for (let weight = this._value;weight > 0; weight--) {
+        const waiters = this._weightedWaiters[weight - 1];
+        if (!waiters)
+          continue;
+        const i3 = waiters.findIndex((waiter) => waiter.priority <= queuedPriority);
+        (i3 === -1 ? waiters : waiters.splice(0, i3)).forEach((waiter) => waiter.resolve());
+      }
+    }
+  }
+  _couldLockImmediately(weight, priority) {
+    return (this._queue.length === 0 || this._queue[0].priority < priority) && weight <= this._value;
+  }
+}
+function insertSorted(a2, v2) {
+  const i3 = findIndexFromEnd(a2, (other) => v2.priority <= other.priority);
+  a2.splice(i3 + 1, 0, v2);
+}
+function findIndexFromEnd(a2, predicate) {
+  for (let i3 = a2.length - 1;i3 >= 0; i3--) {
+    if (predicate(a2[i3])) {
+      return i3;
+    }
+  }
+  return -1;
+}
+
+class Mutex {
+  constructor(cancelError) {
+    this._semaphore = new Semaphore(1, cancelError);
+  }
+  acquire() {
+    return __awaiter$1(this, arguments, undefined, function* (priority = 0) {
+      const [, releaser] = yield this._semaphore.acquire(1, priority);
+      return releaser;
+    });
+  }
+  runExclusive(callback, priority = 0) {
+    return this._semaphore.runExclusive(() => callback(), 1, priority);
+  }
+  isLocked() {
+    return this._semaphore.isLocked();
+  }
+  waitForUnlock(priority = 0) {
+    return this._semaphore.waitForUnlock(1, priority);
+  }
+  release() {
+    if (this._semaphore.isLocked())
+      this._semaphore.release();
+  }
+  cancel() {
+    return this._semaphore.cancel();
+  }
+}
+var E_TIMEOUT, E_ALREADY_LOCKED, E_CANCELED, __awaiter$2 = function(thisArg, _arguments, P2, generator) {
+  function adopt(value) {
+    return value instanceof P2 ? value : new P2(function(resolve28) {
+      resolve28(value);
+    });
+  }
+  return new (P2 || (P2 = Promise))(function(resolve28, reject2) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject2(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject2(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve28(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}, __awaiter$1 = function(thisArg, _arguments, P2, generator) {
+  function adopt(value) {
+    return value instanceof P2 ? value : new P2(function(resolve28) {
+      resolve28(value);
+    });
+  }
+  return new (P2 || (P2 = Promise))(function(resolve28, reject2) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject2(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject2(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve28(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var init_async_mutex = __esm(() => {
+  E_TIMEOUT = new Error("timeout while waiting for mutex to become available");
+  E_ALREADY_LOCKED = new Error("mutex already locked");
+  E_CANCELED = new Error("request for lock canceled");
+});
+
 // src/services/api/grove.ts
 function memoizeWithTTL(fn, ttlMs) {
   let lastCachedAt = 0;
@@ -300891,6 +301123,9 @@ function memoizeWithTTL(fn, ttlMs) {
       const result = await memoized(...args);
       if (result && typeof result === "object" && "success" in result && result.success === true) {
         lastCachedAt = Date.now();
+      } else if (result && typeof result === "object" && "success" in result && result.success === false) {
+        originalClear();
+        lastCachedAt = 0;
       }
       return result;
     } catch (error49) {
@@ -300972,13 +301207,12 @@ async function isQualifiedForGrove() {
   return cachedEntry.grove_enabled;
 }
 async function fetchAndStoreGroveConfig(accountId) {
-  let releaseLock;
-  const lockPromise = new Promise((resolve28) => {
-    releaseLock = resolve28;
-  });
-  const previous = groveConfigLocks.get(accountId) ?? Promise.resolve();
-  groveConfigLocks.set(accountId, lockPromise);
-  await previous;
+  let mutex = groveConfigMutexes.get(accountId);
+  if (!mutex) {
+    mutex = new Mutex;
+    groveConfigMutexes.set(accountId, mutex);
+  }
+  const release = await mutex.acquire();
   try {
     const result = await getGroveNoticeConfig();
     if (!result.success) {
@@ -301002,10 +301236,7 @@ async function fetchAndStoreGroveConfig(accountId) {
   } catch (err2) {
     logForDebugging(`Grove: Failed to fetch and store config: ${err2}`);
   } finally {
-    releaseLock();
-    if (groveConfigLocks.get(accountId) === lockPromise) {
-      groveConfigLocks.delete(accountId);
-    }
+    release();
   }
 }
 function calculateShouldShowGrove(settingsResult, configResult, showIfAlreadyViewed) {
@@ -301059,7 +301290,7 @@ An update to our Consumer Terms and Privacy Policy will take effect on October 8
     }
   }
 }
-var groveConfigLocks, GROVE_CACHE_EXPIRATION_MS, GROVE_API_TIMEOUT_MS, getGroveSettings, getGroveNoticeConfig;
+var groveConfigMutexes, GROVE_CACHE_EXPIRATION_MS, GROVE_API_TIMEOUT_MS, getGroveSettings, getGroveNoticeConfig;
 var init_grove = __esm(() => {
   init_axios2();
   init_memoize();
@@ -301071,7 +301302,8 @@ var init_grove = __esm(() => {
   init_config();
   init_http2();
   init_log3();
-  groveConfigLocks = new Map;
+  init_async_mutex();
+  groveConfigMutexes = new Map;
   GROVE_CACHE_EXPIRATION_MS = 24 * 60 * 60 * 1000;
   GROVE_API_TIMEOUT_MS = parseInt(process.env.GROVE_API_TIMEOUT_MS ?? "3000", 10);
   getGroveSettings = memoizeWithTTL(async () => {
@@ -342110,17 +342342,20 @@ async function appendSessionLogImpl(sessionId, entry, url3, headers) {
           logForDebugging(`Session 409: adopting server lastUuid=${serverLastUuid} from header, retrying entry ${entry.uuid}`);
         } else {
           const sequentialFetch = getOrCreateSequentialFetch(sessionId);
-          const logs2 = await sequentialFetch(sessionId, url3, headers);
+          let logs2 = null;
+          try {
+            logs2 = await sequentialFetch(sessionId, url3, headers);
+          } catch (fetchError) {
+            logError2(new Error(`Session 409: fetch failed for session ${sessionId}, entry ${entry.uuid}: ${fetchError instanceof Error ? fetchError.message : String(fetchError)}`));
+            logForDiagnosticsNoPII("error", "session_persist_409_fetch_fail");
+          }
           const adoptedUuid = findLastUuid(logs2);
           if (adoptedUuid) {
             lastUuidMap.set(sessionId, adoptedUuid);
             logForDebugging(`Session 409: re-fetched ${logs2.length} entries, adopting lastUuid=${adoptedUuid}, retrying entry ${entry.uuid}`);
           } else {
-            const errorData = response.data;
-            const errorMessage2 = errorData.error?.message || "Concurrent modification detected";
-            logError2(new Error(`Session persistence conflict: UUID mismatch for session ${sessionId}, entry ${entry.uuid}. ${errorMessage2}`));
-            logForDiagnosticsNoPII("error", "session_persist_fail_concurrent_modification");
-            return false;
+            logForDebugging(`Session 409: could not determine server state for session ${sessionId}, entry ${entry.uuid}`);
+            logForDiagnosticsNoPII("warn", "session_persist_409_no_adopted_uuid");
           }
         }
         logForDiagnosticsNoPII("info", "session_persist_409_adopt_server_uuid");
@@ -342137,10 +342372,11 @@ async function appendSessionLogImpl(sessionId, entry, url3, headers) {
         attempt
       });
     } catch (error49) {
-      const axiosError = error49;
-      logError2(new Error(`Error persisting session log: ${axiosError.message}`));
+      const errorMessage2 = error49 instanceof Error ? error49.message : String(error49);
+      const axiosStatus = error49 && typeof error49 === "object" && "status" in error49 ? error49.status : undefined;
+      logError2(new Error(`Error persisting session log: ${errorMessage2}`));
       logForDiagnosticsNoPII("error", "session_persist_fail_status", {
-        status: axiosError.status,
+        status: axiosStatus,
         attempt
       });
     }
@@ -348844,7 +349080,7 @@ var require_semaphore = __commonJS((exports) => {
   exports.Semaphore = undefined;
   var ral_1 = require_ral();
 
-  class Semaphore {
+  class Semaphore2 {
     constructor(capacity = 1) {
       if (capacity <= 0) {
         throw new Error("Capacity must be greater than 0");
@@ -348901,7 +349137,7 @@ var require_semaphore = __commonJS((exports) => {
       }
     }
   }
-  exports.Semaphore = Semaphore;
+  exports.Semaphore = Semaphore2;
 });
 
 // node_modules/vscode-jsonrpc/lib/common/messageReader.js
@@ -453615,7 +453851,11 @@ async function fetchAndStorePassesEligibility() {
     logForDebugging("Passes: Reusing in-flight eligibility fetch");
     return fetchInProgress;
   }
-  fetchInProgress = (async () => {
+  let resolvePromise;
+  fetchInProgress = new Promise((resolve47) => {
+    resolvePromise = resolve47;
+  });
+  (async () => {
     try {
       const response = await fetchReferralEligibility();
       const cacheEntry = {
@@ -453630,11 +453870,11 @@ async function fetchAndStorePassesEligibility() {
         }
       }));
       logForDebugging(`Passes eligibility cached for org ${orgId}: ${response.eligible}`);
-      return response;
+      resolvePromise(response);
     } catch (error49) {
       logForDebugging("Failed to fetch and cache passes eligibility");
       logError2(error49);
-      return null;
+      resolvePromise(null);
     } finally {
       fetchInProgress = null;
     }

package/dist/myclaude.mjs

@@ -4,8 +4,8 @@
 // MACRO - build-time constants (injected by build.ts)
 // MACRO injected by build script
 globalThis.MACRO = {
-  VERSION: "0.1.89",
-  BUILD_TIME: "2026-07-17T12:20:44.184Z",
+  VERSION: "0.1.90",
+  BUILD_TIME: "2026-07-17T18:18:41.746Z",
   PACKAGE_URL: "@funnycode/myclaude",
   NATIVE_PACKAGE_URL: "@funnycode/myclaude",
   VERSION_CHANGELOG: '',
@@ -117484,7 +117484,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@funnycode/myclaude",
-    version: "0.1.89",
+    version: "0.1.90",
     private: false,
     description: "An open-source AI coding assistant in your terminal - powered by Claude",
     license: "MIT",
@@ -117548,6 +117548,7 @@ var init_package = __esm(() => {
       "@opentelemetry/semantic-conventions": "1.40.0",
       ajv: "8.18.0",
       asciichart: "1.5.25",
+      "async-mutex": "^0.5.0",
       "auto-bind": "5.0.1",
       axios: "1.14.0",
       "bidi-js": "1.0.3",
@@ -210289,27 +210290,50 @@ function createDumpPromptsFetch(agentIdOrSessionId) {
             const reader = cloned.body.getReader();
             const decoder = new TextDecoder;
             let buffer = "";
+            const chunks = [];
             try {
               while (true) {
                 const { done, value } = await reader.read();
                 if (done)
                   break;
                 buffer += decoder.decode(value, { stream: true });
+                const lastDoubleNewline = buffer.lastIndexOf(`
+
+`);
+                if (lastDoubleNewline !== -1) {
+                  const completeEvents = buffer.slice(0, lastDoubleNewline);
+                  buffer = buffer.slice(lastDoubleNewline + 2);
+                  for (const event of completeEvents.split(`
+
+`)) {
+                    for (const line of event.split(`
+`)) {
+                      if (line.startsWith("data: ") && line !== "data: [DONE]") {
+                        try {
+                          chunks.push(jsonParse(line.slice(6)));
+                        } catch (err2) {
+                          logForDebugging(`dumpPrompts.SSE parse error: ${err2}`, { level: "error" });
+                        }
+                      }
+                    }
+                  }
+                }
               }
             } finally {
               reader.releaseLock();
             }
-            const chunks = [];
-            for (const event of buffer.split(`
+            if (buffer.trim()) {
+              for (const event of buffer.split(`
 
 `)) {
-              for (const line of event.split(`
+                for (const line of event.split(`
 `)) {
-                if (line.startsWith("data: ") && line !== "data: [DONE]") {
-                  try {
-                    chunks.push(jsonParse(line.slice(6)));
-                  } catch (err2) {
-                    logForDebugging(`dumpPrompts.SSE parse error: ${err2}`, { level: "error" });
+                  if (line.startsWith("data: ") && line !== "data: [DONE]") {
+                    try {
+                      chunks.push(jsonParse(line.slice(6)));
+                    } catch (err2) {
+                      logForDebugging(`dumpPrompts.SSE parse error: ${err2}`, { level: "error" });
+                    }
                   }
                 }
               }
@@ -300876,6 +300900,214 @@ var init_gracefulShutdown = __esm(() => {
   };
 });
 
+// node_modules/async-mutex/index.mjs
+class Semaphore {
+  constructor(_value, _cancelError = E_CANCELED) {
+    this._value = _value;
+    this._cancelError = _cancelError;
+    this._queue = [];
+    this._weightedWaiters = [];
+  }
+  acquire(weight = 1, priority = 0) {
+    if (weight <= 0)
+      throw new Error(`invalid weight ${weight}: must be positive`);
+    return new Promise((resolve28, reject2) => {
+      const task = { resolve: resolve28, reject: reject2, weight, priority };
+      const i3 = findIndexFromEnd(this._queue, (other) => priority <= other.priority);
+      if (i3 === -1 && weight <= this._value) {
+        this._dispatchItem(task);
+      } else {
+        this._queue.splice(i3 + 1, 0, task);
+      }
+    });
+  }
+  runExclusive(callback_1) {
+    return __awaiter$2(this, arguments, undefined, function* (callback, weight = 1, priority = 0) {
+      const [value, release] = yield this.acquire(weight, priority);
+      try {
+        return yield callback(value);
+      } finally {
+        release();
+      }
+    });
+  }
+  waitForUnlock(weight = 1, priority = 0) {
+    if (weight <= 0)
+      throw new Error(`invalid weight ${weight}: must be positive`);
+    if (this._couldLockImmediately(weight, priority)) {
+      return Promise.resolve();
+    } else {
+      return new Promise((resolve28) => {
+        if (!this._weightedWaiters[weight - 1])
+          this._weightedWaiters[weight - 1] = [];
+        insertSorted(this._weightedWaiters[weight - 1], { resolve: resolve28, priority });
+      });
+    }
+  }
+  isLocked() {
+    return this._value <= 0;
+  }
+  getValue() {
+    return this._value;
+  }
+  setValue(value) {
+    this._value = value;
+    this._dispatchQueue();
+  }
+  release(weight = 1) {
+    if (weight <= 0)
+      throw new Error(`invalid weight ${weight}: must be positive`);
+    this._value += weight;
+    this._dispatchQueue();
+  }
+  cancel() {
+    this._queue.forEach((entry) => entry.reject(this._cancelError));
+    this._queue = [];
+  }
+  _dispatchQueue() {
+    this._drainUnlockWaiters();
+    while (this._queue.length > 0 && this._queue[0].weight <= this._value) {
+      this._dispatchItem(this._queue.shift());
+      this._drainUnlockWaiters();
+    }
+  }
+  _dispatchItem(item) {
+    const previousValue = this._value;
+    this._value -= item.weight;
+    item.resolve([previousValue, this._newReleaser(item.weight)]);
+  }
+  _newReleaser(weight) {
+    let called = false;
+    return () => {
+      if (called)
+        return;
+      called = true;
+      this.release(weight);
+    };
+  }
+  _drainUnlockWaiters() {
+    if (this._queue.length === 0) {
+      for (let weight = this._value;weight > 0; weight--) {
+        const waiters = this._weightedWaiters[weight - 1];
+        if (!waiters)
+          continue;
+        waiters.forEach((waiter) => waiter.resolve());
+        this._weightedWaiters[weight - 1] = [];
+      }
+    } else {
+      const queuedPriority = this._queue[0].priority;
+      for (let weight = this._value;weight > 0; weight--) {
+        const waiters = this._weightedWaiters[weight - 1];
+        if (!waiters)
+          continue;
+        const i3 = waiters.findIndex((waiter) => waiter.priority <= queuedPriority);
+        (i3 === -1 ? waiters : waiters.splice(0, i3)).forEach((waiter) => waiter.resolve());
+      }
+    }
+  }
+  _couldLockImmediately(weight, priority) {
+    return (this._queue.length === 0 || this._queue[0].priority < priority) && weight <= this._value;
+  }
+}
+function insertSorted(a2, v2) {
+  const i3 = findIndexFromEnd(a2, (other) => v2.priority <= other.priority);
+  a2.splice(i3 + 1, 0, v2);
+}
+function findIndexFromEnd(a2, predicate) {
+  for (let i3 = a2.length - 1;i3 >= 0; i3--) {
+    if (predicate(a2[i3])) {
+      return i3;
+    }
+  }
+  return -1;
+}
+
+class Mutex {
+  constructor(cancelError) {
+    this._semaphore = new Semaphore(1, cancelError);
+  }
+  acquire() {
+    return __awaiter$1(this, arguments, undefined, function* (priority = 0) {
+      const [, releaser] = yield this._semaphore.acquire(1, priority);
+      return releaser;
+    });
+  }
+  runExclusive(callback, priority = 0) {
+    return this._semaphore.runExclusive(() => callback(), 1, priority);
+  }
+  isLocked() {
+    return this._semaphore.isLocked();
+  }
+  waitForUnlock(priority = 0) {
+    return this._semaphore.waitForUnlock(1, priority);
+  }
+  release() {
+    if (this._semaphore.isLocked())
+      this._semaphore.release();
+  }
+  cancel() {
+    return this._semaphore.cancel();
+  }
+}
+var E_TIMEOUT, E_ALREADY_LOCKED, E_CANCELED, __awaiter$2 = function(thisArg, _arguments, P2, generator) {
+  function adopt(value) {
+    return value instanceof P2 ? value : new P2(function(resolve28) {
+      resolve28(value);
+    });
+  }
+  return new (P2 || (P2 = Promise))(function(resolve28, reject2) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject2(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject2(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve28(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}, __awaiter$1 = function(thisArg, _arguments, P2, generator) {
+  function adopt(value) {
+    return value instanceof P2 ? value : new P2(function(resolve28) {
+      resolve28(value);
+    });
+  }
+  return new (P2 || (P2 = Promise))(function(resolve28, reject2) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject2(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject2(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve28(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var init_async_mutex = __esm(() => {
+  E_TIMEOUT = new Error("timeout while waiting for mutex to become available");
+  E_ALREADY_LOCKED = new Error("mutex already locked");
+  E_CANCELED = new Error("request for lock canceled");
+});
+
 // src/services/api/grove.ts
 function memoizeWithTTL(fn, ttlMs) {
   let lastCachedAt = 0;
@@ -300891,6 +301123,9 @@ function memoizeWithTTL(fn, ttlMs) {
       const result = await memoized(...args);
       if (result && typeof result === "object" && "success" in result && result.success === true) {
         lastCachedAt = Date.now();
+      } else if (result && typeof result === "object" && "success" in result && result.success === false) {
+        originalClear();
+        lastCachedAt = 0;
       }
       return result;
     } catch (error49) {
@@ -300972,13 +301207,12 @@ async function isQualifiedForGrove() {
   return cachedEntry.grove_enabled;
 }
 async function fetchAndStoreGroveConfig(accountId) {
-  let releaseLock;
-  const lockPromise = new Promise((resolve28) => {
-    releaseLock = resolve28;
-  });
-  const previous = groveConfigLocks.get(accountId) ?? Promise.resolve();
-  groveConfigLocks.set(accountId, lockPromise);
-  await previous;
+  let mutex = groveConfigMutexes.get(accountId);
+  if (!mutex) {
+    mutex = new Mutex;
+    groveConfigMutexes.set(accountId, mutex);
+  }
+  const release = await mutex.acquire();
   try {
     const result = await getGroveNoticeConfig();
     if (!result.success) {
@@ -301002,10 +301236,7 @@ async function fetchAndStoreGroveConfig(accountId) {
   } catch (err2) {
     logForDebugging(`Grove: Failed to fetch and store config: ${err2}`);
   } finally {
-    releaseLock();
-    if (groveConfigLocks.get(accountId) === lockPromise) {
-      groveConfigLocks.delete(accountId);
-    }
+    release();
   }
 }
 function calculateShouldShowGrove(settingsResult, configResult, showIfAlreadyViewed) {
@@ -301059,7 +301290,7 @@ An update to our Consumer Terms and Privacy Policy will take effect on October 8
     }
   }
 }
-var groveConfigLocks, GROVE_CACHE_EXPIRATION_MS, GROVE_API_TIMEOUT_MS, getGroveSettings, getGroveNoticeConfig;
+var groveConfigMutexes, GROVE_CACHE_EXPIRATION_MS, GROVE_API_TIMEOUT_MS, getGroveSettings, getGroveNoticeConfig;
 var init_grove = __esm(() => {
   init_axios2();
   init_memoize();
@@ -301071,7 +301302,8 @@ var init_grove = __esm(() => {
   init_config();
   init_http2();
   init_log3();
-  groveConfigLocks = new Map;
+  init_async_mutex();
+  groveConfigMutexes = new Map;
   GROVE_CACHE_EXPIRATION_MS = 24 * 60 * 60 * 1000;
   GROVE_API_TIMEOUT_MS = parseInt(process.env.GROVE_API_TIMEOUT_MS ?? "3000", 10);
   getGroveSettings = memoizeWithTTL(async () => {
@@ -342110,17 +342342,20 @@ async function appendSessionLogImpl(sessionId, entry, url3, headers) {
           logForDebugging(`Session 409: adopting server lastUuid=${serverLastUuid} from header, retrying entry ${entry.uuid}`);
         } else {
           const sequentialFetch = getOrCreateSequentialFetch(sessionId);
-          const logs2 = await sequentialFetch(sessionId, url3, headers);
+          let logs2 = null;
+          try {
+            logs2 = await sequentialFetch(sessionId, url3, headers);
+          } catch (fetchError) {
+            logError2(new Error(`Session 409: fetch failed for session ${sessionId}, entry ${entry.uuid}: ${fetchError instanceof Error ? fetchError.message : String(fetchError)}`));
+            logForDiagnosticsNoPII("error", "session_persist_409_fetch_fail");
+          }
           const adoptedUuid = findLastUuid(logs2);
           if (adoptedUuid) {
             lastUuidMap.set(sessionId, adoptedUuid);
             logForDebugging(`Session 409: re-fetched ${logs2.length} entries, adopting lastUuid=${adoptedUuid}, retrying entry ${entry.uuid}`);
           } else {
-            const errorData = response.data;
-            const errorMessage2 = errorData.error?.message || "Concurrent modification detected";
-            logError2(new Error(`Session persistence conflict: UUID mismatch for session ${sessionId}, entry ${entry.uuid}. ${errorMessage2}`));
-            logForDiagnosticsNoPII("error", "session_persist_fail_concurrent_modification");
-            return false;
+            logForDebugging(`Session 409: could not determine server state for session ${sessionId}, entry ${entry.uuid}`);
+            logForDiagnosticsNoPII("warn", "session_persist_409_no_adopted_uuid");
           }
         }
         logForDiagnosticsNoPII("info", "session_persist_409_adopt_server_uuid");
@@ -342137,10 +342372,11 @@ async function appendSessionLogImpl(sessionId, entry, url3, headers) {
         attempt
       });
     } catch (error49) {
-      const axiosError = error49;
-      logError2(new Error(`Error persisting session log: ${axiosError.message}`));
+      const errorMessage2 = error49 instanceof Error ? error49.message : String(error49);
+      const axiosStatus = error49 && typeof error49 === "object" && "status" in error49 ? error49.status : undefined;
+      logError2(new Error(`Error persisting session log: ${errorMessage2}`));
       logForDiagnosticsNoPII("error", "session_persist_fail_status", {
-        status: axiosError.status,
+        status: axiosStatus,
         attempt
       });
     }
@@ -348844,7 +349080,7 @@ var require_semaphore = __commonJS((exports) => {
   exports.Semaphore = undefined;
   var ral_1 = require_ral();
 
-  class Semaphore {
+  class Semaphore2 {
     constructor(capacity = 1) {
       if (capacity <= 0) {
         throw new Error("Capacity must be greater than 0");
@@ -348901,7 +349137,7 @@ var require_semaphore = __commonJS((exports) => {
       }
     }
   }
-  exports.Semaphore = Semaphore;
+  exports.Semaphore = Semaphore2;
 });
 
 // node_modules/vscode-jsonrpc/lib/common/messageReader.js
@@ -453615,7 +453851,11 @@ async function fetchAndStorePassesEligibility() {
     logForDebugging("Passes: Reusing in-flight eligibility fetch");
     return fetchInProgress;
   }
-  fetchInProgress = (async () => {
+  let resolvePromise;
+  fetchInProgress = new Promise((resolve47) => {
+    resolvePromise = resolve47;
+  });
+  (async () => {
     try {
       const response = await fetchReferralEligibility();
       const cacheEntry = {
@@ -453630,11 +453870,11 @@ async function fetchAndStorePassesEligibility() {
         }
       }));
       logForDebugging(`Passes eligibility cached for org ${orgId}: ${response.eligible}`);
-      return response;
+      resolvePromise(response);
     } catch (error49) {
       logForDebugging("Failed to fetch and cache passes eligibility");
       logError2(error49);
-      return null;
+      resolvePromise(null);
     } finally {
       fetchInProgress = null;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@funnycode/myclaude",
-  "version": "0.1.89",
+  "version": "0.1.90",
   "private": false,
   "description": "An open-source AI coding assistant in your terminal - powered by Claude",
   "license": "MIT",
@@ -64,6 +64,7 @@
     "@opentelemetry/semantic-conventions": "1.40.0",
     "ajv": "8.18.0",
     "asciichart": "1.5.25",
+    "async-mutex": "^0.5.0",
     "auto-bind": "5.0.1",
     "axios": "1.14.0",
     "bidi-js": "1.0.3",