@funnycode/myclaude 0.1.92 → 0.1.94

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.92",
-  BUILD_TIME: "2026-07-17T23:07:28.667Z",
+  VERSION: "0.1.94",
+  BUILD_TIME: "2026-07-18T06:27:57.445Z",
   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.92",
+    version: "0.1.94",
     private: false,
     description: "An open-source AI coding assistant in your terminal - powered by Claude",
     license: "MIT",
@@ -210146,6 +210146,214 @@ var init_postSamplingHooks = __esm(() => {
   postSamplingHooks = [];
 });
 
+// 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((resolve25, reject2) => {
+      const task = { resolve: resolve25, 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((resolve25) => {
+        if (!this._weightedWaiters[weight - 1])
+          this._weightedWaiters[weight - 1] = [];
+        insertSorted(this._weightedWaiters[weight - 1], { resolve: resolve25, 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(resolve25) {
+      resolve25(value);
+    });
+  }
+  return new (P2 || (P2 = Promise))(function(resolve25, 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 ? resolve25(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(resolve25) {
+      resolve25(value);
+    });
+  }
+  return new (P2 || (P2 = Promise))(function(resolve25, 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 ? resolve25(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/dumpPrompts.ts
 import { createHash as createHash5 } from "crypto";
 import { promises as fs11 } from "fs";
@@ -210158,26 +210366,34 @@ function enqueueDumpRequest(agentIdOrSessionId, callback) {
     dumpRequestQueue.set(agentIdOrSessionId, []);
   }
   dumpRequestQueue.get(agentIdOrSessionId).push(callback);
-  if (!processingQueues.has(agentIdOrSessionId)) {
-    processingQueues.add(agentIdOrSessionId);
-    processQueue(agentIdOrSessionId);
-  }
+  processQueue(agentIdOrSessionId);
 }
 async function processQueue(agentIdOrSessionId) {
-  processingQueues.add(agentIdOrSessionId);
-  const queue = dumpRequestQueue.get(agentIdOrSessionId);
-  if (!queue || queue.length === 0) {
-    dumpRequestQueue.delete(agentIdOrSessionId);
-    processingQueues.delete(agentIdOrSessionId);
-    return;
+  const mapRelease = await dumpRequestMapMutex.acquire();
+  let mutex = dumpRequestMutexes.get(agentIdOrSessionId);
+  if (!mutex) {
+    mutex = new Mutex;
+    dumpRequestMutexes.set(agentIdOrSessionId, mutex);
   }
-  const callback = queue.shift();
-  await callback();
-  if (queue.length > 0) {
-    setImmediate(() => processQueue(agentIdOrSessionId));
-  } else {
-    dumpRequestQueue.delete(agentIdOrSessionId);
-    processingQueues.delete(agentIdOrSessionId);
+  mapRelease();
+  const release = await mutex.acquire();
+  try {
+    const queue = dumpRequestQueue.get(agentIdOrSessionId);
+    if (!queue || queue.length === 0) {
+      dumpRequestQueue.delete(agentIdOrSessionId);
+      dumpRequestMutexes.delete(agentIdOrSessionId);
+      return;
+    }
+    const callback = queue.shift();
+    await callback();
+    if (queue.length > 0) {
+      setImmediate(() => processQueue(agentIdOrSessionId));
+    } else {
+      dumpRequestQueue.delete(agentIdOrSessionId);
+      dumpRequestMutexes.delete(agentIdOrSessionId);
+    }
+  } finally {
+    release();
   }
 }
 function clearDumpState(agentIdOrSessionId) {
@@ -210223,11 +210439,14 @@ function initFingerprint(req) {
   return `${req.model}|${toolNames}|${sysLen}`;
 }
 async function dumpRequest(body, ts, state, filePath) {
+  if (false)
+    ;
   try {
     const req = jsonParse(body);
     addApiRequestToCache(req);
     if (process.env.USER_TYPE !== "ant" || process.env.DUMP_PROMPTS !== "1")
       return;
+    logForDebugging("DUMP_PROMPTS is enabled. This will write full API payloads (including system prompts, user messages, and tool definitions) to the filesystem. This is intended for debugging only and should NOT be used in production.", { level: "warn" });
     const entries = [];
     const messages = req.messages ?? [];
     const fingerprint = initFingerprint(req);
@@ -210283,7 +210502,7 @@ function createDumpPromptsFetch(agentIdOrSessionId) {
       });
     }
     const response = await globalThis.fetch(input, init2);
-    if (timestamp && response.ok && process.env.USER_TYPE === "ant" && process.env.DUMP_PROMPTS === "1") {
+    if (timestamp && response.ok && true && process.env.USER_TYPE === "ant" && process.env.DUMP_PROMPTS === "1") {
       const cloned = response.clone();
       (async () => {
         try {
@@ -210293,7 +210512,7 @@ function createDumpPromptsFetch(agentIdOrSessionId) {
             const reader = cloned.body.getReader();
             const decoder = new TextDecoder;
             let buffer = "";
-            const chunks = [];
+            const chunkEntries = [];
             try {
               while (true) {
                 const { done, value } = await reader.read();
@@ -210313,7 +210532,12 @@ function createDumpPromptsFetch(agentIdOrSessionId) {
 `)) {
                       if (line.startsWith("data: ") && line !== "data: [DONE]") {
                         try {
-                          chunks.push(jsonParse(line.slice(6)));
+                          const chunk = jsonParse(line.slice(6));
+                          chunkEntries.push(jsonStringify({ type: "chunk", timestamp, data: chunk }));
+                          if (chunkEntries.length >= 50) {
+                            await appendToFile(filePath, chunkEntries);
+                            chunkEntries.length = 0;
+                          }
                         } catch (err2) {
                           logForDebugging(`dumpPrompts.SSE parse error: ${err2}`, { level: "error" });
                         }
@@ -210333,7 +210557,8 @@ function createDumpPromptsFetch(agentIdOrSessionId) {
 `)) {
                   if (line.startsWith("data: ") && line !== "data: [DONE]") {
                     try {
-                      chunks.push(jsonParse(line.slice(6)));
+                      const chunk = jsonParse(line.slice(6));
+                      chunkEntries.push(jsonStringify({ type: "chunk", timestamp, data: chunk }));
                     } catch (err2) {
                       logForDebugging(`dumpPrompts.SSE parse error: ${err2}`, { level: "error" });
                     }
@@ -210341,7 +210566,10 @@ function createDumpPromptsFetch(agentIdOrSessionId) {
                 }
               }
             }
-            data = { stream: true, chunks };
+            if (chunkEntries.length > 0) {
+              await appendToFile(filePath, chunkEntries);
+            }
+            data = { stream: true, chunks: [] };
           } else {
             data = await cloned.json();
           }
@@ -210360,17 +210588,22 @@ function createDumpPromptsFetch(agentIdOrSessionId) {
     return response;
   };
 }
-var MAX_CACHED_REQUESTS = 5, cachedApiRequests, dumpState, dumpRequestQueue, processingQueues;
+var MAX_CACHED_REQUESTS = 5, cachedApiRequests, dumpState, dumpRequestQueue, dumpRequestMutexes, dumpRequestMapMutex;
 var init_dumpPrompts = __esm(() => {
   init_state();
   init_envUtils();
   init_slowOperations();
   init_debug();
   init_log3();
+  init_async_mutex();
+  if (process.env.USER_TYPE === "ant" && process.env.DUMP_PROMPTS === "1") {
+    logForDebugging("DUMP_PROMPTS is enabled. This will write full API payloads (including system prompts, user messages, and tool definitions) to the filesystem. This is intended for debugging only and should NOT be used in production.", { level: "warn" });
+  }
   cachedApiRequests = [];
   dumpState = new Map;
   dumpRequestQueue = new Map;
-  processingQueues = new Set;
+  dumpRequestMutexes = new Map;
+  dumpRequestMapMutex = new Mutex;
 });
 
 // src/utils/abortController.ts
@@ -300904,214 +301137,6 @@ 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;
@@ -342303,21 +342328,21 @@ var init_KeybindingProviderSetup = __esm(() => {
 });
 
 // src/services/api/sessionIngress.ts
-function getOrCreateSequentialAppend(sessionId) {
-  let sequentialAppend = sequentialAppendBySession.get(sessionId);
-  if (!sequentialAppend) {
-    sequentialAppend = sequential(async (entry, url3, headers) => await appendSessionLogImpl(sessionId, entry, url3, headers));
-    sequentialAppendBySession.set(sessionId, sequentialAppend);
-  }
-  return sequentialAppend;
-}
-function getOrCreateSequentialFetch(sessionId) {
-  let sequentialFetch = sequentialFetchBySession.get(sessionId);
-  if (!sequentialFetch) {
-    sequentialFetch = sequential(async (sid, url3, headers) => await fetchSessionLogsFromUrl(sid, url3, headers));
-    sequentialFetchBySession.set(sessionId, sequentialFetch);
+function getOrCreateSequential(sessionId) {
+  let wrapper = sequentialBySession.get(sessionId);
+  if (!wrapper) {
+    wrapper = sequential(async (entryOrSid, url3, headers, isFetch = false) => {
+      if (isFetch) {
+        const sid = entryOrSid;
+        return await fetchSessionLogsFromUrl(sid, url3, headers);
+      } else {
+        const entry = entryOrSid;
+        return await appendSessionLogImpl(sessionId, entry, url3, headers);
+      }
+    });
+    sequentialBySession.set(sessionId, wrapper);
   }
-  return sequentialFetch;
+  return wrapper;
 }
 async function appendSessionLogImpl(sessionId, entry, url3, headers) {
   for (let attempt = 1;attempt <= MAX_RETRIES; attempt++) {
@@ -342348,10 +342373,10 @@ async function appendSessionLogImpl(sessionId, entry, url3, headers) {
           lastUuidMap.set(sessionId, serverLastUuid);
           logForDebugging(`Session 409: adopting server lastUuid=${serverLastUuid} from header, retrying entry ${entry.uuid}`);
         } else {
-          const sequentialFetch = getOrCreateSequentialFetch(sessionId);
+          const sequential2 = getOrCreateSequential(sessionId);
           let logs2 = null;
           try {
-            logs2 = await sequentialFetch(sessionId, url3, headers);
+            logs2 = await sequential2(sessionId, url3, headers, true);
           } 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");
@@ -342409,8 +342434,8 @@ async function appendSessionLog(sessionId, entry, url3) {
     Authorization: `Bearer ${sessionToken}`,
     "Content-Type": "application/json"
   };
-  const sequentialAppend = getOrCreateSequentialAppend(sessionId);
-  return sequentialAppend(entry, url3, headers);
+  const sequential2 = getOrCreateSequential(sessionId);
+  return sequential2(entry, url3, headers, false);
 }
 async function getSessionLogs(sessionId, url3) {
   const sessionToken = getSessionIngressAuthToken();
@@ -342571,10 +342596,9 @@ function findLastUuid(logs2) {
 }
 function clearAllSessions() {
   lastUuidMap.clear();
-  sequentialAppendBySession.clear();
-  sequentialFetchBySession.clear();
+  sequentialBySession.clear();
 }
-var lastUuidMap, MAX_RETRIES = 10, BASE_DELAY_MS2 = 500, sequentialAppendBySession, sequentialFetchBySession;
+var lastUuidMap, MAX_RETRIES = 10, BASE_DELAY_MS2 = 500, sequentialBySession;
 var init_sessionIngress = __esm(() => {
   init_axios2();
   init_oauth();
@@ -342586,8 +342610,7 @@ var init_sessionIngress = __esm(() => {
   init_slowOperations();
   init_api2();
   lastUuidMap = new Map;
-  sequentialAppendBySession = new Map;
-  sequentialFetchBySession = new Map;
+  sequentialBySession = new Map;
 });
 
 // src/utils/fileHistory.ts

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.92",
-  BUILD_TIME: "2026-07-17T23:07:28.667Z",
+  VERSION: "0.1.94",
+  BUILD_TIME: "2026-07-18T06:27:57.445Z",
   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.92",
+    version: "0.1.94",
     private: false,
     description: "An open-source AI coding assistant in your terminal - powered by Claude",
     license: "MIT",
@@ -210146,6 +210146,214 @@ var init_postSamplingHooks = __esm(() => {
   postSamplingHooks = [];
 });
 
+// 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((resolve25, reject2) => {
+      const task = { resolve: resolve25, 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((resolve25) => {
+        if (!this._weightedWaiters[weight - 1])
+          this._weightedWaiters[weight - 1] = [];
+        insertSorted(this._weightedWaiters[weight - 1], { resolve: resolve25, 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(resolve25) {
+      resolve25(value);
+    });
+  }
+  return new (P2 || (P2 = Promise))(function(resolve25, 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 ? resolve25(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(resolve25) {
+      resolve25(value);
+    });
+  }
+  return new (P2 || (P2 = Promise))(function(resolve25, 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 ? resolve25(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/dumpPrompts.ts
 import { createHash as createHash5 } from "crypto";
 import { promises as fs11 } from "fs";
@@ -210158,26 +210366,34 @@ function enqueueDumpRequest(agentIdOrSessionId, callback) {
     dumpRequestQueue.set(agentIdOrSessionId, []);
   }
   dumpRequestQueue.get(agentIdOrSessionId).push(callback);
-  if (!processingQueues.has(agentIdOrSessionId)) {
-    processingQueues.add(agentIdOrSessionId);
-    processQueue(agentIdOrSessionId);
-  }
+  processQueue(agentIdOrSessionId);
 }
 async function processQueue(agentIdOrSessionId) {
-  processingQueues.add(agentIdOrSessionId);
-  const queue = dumpRequestQueue.get(agentIdOrSessionId);
-  if (!queue || queue.length === 0) {
-    dumpRequestQueue.delete(agentIdOrSessionId);
-    processingQueues.delete(agentIdOrSessionId);
-    return;
+  const mapRelease = await dumpRequestMapMutex.acquire();
+  let mutex = dumpRequestMutexes.get(agentIdOrSessionId);
+  if (!mutex) {
+    mutex = new Mutex;
+    dumpRequestMutexes.set(agentIdOrSessionId, mutex);
   }
-  const callback = queue.shift();
-  await callback();
-  if (queue.length > 0) {
-    setImmediate(() => processQueue(agentIdOrSessionId));
-  } else {
-    dumpRequestQueue.delete(agentIdOrSessionId);
-    processingQueues.delete(agentIdOrSessionId);
+  mapRelease();
+  const release = await mutex.acquire();
+  try {
+    const queue = dumpRequestQueue.get(agentIdOrSessionId);
+    if (!queue || queue.length === 0) {
+      dumpRequestQueue.delete(agentIdOrSessionId);
+      dumpRequestMutexes.delete(agentIdOrSessionId);
+      return;
+    }
+    const callback = queue.shift();
+    await callback();
+    if (queue.length > 0) {
+      setImmediate(() => processQueue(agentIdOrSessionId));
+    } else {
+      dumpRequestQueue.delete(agentIdOrSessionId);
+      dumpRequestMutexes.delete(agentIdOrSessionId);
+    }
+  } finally {
+    release();
   }
 }
 function clearDumpState(agentIdOrSessionId) {
@@ -210223,11 +210439,14 @@ function initFingerprint(req) {
   return `${req.model}|${toolNames}|${sysLen}`;
 }
 async function dumpRequest(body, ts, state, filePath) {
+  if (false)
+    ;
   try {
     const req = jsonParse(body);
     addApiRequestToCache(req);
     if (process.env.USER_TYPE !== "ant" || process.env.DUMP_PROMPTS !== "1")
       return;
+    logForDebugging("DUMP_PROMPTS is enabled. This will write full API payloads (including system prompts, user messages, and tool definitions) to the filesystem. This is intended for debugging only and should NOT be used in production.", { level: "warn" });
     const entries = [];
     const messages = req.messages ?? [];
     const fingerprint = initFingerprint(req);
@@ -210283,7 +210502,7 @@ function createDumpPromptsFetch(agentIdOrSessionId) {
       });
     }
     const response = await globalThis.fetch(input, init2);
-    if (timestamp && response.ok && process.env.USER_TYPE === "ant" && process.env.DUMP_PROMPTS === "1") {
+    if (timestamp && response.ok && true && process.env.USER_TYPE === "ant" && process.env.DUMP_PROMPTS === "1") {
       const cloned = response.clone();
       (async () => {
         try {
@@ -210293,7 +210512,7 @@ function createDumpPromptsFetch(agentIdOrSessionId) {
             const reader = cloned.body.getReader();
             const decoder = new TextDecoder;
             let buffer = "";
-            const chunks = [];
+            const chunkEntries = [];
             try {
               while (true) {
                 const { done, value } = await reader.read();
@@ -210313,7 +210532,12 @@ function createDumpPromptsFetch(agentIdOrSessionId) {
 `)) {
                       if (line.startsWith("data: ") && line !== "data: [DONE]") {
                         try {
-                          chunks.push(jsonParse(line.slice(6)));
+                          const chunk = jsonParse(line.slice(6));
+                          chunkEntries.push(jsonStringify({ type: "chunk", timestamp, data: chunk }));
+                          if (chunkEntries.length >= 50) {
+                            await appendToFile(filePath, chunkEntries);
+                            chunkEntries.length = 0;
+                          }
                         } catch (err2) {
                           logForDebugging(`dumpPrompts.SSE parse error: ${err2}`, { level: "error" });
                         }
@@ -210333,7 +210557,8 @@ function createDumpPromptsFetch(agentIdOrSessionId) {
 `)) {
                   if (line.startsWith("data: ") && line !== "data: [DONE]") {
                     try {
-                      chunks.push(jsonParse(line.slice(6)));
+                      const chunk = jsonParse(line.slice(6));
+                      chunkEntries.push(jsonStringify({ type: "chunk", timestamp, data: chunk }));
                     } catch (err2) {
                       logForDebugging(`dumpPrompts.SSE parse error: ${err2}`, { level: "error" });
                     }
@@ -210341,7 +210566,10 @@ function createDumpPromptsFetch(agentIdOrSessionId) {
                 }
               }
             }
-            data = { stream: true, chunks };
+            if (chunkEntries.length > 0) {
+              await appendToFile(filePath, chunkEntries);
+            }
+            data = { stream: true, chunks: [] };
           } else {
             data = await cloned.json();
           }
@@ -210360,17 +210588,22 @@ function createDumpPromptsFetch(agentIdOrSessionId) {
     return response;
   };
 }
-var MAX_CACHED_REQUESTS = 5, cachedApiRequests, dumpState, dumpRequestQueue, processingQueues;
+var MAX_CACHED_REQUESTS = 5, cachedApiRequests, dumpState, dumpRequestQueue, dumpRequestMutexes, dumpRequestMapMutex;
 var init_dumpPrompts = __esm(() => {
   init_state();
   init_envUtils();
   init_slowOperations();
   init_debug();
   init_log3();
+  init_async_mutex();
+  if (process.env.USER_TYPE === "ant" && process.env.DUMP_PROMPTS === "1") {
+    logForDebugging("DUMP_PROMPTS is enabled. This will write full API payloads (including system prompts, user messages, and tool definitions) to the filesystem. This is intended for debugging only and should NOT be used in production.", { level: "warn" });
+  }
   cachedApiRequests = [];
   dumpState = new Map;
   dumpRequestQueue = new Map;
-  processingQueues = new Set;
+  dumpRequestMutexes = new Map;
+  dumpRequestMapMutex = new Mutex;
 });
 
 // src/utils/abortController.ts
@@ -300904,214 +301137,6 @@ 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;
@@ -342303,21 +342328,21 @@ var init_KeybindingProviderSetup = __esm(() => {
 });
 
 // src/services/api/sessionIngress.ts
-function getOrCreateSequentialAppend(sessionId) {
-  let sequentialAppend = sequentialAppendBySession.get(sessionId);
-  if (!sequentialAppend) {
-    sequentialAppend = sequential(async (entry, url3, headers) => await appendSessionLogImpl(sessionId, entry, url3, headers));
-    sequentialAppendBySession.set(sessionId, sequentialAppend);
-  }
-  return sequentialAppend;
-}
-function getOrCreateSequentialFetch(sessionId) {
-  let sequentialFetch = sequentialFetchBySession.get(sessionId);
-  if (!sequentialFetch) {
-    sequentialFetch = sequential(async (sid, url3, headers) => await fetchSessionLogsFromUrl(sid, url3, headers));
-    sequentialFetchBySession.set(sessionId, sequentialFetch);
+function getOrCreateSequential(sessionId) {
+  let wrapper = sequentialBySession.get(sessionId);
+  if (!wrapper) {
+    wrapper = sequential(async (entryOrSid, url3, headers, isFetch = false) => {
+      if (isFetch) {
+        const sid = entryOrSid;
+        return await fetchSessionLogsFromUrl(sid, url3, headers);
+      } else {
+        const entry = entryOrSid;
+        return await appendSessionLogImpl(sessionId, entry, url3, headers);
+      }
+    });
+    sequentialBySession.set(sessionId, wrapper);
   }
-  return sequentialFetch;
+  return wrapper;
 }
 async function appendSessionLogImpl(sessionId, entry, url3, headers) {
   for (let attempt = 1;attempt <= MAX_RETRIES; attempt++) {
@@ -342348,10 +342373,10 @@ async function appendSessionLogImpl(sessionId, entry, url3, headers) {
           lastUuidMap.set(sessionId, serverLastUuid);
           logForDebugging(`Session 409: adopting server lastUuid=${serverLastUuid} from header, retrying entry ${entry.uuid}`);
         } else {
-          const sequentialFetch = getOrCreateSequentialFetch(sessionId);
+          const sequential2 = getOrCreateSequential(sessionId);
           let logs2 = null;
           try {
-            logs2 = await sequentialFetch(sessionId, url3, headers);
+            logs2 = await sequential2(sessionId, url3, headers, true);
           } 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");
@@ -342409,8 +342434,8 @@ async function appendSessionLog(sessionId, entry, url3) {
     Authorization: `Bearer ${sessionToken}`,
     "Content-Type": "application/json"
   };
-  const sequentialAppend = getOrCreateSequentialAppend(sessionId);
-  return sequentialAppend(entry, url3, headers);
+  const sequential2 = getOrCreateSequential(sessionId);
+  return sequential2(entry, url3, headers, false);
 }
 async function getSessionLogs(sessionId, url3) {
   const sessionToken = getSessionIngressAuthToken();
@@ -342571,10 +342596,9 @@ function findLastUuid(logs2) {
 }
 function clearAllSessions() {
   lastUuidMap.clear();
-  sequentialAppendBySession.clear();
-  sequentialFetchBySession.clear();
+  sequentialBySession.clear();
 }
-var lastUuidMap, MAX_RETRIES = 10, BASE_DELAY_MS2 = 500, sequentialAppendBySession, sequentialFetchBySession;
+var lastUuidMap, MAX_RETRIES = 10, BASE_DELAY_MS2 = 500, sequentialBySession;
 var init_sessionIngress = __esm(() => {
   init_axios2();
   init_oauth();
@@ -342586,8 +342610,7 @@ var init_sessionIngress = __esm(() => {
   init_slowOperations();
   init_api2();
   lastUuidMap = new Map;
-  sequentialAppendBySession = new Map;
-  sequentialFetchBySession = new Map;
+  sequentialBySession = new Map;
 });
 
 // src/utils/fileHistory.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@funnycode/myclaude",
-  "version": "0.1.92",
+  "version": "0.1.94",
   "private": false,
   "description": "An open-source AI coding assistant in your terminal - powered by Claude",
   "license": "MIT",