claude-threads 1.17.3 → 1.18.1

package/dist/index.js

@@ -9582,6 +9582,7 @@ var require_receiver = __commonJS((exports, module) => {
       this._opcode = 0;
       this._totalPayloadLength = 0;
       this._messageLength = 0;
+      this._numFragments = 0;
       this._fragments = [];
       this._errored = false;
       this._loop = false;
@@ -9791,17 +9792,17 @@ var require_receiver = __commonJS((exports, module) => {
         this.controlMessage(data, cb);
         return;
       }
+      if (this._maxFragments > 0 && ++this._numFragments > this._maxFragments) {
+        const error = this.createError(RangeError, "Too many message fragments", false, 1008, "WS_ERR_TOO_MANY_BUFFERED_PARTS");
+        cb(error);
+        return;
+      }
       if (this._compressed) {
         this._state = INFLATING;
         this.decompress(data, cb);
         return;
       }
       if (data.length) {
-        if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
-          const error = this.createError(RangeError, "Too many message fragments", false, 1008, "WS_ERR_TOO_MANY_BUFFERED_PARTS");
-          cb(error);
-          return;
-        }
         this._messageLength = this._totalPayloadLength;
         this._fragments.push(data);
       }
@@ -9819,11 +9820,6 @@ var require_receiver = __commonJS((exports, module) => {
             cb(error);
             return;
           }
-          if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
-            const error = this.createError(RangeError, "Too many message fragments", false, 1008, "WS_ERR_TOO_MANY_BUFFERED_PARTS");
-            cb(error);
-            return;
-          }
           this._fragments.push(buf);
         }
         this.dataMessage(cb);
@@ -9841,6 +9837,7 @@ var require_receiver = __commonJS((exports, module) => {
       this._totalPayloadLength = 0;
       this._messageLength = 0;
       this._fragmented = 0;
+      this._numFragments = 0;
       this._fragments = [];
       if (this._opcode === 2) {
         let data;
@@ -10975,8 +10972,8 @@ var require_websocket = __commonJS((exports, module) => {
       autoPong: true,
       closeTimeout: CLOSE_TIMEOUT,
       protocolVersion: protocolVersions[1],
-      maxBufferedChunks: 1024 * 1024,
-      maxFragments: 128 * 1024,
+      maxBufferedChunks: 256 * 1024,
+      maxFragments: 16 * 1024,
       maxPayload: 100 * 1024 * 1024,
       skipUTF8Validation: false,
       perMessageDeflate: true,
@@ -11552,8 +11549,8 @@ var require_websocket_server = __commonJS((exports, module) => {
       options = {
         allowSynchronousEvents: true,
         autoPong: true,
-        maxBufferedChunks: 1024 * 1024,
-        maxFragments: 128 * 1024,
+        maxBufferedChunks: 256 * 1024,
+        maxFragments: 16 * 1024,
         maxPayload: 100 * 1024 * 1024,
         skipUTF8Validation: false,
         perMessageDeflate: false,
@@ -11907,8 +11904,8 @@ import * as fs from "fs/promises";
 import { homedir as homedir5 } from "os";
 async function execGit(args, cwd) {
   const cmd = `git ${args.join(" ")}`;
-  log10.debug(`Executing: ${cmd}`);
-  return new Promise((resolve3, reject) => {
+  log12.debug(`Executing: ${cmd}`);
+  return new Promise((resolve4, reject) => {
     const proc = crossSpawn("git", args, { cwd });
     let stdout = "";
     let stderr = "";
@@ -11920,15 +11917,15 @@ async function execGit(args, cwd) {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        log10.debug(`${cmd} → success`);
-        resolve3(stdout.trim());
+        log12.debug(`${cmd} → success`);
+        resolve4(stdout.trim());
       } else {
-        log10.debug(`${cmd} → failed (code=${code}): ${stderr.substring(0, 100) || stdout.substring(0, 100)}`);
+        log12.debug(`${cmd} → failed (code=${code}): ${stderr.substring(0, 100) || stdout.substring(0, 100)}`);
         reject(new Error(`git ${args.join(" ")} failed: ${stderr || stdout}`));
       }
     });
     proc.on("error", (err) => {
-      log10.warn(`${cmd} → error: ${err}`);
+      log12.warn(`${cmd} → error: ${err}`);
       reject(err);
     });
   });
@@ -11938,7 +11935,7 @@ async function isGitRepository(dir) {
     await execGit(["rev-parse", "--git-dir"], dir);
     return true;
   } catch (err) {
-    log10.debug(`Not a git repository: ${dir} (${err})`);
+    log12.debug(`Not a git repository: ${dir} (${err})`);
     return false;
   }
 }
@@ -12073,7 +12070,7 @@ async function detectWorktreeInfo(workingDir) {
     const branchOutput = await execGit(["rev-parse", "--abbrev-ref", "HEAD"], workingDir);
     const branch = branchOutput?.trim();
     if (!branch) {
-      log10.debug(`Could not detect branch for worktree at ${workingDir}`);
+      log12.debug(`Could not detect branch for worktree at ${workingDir}`);
       return null;
     }
     const gitDirOutput = await execGit(["rev-parse", "--git-common-dir"], workingDir);
@@ -12085,45 +12082,45 @@ async function detectWorktreeInfo(workingDir) {
         repoRoot = repoRoot.slice(0, -4);
       }
     }
-    log10.debug(`Detected worktree: path=${workingDir}, branch=${branch}, repoRoot=${repoRoot}`);
+    log12.debug(`Detected worktree: path=${workingDir}, branch=${branch}, repoRoot=${repoRoot}`);
     return {
       worktreePath: workingDir,
       branch,
       repoRoot: repoRoot || workingDir
     };
   } catch (err) {
-    log10.debug(`Failed to detect worktree info for ${workingDir}: ${err}`);
+    log12.debug(`Failed to detect worktree info for ${workingDir}: ${err}`);
     return null;
   }
 }
 async function createWorktree(repoRoot, branch, targetDir) {
-  log10.info(`Creating worktree for branch '${branch}' at ${targetDir}`);
+  log12.info(`Creating worktree for branch '${branch}' at ${targetDir}`);
   const parentDir = path.dirname(targetDir);
-  log10.debug(`Creating parent directory: ${parentDir}`);
+  log12.debug(`Creating parent directory: ${parentDir}`);
   await fs.mkdir(parentDir, { recursive: true });
   const exists = await branchExists(repoRoot, branch);
   if (exists) {
-    log10.debug(`Branch '${branch}' exists, adding worktree`);
+    log12.debug(`Branch '${branch}' exists, adding worktree`);
     await execGit(["worktree", "add", targetDir, branch], repoRoot);
   } else {
-    log10.debug(`Branch '${branch}' does not exist, creating with worktree`);
+    log12.debug(`Branch '${branch}' does not exist, creating with worktree`);
     await execGit(["worktree", "add", "-b", branch, targetDir], repoRoot);
   }
-  log10.info(`Worktree created successfully: ${targetDir}`);
+  log12.info(`Worktree created successfully: ${targetDir}`);
   return targetDir;
 }
 async function removeWorktree(repoRoot, worktreePath) {
-  log10.info(`Removing worktree: ${worktreePath}`);
+  log12.info(`Removing worktree: ${worktreePath}`);
   try {
     await execGit(["worktree", "remove", worktreePath], repoRoot);
-    log10.debug("Worktree removed cleanly");
+    log12.debug("Worktree removed cleanly");
   } catch (err) {
-    log10.debug(`Clean remove failed (${err}), trying force remove`);
+    log12.debug(`Clean remove failed (${err}), trying force remove`);
     await execGit(["worktree", "remove", "--force", worktreePath], repoRoot);
   }
-  log10.debug("Pruning stale worktree references");
+  log12.debug("Pruning stale worktree references");
   await execGit(["worktree", "prune"], repoRoot);
-  log10.info("Worktree removed and pruned successfully");
+  log12.info("Worktree removed and pruned successfully");
 }
 async function findWorktreeByBranch(repoRoot, branch) {
   const worktrees = await listWorktrees(repoRoot);
@@ -12164,14 +12161,14 @@ async function writeMetadataStore(store) {
     await fs.writeFile(METADATA_STORE_PATH, JSON.stringify(store, null, 2), { encoding: "utf-8", mode: 384 });
     await fs.chmod(METADATA_STORE_PATH, 384);
   } catch (err) {
-    log10.warn(`Failed to write worktree metadata store: ${err}`);
+    log12.warn(`Failed to write worktree metadata store: ${err}`);
   }
 }
 async function writeWorktreeMetadata(worktreePath, metadata) {
   const store = await readMetadataStore();
   store[worktreePath] = metadata;
   await writeMetadataStore(store);
-  log10.debug(`Wrote worktree metadata for: ${worktreePath}`);
+  log12.debug(`Wrote worktree metadata for: ${worktreePath}`);
 }
 async function readWorktreeMetadata(worktreePath) {
   const store = await readMetadataStore();
@@ -12194,14 +12191,14 @@ async function removeWorktreeMetadata(worktreePath) {
   if (store[worktreePath]) {
     delete store[worktreePath];
     await writeMetadataStore(store);
-    log10.debug(`Removed worktree metadata for: ${worktreePath}`);
+    log12.debug(`Removed worktree metadata for: ${worktreePath}`);
   }
 }
-var log10, WORKTREES_DIR, METADATA_STORE_PATH;
+var log12, WORKTREES_DIR, METADATA_STORE_PATH;
 var init_worktree = __esm(() => {
   init_spawn();
   init_logger();
-  log10 = createLogger("git-wt");
+  log12 = createLogger("git-wt");
   WORKTREES_DIR = path.join(homedir5(), ".claude-threads", "worktrees");
   METADATA_STORE_PATH = path.join(homedir5(), ".claude-threads", "worktree-metadata.json");
 });
@@ -20446,7 +20443,7 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
       return hook.checkDCE ? true : false;
     }
     function setIsStrictModeForDevtools(newIsStrictMode) {
-      typeof log36 === "function" && unstable_setDisableYieldValue2(newIsStrictMode);
+      typeof log37 === "function" && unstable_setDisableYieldValue2(newIsStrictMode);
       if (injectedHook && typeof injectedHook.setStrictMode === "function")
         try {
           injectedHook.setStrictMode(rendererID, newIsStrictMode);
@@ -28530,7 +28527,7 @@ Check the render method of %s.`, getComponentNameFromFiber(current) || "Unknown"
     var fiberStack = [];
     var index$jscomp$0 = -1, emptyContextObject = {};
     Object.freeze(emptyContextObject);
-    var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback, log$1 = Math.log, LN2 = Math.LN2, nextTransitionUpdateLane = 256, nextTransitionDeferredLane = 262144, nextRetryLane = 4194304, scheduleCallback$3 = Scheduler.unstable_scheduleCallback, cancelCallback$1 = Scheduler.unstable_cancelCallback, shouldYield = Scheduler.unstable_shouldYield, requestPaint = Scheduler.unstable_requestPaint, now$1 = Scheduler.unstable_now, ImmediatePriority = Scheduler.unstable_ImmediatePriority, UserBlockingPriority = Scheduler.unstable_UserBlockingPriority, NormalPriority$1 = Scheduler.unstable_NormalPriority, IdlePriority = Scheduler.unstable_IdlePriority, log36 = Scheduler.log, unstable_setDisableYieldValue2 = Scheduler.unstable_setDisableYieldValue, rendererID = null, injectedHook = null, hasLoggedError = false, isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined", lastResetTime = 0;
+    var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback, log$1 = Math.log, LN2 = Math.LN2, nextTransitionUpdateLane = 256, nextTransitionDeferredLane = 262144, nextRetryLane = 4194304, scheduleCallback$3 = Scheduler.unstable_scheduleCallback, cancelCallback$1 = Scheduler.unstable_cancelCallback, shouldYield = Scheduler.unstable_shouldYield, requestPaint = Scheduler.unstable_requestPaint, now$1 = Scheduler.unstable_now, ImmediatePriority = Scheduler.unstable_ImmediatePriority, UserBlockingPriority = Scheduler.unstable_UserBlockingPriority, NormalPriority$1 = Scheduler.unstable_NormalPriority, IdlePriority = Scheduler.unstable_IdlePriority, log37 = Scheduler.log, unstable_setDisableYieldValue2 = Scheduler.unstable_setDisableYieldValue, rendererID = null, injectedHook = null, hasLoggedError = false, isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined", lastResetTime = 0;
     if (typeof performance === "object" && typeof performance.now === "function") {
       var localPerformance = performance;
       var getCurrentTime = function() {
@@ -52406,6 +52403,9 @@ class BasePlatformClient extends EventEmitter {
   maxReconnectAttempts = 10;
   reconnectDelay = 1000;
   reconnectTimeout = null;
+  getPostPermalink(post) {
+    return this.getThreadLink(post.rootId || post.id, post.id);
+  }
   isUserAllowed(username) {
     if (this.allowedUsers.length === 0) {
       return true;
@@ -54044,6 +54044,9 @@ class SlackClient extends BasePlatformClient {
     }
     return `#${targetTs}`;
   }
+  getPostPermalink(post) {
+    return this.getThreadLink(post.rootId || post.id, undefined, post.id);
+  }
   async createPost(message, threadId, options) {
     const shouldUnfurl = options?.unfurl ?? threadId !== undefined;
     const truncatedMessage = this.truncateMessageIfNeeded(message);
@@ -55354,952 +55357,267 @@ class GitHubEmailsStore {
 
 // src/claude/account-pool.ts
 init_logger();
-var log8 = createLogger("account-pool");
-function hashThreadId(threadId) {
-  let h = 2166136261;
-  for (let i2 = 0;i2 < threadId.length; i2++) {
-    h ^= threadId.charCodeAt(i2);
-    h = Math.imul(h, 16777619);
-  }
-  return h >>> 0;
-}
 
-class AccountPool {
-  accounts;
-  byId;
-  activeCounts = new Map;
-  coolingUntil = new Map;
-  roundRobinIndex = 0;
-  constructor(accounts) {
-    this.accounts = (accounts ?? []).filter((acc) => {
-      const hasAuth = !!acc.home || !!acc.apiKey;
-      if (!hasAuth) {
-        log8.warn(`Claude account ${acc.id} has neither home nor apiKey — ignoring`);
-        return false;
-      }
-      if (acc.home && acc.apiKey) {
-        log8.warn(`Claude account ${acc.id} has both home and apiKey set — must choose one; ignoring`);
-        return false;
-      }
-      return true;
-    });
-    this.byId = new Map(this.accounts.map((acc) => [acc.id, acc]));
-    for (const acc of this.accounts) {
-      this.activeCounts.set(acc.id, 0);
+// src/claude/usage-probe.ts
+init_spawn();
+
+// src/claude/cli.ts
+init_spawn();
+init_logger();
+import { EventEmitter as EventEmitter2 } from "events";
+import { resolve as resolve3, dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { existsSync as existsSync7, readFileSync as readFileSync6, watchFile, unwatchFile, unlinkSync, statSync, readdirSync, writeFileSync as writeFileSync4 } from "fs";
+import { tmpdir } from "os";
+import { join as join5 } from "path";
+
+// src/mcp/outbound-env.ts
+var OUTBOUND_ENV = {
+  SESSION_WORKING_DIR: "SESSION_WORKING_DIR",
+  SESSION_UPLOAD_DIR: "SESSION_UPLOAD_DIR",
+  OUTBOUND_FILES_ENABLED: "OUTBOUND_FILES_ENABLED",
+  OUTBOUND_FILES_MAX_BYTES: "OUTBOUND_FILES_MAX_BYTES"
+};
+
+// src/claude/rate-limit-detector.ts
+var RATE_LIMIT_PHRASES = [
+  /usage limit reached/i,
+  /rate[_\s-]?limit[_\s-]?error/i,
+  /you have hit the rate limit/i,
+  /quota (has been )?exceeded/i,
+  /\b429\b.*(rate|limit|quota)/i
+];
+var DEFAULT_COOLDOWN_MS = 60 * 60 * 1000;
+function detectRateLimit(text, now = Date.now()) {
+  if (!text)
+    return { detected: false };
+  let matched;
+  for (const phrase of RATE_LIMIT_PHRASES) {
+    const m = text.match(phrase);
+    if (m) {
+      matched = m[0];
+      break;
     }
   }
-  get isEmpty() {
-    return this.accounts.length === 0;
-  }
-  get size() {
-    return this.accounts.length;
-  }
-  acquire(preferredId, threadId) {
-    if (this.isEmpty)
-      return null;
-    if (preferredId) {
-      const preferred = this.byId.get(preferredId);
-      if (preferred) {
-        this.incrementActive(preferred.id);
-        return preferred;
-      }
-      log8.warn(`Preferred account "${preferredId}" not in pool — falling back to round-robin`);
-    }
-    const now = Date.now();
-    const n = this.accounts.length;
-    if (threadId) {
-      const sticky = this.accounts[hashThreadId(threadId) % n];
-      const cooling = this.coolingUntil.get(sticky.id) ?? 0;
-      if (cooling <= now) {
-        this.incrementActive(sticky.id);
-        return sticky;
-      }
-    }
-    for (let i2 = 0;i2 < n; i2++) {
-      const idx = (this.roundRobinIndex + i2) % n;
-      const candidate = this.accounts[idx];
-      const cooling = this.coolingUntil.get(candidate.id) ?? 0;
-      if (cooling <= now) {
-        this.roundRobinIndex = (idx + 1) % n;
-        this.incrementActive(candidate.id);
-        return candidate;
-      }
-    }
-    log8.warn(`All ${n} accounts are in rate-limit cooldown`);
-    return null;
+  if (!matched)
+    return { detected: false };
+  const resetAtEpochMs = extractResetAt(text, now);
+  return { detected: true, matched, resetAtEpochMs };
+}
+function cooldownDeadline(hit, now = Date.now()) {
+  if (!hit.detected)
+    return now;
+  return hit.resetAtEpochMs ?? now + DEFAULT_COOLDOWN_MS;
+}
+function extractResetAt(text, now) {
+  const relative = text.match(/(?:retry[_\s-]?after|resets?\s+in)\s+(\d+)\s*(second|minute|hour|day)s?/i);
+  if (relative) {
+    const value = parseInt(relative[1], 10);
+    const unit = relative[2].toLowerCase();
+    const unitMs = {
+      second: 1000,
+      minute: 60000,
+      hour: 3600000,
+      day: 86400000
+    };
+    return now + value * unitMs[unit];
   }
-  release(accountId) {
-    const current = this.activeCounts.get(accountId);
-    if (current === undefined)
-      return;
-    this.activeCounts.set(accountId, Math.max(0, current - 1));
+  const unix = text.match(/\breset(?:_at)?\b\s*["']?\s*[:=]\s*(\d{10,13})/);
+  if (unix) {
+    const raw = parseInt(unix[1], 10);
+    return unix[1].length === 13 ? raw : raw * 1000;
   }
-  markCooling(accountId, untilEpochMs) {
-    if (!this.byId.has(accountId)) {
-      log8.warn(`markCooling called for unknown account "${accountId}"`);
-      return;
-    }
-    const existing = this.coolingUntil.get(accountId) ?? 0;
-    if (untilEpochMs > existing) {
-      this.coolingUntil.set(accountId, untilEpochMs);
-      const minutes = Math.ceil((untilEpochMs - Date.now()) / 60000);
-      log8.info(`Account "${accountId}" cooling for ~${minutes}min`);
+  const clock = text.match(/resets?\s+at\s+(\d{1,2}):(\d{2})\s*(utc|gmt)?/i);
+  if (clock) {
+    const hh = parseInt(clock[1], 10);
+    const mm = parseInt(clock[2], 10);
+    if (hh < 24 && mm < 60) {
+      const reference = new Date(now);
+      const target = new Date(Date.UTC(reference.getUTCFullYear(), reference.getUTCMonth(), reference.getUTCDate(), hh, mm)).getTime();
+      return target > now ? target : target + 86400000;
     }
   }
-  get(accountId) {
-    return this.byId.get(accountId);
-  }
-  status() {
-    const now = Date.now();
-    return this.accounts.map((acc) => {
-      const cooling = this.coolingUntil.get(acc.id) ?? 0;
-      return {
-        id: acc.id,
-        displayName: acc.displayName ?? acc.id,
-        activeSessions: this.activeCounts.get(acc.id) ?? 0,
-        coolingUntil: cooling > now ? cooling : null
-      };
-    });
-  }
-  incrementActive(accountId) {
-    this.activeCounts.set(accountId, (this.activeCounts.get(accountId) ?? 0) + 1);
-  }
+  return;
 }
 
-// src/cleanup/scheduler.ts
-init_logger();
-import { existsSync as existsSync8 } from "fs";
-import { readdir, rm } from "fs/promises";
-import { join as join7 } from "path";
-
-// src/persistence/thread-logger.ts
-init_logger();
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, appendFileSync, readdirSync, statSync, unlinkSync, rmdirSync, readFileSync as readFileSync6, chmodSync as chmodSync4 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join5, dirname as dirname4 } from "path";
-var log9 = createLogger("thread-log");
-var LOGS_BASE_DIR = join5(homedir4(), ".claude-threads", "logs");
-
-class ThreadLoggerImpl {
-  platformId;
-  threadId;
-  claudeSessionId;
-  enabled;
-  bufferSize;
-  flushIntervalMs;
-  logPath;
-  buffer = [];
-  flushTimer = null;
-  isClosed = false;
-  constructor(platformId, threadId, claudeSessionId, options) {
-    this.platformId = platformId;
-    this.threadId = threadId;
-    this.claudeSessionId = claudeSessionId;
-    this.enabled = options?.enabled ?? true;
-    this.bufferSize = options?.bufferSize ?? 10;
-    this.flushIntervalMs = options?.flushIntervalMs ?? 1000;
-    this.logPath = join5(LOGS_BASE_DIR, platformId, `${claudeSessionId}.jsonl`);
-    if (this.enabled) {
-      const dir = dirname4(this.logPath);
-      if (!existsSync7(dir)) {
-        mkdirSync4(dir, { recursive: true });
+// src/claude/cli.ts
+var log8 = createLogger("claude");
+function cleanupBrowserBridgeSockets() {
+  try {
+    const tempDir = tmpdir();
+    const files = readdirSync(tempDir);
+    for (const file of files) {
+      if (file.startsWith("claude-mcp-browser-bridge-")) {
+        const filePath = join5(tempDir, file);
+        try {
+          const stats = statSync(filePath);
+          if (stats.isSocket()) {
+            unlinkSync(filePath);
+            log8.debug(`Removed stale browser bridge socket: ${file}`);
+          }
+        } catch {}
       }
-      this.flushTimer = setInterval(() => {
-        this.flushSync();
-      }, this.flushIntervalMs);
-      log9.debug(`Thread logger initialized: ${this.logPath}`);
     }
+  } catch (err) {
+    log8.debug(`Browser bridge cleanup failed: ${err}`);
   }
-  isEnabled() {
-    return this.enabled;
+}
+function buildClaudeChildEnv(parentEnv, account) {
+  const env = { ...parentEnv };
+  if (env.MCP_CONNECTION_NONBLOCKING === undefined) {
+    env.MCP_CONNECTION_NONBLOCKING = "true";
   }
-  getLogPath() {
-    return this.logPath;
+  if (env.ENABLE_PROMPT_CACHING_1H === undefined) {
+    env.ENABLE_PROMPT_CACHING_1H = "true";
   }
-  logEvent(event) {
-    if (!this.enabled || this.isClosed)
-      return;
-    const entry = {
-      ts: Date.now(),
-      sessionId: this.claudeSessionId,
-      type: "claude_event",
-      eventType: event.type,
-      event
-    };
-    this.addEntry(entry);
+  if (account?.home) {
+    env.HOME = account.home;
+    env.USERPROFILE = account.home;
+    delete env.ANTHROPIC_API_KEY;
+    delete env.CLAUDE_CODE_OAUTH_TOKEN;
+  } else if (account?.apiKey) {
+    env.ANTHROPIC_API_KEY = account.apiKey;
+    delete env.CLAUDE_CODE_OAUTH_TOKEN;
   }
-  logUserMessage(username, message, displayName, hasFiles) {
-    if (!this.enabled || this.isClosed)
-      return;
-    const entry = {
-      ts: Date.now(),
-      sessionId: this.claudeSessionId,
-      type: "user_message",
-      username,
-      displayName,
-      message,
-      hasFiles
-    };
-    this.addEntry(entry);
+  return env;
+}
+function isErrorResultEvent(event) {
+  const ev = event;
+  if (typeof ev.subtype === "string" && ev.subtype.startsWith("error"))
+    return true;
+  if (ev.is_error === true)
+    return true;
+  return false;
+}
+function materializeMcpConfig(config, sessionId, opts = {}) {
+  if (opts.inline) {
+    return { mode: "inline", value: JSON.stringify(config) };
   }
-  logLifecycle(action, details) {
-    if (!this.enabled || this.isClosed)
-      return;
-    const entry = {
-      ts: Date.now(),
-      sessionId: this.claudeSessionId,
-      type: "lifecycle",
-      action,
-      ...details
-    };
-    this.addEntry(entry);
+  const dir = opts.tmpDirOverride ?? tmpdir();
+  const path = join5(dir, `claude-threads-mcp-${sessionId ?? process.pid}-${Date.now()}.json`);
+  writeFileSync4(path, JSON.stringify(config), { mode: 384 });
+  return { mode: "file", path };
+}
+function buildPermissionArgs(opts) {
+  const args = [];
+  if (opts.permissionMode === "bypass" && !opts.platformConfig) {
+    args.push("--dangerously-skip-permissions");
+    return { args, tempFile: null };
   }
-  logCommand(command, args, username) {
-    if (!this.enabled || this.isClosed)
-      return;
-    const entry = {
-      ts: Date.now(),
-      sessionId: this.claudeSessionId,
-      type: "command",
-      command,
-      args,
-      username
-    };
-    this.addEntry(entry);
+  if (!opts.platformConfig) {
+    throw new Error(`platformConfig is required when permissionMode is '${opts.permissionMode}'`);
   }
-  logPermission(action, permission, username) {
-    if (!this.enabled || this.isClosed)
-      return;
-    const entry = {
-      ts: Date.now(),
-      sessionId: this.claudeSessionId,
-      type: "permission",
-      action,
-      permission,
-      username
-    };
-    this.addEntry(entry);
+  const mcpEnv = {
+    PLATFORM_TYPE: opts.platformConfig.type,
+    PLATFORM_URL: opts.platformConfig.url,
+    PLATFORM_TOKEN: opts.platformConfig.token,
+    PLATFORM_CHANNEL_ID: opts.platformConfig.channelId,
+    PLATFORM_THREAD_ID: opts.threadId || "",
+    ALLOWED_USERS: opts.platformConfig.allowedUsers.join(","),
+    DEBUG: opts.debug ? "1" : "",
+    PERMISSION_TIMEOUT_MS: String(opts.permissionTimeoutMs),
+    SESSION_OWNER_USERNAME: opts.sessionOwnerUsername || ""
+  };
+  if (opts.platformConfig.appToken) {
+    mcpEnv.PLATFORM_APP_TOKEN = opts.platformConfig.appToken;
   }
-  logReaction(action, username, emoji, answer) {
-    if (!this.enabled || this.isClosed)
-      return;
-    const entry = {
-      ts: Date.now(),
-      sessionId: this.claudeSessionId,
-      type: "reaction",
-      action,
-      username,
-      emoji,
-      answer
-    };
-    this.addEntry(entry);
+  if (opts.workingDir) {
+    mcpEnv[OUTBOUND_ENV.SESSION_WORKING_DIR] = opts.workingDir;
   }
-  logExecutor(executor, operation, postId, details, method) {
-    if (!this.enabled || this.isClosed)
-      return;
-    const entry = {
-      ts: Date.now(),
-      sessionId: this.claudeSessionId,
-      type: "executor",
-      executor,
-      operation,
-      postId,
-      method,
-      details
-    };
-    this.addEntry(entry);
+  if (opts.uploadDir) {
+    mcpEnv[OUTBOUND_ENV.SESSION_UPLOAD_DIR] = opts.uploadDir;
   }
-  async flush() {
-    this.flushSync();
+  if (opts.outboundFiles?.enabled === false) {
+    mcpEnv[OUTBOUND_ENV.OUTBOUND_FILES_ENABLED] = "0";
   }
-  async close() {
-    if (this.isClosed)
-      return;
-    this.isClosed = true;
-    if (this.flushTimer) {
-      clearInterval(this.flushTimer);
-      this.flushTimer = null;
-    }
-    this.flushSync();
-    log9.debug(`Thread logger closed: ${this.logPath}`);
+  if (typeof opts.outboundFiles?.maxBytes === "number" && Number.isFinite(opts.outboundFiles.maxBytes) && opts.outboundFiles.maxBytes > 0) {
+    mcpEnv[OUTBOUND_ENV.OUTBOUND_FILES_MAX_BYTES] = String(opts.outboundFiles.maxBytes);
   }
-  addEntry(entry) {
-    this.buffer.push(entry);
-    if (this.buffer.length >= this.bufferSize) {
-      this.flushSync();
+  const mcpConfig = {
+    mcpServers: {
+      "claude-threads-mcp": {
+        type: "stdio",
+        command: "node",
+        args: [opts.mcpServerPath],
+        env: mcpEnv
+      }
     }
+  };
+  const materialized = materializeMcpConfig(mcpConfig, opts.sessionId, { inline: opts.inline });
+  let tempFile = null;
+  if (materialized.mode === "file") {
+    tempFile = materialized.path;
+    args.push("--mcp-config", materialized.path);
+  } else {
+    args.push("--mcp-config", materialized.value);
   }
-  flushSync() {
-    if (this.buffer.length === 0)
-      return;
-    try {
-      const lines = this.buffer.map((entry) => JSON.stringify(entry)).join(`
-`) + `
-`;
-      const isNewFile = !existsSync7(this.logPath);
-      appendFileSync(this.logPath, lines, { encoding: "utf8", mode: 384 });
-      if (isNewFile) {
-        chmodSync4(this.logPath, 384);
-      }
-      this.buffer = [];
-    } catch (err) {
-      log9.error(`Failed to flush thread log: ${err}`);
+  if (opts.permissionMode === "bypass") {
+    args.push("--dangerously-skip-permissions");
+  } else {
+    args.push("--permission-prompt-tool", "mcp__claude-threads-mcp__permission_prompt");
+    if (opts.permissionMode === "auto") {
+      args.push("--permission-mode", "auto");
     }
   }
+  return { args, tempFile };
 }
+var STDERR_PER_INSTANCE_CAP = 10240;
+var STDERR_AGGREGATE_SOFT_CAP = 10 * 1024 * 1024;
+var totalStderrBytes = 0;
 
-class DisabledThreadLogger {
-  logEvent() {}
-  logUserMessage() {}
-  logLifecycle() {}
-  logCommand() {}
-  logPermission() {}
-  logReaction() {}
-  logExecutor() {}
-  async flush() {}
-  async close() {}
-  isEnabled() {
-    return false;
-  }
-  getLogPath() {
-    return "";
+class ClaudeCli extends EventEmitter2 {
+  process = null;
+  options;
+  buffer = "";
+  debug = process.env.DEBUG === "1" || process.argv.includes("--debug");
+  statusFilePath = null;
+  lastStatusData = null;
+  stderrBuffer = "";
+  mcpConfigTempFile = null;
+  lastEmittedRateLimitDeadline = 0;
+  log;
+  constructor(options) {
+    super();
+    this.options = options;
+    this.log = options.logSessionId ? createLogger("claude").forSession(options.logSessionId) : createLogger("claude");
   }
-}
-function createThreadLogger(platformId, threadId, claudeSessionId, options) {
-  if (options?.enabled === false) {
-    return new DisabledThreadLogger;
+  getStatusFilePath() {
+    return this.statusFilePath;
   }
-  return new ThreadLoggerImpl(platformId, threadId, claudeSessionId, options);
-}
-function cleanupOldLogs(retentionDays = 30) {
-  const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
-  let deletedCount = 0;
-  if (!existsSync7(LOGS_BASE_DIR)) {
-    return 0;
+  getStatusData() {
+    if (!this.statusFilePath)
+      return null;
+    try {
+      if (existsSync7(this.statusFilePath)) {
+        const data = readFileSync6(this.statusFilePath, "utf8");
+        this.lastStatusData = JSON.parse(data);
+      }
+    } catch (err) {
+      this.log.debug(`Failed to read status file: ${err}`);
+    }
+    return this.lastStatusData;
   }
-  try {
-    const platformDirs = readdirSync(LOGS_BASE_DIR);
-    for (const platformId of platformDirs) {
-      const platformDir = join5(LOGS_BASE_DIR, platformId);
-      const stat = statSync(platformDir);
-      if (!stat.isDirectory())
-        continue;
-      const logFiles = readdirSync(platformDir);
-      for (const file of logFiles) {
-        if (!file.endsWith(".jsonl"))
-          continue;
-        const filePath = join5(platformDir, file);
-        try {
-          const fileStat = statSync(filePath);
-          if (fileStat.mtimeMs < cutoffMs) {
-            unlinkSync(filePath);
-            deletedCount++;
-            log9.debug(`Deleted old log file: ${filePath}`);
-          }
-        } catch (err) {
-          log9.warn(`Failed to check/delete log file ${filePath}: ${err}`);
-        }
+  startStatusWatch() {
+    if (!this.statusFilePath) {
+      this.log.debug("No status file path, skipping status watch");
+      return;
+    }
+    this.log.debug(`Starting status watch: ${this.statusFilePath}`);
+    const checkStatus = () => {
+      const data = this.getStatusData();
+      if (data && data.timestamp !== this.lastStatusData?.timestamp) {
+        this.lastStatusData = data;
+        this.emit("status", data);
       }
+    };
+    watchFile(this.statusFilePath, { interval: 1000 }, checkStatus);
+  }
+  stopStatusWatch() {
+    if (this.statusFilePath) {
+      unwatchFile(this.statusFilePath);
       try {
-        const remaining = readdirSync(platformDir);
-        if (remaining.length === 0) {
-          rmdirSync(platformDir);
-          log9.debug(`Removed empty platform log directory: ${platformDir}`);
-        }
-      } catch {}
-    }
-    if (deletedCount > 0) {
-      log9.info(`Cleaned up ${deletedCount} old log file(s)`);
-    }
-  } catch (err) {
-    log9.error(`Failed to clean up old logs: ${err}`);
-  }
-  return deletedCount;
-}
-function getLogFilePath(platformId, sessionId) {
-  return join5(LOGS_BASE_DIR, platformId, `${sessionId}.jsonl`);
-}
-function readRecentLogEntries(platformId, sessionId, maxLines = 50) {
-  const logPath = getLogFilePath(platformId, sessionId);
-  log9.debug(`Reading log entries from: ${logPath}`);
-  if (!existsSync7(logPath)) {
-    log9.debug(`Log file does not exist: ${logPath}`);
-    return [];
-  }
-  try {
-    const content = readFileSync6(logPath, "utf8");
-    const lines = content.trim().split(`
-`);
-    log9.debug(`Log file has ${lines.length} lines`);
-    const recentLines = lines.slice(-maxLines);
-    const entries = [];
-    for (const line of recentLines) {
-      if (!line.trim())
-        continue;
-      try {
-        entries.push(JSON.parse(line));
-      } catch {}
-    }
-    log9.debug(`Parsed ${entries.length} log entries`);
-    return entries;
-  } catch (err) {
-    log9.error(`Failed to read log file: ${err}`);
-    return [];
-  }
-}
-
-// src/cleanup/scheduler.ts
-init_worktree();
-var log11 = createLogger("cleanup");
-var DEFAULT_CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
-var MAX_WORKTREE_AGE_MS = 24 * 60 * 60 * 1000;
-
-class CleanupScheduler {
-  intervalMs;
-  logRetentionDays;
-  threadLogsEnabled;
-  sessionStore;
-  maxWorktreeAgeMs;
-  cleanupWorktrees;
-  timer = null;
-  isRunning = false;
-  constructor(options) {
-    this.intervalMs = options.intervalMs ?? DEFAULT_CLEANUP_INTERVAL_MS;
-    this.logRetentionDays = options.logRetentionDays ?? 30;
-    this.threadLogsEnabled = options.threadLogsEnabled ?? true;
-    this.sessionStore = options.sessionStore;
-    this.maxWorktreeAgeMs = options.maxWorktreeAgeMs ?? MAX_WORKTREE_AGE_MS;
-    this.cleanupWorktrees = options.cleanupWorktrees ?? true;
-  }
-  start() {
-    if (this.isRunning) {
-      log11.debug("Cleanup scheduler already running");
-      return;
-    }
-    this.isRunning = true;
-    log11.info(`Cleanup scheduler started (interval: ${Math.round(this.intervalMs / 60000)}min)`);
-    this.runCleanup().catch((err) => {
-      log11.warn(`Initial cleanup failed: ${err}`);
-    });
-    this.timer = setInterval(() => {
-      this.runCleanup().catch((err) => {
-        log11.warn(`Periodic cleanup failed: ${err}`);
-      });
-    }, this.intervalMs);
-  }
-  stop() {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-    this.isRunning = false;
-    log11.debug("Cleanup scheduler stopped");
-  }
-  async runCleanup() {
-    const startTime = Date.now();
-    log11.debug("Running background cleanup...");
-    const stats = {
-      logsDeleted: 0,
-      worktreesCleaned: 0,
-      metadataCleaned: 0,
-      errors: []
-    };
-    const cleanupTasks = [
-      this.cleanupLogs().catch((err) => {
-        stats.errors.push(`Log cleanup: ${err}`);
-        return 0;
-      })
-    ];
-    if (this.cleanupWorktrees) {
-      cleanupTasks.push(this.cleanupOrphanedWorktrees().catch((err) => {
-        stats.errors.push(`Worktree cleanup: ${err}`);
-        return { cleaned: 0, metadata: 0 };
-      }));
-    }
-    const [logStats, worktreeStats = { cleaned: 0, metadata: 0 }] = await Promise.all(cleanupTasks);
-    stats.logsDeleted = logStats;
-    stats.worktreesCleaned = worktreeStats.cleaned;
-    stats.metadataCleaned = worktreeStats.metadata;
-    const elapsed = Date.now() - startTime;
-    const totalCleaned = stats.logsDeleted + stats.worktreesCleaned + stats.metadataCleaned;
-    if (totalCleaned > 0 || stats.errors.length > 0) {
-      log11.info(`Cleanup completed in ${elapsed}ms: ` + `${stats.logsDeleted} logs, ${stats.worktreesCleaned} worktrees, ${stats.metadataCleaned} metadata` + (stats.errors.length > 0 ? ` (${stats.errors.length} errors)` : ""));
-    } else {
-      log11.debug(`Cleanup completed in ${elapsed}ms (nothing to clean)`);
-    }
-    return stats;
-  }
-  async cleanupLogs() {
-    if (!this.threadLogsEnabled) {
-      return 0;
-    }
-    return new Promise((resolve3) => {
-      try {
-        const deleted = cleanupOldLogs(this.logRetentionDays);
-        resolve3(deleted);
-      } catch (err) {
-        log11.warn(`Log cleanup error: ${err}`);
-        resolve3(0);
-      }
-    });
-  }
-  async cleanupOrphanedWorktrees() {
-    const worktreesDir = getWorktreesDir();
-    const result = { cleaned: 0, metadata: 0 };
-    if (!existsSync8(worktreesDir)) {
-      log11.debug("No worktrees directory exists, nothing to clean");
-      return result;
-    }
-    const persisted = this.sessionStore.load();
-    const activeWorktrees = new Set;
-    for (const session of persisted.values()) {
-      if (session.worktreeInfo?.worktreePath) {
-        activeWorktrees.add(session.worktreeInfo.worktreePath);
-      }
-    }
-    const now = Date.now();
-    try {
-      const entries = await readdir(worktreesDir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory())
-          continue;
-        const worktreePath = join7(worktreesDir, entry.name);
-        if (activeWorktrees.has(worktreePath)) {
-          log11.debug(`Worktree in use by persisted session, skipping: ${entry.name}`);
-          continue;
-        }
-        const meta = await readWorktreeMetadata(worktreePath);
-        let shouldCleanup = false;
-        let cleanupReason = "";
-        if (meta) {
-          const lastActivity = new Date(meta.lastActivityAt).getTime();
-          const age = now - lastActivity;
-          if (meta.sessionId && age < this.maxWorktreeAgeMs) {
-            log11.debug(`Worktree has active session (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
-            continue;
-          }
-          const merged = age >= this.maxWorktreeAgeMs ? await isBranchMerged(meta.repoRoot, meta.branch).catch(() => false) : false;
-          if (merged) {
-            shouldCleanup = true;
-            cleanupReason = `branch "${meta.branch}" was merged`;
-          } else if (age >= this.maxWorktreeAgeMs) {
-            shouldCleanup = true;
-            cleanupReason = `inactive for ${Math.round(age / 3600000)}h`;
-          } else {
-            log11.debug(`Worktree recent (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
-            continue;
-          }
-        } else {
-          shouldCleanup = true;
-          cleanupReason = "no metadata";
-        }
-        if (!shouldCleanup)
-          continue;
-        log11.info(`Cleaning worktree (${cleanupReason}): ${entry.name}`);
-        try {
-          if (meta?.repoRoot) {
-            await removeWorktree(meta.repoRoot, worktreePath);
-          } else {
-            await rm(worktreePath, { recursive: true, force: true });
-          }
-          result.cleaned++;
-          await removeWorktreeMetadata(worktreePath);
-          result.metadata++;
-        } catch (err) {
-          log11.warn(`Failed to clean orphaned worktree ${entry.name}: ${err}`);
-          try {
-            await rm(worktreePath, { recursive: true, force: true });
-            result.cleaned++;
-            await removeWorktreeMetadata(worktreePath);
-            result.metadata++;
-          } catch (rmErr) {
-            log11.error(`Failed to force remove worktree ${entry.name}: ${rmErr}`);
-          }
-        }
-      }
-    } catch (err) {
-      log11.warn(`Failed to scan worktrees directory: ${err}`);
-    }
-    return result;
-  }
-}
-// src/operations/monitor/handler.ts
-init_logger();
-
-// src/session/lifecycle-fsm.ts
-init_logger();
-var log12 = createLogger("fsm");
-var ALLOWED_TRANSITIONS = {
-  starting: new Set(["active", "paused", "interrupted", "cancelling", "restarting"]),
-  active: new Set([
-    "active",
-    "processing",
-    "paused",
-    "interrupted",
-    "restarting",
-    "cancelling",
-    "ending"
-  ]),
-  processing: new Set([
-    "active",
-    "paused",
-    "interrupted",
-    "restarting",
-    "cancelling"
-  ]),
-  paused: new Set(["active", "cancelling", "restarting"]),
-  interrupted: new Set(["active", "cancelling", "restarting", "paused"]),
-  restarting: new Set(["active", "paused", "cancelling"]),
-  cancelling: new Set(["ending"]),
-  ending: new Set
-};
-function checkTransition(from, to, sessionId) {
-  const allowed = ALLOWED_TRANSITIONS[from];
-  if (allowed.has(to))
-    return;
-  const msg = `illegal lifecycle transition ${from} -> ${to}`;
-  const payload = {
-    event: "fsm.illegal_transition",
-    from,
-    to,
-    sessionId
-  };
-  if (process.env.CLAUDE_THREADS_FSM_STRICT === "1") {
-    throw new Error(`${msg} (sessionId=${sessionId})`);
-  }
-  log12.warn(msg, payload);
-}
-
-// src/session/timer-manager.ts
-function createSessionTimers() {
-  return {
-    updateTimer: null,
-    typingTimer: null,
-    statusBarTimer: null
-  };
-}
-function clearAllTimers(timers) {
-  if (timers.updateTimer) {
-    clearTimeout(timers.updateTimer);
-    timers.updateTimer = null;
-  }
-  if (timers.typingTimer) {
-    clearInterval(timers.typingTimer);
-    timers.typingTimer = null;
-  }
-  if (timers.statusBarTimer) {
-    clearInterval(timers.statusBarTimer);
-    timers.statusBarTimer = null;
-  }
-}
-
-// src/session/types.ts
-function createSessionLifecycle() {
-  return {
-    state: "starting",
-    resumeFailCount: 0,
-    hasClaudeResponded: false
-  };
-}
-function createResumedLifecycle(resumeFailCount = 0) {
-  return {
-    state: "active",
-    resumeFailCount,
-    hasClaudeResponded: true
-  };
-}
-function isSessionRestarting(session) {
-  return session.lifecycle.state === "restarting";
-}
-function isSessionCancelled(session) {
-  return session.lifecycle.state === "cancelling";
-}
-function transitionTo(session, newState) {
-  checkTransition(session.lifecycle.state, newState, session.sessionId);
-  session.lifecycle.state = newState;
-}
-function markClaudeResponded(session) {
-  session.lifecycle.hasClaudeResponded = true;
-  if (session.lifecycle.state === "starting") {
-    session.lifecycle.state = "active";
-  }
-}
-function getSessionStatus(session) {
-  if (session.isProcessing) {
-    return session.lifecycle.hasClaudeResponded ? "active" : "starting";
-  }
-  return "idle";
-}
-
-// src/session/authorization.ts
-function isAuthorizedForSession(check) {
-  const { username, platform, sessionAllowedUsers } = check;
-  if (!username || username === "unknown") {
-    return false;
-  }
-  if (platform.isUserAllowed(username)) {
-    return true;
-  }
-  return sessionAllowedUsers?.has(username) ?? false;
-}
-
-// src/claude/cli.ts
-init_spawn();
-init_logger();
-import { EventEmitter as EventEmitter2 } from "events";
-import { resolve as resolve3, dirname as dirname6 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { existsSync as existsSync9, readFileSync as readFileSync7, watchFile, unwatchFile, unlinkSync as unlinkSync2, statSync as statSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync4 } from "fs";
-import { tmpdir } from "os";
-import { join as join8 } from "path";
-
-// src/mcp/outbound-env.ts
-var OUTBOUND_ENV = {
-  SESSION_WORKING_DIR: "SESSION_WORKING_DIR",
-  SESSION_UPLOAD_DIR: "SESSION_UPLOAD_DIR",
-  OUTBOUND_FILES_ENABLED: "OUTBOUND_FILES_ENABLED",
-  OUTBOUND_FILES_MAX_BYTES: "OUTBOUND_FILES_MAX_BYTES"
-};
-
-// src/claude/rate-limit-detector.ts
-var RATE_LIMIT_PHRASES = [
-  /usage limit reached/i,
-  /rate[_\s-]?limit[_\s-]?error/i,
-  /you have hit the rate limit/i,
-  /quota (has been )?exceeded/i,
-  /\b429\b.*(rate|limit|quota)/i
-];
-var DEFAULT_COOLDOWN_MS = 60 * 60 * 1000;
-function detectRateLimit(text, now = Date.now()) {
-  if (!text)
-    return { detected: false };
-  let matched;
-  for (const phrase of RATE_LIMIT_PHRASES) {
-    const m = text.match(phrase);
-    if (m) {
-      matched = m[0];
-      break;
-    }
-  }
-  if (!matched)
-    return { detected: false };
-  const resetAtEpochMs = extractResetAt(text, now);
-  return { detected: true, matched, resetAtEpochMs };
-}
-function cooldownDeadline(hit, now = Date.now()) {
-  if (!hit.detected)
-    return now;
-  return hit.resetAtEpochMs ?? now + DEFAULT_COOLDOWN_MS;
-}
-function extractResetAt(text, now) {
-  const relative = text.match(/(?:retry[_\s-]?after|resets?\s+in)\s+(\d+)\s*(second|minute|hour|day)s?/i);
-  if (relative) {
-    const value = parseInt(relative[1], 10);
-    const unit = relative[2].toLowerCase();
-    const unitMs = {
-      second: 1000,
-      minute: 60000,
-      hour: 3600000,
-      day: 86400000
-    };
-    return now + value * unitMs[unit];
-  }
-  const unix = text.match(/\breset(?:_at)?\b\s*["']?\s*[:=]\s*(\d{10,13})/);
-  if (unix) {
-    const raw = parseInt(unix[1], 10);
-    return unix[1].length === 13 ? raw : raw * 1000;
-  }
-  const clock = text.match(/resets?\s+at\s+(\d{1,2}):(\d{2})\s*(utc|gmt)?/i);
-  if (clock) {
-    const hh = parseInt(clock[1], 10);
-    const mm = parseInt(clock[2], 10);
-    if (hh < 24 && mm < 60) {
-      const reference = new Date(now);
-      const target = new Date(Date.UTC(reference.getUTCFullYear(), reference.getUTCMonth(), reference.getUTCDate(), hh, mm)).getTime();
-      return target > now ? target : target + 86400000;
-    }
-  }
-  return;
-}
-
-// src/claude/cli.ts
-var log13 = createLogger("claude");
-function cleanupBrowserBridgeSockets() {
-  try {
-    const tempDir = tmpdir();
-    const files = readdirSync2(tempDir);
-    for (const file of files) {
-      if (file.startsWith("claude-mcp-browser-bridge-")) {
-        const filePath = join8(tempDir, file);
-        try {
-          const stats = statSync2(filePath);
-          if (stats.isSocket()) {
-            unlinkSync2(filePath);
-            log13.debug(`Removed stale browser bridge socket: ${file}`);
-          }
-        } catch {}
-      }
-    }
-  } catch (err) {
-    log13.debug(`Browser bridge cleanup failed: ${err}`);
-  }
-}
-function buildClaudeChildEnv(parentEnv, account) {
-  const env = { ...parentEnv };
-  if (env.MCP_CONNECTION_NONBLOCKING === undefined) {
-    env.MCP_CONNECTION_NONBLOCKING = "true";
-  }
-  if (env.ENABLE_PROMPT_CACHING_1H === undefined) {
-    env.ENABLE_PROMPT_CACHING_1H = "true";
-  }
-  if (account?.home) {
-    env.HOME = account.home;
-    env.USERPROFILE = account.home;
-    delete env.ANTHROPIC_API_KEY;
-    delete env.CLAUDE_CODE_OAUTH_TOKEN;
-  } else if (account?.apiKey) {
-    env.ANTHROPIC_API_KEY = account.apiKey;
-    delete env.CLAUDE_CODE_OAUTH_TOKEN;
-  }
-  return env;
-}
-function isErrorResultEvent(event) {
-  const ev = event;
-  if (typeof ev.subtype === "string" && ev.subtype.startsWith("error"))
-    return true;
-  if (ev.is_error === true)
-    return true;
-  return false;
-}
-function materializeMcpConfig(config, sessionId, opts = {}) {
-  if (opts.inline) {
-    return { mode: "inline", value: JSON.stringify(config) };
-  }
-  const dir = opts.tmpDirOverride ?? tmpdir();
-  const path2 = join8(dir, `claude-threads-mcp-${sessionId ?? process.pid}-${Date.now()}.json`);
-  writeFileSync4(path2, JSON.stringify(config), { mode: 384 });
-  return { mode: "file", path: path2 };
-}
-function buildPermissionArgs(opts) {
-  const args = [];
-  if (opts.permissionMode === "bypass" && !opts.platformConfig) {
-    args.push("--dangerously-skip-permissions");
-    return { args, tempFile: null };
-  }
-  if (!opts.platformConfig) {
-    throw new Error(`platformConfig is required when permissionMode is '${opts.permissionMode}'`);
-  }
-  const mcpEnv = {
-    PLATFORM_TYPE: opts.platformConfig.type,
-    PLATFORM_URL: opts.platformConfig.url,
-    PLATFORM_TOKEN: opts.platformConfig.token,
-    PLATFORM_CHANNEL_ID: opts.platformConfig.channelId,
-    PLATFORM_THREAD_ID: opts.threadId || "",
-    ALLOWED_USERS: opts.platformConfig.allowedUsers.join(","),
-    DEBUG: opts.debug ? "1" : "",
-    PERMISSION_TIMEOUT_MS: String(opts.permissionTimeoutMs),
-    SESSION_OWNER_USERNAME: opts.sessionOwnerUsername || ""
-  };
-  if (opts.platformConfig.appToken) {
-    mcpEnv.PLATFORM_APP_TOKEN = opts.platformConfig.appToken;
-  }
-  if (opts.workingDir) {
-    mcpEnv[OUTBOUND_ENV.SESSION_WORKING_DIR] = opts.workingDir;
-  }
-  if (opts.uploadDir) {
-    mcpEnv[OUTBOUND_ENV.SESSION_UPLOAD_DIR] = opts.uploadDir;
-  }
-  if (opts.outboundFiles?.enabled === false) {
-    mcpEnv[OUTBOUND_ENV.OUTBOUND_FILES_ENABLED] = "0";
-  }
-  if (typeof opts.outboundFiles?.maxBytes === "number" && Number.isFinite(opts.outboundFiles.maxBytes) && opts.outboundFiles.maxBytes > 0) {
-    mcpEnv[OUTBOUND_ENV.OUTBOUND_FILES_MAX_BYTES] = String(opts.outboundFiles.maxBytes);
-  }
-  const mcpConfig = {
-    mcpServers: {
-      "claude-threads-mcp": {
-        type: "stdio",
-        command: "node",
-        args: [opts.mcpServerPath],
-        env: mcpEnv
-      }
-    }
-  };
-  const materialized = materializeMcpConfig(mcpConfig, opts.sessionId, { inline: opts.inline });
-  let tempFile = null;
-  if (materialized.mode === "file") {
-    tempFile = materialized.path;
-    args.push("--mcp-config", materialized.path);
-  } else {
-    args.push("--mcp-config", materialized.value);
-  }
-  if (opts.permissionMode === "bypass") {
-    args.push("--dangerously-skip-permissions");
-  } else {
-    args.push("--permission-prompt-tool", "mcp__claude-threads-mcp__permission_prompt");
-    if (opts.permissionMode === "auto") {
-      args.push("--permission-mode", "auto");
-    }
-  }
-  return { args, tempFile };
-}
-var STDERR_PER_INSTANCE_CAP = 10240;
-var STDERR_AGGREGATE_SOFT_CAP = 10 * 1024 * 1024;
-var totalStderrBytes = 0;
-
-class ClaudeCli extends EventEmitter2 {
-  process = null;
-  options;
-  buffer = "";
-  debug = process.env.DEBUG === "1" || process.argv.includes("--debug");
-  statusFilePath = null;
-  lastStatusData = null;
-  stderrBuffer = "";
-  mcpConfigTempFile = null;
-  lastEmittedRateLimitDeadline = 0;
-  log;
-  constructor(options) {
-    super();
-    this.options = options;
-    this.log = options.logSessionId ? createLogger("claude").forSession(options.logSessionId) : createLogger("claude");
-  }
-  getStatusFilePath() {
-    return this.statusFilePath;
-  }
-  getStatusData() {
-    if (!this.statusFilePath)
-      return null;
-    try {
-      if (existsSync9(this.statusFilePath)) {
-        const data = readFileSync7(this.statusFilePath, "utf8");
-        this.lastStatusData = JSON.parse(data);
-      }
-    } catch (err) {
-      this.log.debug(`Failed to read status file: ${err}`);
-    }
-    return this.lastStatusData;
-  }
-  startStatusWatch() {
-    if (!this.statusFilePath) {
-      this.log.debug("No status file path, skipping status watch");
-      return;
-    }
-    this.log.debug(`Starting status watch: ${this.statusFilePath}`);
-    const checkStatus = () => {
-      const data = this.getStatusData();
-      if (data && data.timestamp !== this.lastStatusData?.timestamp) {
-        this.lastStatusData = data;
-        this.emit("status", data);
-      }
-    };
-    watchFile(this.statusFilePath, { interval: 1000 }, checkStatus);
-  }
-  stopStatusWatch() {
-    if (this.statusFilePath) {
-      unwatchFile(this.statusFilePath);
-      try {
-        if (existsSync9(this.statusFilePath)) {
-          unlinkSync2(this.statusFilePath);
+        if (existsSync7(this.statusFilePath)) {
+          unlinkSync(this.statusFilePath);
         }
       } catch {}
     }
@@ -56349,7 +55667,7 @@ class ClaudeCli extends EventEmitter2 {
       args.push("--append-system-prompt", this.options.appendSystemPrompt);
     }
     if (this.options.sessionId) {
-      this.statusFilePath = join8(tmpdir(), `claude-threads-status-${this.options.sessionId}.json`);
+      this.statusFilePath = join5(tmpdir(), `claude-threads-status-${this.options.sessionId}.json`);
       const statusLineWriterPath = this.getStatusLineWriterPath();
       const statusLineSettings = {
         statusLine: {
@@ -56399,170 +55717,1001 @@ class ClaudeCli extends EventEmitter2 {
       this.buffer = "";
       totalStderrBytes -= this.stderrBuffer.length;
       if (this.mcpConfigTempFile) {
-        const path2 = this.mcpConfigTempFile;
+        const path = this.mcpConfigTempFile;
         this.mcpConfigTempFile = null;
         try {
-          unlinkSync2(path2);
+          unlinkSync(path);
         } catch {}
       }
       this.emit("exit", code);
     });
   }
-  sendMessage(content) {
-    if (!this.process?.stdin)
-      throw new Error("Not running");
-    const msg = JSON.stringify({
-      type: "user",
-      message: { role: "user", content }
-    }) + `
-`;
-    const preview = content.substring(0, 50);
-    this.log.debug(`Sending: ${preview}...`);
-    if (process.env.INTEGRATION_TEST === "1") {
-      const stack = new Error().stack?.split(`
-`).slice(2, 6).join(" > ").replace(/\s+at\s+/g, " < ") ?? "?";
-      process.stderr.write(`[claude-cli sendMessage pid=${this.process.pid}] ${preview} | ${stack}
-`);
+  sendMessage(content) {
+    if (!this.process?.stdin)
+      throw new Error("Not running");
+    const msg = JSON.stringify({
+      type: "user",
+      message: { role: "user", content }
+    }) + `
+`;
+    const preview = content.substring(0, 50);
+    this.log.debug(`Sending: ${preview}...`);
+    if (process.env.INTEGRATION_TEST === "1") {
+      const stack = new Error().stack?.split(`
+`).slice(2, 6).join(" > ").replace(/\s+at\s+/g, " < ") ?? "?";
+      process.stderr.write(`[claude-cli sendMessage pid=${this.process.pid}] ${preview} | ${stack}
+`);
+    }
+    this.process.stdin.write(msg);
+  }
+  sendToolResult(toolUseId, content) {
+    if (!this.process?.stdin)
+      throw new Error("Not running");
+    const msg = JSON.stringify({
+      type: "user",
+      message: {
+        role: "user",
+        content: [{
+          type: "tool_result",
+          tool_use_id: toolUseId,
+          content: typeof content === "string" ? content : JSON.stringify(content)
+        }]
+      }
+    }) + `
+`;
+    this.log.debug(`Sending tool_result for ${toolUseId}`);
+    this.process.stdin.write(msg);
+  }
+  parseOutput(data) {
+    this.buffer += data;
+    const lines = this.buffer.split(`
+`);
+    this.buffer = lines.pop() || "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed)
+        continue;
+      try {
+        const event = JSON.parse(trimmed);
+        this.emit("event", event);
+        if (event.type === "result" && isErrorResultEvent(event)) {
+          this.maybeEmitRateLimit(trimmed);
+        }
+      } catch {}
+    }
+  }
+  maybeEmitRateLimit(text) {
+    const hit = detectRateLimit(text);
+    if (!hit.detected)
+      return;
+    const newDeadline = cooldownDeadline(hit);
+    const MIN_ADVANCE_MS = 60000;
+    if (newDeadline - this.lastEmittedRateLimitDeadline < MIN_ADVANCE_MS)
+      return;
+    this.lastEmittedRateLimitDeadline = newDeadline;
+    this.log.warn(`Rate limit detected: ${hit.matched ?? "(no match text)"}`);
+    this.emit("rate-limit", hit);
+  }
+  isRunning() {
+    return this.process !== null;
+  }
+  getLastStderr() {
+    return this.stderrBuffer;
+  }
+  isPermanentFailure() {
+    const stderr = this.stderrBuffer;
+    if (stderr.includes("claude-mcp-browser-bridge") && (stderr.includes("EOPNOTSUPP") || stderr.includes("ENOENT"))) {
+      return true;
+    }
+    if (stderr.includes("No conversation found with session ID")) {
+      return true;
+    }
+    return false;
+  }
+  getPermanentFailureReason() {
+    const stderr = this.stderrBuffer;
+    if (stderr.includes("claude-mcp-browser-bridge") && (stderr.includes("EOPNOTSUPP") || stderr.includes("ENOENT"))) {
+      return "Claude browser bridge state from a previous session is no longer accessible. This typically happens when a session with Chrome integration is resumed after a restart.";
+    }
+    if (stderr.includes("No conversation found with session ID")) {
+      return "The conversation history for this session no longer exists. This can happen if Claude's history was cleared or if the session was created on a different machine.";
+    }
+    return null;
+  }
+  kill() {
+    this.stopStatusWatch();
+    if (!this.process) {
+      this.log.debug("Kill called but process not running");
+      return Promise.resolve();
+    }
+    const proc = this.process;
+    const pid = proc.pid;
+    this.process = null;
+    this.log.debug(`Killing Claude process (pid=${pid})`);
+    return new Promise((resolve4) => {
+      this.log.debug("Sending first SIGINT");
+      proc.kill("SIGINT");
+      const secondSigint = setTimeout(() => {
+        try {
+          this.log.debug("Sending second SIGINT");
+          proc.kill("SIGINT");
+        } catch {}
+      }, 100);
+      const forceKillTimeout = setTimeout(() => {
+        try {
+          this.log.debug("Sending SIGTERM (force kill)");
+          proc.kill("SIGTERM");
+        } catch {}
+      }, 2000);
+      proc.once("exit", (code) => {
+        this.log.debug(`Claude process exited (code=${code})`);
+        clearTimeout(secondSigint);
+        clearTimeout(forceKillTimeout);
+        resolve4();
+      });
+    });
+  }
+  interrupt() {
+    if (!this.process) {
+      this.log.debug("Interrupt called but process not running");
+      return false;
+    }
+    this.log.debug(`Interrupting Claude process (pid=${this.process.pid})`);
+    this.process.kill("SIGINT");
+    return true;
+  }
+  buildChildEnv() {
+    return buildClaudeChildEnv(process.env, this.options.account);
+  }
+  getMcpServerPath() {
+    const __filename2 = fileURLToPath3(import.meta.url);
+    const __dirname4 = dirname4(__filename2);
+    const bundledPath = resolve3(__dirname4, "mcp", "mcp-server.js");
+    if (existsSync7(bundledPath)) {
+      return bundledPath;
+    }
+    return resolve3(__dirname4, "..", "mcp", "mcp-server.js");
+  }
+  getStatusLineWriterPath() {
+    const __filename2 = fileURLToPath3(import.meta.url);
+    const __dirname4 = dirname4(__filename2);
+    const bundledPath = resolve3(__dirname4, "statusline", "writer.js");
+    if (existsSync7(bundledPath)) {
+      return bundledPath;
+    }
+    return resolve3(__dirname4, "..", "statusline", "writer.js");
+  }
+}
+
+// src/claude/usage-probe.ts
+init_logger();
+var log9 = createLogger("usage-probe");
+var DEFAULT_USAGE_PROBE_TIMEOUT_MS = 30000;
+function parseUsageOutput(text) {
+  if (!text)
+    return null;
+  const sessionMatch = text.match(/Current session:\s*(\d+)%\s*used(?:\s*·\s*resets\s*([^\n]+?))?\s*(?:\n|$)/i);
+  const weekAllMatch = text.match(/Current week(?: \(all models\))?:\s*(\d+)%\s*used(?:\s*·\s*resets\s*([^\n]+?))?\s*(?:\n|$)/i);
+  if (!sessionMatch && !weekAllMatch)
+    return null;
+  const sessionPct = sessionMatch ? clampPct(Number(sessionMatch[1])) : 0;
+  const weekAllModelsPct = weekAllMatch ? clampPct(Number(weekAllMatch[1])) : 0;
+  let weekPerModelPct = null;
+  const perModelRe = /Current week \((?!all models\))[^)]+\):\s*(\d+)%\s*used/gi;
+  for (const m of text.matchAll(perModelRe)) {
+    const pct = clampPct(Number(m[1]));
+    weekPerModelPct = weekPerModelPct === null ? pct : Math.max(weekPerModelPct, pct);
+  }
+  return {
+    sessionPct,
+    weekAllModelsPct,
+    weekPerModelPct,
+    sessionResetsAt: sessionMatch?.[2]?.trim() || null,
+    weekResetsAt: weekAllMatch?.[2]?.trim() || null
+  };
+}
+function usageLoadScore(usage) {
+  return Math.max(usage.sessionPct, usage.weekAllModelsPct, usage.weekPerModelPct ?? 0);
+}
+function clampPct(n) {
+  if (!Number.isFinite(n))
+    return 0;
+  return Math.max(0, Math.min(100, Math.round(n)));
+}
+async function probeAccountUsage(account, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_USAGE_PROBE_TIMEOUT_MS;
+  const claudePath = getClaudePath();
+  const env = buildClaudeChildEnv(process.env, account);
+  return new Promise((resolve4) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve4(value);
+    };
+    let child;
+    try {
+      child = crossSpawn(claudePath, ["-p", "/usage", "--output-format", "json"], {
+        env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (err) {
+      log9.warn(`Failed to spawn /usage probe for "${account.id}": ${err}`);
+      resolve4(null);
+      return;
+    }
+    const timer = setTimeout(() => {
+      log9.warn(`/usage probe for "${account.id}" timed out after ${timeoutMs}ms`);
+      try {
+        child.kill("SIGKILL");
+      } catch {}
+      finish(null);
+    }, timeoutMs);
+    let stdout = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", () => {});
+    child.on("error", (err) => {
+      log9.warn(`/usage probe for "${account.id}" errored: ${err}`);
+      finish(null);
+    });
+    child.on("close", () => {
+      const usage = extractUsage(stdout);
+      if (!usage) {
+        log9.debug(`/usage probe for "${account.id}" returned no parseable usage`);
+      }
+      finish(usage);
+    });
+  });
+}
+function extractUsage(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed)
+    return null;
+  let text = trimmed;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed.result === "string") {
+      text = parsed.result;
+    }
+  } catch {}
+  return parseUsageOutput(text);
+}
+
+// src/claude/account-pool.ts
+var log10 = createLogger("account-pool");
+var ACTIVE_SESSION_LOAD_PENALTY = 5;
+function hashThreadId(threadId) {
+  let h = 2166136261;
+  for (let i2 = 0;i2 < threadId.length; i2++) {
+    h ^= threadId.charCodeAt(i2);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+
+class AccountPool {
+  accounts;
+  byId;
+  orderIndex;
+  activeCounts = new Map;
+  coolingUntil = new Map;
+  usage = new Map;
+  rrCursor = 0;
+  constructor(accounts) {
+    this.accounts = (accounts ?? []).filter((acc) => {
+      const hasAuth = !!acc.home || !!acc.apiKey;
+      if (!hasAuth) {
+        log10.warn(`Claude account ${acc.id} has neither home nor apiKey — ignoring`);
+        return false;
+      }
+      if (acc.home && acc.apiKey) {
+        log10.warn(`Claude account ${acc.id} has both home and apiKey set — must choose one; ignoring`);
+        return false;
+      }
+      return true;
+    });
+    this.byId = new Map(this.accounts.map((acc) => [acc.id, acc]));
+    this.orderIndex = new Map(this.accounts.map((acc, i2) => [acc.id, i2]));
+    for (const acc of this.accounts) {
+      this.activeCounts.set(acc.id, 0);
+      this.usage.set(acc.id, null);
+    }
+  }
+  get isEmpty() {
+    return this.accounts.length === 0;
+  }
+  get size() {
+    return this.accounts.length;
+  }
+  get all() {
+    return this.accounts;
+  }
+  acquire(preferredId, threadId, opts) {
+    if (this.isEmpty)
+      return null;
+    if (preferredId) {
+      const preferred = this.byId.get(preferredId);
+      if (preferred) {
+        this.incrementActive(preferred.id);
+        return preferred;
+      }
+      log10.warn(`Preferred account "${preferredId}" not in pool — falling back to usage balancing`);
+    }
+    const now = Date.now();
+    const n = this.accounts.length;
+    if (threadId && !opts?.balanceByUsage) {
+      const sticky = this.accounts[hashThreadId(threadId) % n];
+      const cooling = this.coolingUntil.get(sticky.id) ?? 0;
+      if (cooling <= now) {
+        this.incrementActive(sticky.id);
+        return sticky;
+      }
+    }
+    const chosen = this.selectLeastLoaded(now);
+    if (!chosen) {
+      log10.warn(`All ${n} accounts are in rate-limit cooldown`);
+      return null;
+    }
+    this.incrementActive(chosen.id);
+    return chosen;
+  }
+  selectLeastLoaded(now) {
+    const n = this.accounts.length;
+    let best = null;
+    let bestScore = Number.POSITIVE_INFINITY;
+    let bestIdx = -1;
+    for (let k = 0;k < n; k++) {
+      const idx = (this.rrCursor + k) % n;
+      const acc = this.accounts[idx];
+      if ((this.coolingUntil.get(acc.id) ?? 0) > now)
+        continue;
+      const score = this.effectiveLoad(acc.id);
+      if (best === null || score < bestScore) {
+        best = acc;
+        bestScore = score;
+        bestIdx = idx;
+      }
+    }
+    if (bestIdx >= 0)
+      this.rrCursor = (bestIdx + 1) % n;
+    return best;
+  }
+  loadScore(accountId) {
+    const u = this.usage.get(accountId);
+    return u ? usageLoadScore(u) : Number.POSITIVE_INFINITY;
+  }
+  effectiveLoad(accountId) {
+    const base = this.loadScore(accountId);
+    const active = this.activeCounts.get(accountId) ?? 0;
+    return base + ACTIVE_SESSION_LOAD_PENALTY * active;
+  }
+  release(accountId) {
+    const current = this.activeCounts.get(accountId);
+    if (current === undefined)
+      return;
+    this.activeCounts.set(accountId, Math.max(0, current - 1));
+  }
+  setUsage(accountId, usage) {
+    if (!this.byId.has(accountId))
+      return;
+    this.usage.set(accountId, usage);
+    if (usage) {
+      log10.debug(`Account "${accountId}" usage: ${usageLoadScore(usage)}% (load score)`);
+    }
+  }
+  markCooling(accountId, untilEpochMs) {
+    if (!this.byId.has(accountId)) {
+      log10.warn(`markCooling called for unknown account "${accountId}"`);
+      return;
+    }
+    const existing = this.coolingUntil.get(accountId) ?? 0;
+    if (untilEpochMs > existing) {
+      this.coolingUntil.set(accountId, untilEpochMs);
+      const minutes = Math.ceil((untilEpochMs - Date.now()) / 60000);
+      log10.info(`Account "${accountId}" cooling for ~${minutes}min`);
+    }
+  }
+  get(accountId) {
+    return this.byId.get(accountId);
+  }
+  status() {
+    const now = Date.now();
+    return this.accounts.map((acc) => {
+      const cooling = this.coolingUntil.get(acc.id) ?? 0;
+      const usage = this.usage.get(acc.id) ?? null;
+      return {
+        id: acc.id,
+        displayName: acc.displayName ?? acc.id,
+        activeSessions: this.activeCounts.get(acc.id) ?? 0,
+        coolingUntil: cooling > now ? cooling : null,
+        usagePercent: usage ? usageLoadScore(usage) : null
+      };
+    });
+  }
+  incrementActive(accountId) {
+    this.activeCounts.set(accountId, (this.activeCounts.get(accountId) ?? 0) + 1);
+  }
+}
+
+// src/cleanup/scheduler.ts
+init_logger();
+import { existsSync as existsSync9 } from "fs";
+import { readdir, rm } from "fs/promises";
+import { join as join8 } from "path";
+
+// src/persistence/thread-logger.ts
+init_logger();
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, appendFileSync, readdirSync as readdirSync2, statSync as statSync2, unlinkSync as unlinkSync2, rmdirSync, readFileSync as readFileSync7, chmodSync as chmodSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join6, dirname as dirname5 } from "path";
+var log11 = createLogger("thread-log");
+var LOGS_BASE_DIR = join6(homedir4(), ".claude-threads", "logs");
+
+class ThreadLoggerImpl {
+  platformId;
+  threadId;
+  claudeSessionId;
+  enabled;
+  bufferSize;
+  flushIntervalMs;
+  logPath;
+  buffer = [];
+  flushTimer = null;
+  isClosed = false;
+  constructor(platformId, threadId, claudeSessionId, options) {
+    this.platformId = platformId;
+    this.threadId = threadId;
+    this.claudeSessionId = claudeSessionId;
+    this.enabled = options?.enabled ?? true;
+    this.bufferSize = options?.bufferSize ?? 10;
+    this.flushIntervalMs = options?.flushIntervalMs ?? 1000;
+    this.logPath = join6(LOGS_BASE_DIR, platformId, `${claudeSessionId}.jsonl`);
+    if (this.enabled) {
+      const dir = dirname5(this.logPath);
+      if (!existsSync8(dir)) {
+        mkdirSync4(dir, { recursive: true });
+      }
+      this.flushTimer = setInterval(() => {
+        this.flushSync();
+      }, this.flushIntervalMs);
+      log11.debug(`Thread logger initialized: ${this.logPath}`);
+    }
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  getLogPath() {
+    return this.logPath;
+  }
+  logEvent(event) {
+    if (!this.enabled || this.isClosed)
+      return;
+    const entry = {
+      ts: Date.now(),
+      sessionId: this.claudeSessionId,
+      type: "claude_event",
+      eventType: event.type,
+      event
+    };
+    this.addEntry(entry);
+  }
+  logUserMessage(username, message, displayName, hasFiles) {
+    if (!this.enabled || this.isClosed)
+      return;
+    const entry = {
+      ts: Date.now(),
+      sessionId: this.claudeSessionId,
+      type: "user_message",
+      username,
+      displayName,
+      message,
+      hasFiles
+    };
+    this.addEntry(entry);
+  }
+  logLifecycle(action, details) {
+    if (!this.enabled || this.isClosed)
+      return;
+    const entry = {
+      ts: Date.now(),
+      sessionId: this.claudeSessionId,
+      type: "lifecycle",
+      action,
+      ...details
+    };
+    this.addEntry(entry);
+  }
+  logCommand(command, args, username) {
+    if (!this.enabled || this.isClosed)
+      return;
+    const entry = {
+      ts: Date.now(),
+      sessionId: this.claudeSessionId,
+      type: "command",
+      command,
+      args,
+      username
+    };
+    this.addEntry(entry);
+  }
+  logPermission(action, permission, username) {
+    if (!this.enabled || this.isClosed)
+      return;
+    const entry = {
+      ts: Date.now(),
+      sessionId: this.claudeSessionId,
+      type: "permission",
+      action,
+      permission,
+      username
+    };
+    this.addEntry(entry);
+  }
+  logReaction(action, username, emoji, answer) {
+    if (!this.enabled || this.isClosed)
+      return;
+    const entry = {
+      ts: Date.now(),
+      sessionId: this.claudeSessionId,
+      type: "reaction",
+      action,
+      username,
+      emoji,
+      answer
+    };
+    this.addEntry(entry);
+  }
+  logExecutor(executor, operation, postId, details, method) {
+    if (!this.enabled || this.isClosed)
+      return;
+    const entry = {
+      ts: Date.now(),
+      sessionId: this.claudeSessionId,
+      type: "executor",
+      executor,
+      operation,
+      postId,
+      method,
+      details
+    };
+    this.addEntry(entry);
+  }
+  async flush() {
+    this.flushSync();
+  }
+  async close() {
+    if (this.isClosed)
+      return;
+    this.isClosed = true;
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
     }
-    this.process.stdin.write(msg);
+    this.flushSync();
+    log11.debug(`Thread logger closed: ${this.logPath}`);
   }
-  sendToolResult(toolUseId, content) {
-    if (!this.process?.stdin)
-      throw new Error("Not running");
-    const msg = JSON.stringify({
-      type: "user",
-      message: {
-        role: "user",
-        content: [{
-          type: "tool_result",
-          tool_use_id: toolUseId,
-          content: typeof content === "string" ? content : JSON.stringify(content)
-        }]
-      }
-    }) + `
+  addEntry(entry) {
+    this.buffer.push(entry);
+    if (this.buffer.length >= this.bufferSize) {
+      this.flushSync();
+    }
+  }
+  flushSync() {
+    if (this.buffer.length === 0)
+      return;
+    try {
+      const lines = this.buffer.map((entry) => JSON.stringify(entry)).join(`
+`) + `
 `;
-    this.log.debug(`Sending tool_result for ${toolUseId}`);
-    this.process.stdin.write(msg);
+      const isNewFile = !existsSync8(this.logPath);
+      appendFileSync(this.logPath, lines, { encoding: "utf8", mode: 384 });
+      if (isNewFile) {
+        chmodSync4(this.logPath, 384);
+      }
+      this.buffer = [];
+    } catch (err) {
+      log11.error(`Failed to flush thread log: ${err}`);
+    }
   }
-  parseOutput(data) {
-    this.buffer += data;
-    const lines = this.buffer.split(`
-`);
-    this.buffer = lines.pop() || "";
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed)
+}
+
+class DisabledThreadLogger {
+  logEvent() {}
+  logUserMessage() {}
+  logLifecycle() {}
+  logCommand() {}
+  logPermission() {}
+  logReaction() {}
+  logExecutor() {}
+  async flush() {}
+  async close() {}
+  isEnabled() {
+    return false;
+  }
+  getLogPath() {
+    return "";
+  }
+}
+function createThreadLogger(platformId, threadId, claudeSessionId, options) {
+  if (options?.enabled === false) {
+    return new DisabledThreadLogger;
+  }
+  return new ThreadLoggerImpl(platformId, threadId, claudeSessionId, options);
+}
+function cleanupOldLogs(retentionDays = 30) {
+  const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+  let deletedCount = 0;
+  if (!existsSync8(LOGS_BASE_DIR)) {
+    return 0;
+  }
+  try {
+    const platformDirs = readdirSync2(LOGS_BASE_DIR);
+    for (const platformId of platformDirs) {
+      const platformDir = join6(LOGS_BASE_DIR, platformId);
+      const stat = statSync2(platformDir);
+      if (!stat.isDirectory())
         continue;
+      const logFiles = readdirSync2(platformDir);
+      for (const file of logFiles) {
+        if (!file.endsWith(".jsonl"))
+          continue;
+        const filePath = join6(platformDir, file);
+        try {
+          const fileStat = statSync2(filePath);
+          if (fileStat.mtimeMs < cutoffMs) {
+            unlinkSync2(filePath);
+            deletedCount++;
+            log11.debug(`Deleted old log file: ${filePath}`);
+          }
+        } catch (err) {
+          log11.warn(`Failed to check/delete log file ${filePath}: ${err}`);
+        }
+      }
       try {
-        const event = JSON.parse(trimmed);
-        this.emit("event", event);
-        if (event.type === "result" && isErrorResultEvent(event)) {
-          this.maybeEmitRateLimit(trimmed);
+        const remaining = readdirSync2(platformDir);
+        if (remaining.length === 0) {
+          rmdirSync(platformDir);
+          log11.debug(`Removed empty platform log directory: ${platformDir}`);
         }
       } catch {}
     }
+    if (deletedCount > 0) {
+      log11.info(`Cleaned up ${deletedCount} old log file(s)`);
+    }
+  } catch (err) {
+    log11.error(`Failed to clean up old logs: ${err}`);
   }
-  maybeEmitRateLimit(text) {
-    const hit = detectRateLimit(text);
-    if (!hit.detected)
-      return;
-    const newDeadline = cooldownDeadline(hit);
-    const MIN_ADVANCE_MS = 60000;
-    if (newDeadline - this.lastEmittedRateLimitDeadline < MIN_ADVANCE_MS)
-      return;
-    this.lastEmittedRateLimitDeadline = newDeadline;
-    this.log.warn(`Rate limit detected: ${hit.matched ?? "(no match text)"}`);
-    this.emit("rate-limit", hit);
+  return deletedCount;
+}
+function getLogFilePath(platformId, sessionId) {
+  return join6(LOGS_BASE_DIR, platformId, `${sessionId}.jsonl`);
+}
+function readRecentLogEntries(platformId, sessionId, maxLines = 50) {
+  const logPath = getLogFilePath(platformId, sessionId);
+  log11.debug(`Reading log entries from: ${logPath}`);
+  if (!existsSync8(logPath)) {
+    log11.debug(`Log file does not exist: ${logPath}`);
+    return [];
   }
-  isRunning() {
-    return this.process !== null;
+  try {
+    const content = readFileSync7(logPath, "utf8");
+    const lines = content.trim().split(`
+`);
+    log11.debug(`Log file has ${lines.length} lines`);
+    const recentLines = lines.slice(-maxLines);
+    const entries = [];
+    for (const line of recentLines) {
+      if (!line.trim())
+        continue;
+      try {
+        entries.push(JSON.parse(line));
+      } catch {}
+    }
+    log11.debug(`Parsed ${entries.length} log entries`);
+    return entries;
+  } catch (err) {
+    log11.error(`Failed to read log file: ${err}`);
+    return [];
   }
-  getLastStderr() {
-    return this.stderrBuffer;
+}
+
+// src/cleanup/scheduler.ts
+init_worktree();
+var log13 = createLogger("cleanup");
+var DEFAULT_CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
+var MAX_WORKTREE_AGE_MS = 24 * 60 * 60 * 1000;
+
+class CleanupScheduler {
+  intervalMs;
+  logRetentionDays;
+  threadLogsEnabled;
+  sessionStore;
+  maxWorktreeAgeMs;
+  cleanupWorktrees;
+  timer = null;
+  isRunning = false;
+  constructor(options) {
+    this.intervalMs = options.intervalMs ?? DEFAULT_CLEANUP_INTERVAL_MS;
+    this.logRetentionDays = options.logRetentionDays ?? 30;
+    this.threadLogsEnabled = options.threadLogsEnabled ?? true;
+    this.sessionStore = options.sessionStore;
+    this.maxWorktreeAgeMs = options.maxWorktreeAgeMs ?? MAX_WORKTREE_AGE_MS;
+    this.cleanupWorktrees = options.cleanupWorktrees ?? true;
   }
-  isPermanentFailure() {
-    const stderr = this.stderrBuffer;
-    if (stderr.includes("claude-mcp-browser-bridge") && (stderr.includes("EOPNOTSUPP") || stderr.includes("ENOENT"))) {
-      return true;
+  start() {
+    if (this.isRunning) {
+      log13.debug("Cleanup scheduler already running");
+      return;
     }
-    if (stderr.includes("No conversation found with session ID")) {
-      return true;
+    this.isRunning = true;
+    log13.info(`Cleanup scheduler started (interval: ${Math.round(this.intervalMs / 60000)}min)`);
+    this.runCleanup().catch((err) => {
+      log13.warn(`Initial cleanup failed: ${err}`);
+    });
+    this.timer = setInterval(() => {
+      this.runCleanup().catch((err) => {
+        log13.warn(`Periodic cleanup failed: ${err}`);
+      });
+    }, this.intervalMs);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
     }
-    return false;
+    this.isRunning = false;
+    log13.debug("Cleanup scheduler stopped");
   }
-  getPermanentFailureReason() {
-    const stderr = this.stderrBuffer;
-    if (stderr.includes("claude-mcp-browser-bridge") && (stderr.includes("EOPNOTSUPP") || stderr.includes("ENOENT"))) {
-      return "Claude browser bridge state from a previous session is no longer accessible. This typically happens when a session with Chrome integration is resumed after a restart.";
+  async runCleanup() {
+    const startTime = Date.now();
+    log13.debug("Running background cleanup...");
+    const stats = {
+      logsDeleted: 0,
+      worktreesCleaned: 0,
+      metadataCleaned: 0,
+      errors: []
+    };
+    const cleanupTasks = [
+      this.cleanupLogs().catch((err) => {
+        stats.errors.push(`Log cleanup: ${err}`);
+        return 0;
+      })
+    ];
+    if (this.cleanupWorktrees) {
+      cleanupTasks.push(this.cleanupOrphanedWorktrees().catch((err) => {
+        stats.errors.push(`Worktree cleanup: ${err}`);
+        return { cleaned: 0, metadata: 0 };
+      }));
     }
-    if (stderr.includes("No conversation found with session ID")) {
-      return "The conversation history for this session no longer exists. This can happen if Claude's history was cleared or if the session was created on a different machine.";
+    const [logStats, worktreeStats = { cleaned: 0, metadata: 0 }] = await Promise.all(cleanupTasks);
+    stats.logsDeleted = logStats;
+    stats.worktreesCleaned = worktreeStats.cleaned;
+    stats.metadataCleaned = worktreeStats.metadata;
+    const elapsed = Date.now() - startTime;
+    const totalCleaned = stats.logsDeleted + stats.worktreesCleaned + stats.metadataCleaned;
+    if (totalCleaned > 0 || stats.errors.length > 0) {
+      log13.info(`Cleanup completed in ${elapsed}ms: ` + `${stats.logsDeleted} logs, ${stats.worktreesCleaned} worktrees, ${stats.metadataCleaned} metadata` + (stats.errors.length > 0 ? ` (${stats.errors.length} errors)` : ""));
+    } else {
+      log13.debug(`Cleanup completed in ${elapsed}ms (nothing to clean)`);
     }
-    return null;
+    return stats;
   }
-  kill() {
-    this.stopStatusWatch();
-    if (!this.process) {
-      this.log.debug("Kill called but process not running");
-      return Promise.resolve();
+  async cleanupLogs() {
+    if (!this.threadLogsEnabled) {
+      return 0;
     }
-    const proc = this.process;
-    const pid = proc.pid;
-    this.process = null;
-    this.log.debug(`Killing Claude process (pid=${pid})`);
     return new Promise((resolve4) => {
-      this.log.debug("Sending first SIGINT");
-      proc.kill("SIGINT");
-      const secondSigint = setTimeout(() => {
-        try {
-          this.log.debug("Sending second SIGINT");
-          proc.kill("SIGINT");
-        } catch {}
-      }, 100);
-      const forceKillTimeout = setTimeout(() => {
-        try {
-          this.log.debug("Sending SIGTERM (force kill)");
-          proc.kill("SIGTERM");
-        } catch {}
-      }, 2000);
-      proc.once("exit", (code) => {
-        this.log.debug(`Claude process exited (code=${code})`);
-        clearTimeout(secondSigint);
-        clearTimeout(forceKillTimeout);
-        resolve4();
-      });
+      try {
+        const deleted = cleanupOldLogs(this.logRetentionDays);
+        resolve4(deleted);
+      } catch (err) {
+        log13.warn(`Log cleanup error: ${err}`);
+        resolve4(0);
+      }
     });
   }
-  interrupt() {
-    if (!this.process) {
-      this.log.debug("Interrupt called but process not running");
-      return false;
+  async cleanupOrphanedWorktrees() {
+    const worktreesDir = getWorktreesDir();
+    const result = { cleaned: 0, metadata: 0 };
+    if (!existsSync9(worktreesDir)) {
+      log13.debug("No worktrees directory exists, nothing to clean");
+      return result;
     }
-    this.log.debug(`Interrupting Claude process (pid=${this.process.pid})`);
-    this.process.kill("SIGINT");
-    return true;
+    const persisted = this.sessionStore.load();
+    const activeWorktrees = new Set;
+    for (const session of persisted.values()) {
+      if (session.worktreeInfo?.worktreePath) {
+        activeWorktrees.add(session.worktreeInfo.worktreePath);
+      }
+    }
+    const now = Date.now();
+    try {
+      const entries = await readdir(worktreesDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory())
+          continue;
+        const worktreePath = join8(worktreesDir, entry.name);
+        if (activeWorktrees.has(worktreePath)) {
+          log13.debug(`Worktree in use by persisted session, skipping: ${entry.name}`);
+          continue;
+        }
+        const meta = await readWorktreeMetadata(worktreePath);
+        let shouldCleanup = false;
+        let cleanupReason = "";
+        if (meta) {
+          const lastActivity = new Date(meta.lastActivityAt).getTime();
+          const age = now - lastActivity;
+          if (meta.sessionId && age < this.maxWorktreeAgeMs) {
+            log13.debug(`Worktree has active session (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
+            continue;
+          }
+          const merged = age >= this.maxWorktreeAgeMs ? await isBranchMerged(meta.repoRoot, meta.branch).catch(() => false) : false;
+          if (merged) {
+            shouldCleanup = true;
+            cleanupReason = `branch "${meta.branch}" was merged`;
+          } else if (age >= this.maxWorktreeAgeMs) {
+            shouldCleanup = true;
+            cleanupReason = `inactive for ${Math.round(age / 3600000)}h`;
+          } else {
+            log13.debug(`Worktree recent (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
+            continue;
+          }
+        } else {
+          shouldCleanup = true;
+          cleanupReason = "no metadata";
+        }
+        if (!shouldCleanup)
+          continue;
+        log13.info(`Cleaning worktree (${cleanupReason}): ${entry.name}`);
+        try {
+          if (meta?.repoRoot) {
+            await removeWorktree(meta.repoRoot, worktreePath);
+          } else {
+            await rm(worktreePath, { recursive: true, force: true });
+          }
+          result.cleaned++;
+          await removeWorktreeMetadata(worktreePath);
+          result.metadata++;
+        } catch (err) {
+          log13.warn(`Failed to clean orphaned worktree ${entry.name}: ${err}`);
+          try {
+            await rm(worktreePath, { recursive: true, force: true });
+            result.cleaned++;
+            await removeWorktreeMetadata(worktreePath);
+            result.metadata++;
+          } catch (rmErr) {
+            log13.error(`Failed to force remove worktree ${entry.name}: ${rmErr}`);
+          }
+        }
+      }
+    } catch (err) {
+      log13.warn(`Failed to scan worktrees directory: ${err}`);
+    }
+    return result;
   }
-  buildChildEnv() {
-    return buildClaudeChildEnv(process.env, this.options.account);
+}
+// src/operations/monitor/handler.ts
+init_logger();
+
+// src/session/lifecycle-fsm.ts
+init_logger();
+var log14 = createLogger("fsm");
+var ALLOWED_TRANSITIONS = {
+  starting: new Set(["active", "paused", "interrupted", "cancelling", "restarting"]),
+  active: new Set([
+    "active",
+    "processing",
+    "paused",
+    "interrupted",
+    "restarting",
+    "cancelling",
+    "ending"
+  ]),
+  processing: new Set([
+    "active",
+    "paused",
+    "interrupted",
+    "restarting",
+    "cancelling"
+  ]),
+  paused: new Set(["active", "cancelling", "restarting"]),
+  interrupted: new Set(["active", "cancelling", "restarting", "paused"]),
+  restarting: new Set(["active", "paused", "cancelling"]),
+  cancelling: new Set(["ending"]),
+  ending: new Set
+};
+function checkTransition(from, to, sessionId) {
+  const allowed = ALLOWED_TRANSITIONS[from];
+  if (allowed.has(to))
+    return;
+  const msg = `illegal lifecycle transition ${from} -> ${to}`;
+  const payload = {
+    event: "fsm.illegal_transition",
+    from,
+    to,
+    sessionId
+  };
+  if (process.env.CLAUDE_THREADS_FSM_STRICT === "1") {
+    throw new Error(`${msg} (sessionId=${sessionId})`);
   }
-  getMcpServerPath() {
-    const __filename2 = fileURLToPath3(import.meta.url);
-    const __dirname4 = dirname6(__filename2);
-    const bundledPath = resolve3(__dirname4, "mcp", "mcp-server.js");
-    if (existsSync9(bundledPath)) {
-      return bundledPath;
-    }
-    return resolve3(__dirname4, "..", "mcp", "mcp-server.js");
+  log14.warn(msg, payload);
+}
+
+// src/session/timer-manager.ts
+function createSessionTimers() {
+  return {
+    updateTimer: null,
+    typingTimer: null,
+    statusBarTimer: null
+  };
+}
+function clearAllTimers(timers) {
+  if (timers.updateTimer) {
+    clearTimeout(timers.updateTimer);
+    timers.updateTimer = null;
   }
-  getStatusLineWriterPath() {
-    const __filename2 = fileURLToPath3(import.meta.url);
-    const __dirname4 = dirname6(__filename2);
-    const bundledPath = resolve3(__dirname4, "statusline", "writer.js");
-    if (existsSync9(bundledPath)) {
-      return bundledPath;
-    }
-    return resolve3(__dirname4, "..", "statusline", "writer.js");
+  if (timers.typingTimer) {
+    clearInterval(timers.typingTimer);
+    timers.typingTimer = null;
+  }
+  if (timers.statusBarTimer) {
+    clearInterval(timers.statusBarTimer);
+    timers.statusBarTimer = null;
+  }
+}
+
+// src/session/types.ts
+function createSessionLifecycle() {
+  return {
+    state: "starting",
+    resumeFailCount: 0,
+    hasClaudeResponded: false
+  };
+}
+function createResumedLifecycle(resumeFailCount = 0) {
+  return {
+    state: "active",
+    resumeFailCount,
+    hasClaudeResponded: true
+  };
+}
+function isSessionRestarting(session) {
+  return session.lifecycle.state === "restarting";
+}
+function isSessionCancelled(session) {
+  return session.lifecycle.state === "cancelling";
+}
+function transitionTo(session, newState) {
+  checkTransition(session.lifecycle.state, newState, session.sessionId);
+  session.lifecycle.state = newState;
+}
+function markClaudeResponded(session) {
+  session.lifecycle.hasClaudeResponded = true;
+  if (session.lifecycle.state === "starting") {
+    session.lifecycle.state = "active";
+  }
+}
+function getSessionStatus(session) {
+  if (session.isProcessing) {
+    return session.lifecycle.hasClaudeResponded ? "active" : "starting";
+  }
+  return "idle";
+}
+
+// src/session/authorization.ts
+function isAuthorizedForSession(check) {
+  const { username, platform, sessionAllowedUsers } = check;
+  if (!username || username === "unknown") {
+    return false;
+  }
+  if (platform.isUserAllowed(username)) {
+    return true;
   }
+  return sessionAllowedUsers?.has(username) ?? false;
 }
 
 // src/commands/registry.ts
@@ -57349,7 +57498,7 @@ async function handleDynamicSlashCommand(command, args, ctx) {
 }
 // src/commands/system-prompt-generator.ts
 init_logger();
-var log14 = createLogger("system-prompt");
+var log15 = createLogger("system-prompt");
 function formatUserCommand(cmd) {
   const cmdStr = cmd.args ? `\`!${cmd.command} ${cmd.args}\`` : `\`!${cmd.command}\``;
   const description = cmd.description;
@@ -57388,7 +57537,7 @@ async function resolveCollaborators(platform, platformId, ownerUsername, allowed
       continue;
     const email = githubEmailsStore.get(platformId, username);
     if (!email) {
-      log14.debug(`Collaborator @${username} has no registered GitHub noreply email — skipping`);
+      log15.debug(`Collaborator @${username} has no registered GitHub noreply email — skipping`);
       continue;
     }
     let name = username;
@@ -57397,7 +57546,7 @@ async function resolveCollaborators(platform, platformId, ownerUsername, allowed
       if (user)
         name = user.displayName || user.username;
     } catch (err) {
-      log14.debug(`Display name lookup failed for @${username}: ${err.message}`);
+      log15.debug(`Display name lookup failed for @${username}: ${err.message}`);
     }
     resolved.push({ username, name, email });
   }
@@ -57503,7 +57652,7 @@ import { existsSync as existsSync12 } from "fs";
 // src/utils/keep-alive.ts
 init_logger();
 import { spawn as spawn2 } from "child_process";
-var log15 = createLogger("keepalive");
+var log16 = createLogger("keepalive");
 
 class KeepAliveManager {
   activeSessionCount = 0;
@@ -57518,7 +57667,7 @@ class KeepAliveManager {
     if (!enabled && this.keepAliveProcess) {
       this.stopKeepAlive();
     }
-    log15.debug(`Keep-alive ${enabled ? "enabled" : "disabled"}`);
+    log16.debug(`Keep-alive ${enabled ? "enabled" : "disabled"}`);
   }
   isEnabled() {
     return this.enabled;
@@ -57528,7 +57677,7 @@ class KeepAliveManager {
   }
   sessionStarted() {
     this.activeSessionCount++;
-    log15.debug(`Session started (${this.activeSessionCount} active)`);
+    log16.debug(`Session started (${this.activeSessionCount} active)`);
     if (this.activeSessionCount === 1) {
       this.startKeepAlive();
     }
@@ -57537,7 +57686,7 @@ class KeepAliveManager {
     if (this.activeSessionCount > 0) {
       this.activeSessionCount--;
     }
-    log15.debug(`Session ended (${this.activeSessionCount} active)`);
+    log16.debug(`Session ended (${this.activeSessionCount} active)`);
     if (this.activeSessionCount === 0) {
       this.stopKeepAlive();
     }
@@ -57551,11 +57700,11 @@ class KeepAliveManager {
   }
   startKeepAlive() {
     if (!this.enabled) {
-      log15.debug("Keep-alive disabled, skipping");
+      log16.debug("Keep-alive disabled, skipping");
       return;
     }
     if (this.keepAliveProcess) {
-      log15.debug("Keep-alive already running");
+      log16.debug("Keep-alive already running");
       return;
     }
     switch (this.platform) {
@@ -57569,12 +57718,12 @@ class KeepAliveManager {
         this.startWindowsKeepAlive();
         break;
       default:
-        log15.warn(`Keep-alive not supported on ${this.platform}`);
+        log16.warn(`Keep-alive not supported on ${this.platform}`);
     }
   }
   stopKeepAlive() {
     if (this.keepAliveProcess) {
-      log15.debug("Stopping keep-alive");
+      log16.debug("Stopping keep-alive");
       this.keepAliveProcess.kill();
       this.keepAliveProcess = null;
     }
@@ -57586,18 +57735,18 @@ class KeepAliveManager {
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log15.error(`Failed to start caffeinate: ${err.message}`);
+        log16.error(`Failed to start caffeinate: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", (code) => {
         if (code !== null && code !== 0 && this.activeSessionCount > 0) {
-          log15.debug(`caffeinate exited with code ${code}`);
+          log16.debug(`caffeinate exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log15.info("Sleep prevention active (caffeinate)");
+      log16.info("Sleep prevention active (caffeinate)");
     } catch (err) {
-      log15.error(`Failed to start caffeinate: ${err}`);
+      log16.error(`Failed to start caffeinate: ${err}`);
     }
   }
   startLinuxKeepAlive() {
@@ -57613,19 +57762,19 @@ class KeepAliveManager {
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log15.debug(`systemd-inhibit not available: ${err.message}`);
+        log16.debug(`systemd-inhibit not available: ${err.message}`);
         this.keepAliveProcess = null;
         this.startLinuxKeepAliveFallback();
       });
       this.keepAliveProcess.on("exit", (code) => {
         if (code !== null && code !== 0 && this.activeSessionCount > 0) {
-          log15.debug(`systemd-inhibit exited with code ${code}`);
+          log16.debug(`systemd-inhibit exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log15.info("Sleep prevention active (systemd-inhibit)");
+      log16.info("Sleep prevention active (systemd-inhibit)");
     } catch (err) {
-      log15.debug(`Failed to start systemd-inhibit: ${err}`);
+      log16.debug(`Failed to start systemd-inhibit: ${err}`);
       this.startLinuxKeepAliveFallback();
     }
   }
@@ -57639,15 +57788,15 @@ class KeepAliveManager {
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log15.warn(`Linux keep-alive fallback not available: ${err.message}`);
+        log16.warn(`Linux keep-alive fallback not available: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", () => {
         this.keepAliveProcess = null;
       });
-      log15.info("Sleep prevention active (xdg-screensaver)");
+      log16.info("Sleep prevention active (xdg-screensaver)");
     } catch (err) {
-      log15.warn(`Linux keep-alive not available: ${err}`);
+      log16.warn(`Linux keep-alive not available: ${err}`);
     }
   }
   startWindowsKeepAlive() {
@@ -57672,18 +57821,18 @@ class KeepAliveManager {
         windowsHide: true
       });
       this.keepAliveProcess.on("error", (err) => {
-        log15.warn(`Windows keep-alive not available: ${err.message}`);
+        log16.warn(`Windows keep-alive not available: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", (code) => {
         if (code !== null && code !== 0 && this.activeSessionCount > 0) {
-          log15.debug(`PowerShell keep-alive exited with code ${code}`);
+          log16.debug(`PowerShell keep-alive exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log15.info("Sleep prevention active (SetThreadExecutionState)");
+      log16.info("Sleep prevention active (SetThreadExecutionState)");
     } catch (err) {
-      log15.warn(`Windows keep-alive not available: ${err}`);
+      log16.warn(`Windows keep-alive not available: ${err}`);
     }
   }
 }
@@ -57691,7 +57840,7 @@ var keepAlive = new KeepAliveManager;
 
 // src/utils/error-handler/index.ts
 init_logger();
-var log16 = createLogger("error");
+var log17 = createLogger("error");
 
 class SessionError extends Error {
   sessionId;
@@ -57717,19 +57866,19 @@ async function handleError(error, context, severity = "recoverable") {
   const sessionPart = sessionId ? ` (${formatShortId(sessionId)})` : "";
   const logMessage = `${context.action}${sessionPart}: ${message}`;
   if (severity === "recoverable") {
-    log16.warn(logMessage);
+    log17.warn(logMessage);
   } else {
-    log16.error(logMessage, error instanceof Error ? error : undefined);
+    log17.error(logMessage, error instanceof Error ? error : undefined);
   }
   if (context.details) {
-    log16.debugJson("Error details", context.details);
+    log17.debugJson("Error details", context.details);
   }
   if (context.notifyUser && context.session) {
     try {
       const fmt = context.session.platform.getFormatter();
       await context.session.platform.createPost(`⚠️ ${fmt.formatBold("Error")}: ${context.action} failed - ${message}`, context.session.threadId);
     } catch (notifyError) {
-      log16.warn(`Could not notify user: ${notifyError}`);
+      log17.warn(`Could not notify user: ${notifyError}`);
     }
   }
   if (severity === "session-fatal" || severity === "system-fatal") {
@@ -57756,7 +57905,7 @@ async function logAndNotify(error, context) {
 }
 function logSilentError(context, error) {
   const message = error instanceof Error ? error.message : String(error);
-  log16.debug(`[${context}] Silently caught: ${message}`);
+  log17.debug(`[${context}] Silently caught: ${message}`);
 }
 
 // src/session/lifecycle.ts
@@ -57776,8 +57925,8 @@ function createSessionLog(baseLog) {
 init_logger();
 init_emoji();
 init_worktree();
-var log17 = createLogger("helpers");
-var sessionLog = createSessionLog(log17);
+var log18 = createLogger("helpers");
+var sessionLog = createSessionLog(log18);
 var POST_TYPES = {
   info: "",
   success: "✅",
@@ -57863,7 +58012,7 @@ init_logger();
 import { lstat, mkdir as mkdir2, mkdtemp, rm as rm2, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join9 } from "path";
-var log18 = createLogger("streaming");
+var log19 = createLogger("streaming");
 var UPLOAD_ROOT_DIR = "claude-threads-uploads";
 function safeIdSegment(id) {
   return id.replace(/[^A-Za-z0-9._-]/g, "_");
@@ -57878,7 +58027,7 @@ async function cleanupSessionUploads(platformId, threadId) {
   try {
     await rm2(dir, { recursive: true, force: true });
   } catch (err) {
-    log18.debug(`Upload cleanup for ${platformId}:${threadId} failed (ignored): ${err}`);
+    log19.debug(`Upload cleanup for ${platformId}:${threadId} failed (ignored): ${err}`);
   }
 }
 function sanitizeForPrompt(value) {
@@ -57899,7 +58048,7 @@ async function saveFilesToUploadDir(platform, uploadDir, files, debug = false) {
     for (const file of files) {
       skipped.push({ name: file.name, reason: "Refusing to write under symlinked upload directory" });
     }
-    log18.error(`Upload dir is a symlink, refusing all writes: ${uploadDir}`);
+    log19.error(`Upload dir is a symlink, refusing all writes: ${uploadDir}`);
     return { saved, skipped };
   }
   const messageDir = await mkdtemp(join9(uploadDir, `${Date.now().toString(36)}-`));
@@ -57917,11 +58066,11 @@ async function saveFilesToUploadDir(platform, uploadDir, files, debug = false) {
         size: buffer.length
       });
       if (debug) {
-        log18.debug(`Saved ${file.name} → ${absolutePath} (${formatBytes(buffer.length)})`);
+        log19.debug(`Saved ${file.name} → ${absolutePath} (${formatBytes(buffer.length)})`);
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      log18.error(`Failed to save uploaded file ${file.name}: ${message}`);
+      log19.error(`Failed to save uploaded file ${file.name}: ${message}`);
       skipped.push({
         name: file.name,
         reason: `Download failed: ${message}`
@@ -65720,7 +65869,7 @@ class BugReportExecutor extends BaseExecutor {
 // src/operations/executors/worktree-prompt.ts
 init_emoji();
 init_logger();
-var log19 = createLogger("wt-prompt");
+var log20 = createLogger("wt-prompt");
 // src/operations/message-manager.ts
 init_logger();
 
@@ -65752,7 +65901,7 @@ function createMessageManagerEvents() {
 }
 
 // src/operations/message-manager.ts
-var log20 = createLogger("msg-mgr");
+var log21 = createLogger("msg-mgr");
 
 class MessageManager {
   platform;
@@ -65842,7 +65991,7 @@ class MessageManager {
     });
   }
   async handleEvent(event) {
-    const logger = log20.forSession(this.sessionId);
+    const logger = log21.forSession(this.sessionId);
     const transformCtx = {
       sessionId: this.sessionId,
       formatter: this.platform.getFormatter(),
@@ -65892,7 +66041,7 @@ class MessageManager {
     }
   }
   async executeOperation(op) {
-    const logger = log20.forSession(this.sessionId);
+    const logger = log21.forSession(this.sessionId);
     const ctx = this.getExecutorContext();
     try {
       if (isContentOp(op)) {
@@ -65960,7 +66109,7 @@ class MessageManager {
       threadId: this.threadId,
       platform: this.platform,
       formatter: this.platform.getFormatter(),
-      logger: log20.forSession(this.sessionId),
+      logger: log21.forSession(this.sessionId),
       postTracker: this.postTracker,
       contentBreaker: this.contentBreaker,
       threadLogger: this.session.threadLogger,
@@ -66171,13 +66320,13 @@ class MessageManager {
     return this.systemExecutor.postSuccess(message, this.getExecutorContext());
   }
   async prepareForUserMessage() {
-    const logger = log20.forSession(this.sessionId);
+    const logger = log21.forSession(this.sessionId);
     logger.debug("Preparing for new user message");
     await this.closeCurrentPost();
     await this.bumpTaskList();
   }
   async handleUserMessage(message, files, username, displayName) {
-    const logger = log20.forSession(this.sessionId);
+    const logger = log21.forSession(this.sessionId);
     if (!this.session.claude.isRunning()) {
       logger.debug("Claude not running, ignoring user message");
       return false;
@@ -66214,7 +66363,7 @@ class MessageManager {
     ];
   }
   async handleReaction(postId, emoji, user, action) {
-    const logger = log20.forSession(this.sessionId);
+    const logger = log21.forSession(this.sessionId);
     const ctx = this.getExecutorContext();
     logger.debug(`Routing reaction: postId=${postId}, emoji=${emoji}, user=${user}, action=${action}`);
     for (const { name, executor } of this.reactionDispatchList()) {
@@ -66249,7 +66398,7 @@ class MessageManager {
 }
 // src/operations/sticky-message/handler.ts
 init_logger();
-var log21 = createLogger("sticky");
+var log22 = createLogger("sticky");
 var botStartedAt = new Date;
 function getPendingPrompts(session) {
   const prompts2 = [];
@@ -66324,21 +66473,21 @@ function initialize(store) {
     stickyPostIds.set(platformId, postId);
   }
   if (persistedIds.size > 0) {
-    log21.info(`\uD83D\uDCCC Restored ${persistedIds.size} sticky post ID(s) from persistence`);
+    log22.info(`\uD83D\uDCCC Restored ${persistedIds.size} sticky post ID(s) from persistence`);
   }
 }
 function setPlatformPaused(platformId, paused) {
   if (paused) {
     pausedPlatforms.set(platformId, true);
-    log21.debug(`Platform ${platformId} marked as paused`);
+    log22.debug(`Platform ${platformId} marked as paused`);
   } else {
     pausedPlatforms.delete(platformId);
-    log21.debug(`Platform ${platformId} marked as active`);
+    log22.debug(`Platform ${platformId} marked as active`);
   }
 }
 function setShuttingDown(shuttingDown) {
   isShuttingDown = shuttingDown;
-  log21.debug(`Bot shutdown state: ${shuttingDown}`);
+  log22.debug(`Bot shutdown state: ${shuttingDown}`);
 }
 function getTaskContent(session) {
   const taskState = session.messageManager?.getTaskListState();
@@ -66439,7 +66588,13 @@ async function buildStatusBar(sessionCount, config, formatter, platformId) {
     const total = config.accountPoolStatus.length;
     const cooling = config.accountPoolStatus.filter((a) => a.coolingUntil !== null).length;
     const available = total - cooling;
-    const label = cooling > 0 ? `\uD83D\uDD11 ${available}/${total} accounts (${cooling} cooling)` : `\uD83D\uDD11 ${total} account${total === 1 ? "" : "s"}`;
+    let label = cooling > 0 ? `\uD83D\uDD11 ${available}/${total} accounts (${cooling} cooling)` : `\uD83D\uDD11 ${total} account${total === 1 ? "" : "s"}`;
+    const pcts = config.accountPoolStatus.map((a) => a.usagePercent).filter((p) => p !== null);
+    if (pcts.length > 0) {
+      const min = Math.min(...pcts);
+      const max = Math.max(...pcts);
+      label += min === max ? ` · ${max}% used` : ` · ${min}–${max}% used`;
+    }
     items.push(formatter.formatCode(label));
   }
   items.push(formatter.formatCode(permissionModeDisplay(config.permissionMode).chip));
@@ -66656,12 +66811,12 @@ async function validateLastMessageIds(platform, sessions) {
     try {
       const post2 = await platform.getPost(lastMessageId);
       if (!post2) {
-        log21.debug(`lastMessageId ${lastMessageId.substring(0, 8)} for session ${session.sessionId} was deleted, clearing`);
+        log22.debug(`lastMessageId ${lastMessageId.substring(0, 8)} for session ${session.sessionId} was deleted, clearing`);
         session.lastMessageId = undefined;
         session.lastMessageTs = undefined;
       }
     } catch (err) {
-      log21.debug(`Failed to validate lastMessageId for session ${session.sessionId}, clearing: ${err}`);
+      log22.debug(`Failed to validate lastMessageId for session ${session.sessionId}, clearing: ${err}`);
       session.lastMessageId = undefined;
       session.lastMessageTs = undefined;
     }
@@ -66678,7 +66833,7 @@ async function updateStickyMessageImpl(platform, sessions, config) {
       hiddenCleanupDone.add(platform.platformId);
       const existing = stickyPostIds.get(platform.platformId);
       if (existing) {
-        log21.info(`sticky[${platform.platformId}] hidden mode: removing leftover ${formatShortId(existing)}`);
+        log22.info(`sticky[${platform.platformId}] hidden mode: removing leftover ${formatShortId(existing)}`);
         try {
           await platform.unpinPost(existing);
         } catch {}
@@ -66698,63 +66853,63 @@ async function updateStickyMessageImpl(platform, sessions, config) {
     return;
   }
   const platformSessions = [...sessions.values()].filter((s) => s.platformId === platform.platformId);
-  log21.debug(`updateStickyMessage for ${platform.platformId}, ${platformSessions.length} sessions`);
+  log22.debug(`updateStickyMessage for ${platform.platformId}, ${platformSessions.length} sessions`);
   for (const s of platformSessions) {
-    log21.debug(`  - ${s.sessionId}: title="${s.sessionTitle}" firstPrompt="${s.firstPrompt?.substring(0, 30)}..."`);
+    log22.debug(`  - ${s.sessionId}: title="${s.sessionTitle}" firstPrompt="${s.firstPrompt?.substring(0, 30)}..."`);
   }
   await validateLastMessageIds(platform, platformSessions);
   const formatter = platform.getFormatter();
   const content = await buildStickyMessage(sessions, platform.platformId, config, formatter, (threadId) => platform.getThreadLink(threadId));
   const existingPostId = stickyPostIds.get(platform.platformId);
   const shouldBump = needsBump.get(platform.platformId) ?? false;
-  log21.debug(`existingPostId: ${existingPostId || "(none)"}, needsBump: ${shouldBump}`);
+  log22.debug(`existingPostId: ${existingPostId || "(none)"}, needsBump: ${shouldBump}`);
   try {
     if (existingPostId && !shouldBump) {
-      log21.debug(`Updating existing post in place...`);
+      log22.debug(`Updating existing post in place...`);
       try {
         await platform.updatePost(existingPostId, content);
         try {
           await platform.pinPost(existingPostId);
-          log21.debug(`Re-pinned post`);
+          log22.debug(`Re-pinned post`);
         } catch (pinErr) {
-          log21.debug(`Re-pin failed (might already be pinned): ${pinErr}`);
+          log22.debug(`Re-pin failed (might already be pinned): ${pinErr}`);
         }
-        log21.debug(`Updated successfully`);
+        log22.debug(`Updated successfully`);
         return;
       } catch (err) {
-        log21.debug(`Update failed, will create new: ${err}`);
+        log22.debug(`Update failed, will create new: ${err}`);
       }
     }
     needsBump.set(platform.platformId, false);
     if (existingPostId) {
-      log21.debug(`Unpinning and deleting existing post ${existingPostId.substring(0, 8)}...`);
+      log22.debug(`Unpinning and deleting existing post ${existingPostId.substring(0, 8)}...`);
       try {
         await platform.unpinPost(existingPostId);
-        log21.debug(`Unpinned successfully`);
+        log22.debug(`Unpinned successfully`);
       } catch (err) {
-        log21.debug(`Unpin failed (probably already unpinned): ${err}`);
+        log22.debug(`Unpin failed (probably already unpinned): ${err}`);
       }
       try {
         await platform.deletePost(existingPostId);
-        log21.debug(`Deleted successfully`);
+        log22.debug(`Deleted successfully`);
       } catch (err) {
-        log21.debug(`Delete failed (probably already deleted): ${err}`);
+        log22.debug(`Delete failed (probably already deleted): ${err}`);
       }
       stickyPostIds.delete(platform.platformId);
     }
-    log21.debug(`Creating new post...`);
+    log22.debug(`Creating new post...`);
     const post2 = await platform.createPost(content);
     stickyPostIds.set(platform.platformId, post2.id);
     try {
       await platform.pinPost(post2.id);
-      log21.debug(`Pinned post successfully`);
+      log22.debug(`Pinned post successfully`);
     } catch (err) {
-      log21.debug(`Failed to pin post: ${err}`);
+      log22.debug(`Failed to pin post: ${err}`);
     }
     if (sessionStore) {
       sessionStore.saveStickyPostId(platform.platformId, post2.id);
     }
-    log21.info(`\uD83D\uDCCC Created sticky message for ${platform.platformId}: ${formatShortId(post2.id)}`);
+    log22.info(`\uD83D\uDCCC Created sticky message for ${platform.platformId}: ${formatShortId(post2.id)}`);
     const excludePostIds = new Set;
     if (sessionStore) {
       for (const session of sessionStore.load().values()) {
@@ -66770,10 +66925,10 @@ async function updateStickyMessageImpl(platform, sessions, config) {
     }
     const botUser = await platform.getBotUser();
     cleanupOldStickyMessages(platform, botUser.id, false, excludePostIds).catch((err) => {
-      log21.debug(`Background cleanup failed: ${err}`);
+      log22.debug(`Background cleanup failed: ${err}`);
     });
   } catch (err) {
-    log21.error(`Failed to update sticky message for ${platform.platformId}`, err instanceof Error ? err : undefined);
+    log22.error(`Failed to update sticky message for ${platform.platformId}`, err instanceof Error ? err : undefined);
   }
 }
 async function updateAllStickyMessages(platforms, sessions, config, overheadByPlatform) {
@@ -66801,7 +66956,7 @@ async function cleanupOldStickyMessages(platform, botUserId, forceRun = false, e
   if (!forceRun) {
     const lastRun = lastCleanupTime.get(platformId) || 0;
     if (now - lastRun < CLEANUP_THROTTLE_MS) {
-      log21.debug(`Cleanup throttled for ${platformId} (last run ${Math.round((now - lastRun) / 1000)}s ago)`);
+      log22.debug(`Cleanup throttled for ${platformId} (last run ${Math.round((now - lastRun) / 1000)}s ago)`);
       return;
     }
   }
@@ -66811,37 +66966,37 @@ async function cleanupOldStickyMessages(platform, botUserId, forceRun = false, e
     const pinnedPostIds = await platform.getPinnedPosts();
     const recentPinnedIds = pinnedPostIds.filter((id) => id !== currentStickyId && !excludePostIds?.has(id) && isRecentPost(id));
     if (recentPinnedIds.length === 0) {
-      log21.debug(`No recent pinned posts to check (${pinnedPostIds.length} total, current: ${currentStickyId?.substring(0, 8) || "(none)"})`);
+      log22.debug(`No recent pinned posts to check (${pinnedPostIds.length} total, current: ${currentStickyId?.substring(0, 8) || "(none)"})`);
       return;
     }
-    log21.debug(`Checking ${recentPinnedIds.length} recent pinned posts (of ${pinnedPostIds.length} total)`);
+    log22.debug(`Checking ${recentPinnedIds.length} recent pinned posts (of ${pinnedPostIds.length} total)`);
     for (const postId of recentPinnedIds) {
       try {
         const post2 = await platform.getPost(postId);
         if (!post2)
           continue;
         if (post2.userId === botUserId) {
-          log21.debug(`Cleaning up old sticky: ${postId.substring(0, 8)}...`);
+          log22.debug(`Cleaning up old sticky: ${postId.substring(0, 8)}...`);
           try {
             await platform.unpinPost(postId);
             await platform.deletePost(postId);
-            log21.info(`\uD83E\uDDF9 Cleaned up old sticky message: ${postId.substring(0, 8)}...`);
+            log22.info(`\uD83E\uDDF9 Cleaned up old sticky message: ${postId.substring(0, 8)}...`);
           } catch (err) {
-            log21.debug(`Failed to cleanup ${postId}: ${err}`);
+            log22.debug(`Failed to cleanup ${postId}: ${err}`);
           }
         }
       } catch (err) {
-        log21.debug(`Could not check post ${postId}: ${err}`);
+        log22.debug(`Could not check post ${postId}: ${err}`);
       }
     }
   } catch (err) {
-    log21.error(`Failed to cleanup old sticky messages`, err instanceof Error ? err : undefined);
+    log22.error(`Failed to cleanup old sticky messages`, err instanceof Error ? err : undefined);
   }
 }
 // src/claude/quick-query.ts
 init_spawn();
 init_logger();
-var log22 = createLogger("query");
+var log23 = createLogger("query");
 async function quickQuery(options) {
   const {
     prompt,
@@ -66857,7 +67012,7 @@ async function quickQuery(options) {
     args.push("--system-prompt", systemPrompt);
   }
   args.push(prompt);
-  log22.debug(`Quick query: model=${model}, timeout=${timeout2}ms, prompt="${prompt.substring(0, 50)}..."`);
+  log23.debug(`Quick query: model=${model}, timeout=${timeout2}ms, prompt="${prompt.substring(0, 50)}..."`);
   return new Promise((resolve5) => {
     let stdout = "";
     let stderr = "";
@@ -66871,7 +67026,7 @@ async function quickQuery(options) {
       if (!resolved) {
         resolved = true;
         proc.kill("SIGTERM");
-        log22.debug(`Quick query timed out after ${timeout2}ms`);
+        log23.debug(`Quick query timed out after ${timeout2}ms`);
         resolve5({
           success: false,
           error: "timeout",
@@ -66889,7 +67044,7 @@ async function quickQuery(options) {
       if (!resolved) {
         resolved = true;
         clearTimeout(timeoutId);
-        log22.debug(`Quick query error: ${err.message}`);
+        log23.debug(`Quick query error: ${err.message}`);
         resolve5({
           success: false,
           error: err.message,
@@ -66903,14 +67058,14 @@ async function quickQuery(options) {
         clearTimeout(timeoutId);
         const durationMs = Date.now() - startTime;
         if (code === 0 && stdout.trim()) {
-          log22.debug(`Quick query success: ${durationMs}ms, ${stdout.length} chars`);
+          log23.debug(`Quick query success: ${durationMs}ms, ${stdout.length} chars`);
           resolve5({
             success: true,
             response: stdout.trim(),
             durationMs
           });
         } else {
-          log22.debug(`Quick query failed: code=${code}, stderr=${stderr.substring(0, 100)}`);
+          log23.debug(`Quick query failed: code=${code}, stderr=${stderr.substring(0, 100)}`);
           resolve5({
             success: false,
             error: stderr || `exit code ${code}`,
@@ -66929,7 +67084,7 @@ init_logger();
 import { exec as exec3 } from "child_process";
 import { promisify as promisify3 } from "util";
 var execAsync2 = promisify3(exec3);
-var log23 = createLogger("branch");
+var log24 = createLogger("branch");
 var SUGGESTION_TIMEOUT = 15000;
 var MAX_SUGGESTIONS = 3;
 async function getCurrentBranch3(workingDir) {
@@ -66978,7 +67133,7 @@ function parseBranchSuggestions(response) {
   return lines.slice(0, MAX_SUGGESTIONS);
 }
 async function suggestBranchNames(workingDir, userMessage) {
-  log23.debug(`Suggesting branch names for: "${userMessage.substring(0, 50)}..."`);
+  log24.debug(`Suggesting branch names for: "${userMessage.substring(0, 50)}..."`);
   try {
     const [currentBranch, recentCommits] = await Promise.all([
       getCurrentBranch3(workingDir),
@@ -66992,14 +67147,14 @@ async function suggestBranchNames(workingDir, userMessage) {
       workingDir
     });
     if (!result.success || !result.response) {
-      log23.debug(`Branch suggestion failed: ${result.error || "no response"}`);
+      log24.debug(`Branch suggestion failed: ${result.error || "no response"}`);
       return [];
     }
     const suggestions = parseBranchSuggestions(result.response);
-    log23.debug(`Got ${suggestions.length} branch suggestions: ${suggestions.join(", ")}`);
+    log24.debug(`Got ${suggestions.length} branch suggestions: ${suggestions.join(", ")}`);
     return suggestions;
   } catch (err) {
-    log23.debug(`Branch suggestion error: ${err}`);
+    log24.debug(`Branch suggestion error: ${err}`);
     return [];
   }
 }
@@ -67008,8 +67163,8 @@ async function suggestBranchNames(workingDir, userMessage) {
 init_worktree();
 import { randomUUID as randomUUID2 } from "crypto";
 init_logger();
-var log24 = createLogger("worktree");
-var sessionLog2 = createSessionLog(log24);
+var log25 = createLogger("worktree");
+var sessionLog2 = createSessionLog(log25);
 function parseWorktreeError(error) {
   const message = error instanceof Error ? error.message : String(error);
   const lowerMessage = message.toLowerCase();
@@ -67575,8 +67730,8 @@ async function cleanupWorktreeCommand(session, username, hasOtherSessionsUsingWo
 }
 // src/operations/events/handler.ts
 init_logger();
-var log25 = createLogger("events");
-var sessionLog3 = createSessionLog(log25);
+var log26 = createLogger("events");
+var sessionLog3 = createSessionLog(log26);
 function detectAndExecuteClaudeCommands(text, session, ctx) {
   const parsed = parseClaudeCommand(text);
   if (parsed && isClaudeAllowedCommand(parsed.command)) {
@@ -67824,8 +67979,8 @@ function createSessionContext(config, state, ops) {
 // src/operations/context-prompt/handler.ts
 init_emoji();
 init_logger();
-var log26 = createLogger("context");
-var sessionLog4 = createSessionLog(log26);
+var log27 = createLogger("context");
+var sessionLog4 = createSessionLog(log27);
 var CONTEXT_PROMPT_TIMEOUT_MS = 30000;
 var CONTEXT_OPTIONS = [3, 5, 10];
 var contextPromptTimeouts = new Map;
@@ -68047,7 +68202,7 @@ async function offerContextPrompt(session, queuedPrompt, queuedFiles, ctx, exclu
 }
 // src/operations/suggestions/tag.ts
 init_logger();
-var log27 = createLogger("tags");
+var log28 = createLogger("tags");
 var SUGGESTION_TIMEOUT2 = 15000;
 var MAX_TAGS = 3;
 var VALID_TAGS = [
@@ -68079,7 +68234,7 @@ function parseTags(response) {
   return [...new Set(tags)].slice(0, MAX_TAGS);
 }
 async function suggestSessionTags(userMessage) {
-  log27.debug(`Suggesting tags for: "${userMessage.substring(0, 50)}..."`);
+  log28.debug(`Suggesting tags for: "${userMessage.substring(0, 50)}..."`);
   try {
     const result = await quickQuery({
       prompt: buildTagPrompt(userMessage),
@@ -68087,20 +68242,20 @@ async function suggestSessionTags(userMessage) {
       timeout: SUGGESTION_TIMEOUT2
     });
     if (!result.success || !result.response) {
-      log27.debug(`Tag suggestion failed: ${result.error || "no response"}`);
+      log28.debug(`Tag suggestion failed: ${result.error || "no response"}`);
       return [];
     }
     const tags = parseTags(result.response);
-    log27.debug(`Got tags: ${tags.join(", ")} (${result.durationMs}ms)`);
+    log28.debug(`Got tags: ${tags.join(", ")} (${result.durationMs}ms)`);
     return tags;
   } catch (err) {
-    log27.debug(`Tag suggestion error: ${err}`);
+    log28.debug(`Tag suggestion error: ${err}`);
     return [];
   }
 }
 // src/operations/suggestions/title.ts
 init_logger();
-var log28 = createLogger("title");
+var log29 = createLogger("title");
 var SUGGESTION_TIMEOUT3 = 15000;
 var MIN_TITLE_LENGTH = 3;
 var MAX_TITLE_LENGTH = 50;
@@ -68164,32 +68319,32 @@ function parseMetadata(response) {
   const titleMatch = response.match(/TITLE:\s*(.+)/i);
   const descMatch = response.match(/DESC:\s*(.+)/i);
   if (!titleMatch || !descMatch) {
-    log28.debug("Failed to parse title/description from response");
+    log29.debug("Failed to parse title/description from response");
     return null;
   }
   let title = titleMatch[1].trim();
   let description = descMatch[1].trim();
   if (title.length < MIN_TITLE_LENGTH) {
-    log28.debug(`Title too short: ${title.length} chars`);
+    log29.debug(`Title too short: ${title.length} chars`);
     return null;
   }
   if (title.length > MAX_TITLE_LENGTH) {
-    log28.debug(`Title too long (${title.length} chars), truncating`);
+    log29.debug(`Title too long (${title.length} chars), truncating`);
     title = truncateAtWord(title, MAX_TITLE_LENGTH);
   }
   if (description.length < MIN_DESC_LENGTH) {
-    log28.debug(`Description too short: ${description.length} chars`);
+    log29.debug(`Description too short: ${description.length} chars`);
     return null;
   }
   if (description.length > MAX_DESC_LENGTH) {
-    log28.debug(`Description too long (${description.length} chars), truncating`);
+    log29.debug(`Description too long (${description.length} chars), truncating`);
     description = truncateAtWord(description, MAX_DESC_LENGTH);
   }
   return { title, description };
 }
 async function suggestSessionMetadata(context) {
   const logContext = typeof context === "string" ? context.substring(0, 50) : context.originalTask.substring(0, 50);
-  log28.debug(`Suggesting title for: "${logContext}..."`);
+  log29.debug(`Suggesting title for: "${logContext}..."`);
   try {
     const result = await quickQuery({
       prompt: buildTitlePrompt(context),
@@ -68197,22 +68352,22 @@ async function suggestSessionMetadata(context) {
       timeout: SUGGESTION_TIMEOUT3
     });
     if (!result.success || !result.response) {
-      log28.debug(`Title suggestion failed: ${result.error || "no response"}`);
+      log29.debug(`Title suggestion failed: ${result.error || "no response"}`);
       return null;
     }
     const metadata = parseMetadata(result.response);
     if (metadata) {
-      log28.debug(`Got title: "${metadata.title}" (${result.durationMs}ms)`);
+      log29.debug(`Got title: "${metadata.title}" (${result.durationMs}ms)`);
     }
     return metadata;
   } catch (err) {
-    log28.debug(`Title suggestion error: ${err}`);
+    log29.debug(`Title suggestion error: ${err}`);
     return null;
   }
 }
 // src/operations/commands/handler.ts
-var log29 = createLogger("commands");
-var sessionLog5 = createSessionLog(log29);
+var log30 = createLogger("commands");
+var sessionLog5 = createSessionLog(log30);
 function sessionAccountOption(session, ctx) {
   if (!session.claudeAccountId)
     return;
@@ -68867,8 +69022,8 @@ function formatRelativeTime(date) {
 }
 // src/session/lifecycle.ts
 init_worktree();
-var log30 = createLogger("lifecycle");
-var sessionLog6 = createSessionLog(log30);
+var log31 = createLogger("lifecycle");
+var sessionLog6 = createSessionLog(log31);
 function mutableSessions(ctx) {
   return ctx.state.sessions;
 }
@@ -69208,7 +69363,7 @@ function resumeSessionHeaderMode(persisted, platformConfigured) {
 function resolveSessionHeaderMode(configured, replyToPostId, platformId) {
   const mode = configured ?? DEFAULT_OVERHEAD_VISIBILITY;
   if (mode === "hidden" && !replyToPostId) {
-    log30.error(`sessionHeader: hidden requires a replyToPostId for ${platformId}; ` + `downgrading this session to 'minimal' so the header post is still short.`);
+    log31.error(`sessionHeader: hidden requires a replyToPostId for ${platformId}; ` + `downgrading this session to 'minimal' so the header post is still short.`);
     return "minimal";
   }
   return mode;
@@ -69227,7 +69382,7 @@ async function startSession(options, username, displayName, replyToPostId, platf
     throw new Error(`Platform '${platformId}' not found. Call addPlatform() first.`);
   }
   if (!isAuthorizedForSession({ username, platform, sessionAllowedUsers: undefined })) {
-    log30.warn(`auth.denied.startSession: @${username || "unknown"} not authorized to start session in ${threadId.substring(0, 8)}...`);
+    log31.warn(`auth.denied.startSession: @${username || "unknown"} not authorized to start session in ${threadId.substring(0, 8)}...`);
     return;
   }
   const activeOrPending = ctx.state.sessions.size + pendingStartsCount;
@@ -69288,23 +69443,26 @@ async function startSession(options, username, displayName, replyToPostId, platf
       return;
     }
     workingDir = resolvedDir;
-    log30.info(`Starting session in directory: ${workingDir} (from !cd command)`);
+    log31.info(`Starting session in directory: ${workingDir} (from !cd command)`);
   }
   if (initialOptions?.permissionMode) {
     permissionMode = initialOptions.permissionMode;
     forceInteractivePermissions = permissionMode === "default";
     sessionPermissionModeOverride = permissionMode;
-    log30.info(`Starting session with permission mode "${permissionMode}" (from !permissions command)`);
+    log31.info(`Starting session with permission mode "${permissionMode}" (from !permissions command)`);
   } else if (initialOptions?.forceInteractivePermissions) {
     forceInteractivePermissions = true;
     permissionMode = "default";
-    log30.info(`Starting session with interactive permissions (from !permissions command)`);
+    log31.info(`Starting session with interactive permissions (from !permissions command)`);
   }
   const systemPrompt = await buildAppendSystemPrompt(platform, platformId, workingDir, actualThreadId, username, [username], CHAT_PLATFORM_PROMPT, ctx.state.githubEmailsStore);
   const platformMcpConfig = platform.getMcpConfig();
-  const claudeAccount = ctx.ops.acquireClaudeAccount(undefined, actualThreadId);
+  await ctx.ops.refreshClaudeAccountUsage();
+  const claudeAccount = ctx.ops.acquireClaudeAccount(undefined, actualThreadId, {
+    balanceByUsage: true
+  });
   if (claudeAccount) {
-    log30.info(`Session ${sessionId.substring(0, 20)} reserved Claude account "${claudeAccount.id}"`);
+    log31.info(`Session ${sessionId.substring(0, 20)} reserved Claude account "${claudeAccount.id}"`);
   }
   const cliOptions = {
     workingDir,
@@ -69418,28 +69576,28 @@ async function resumeSession(state, ctx) {
       !state.claudeSessionId && "claudeSessionId",
       !state.workingDir && "workingDir"
     ].filter(Boolean).join(", ");
-    log30.warn(`Skipping session with missing required fields: ${missing}`);
+    log31.warn(`Skipping session with missing required fields: ${missing}`);
     return;
   }
   const shortId = state.threadId.substring(0, 8);
   const platforms = ctx.state.platforms;
   const platform = platforms.get(state.platformId);
   if (!platform) {
-    log30.warn(`Platform ${state.platformId} not registered, skipping resume for ${shortId}...`);
+    log31.warn(`Platform ${state.platformId} not registered, skipping resume for ${shortId}...`);
     return;
   }
   const threadPost = await platform.getPost(state.threadId);
   if (!threadPost) {
-    log30.warn(`Thread ${shortId}... deleted, skipping resume`);
+    log31.warn(`Thread ${shortId}... deleted, skipping resume`);
     ctx.state.sessionStore.remove(`${state.platformId}:${state.threadId}`);
     return;
   }
   if (ctx.state.sessions.size >= ctx.config.maxSessions) {
-    log30.warn(`Max sessions reached, skipping resume for ${shortId}...`);
+    log31.warn(`Max sessions reached, skipping resume for ${shortId}...`);
     return;
   }
   if (!existsSync12(state.workingDir)) {
-    log30.warn(`Working directory ${state.workingDir} no longer exists, skipping resume for ${shortId}...`);
+    log31.warn(`Working directory ${state.workingDir} no longer exists, skipping resume for ${shortId}...`);
     ctx.state.sessionStore.remove(`${state.platformId}:${state.threadId}`);
     const resumeFormatter = platform.getFormatter();
     const tempSession = {
@@ -69460,7 +69618,7 @@ Please start a new session.`), { action: "Post resume failure notification" });
   const appendSystemPrompt = await buildAppendSystemPrompt(platform, state.platformId, state.workingDir, state.threadId, state.startedBy, state.sessionAllowedUsers || [state.startedBy], CHAT_PLATFORM_PROMPT, ctx.state.githubEmailsStore);
   const claudeAccount = ctx.ops.acquireClaudeAccount(state.claudeAccountId, state.threadId);
   if (state.claudeAccountId && !claudeAccount) {
-    log30.warn(`Persisted session referenced Claude account "${state.claudeAccountId}" ` + `which is no longer configured — resuming under default env`);
+    log31.warn(`Persisted session referenced Claude account "${state.claudeAccountId}" ` + `which is no longer configured — resuming under default env`);
   }
   const cliOptions = {
     workingDir: state.workingDir,
@@ -69530,7 +69688,7 @@ Please start a new session.`), { action: "Post resume failure notification" });
         worktreePath: detected.worktreePath,
         branch: detected.branch
       };
-      log30.info(`Auto-detected worktree info for resumed session: branch=${detected.branch}`);
+      log31.info(`Auto-detected worktree info for resumed session: branch=${detected.branch}`);
     }
   }
   session.messageManager = createMessageManager(session, ctx);
@@ -69587,7 +69745,7 @@ ${sessionFormatter.formatItalic("Reconnected to Claude session. You can continue
     await postResumeCoAuthorOnboarding(session, ctx);
     ctx.ops.persistSession(session);
   } catch (err) {
-    log30.error(`Failed to resume session ${shortId}`, err instanceof Error ? err : undefined);
+    log31.error(`Failed to resume session ${shortId}`, err instanceof Error ? err : undefined);
     session.messageManager?.dispose();
     ctx.ops.emitSessionRemove(sessionId);
     mutableSessions(ctx).delete(sessionId);
@@ -69634,28 +69792,28 @@ async function resumePausedSession(threadId, message, files, ctx, username) {
   const persisted = ctx.state.sessionStore.load();
   const state = findPersistedByThreadId(persisted, threadId);
   if (!state) {
-    log30.debug(`No persisted session found for ${threadId.substring(0, 8)}...`);
+    log31.debug(`No persisted session found for ${threadId.substring(0, 8)}...`);
     return;
   }
   const shortId = threadId.substring(0, 8);
   const platform = ctx.state.platforms.get(state.platformId);
   if (!platform) {
-    log30.warn(`auth.denied.resume: platform '${state.platformId}' not found for ${shortId}...`);
+    log31.warn(`auth.denied.resume: platform '${state.platformId}' not found for ${shortId}...`);
     return;
   }
   const sessionAllowedUsers = new Set(state.sessionAllowedUsers || [state.startedBy].filter(Boolean));
   if (!isAuthorizedForSession({ username, platform, sessionAllowedUsers })) {
-    log30.warn(`auth.denied.resume: @${username || "unknown"} not authorized to resume ${shortId}...`);
+    log31.warn(`auth.denied.resume: @${username || "unknown"} not authorized to resume ${shortId}...`);
     return;
   }
-  log30.info(`\uD83D\uDD04 Resuming paused session ${shortId}... for new message`);
+  log31.info(`\uD83D\uDD04 Resuming paused session ${shortId}... for new message`);
   await resumeSession(state, ctx);
   const session = ctx.ops.findSessionByThreadId(threadId);
   if (session && session.claude.isRunning() && session.messageManager) {
     session.messageCount++;
     await session.messageManager.handleUserMessage(message, files, state.startedBy);
   } else {
-    log30.warn(`Failed to resume session ${shortId}..., could not send message`);
+    log31.warn(`Failed to resume session ${shortId}..., could not send message`);
   }
 }
 async function handleExit(sessionId, code, ctx) {
@@ -69663,7 +69821,7 @@ async function handleExit(sessionId, code, ctx) {
   const shortId = sessionId.substring(0, 8);
   sessionLog6(session).debug(`handleExit called code=${code} isShuttingDown=${ctx.state.isShuttingDown}`);
   if (!session) {
-    log30.debug(`Session ${shortId}... not found (already cleaned up)`);
+    log31.debug(`Session ${shortId}... not found (already cleaned up)`);
     return;
   }
   if (isSessionRestarting(session)) {
@@ -69856,7 +70014,7 @@ async function cleanupIdleSessions(timeoutMs, warningMs, ctx) {
 }
 
 // src/operations/monitor/handler.ts
-var log31 = createLogger("monitor");
+var log32 = createLogger("monitor");
 var DEFAULT_INTERVAL_MS = 60 * 1000;
 
 class SessionMonitor {
@@ -69878,14 +70036,14 @@ class SessionMonitor {
   }
   start() {
     if (this.isRunning) {
-      log31.debug("Session monitor already running");
+      log32.debug("Session monitor already running");
       return;
     }
     this.isRunning = true;
-    log31.debug(`Session monitor started (interval: ${this.intervalMs / 1000}s)`);
+    log32.debug(`Session monitor started (interval: ${this.intervalMs / 1000}s)`);
     this.timer = setInterval(() => {
       this.runCheck().catch((err) => {
-        log31.error(`Error during session monitoring: ${err}`);
+        log32.error(`Error during session monitoring: ${err}`);
       });
     }, this.intervalMs);
   }
@@ -69895,7 +70053,7 @@ class SessionMonitor {
       this.timer = null;
     }
     this.isRunning = false;
-    log31.debug("Session monitor stopped");
+    log32.debug("Session monitor stopped");
   }
   async runCheck() {
     await cleanupIdleSessions(this.sessionTimeoutMs, this.sessionWarningMs, this.getContext());
@@ -69907,8 +70065,8 @@ class SessionMonitor {
 // src/operations/plugin/handler.ts
 init_spawn();
 init_logger();
-var log32 = createLogger("plugin");
-var sessionLog7 = createSessionLog(log32);
+var log33 = createLogger("plugin");
+var sessionLog7 = createSessionLog(log33);
 async function runPluginCommand(args, cwd, timeout2 = 60000) {
   return new Promise((resolve6) => {
     const claudePath = process.env.CLAUDE_PATH || "claude";
@@ -69929,7 +70087,7 @@ async function runPluginCommand(args, cwd, timeout2 = 60000) {
     });
     proc.on("error", (err) => {
       resolve6({ stdout, stderr, exitCode: 1 });
-      log32.error(`Plugin command error: ${err.message}`);
+      log33.error(`Plugin command error: ${err.message}`);
     });
   });
 }
@@ -70131,7 +70289,7 @@ class SessionRegistry {
 // src/session/reaction-router.ts
 init_emoji();
 init_logger();
-var log33 = createLogger("manager");
+var log34 = createLogger("manager");
 async function handleReaction(deps, platformId, postId, emojiName, username, action) {
   const normalizedEmoji = normalizeEmojiName(emojiName);
   if (action === "added" && isResumeEmoji(normalizedEmoji)) {
@@ -70145,7 +70303,7 @@ async function handleReaction(deps, platformId, postId, emojiName, username, act
   if (session.platformId !== platformId)
     return;
   if (!session.sessionAllowedUsers.has(username) && !session.platform.isUserAllowed(username)) {
-    log33.info(`\uD83D\uDEAB rejected reaction from unauthorized user`, {
+    log34.info(`\uD83D\uDEAB rejected reaction from unauthorized user`, {
       event: "reaction.rejected",
       platformId,
       sessionId: session.sessionId,
@@ -70181,7 +70339,7 @@ async function tryResumeFromReaction(deps, platformId, postId, username) {
     return false;
   }
   const shortId = persistedSession.threadId.substring(0, 8);
-  log33.info(`\uD83D\uDD04 Resuming session ${shortId}... via emoji reaction by @${username}`);
+  log34.info(`\uD83D\uDD04 Resuming session ${shortId}... via emoji reaction by @${username}`);
   await resumeSession(persistedSession, deps.getContext());
   return true;
 }
@@ -70211,7 +70369,7 @@ async function dispatch(deps, session, postId, emojiName, username, action) {
     }
     if (session.lastError?.postId === postId && isBugReportEmoji(emojiName)) {
       if (session.startedBy === username || session.platform.isUserAllowed(username) || session.sessionAllowedUsers.has(username)) {
-        log33.info(`\uD83D\uDC1B @${username} triggered bug report from error reaction`);
+        log34.info(`\uD83D\uDC1B @${username} triggered bug report from error reaction`);
         await reportBug(session, undefined, username, deps.getContext(), session.lastError);
         return;
       }
@@ -70226,7 +70384,10 @@ async function dispatch(deps, session, postId, emojiName, username, action) {
 
 // src/session/manager.ts
 init_logger();
-var log34 = createLogger("manager");
+var log35 = createLogger("manager");
+var USAGE_PROBE_TIMEOUT_MS = 1e4;
+var USAGE_REFRESH_DEADLINE_MS = 5000;
+var USAGE_CACHE_TTL_MS = 15000;
 
 class SessionManager extends EventEmitter4 {
   platforms = new Map;
@@ -70253,6 +70414,8 @@ class SessionManager extends EventEmitter4 {
   platformOverhead = new Map;
   autoUpdateManager = null;
   accountPool;
+  usageRefreshInFlight = null;
+  usageRefreshedAt = 0;
   constructor(workingDir, permissionModeOrSkipFlag = "default", chromeEnabled = false, worktreeMode = "prompt", sessionsPath, threadLogsEnabled = true, threadLogsRetentionDays = 30, limits, claudeAccounts, respondOnlyWhenMentioned = false) {
     super();
     this.workingDir = workingDir;
@@ -70307,7 +70470,7 @@ class SessionManager extends EventEmitter4 {
       markNeedsBump(platformId);
       this.updateStickyMessage();
     });
-    log34.info(`\uD83D\uDCE1 Platform "${platformId}" registered`);
+    log35.info(`\uD83D\uDCE1 Platform "${platformId}" registered`);
   }
   removePlatform(platformId) {
     this.platforms.delete(platformId);
@@ -70325,7 +70488,7 @@ class SessionManager extends EventEmitter4 {
     if (users) {
       users.add(sessionId);
     }
-    log34.debug(`Registered session ${sessionId.substring(0, 20)} as worktree user for ${worktreePath}`);
+    log35.debug(`Registered session ${sessionId.substring(0, 20)} as worktree user for ${worktreePath}`);
   }
   unregisterWorktreeUser(worktreePath, sessionId) {
     const users = this.worktreeUsers.get(worktreePath);
@@ -70395,7 +70558,8 @@ class SessionManager extends EventEmitter4 {
       emitSessionAdd: (s) => this.emitSessionAdd(s),
       emitSessionUpdate: (sid, u) => this.emitSessionUpdate(sid, u),
       emitSessionRemove: (sid) => this.emitSessionRemove(sid),
-      acquireClaudeAccount: (preferredId, threadId) => this.accountPool.acquire(preferredId, threadId),
+      acquireClaudeAccount: (preferredId, threadId, opts) => this.accountPool.acquire(preferredId, threadId, opts),
+      refreshClaudeAccountUsage: () => this.refreshAccountUsage(),
       getClaudeAccount: (id) => this.accountPool.get(id),
       releaseClaudeAccount: (id) => this.accountPool.release(id),
       markClaudeAccountCooling: (id, untilMs) => this.accountPool.markCooling(id, untilMs),
@@ -70626,11 +70790,11 @@ class SessionManager extends EventEmitter4 {
       }
     }
     if (sessionsToKill.length === 0) {
-      log34.info(`No active sessions to pause for platform ${platformId}`);
+      log35.info(`No active sessions to pause for platform ${platformId}`);
       await this.updateStickyMessage();
       return;
     }
-    log34.info(`⏸️ Pausing ${sessionsToKill.length} session(s) for platform ${platformId}`);
+    log35.info(`⏸️ Pausing ${sessionsToKill.length} session(s) for platform ${platformId}`);
     for (const session of sessionsToKill) {
       try {
         const fmt = session.platform.getFormatter();
@@ -70646,9 +70810,9 @@ class SessionManager extends EventEmitter4 {
         session.claude.kill();
         this.registry.unregister(session.sessionId);
         this.emitSessionRemove(session.sessionId);
-        log34.info(`⏸️ Paused session ${session.threadId.substring(0, 8)}`);
+        log35.info(`⏸️ Paused session ${session.threadId.substring(0, 8)}`);
       } catch (err) {
-        log34.warn(`Failed to pause session ${session.threadId}: ${err}`);
+        log35.warn(`Failed to pause session ${session.threadId}: ${err}`);
       }
     }
     for (const session of sessionsToKill) {
@@ -70669,21 +70833,47 @@ class SessionManager extends EventEmitter4 {
       sessionsToResume.push(state);
     }
     if (sessionsToResume.length === 0) {
-      log34.info(`No paused sessions to resume for platform ${platformId}`);
+      log35.info(`No paused sessions to resume for platform ${platformId}`);
       await this.updateStickyMessage();
       return;
     }
-    log34.info(`▶️ Resuming ${sessionsToResume.length} paused session(s) for platform ${platformId}`);
+    log35.info(`▶️ Resuming ${sessionsToResume.length} paused session(s) for platform ${platformId}`);
     for (const state of sessionsToResume) {
       try {
         await resumeSession(state, this.getContext());
-        log34.info(`▶️ Resumed session ${state.threadId.substring(0, 8)}`);
+        log35.info(`▶️ Resumed session ${state.threadId.substring(0, 8)}`);
       } catch (err) {
-        log34.warn(`Failed to resume session ${state.threadId}: ${err}`);
+        log35.warn(`Failed to resume session ${state.threadId}: ${err}`);
       }
     }
     await this.updateStickyMessage();
   }
+  async refreshAccountUsage() {
+    const accounts = this.accountPool.all;
+    if (accounts.length < 2)
+      return;
+    if (Date.now() - this.usageRefreshedAt < USAGE_CACHE_TTL_MS)
+      return;
+    if (!this.usageRefreshInFlight) {
+      this.usageRefreshInFlight = this.probeAllAccounts(accounts).finally(() => {
+        this.usageRefreshedAt = Date.now();
+        this.usageRefreshInFlight = null;
+      });
+    }
+    await Promise.race([
+      this.usageRefreshInFlight,
+      new Promise((resolve6) => setTimeout(resolve6, USAGE_REFRESH_DEADLINE_MS))
+    ]);
+  }
+  async probeAllAccounts(accounts) {
+    await Promise.all(accounts.map(async (acc) => {
+      try {
+        this.accountPool.setUsage(acc.id, await probeAccountUsage(acc, { timeoutMs: USAGE_PROBE_TIMEOUT_MS }));
+      } catch {
+        this.accountPool.setUsage(acc.id, null);
+      }
+    }));
+  }
   async initialize() {
     initialize(this.sessionStore);
     this.sessionMonitor?.start();
@@ -70691,14 +70881,14 @@ class SessionManager extends EventEmitter4 {
     const sessionTimeoutMs = this.limits.sessionTimeoutMinutes * 60 * 1000;
     const staleIds = this.sessionStore.cleanStale(sessionTimeoutMs * 2);
     if (staleIds.length > 0) {
-      log34.info(`\uD83E\uDDF9 Soft-deleted ${staleIds.length} stale session(s) (kept for history)`);
+      log35.info(`\uD83E\uDDF9 Soft-deleted ${staleIds.length} stale session(s) (kept for history)`);
     }
     const removedCount = this.sessionStore.cleanHistory();
     if (removedCount > 0) {
-      log34.info(`\uD83D\uDDD1️ Permanently removed ${removedCount} old session(s) from history`);
+      log35.info(`\uD83D\uDDD1️ Permanently removed ${removedCount} old session(s) from history`);
     }
     const persisted = this.sessionStore.load();
-    log34.info(`\uD83D\uDCC2 Loaded ${persisted.size} session(s) from persistence`);
+    log35.info(`\uD83D\uDCC2 Loaded ${persisted.size} session(s) from persistence`);
     const excludePostIdsByPlatform = new Map;
     for (const session of persisted.values()) {
       const platformId = session.platformId;
@@ -70718,10 +70908,10 @@ class SessionManager extends EventEmitter4 {
       const excludePostIds = excludePostIdsByPlatform.get(platform.platformId);
       platform.getBotUser().then((botUser) => {
         cleanupOldStickyMessages(platform, botUser.id, true, excludePostIds).catch((err) => {
-          log34.warn(`Failed to cleanup old sticky messages for ${platform.platformId}: ${err}`);
+          log35.warn(`Failed to cleanup old sticky messages for ${platform.platformId}: ${err}`);
         });
       }).catch((err) => {
-        log34.warn(`Failed to get bot user for cleanup on ${platform.platformId}: ${err}`);
+        log35.warn(`Failed to get bot user for cleanup on ${platform.platformId}: ${err}`);
       });
     }
     if (persisted.size > 0) {
@@ -70735,10 +70925,10 @@ class SessionManager extends EventEmitter4 {
         }
       }
       if (pausedToSkip.length > 0) {
-        log34.info(`⏸️ ${pausedToSkip.length} session(s) remain paused (waiting for user message)`);
+        log35.info(`⏸️ ${pausedToSkip.length} session(s) remain paused (waiting for user message)`);
       }
       if (activeToResume.length > 0) {
-        log34.info(`\uD83D\uDD04 Attempting to resume ${activeToResume.length} active session(s)...`);
+        log35.info(`\uD83D\uDD04 Attempting to resume ${activeToResume.length} active session(s)...`);
         for (const state of activeToResume) {
           await resumeSession(state, this.getContext());
         }
@@ -71179,7 +71369,7 @@ Mention me to start a session in this worktree.`, threadId);
         const message = messageBuilder(formatter);
         await post(session, "info", message);
       } catch (err) {
-        log34.warn(`Failed to broadcast to session ${session.threadId}: ${err}`);
+        log35.warn(`Failed to broadcast to session ${session.threadId}: ${err}`);
       }
     }
   }
@@ -71198,7 +71388,7 @@ Mention me to start a session in this worktree.`, threadId);
         session.messageManager?.setPendingUpdatePrompt({ postId: post2.id });
         this.registerPost(post2.id, session.threadId);
       } catch (err) {
-        log34.warn(`Failed to post ask message to ${threadId}: ${err}`);
+        log35.warn(`Failed to post ask message to ${threadId}: ${err}`);
       }
     }
   }
@@ -78805,29 +78995,29 @@ function SessionLog({ logs, maxLines = 20 }) {
   return /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
     flexDirection: "column",
     flexShrink: 0,
-    children: displayLogs.map((log35) => /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
+    children: displayLogs.map((log36) => /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
       flexShrink: 0,
       children: [
         /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
-          color: getColorForLevel(log35.level),
+          color: getColorForLevel(log36.level),
           dimColor: true,
           wrap: "truncate",
           children: [
             "[",
-            padComponent(log35.component),
+            padComponent(log36.component),
             "]"
           ]
         }, undefined, true, undefined, this),
         /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
-          color: getColorForLevel(log35.level),
+          color: getColorForLevel(log36.level),
           wrap: "truncate",
           children: [
             " ",
-            log35.message
+            log36.message
           ]
         }, undefined, true, undefined, this)
       ]
-    }, log35.id, true, undefined, this))
+    }, log36.id, true, undefined, this))
   }, undefined, false, undefined, this);
 }
 // src/ui/components/Footer.tsx
@@ -79351,7 +79541,7 @@ function LogPanel({ logs, maxLines = 10, focused = false }) {
   const scrollRef = import_react59.default.useRef(null);
   const { stdout } = use_stdout_default();
   const isDebug = process.env.DEBUG === "1";
-  const displayLogs = logs.filter((log35) => isDebug || log35.level !== "debug");
+  const displayLogs = logs.filter((log36) => isDebug || log36.level !== "debug");
   const visibleLogs = displayLogs.slice(-Math.max(maxLines * 3, 100));
   import_react59.default.useEffect(() => {
     const handleResize = () => scrollRef.current?.remeasure();
@@ -79391,25 +79581,25 @@ function LogPanel({ logs, maxLines = 10, focused = false }) {
     overflow: "hidden",
     children: /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(ScrollView, {
       ref: scrollRef,
-      children: visibleLogs.map((log35) => /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
+      children: visibleLogs.map((log36) => /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
         children: [
           /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
             dimColor: true,
             children: [
               "[",
-              padComponent2(log35.component),
+              padComponent2(log36.component),
               "]"
             ]
           }, undefined, true, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
-            color: getLevelColor(log35.level),
+            color: getLevelColor(log36.level),
             children: [
               " ",
-              log35.message
+              log36.message
             ]
           }, undefined, true, undefined, this)
         ]
-      }, log35.id, true, undefined, this))
+      }, log36.id, true, undefined, this))
     }, undefined, false, undefined, this)
   }, undefined, false, undefined, this);
 }
@@ -79926,10 +80116,10 @@ function useAppState(initialConfig) {
     });
   }, []);
   const getLogsForSession = import_react60.useCallback((sessionId) => {
-    return state.logs.filter((log35) => log35.sessionId === sessionId);
+    return state.logs.filter((log36) => log36.sessionId === sessionId);
   }, [state.logs]);
   const getGlobalLogs = import_react60.useCallback(() => {
-    return state.logs.filter((log35) => !log35.sessionId);
+    return state.logs.filter((log36) => !log36.sessionId);
   }, [state.logs]);
   const togglePlatformEnabled = import_react60.useCallback((platformId) => {
     let newEnabled = false;
@@ -80942,7 +81132,7 @@ import { EventEmitter as EventEmitter9 } from "events";
 // src/auto-update/checker.ts
 init_logger();
 import { EventEmitter as EventEmitter7 } from "events";
-var log35 = createLogger("checker");
+var log36 = createLogger("checker");
 var PACKAGE_NAME = "claude-threads";
 function compareVersions(a, b) {
   const partsA = a.replace(/^v/, "").split(".").map(Number);
@@ -80965,13 +81155,13 @@ async function fetchLatestVersion() {
       }
     });
     if (!response.ok) {
-      log35.warn(`Failed to fetch latest version: HTTP ${response.status}`);
+      log36.warn(`Failed to fetch latest version: HTTP ${response.status}`);
       return null;
     }
     const data = await response.json();
     return data.version ?? null;
   } catch (err) {
-    log35.warn(`Failed to fetch latest version: ${err}`);
+    log36.warn(`Failed to fetch latest version: ${err}`);
     return null;
   }
 }
@@ -80988,38 +81178,38 @@ class UpdateChecker extends EventEmitter7 {
   }
   start() {
     if (!this.config.enabled) {
-      log35.debug("Auto-update disabled, not starting checker");
+      log36.debug("Auto-update disabled, not starting checker");
       return;
     }
     setTimeout(() => {
       this.check().catch((err) => {
-        log35.warn(`Initial update check failed: ${err}`);
+        log36.warn(`Initial update check failed: ${err}`);
       });
     }, 5000);
     const intervalMs = this.config.checkIntervalMinutes * 60 * 1000;
     this.checkInterval = setInterval(() => {
       this.check().catch((err) => {
-        log35.warn(`Periodic update check failed: ${err}`);
+        log36.warn(`Periodic update check failed: ${err}`);
       });
     }, intervalMs);
-    log35.info(`\uD83D\uDD04 Update checker started (every ${this.config.checkIntervalMinutes} minutes)`);
+    log36.info(`\uD83D\uDD04 Update checker started (every ${this.config.checkIntervalMinutes} minutes)`);
   }
   stop() {
     if (this.checkInterval) {
       clearInterval(this.checkInterval);
       this.checkInterval = null;
     }
-    log35.debug("Update checker stopped");
+    log36.debug("Update checker stopped");
   }
   async check() {
     if (this.isChecking) {
-      log35.debug("Check already in progress, skipping");
+      log36.debug("Check already in progress, skipping");
       return this.lastUpdateInfo;
     }
     this.isChecking = true;
     this.emit("check:start");
     try {
-      log35.debug("Checking for updates...");
+      log36.debug("Checking for updates...");
       const latestVersion2 = await fetchLatestVersion();
       if (!latestVersion2) {
         this.emit("check:complete", false);
@@ -81036,18 +81226,18 @@ class UpdateChecker extends EventEmitter7 {
           detectedAt: new Date
         };
         if (!this.lastUpdateInfo || this.lastUpdateInfo.latestVersion !== latestVersion2) {
-          log35.info(`\uD83C\uDD95 Update available: v${currentVersion} → v${latestVersion2}`);
+          log36.info(`\uD83C\uDD95 Update available: v${currentVersion} → v${latestVersion2}`);
           this.lastUpdateInfo = updateInfo;
           this.emit("update", updateInfo);
         }
         this.emit("check:complete", true);
         return updateInfo;
       }
-      log35.debug(`Up to date (v${currentVersion})`);
+      log36.debug(`Up to date (v${currentVersion})`);
       this.emit("check:complete", false);
       return null;
     } catch (err) {
-      log35.warn(`Update check failed: ${err}`);
+      log36.warn(`Update check failed: ${err}`);
       this.emit("check:error", err);
       return null;
     } finally {
@@ -81118,7 +81308,7 @@ function isInScheduledWindow(window2) {
 }
 
 // src/auto-update/scheduler.ts
-var log36 = createLogger("scheduler");
+var log37 = createLogger("scheduler");
 
 class UpdateScheduler extends EventEmitter8 {
   config;
@@ -81142,7 +81332,7 @@ class UpdateScheduler extends EventEmitter8 {
   scheduleUpdate(updateInfo) {
     this.pendingUpdate = updateInfo;
     if (this.config.autoRestartMode === "immediate") {
-      log36.info("Immediate mode: triggering update now");
+      log37.info("Immediate mode: triggering update now");
       this.emit("ready", updateInfo);
       return;
     }
@@ -81155,19 +81345,19 @@ class UpdateScheduler extends EventEmitter8 {
     this.scheduledRestartAt = null;
     this.askApprovals.clear();
     this.askStartTime = null;
-    log36.debug("Update schedule cancelled");
+    log37.debug("Update schedule cancelled");
   }
   deferUpdate(minutes) {
     const deferUntil = new Date(Date.now() + minutes * 60 * 1000);
     this.scheduledRestartAt = null;
     this.idleStartTime = null;
     this.emit("deferred", deferUntil);
-    log36.info(`Update deferred until ${deferUntil.toLocaleTimeString()}`);
+    log37.info(`Update deferred until ${deferUntil.toLocaleTimeString()}`);
     return deferUntil;
   }
   recordAskResponse(threadId, approved) {
     this.askApprovals.set(threadId, approved);
-    log36.debug(`Thread ${threadId.substring(0, 8)} ${approved ? "approved" : "denied"} update`);
+    log37.debug(`Thread ${threadId.substring(0, 8)} ${approved ? "approved" : "denied"} update`);
     this.checkAskCondition();
   }
   getScheduledRestartAt() {
@@ -81188,7 +81378,7 @@ class UpdateScheduler extends EventEmitter8 {
       return;
     this.checkCondition();
     this.checkTimer = setInterval(() => this.checkCondition(), 1e4);
-    log36.debug(`Started checking for ${this.config.autoRestartMode} condition`);
+    log37.debug(`Started checking for ${this.config.autoRestartMode} condition`);
   }
   stopChecking() {
     if (this.checkTimer) {
@@ -81219,17 +81409,17 @@ class UpdateScheduler extends EventEmitter8 {
     if (activity.activeSessionCount === 0) {
       if (!this.idleStartTime) {
         this.idleStartTime = new Date;
-        log36.debug("No active sessions, starting idle timer");
+        log37.debug("No active sessions, starting idle timer");
       }
       const idleMs = Date.now() - this.idleStartTime.getTime();
       const requiredMs = this.config.idleTimeoutMinutes * 60 * 1000;
       if (idleMs >= requiredMs) {
-        log36.info(`Idle for ${this.config.idleTimeoutMinutes} minutes, triggering update`);
+        log37.info(`Idle for ${this.config.idleTimeoutMinutes} minutes, triggering update`);
         this.triggerCountdown();
       }
     } else {
       if (this.idleStartTime) {
-        log36.debug("Sessions became active, resetting idle timer");
+        log37.debug("Sessions became active, resetting idle timer");
         this.idleStartTime = null;
       }
     }
@@ -81240,7 +81430,7 @@ class UpdateScheduler extends EventEmitter8 {
       const quietMs = Date.now() - activity.lastActivityAt.getTime();
       const requiredMs = this.config.quietTimeoutMinutes * 60 * 1000;
       if (quietMs >= requiredMs && !activity.anySessionBusy) {
-        log36.info(`Sessions quiet for ${this.config.quietTimeoutMinutes} minutes, triggering update`);
+        log37.info(`Sessions quiet for ${this.config.quietTimeoutMinutes} minutes, triggering update`);
         this.triggerCountdown();
       }
     } else if (activity.activeSessionCount === 0) {
@@ -81250,7 +81440,7 @@ class UpdateScheduler extends EventEmitter8 {
       const idleMs = Date.now() - this.idleStartTime.getTime();
       const requiredMs = this.config.quietTimeoutMinutes * 60 * 1000;
       if (idleMs >= requiredMs) {
-        log36.info("No sessions and quiet timeout reached, triggering update");
+        log37.info("No sessions and quiet timeout reached, triggering update");
         this.triggerCountdown();
       }
     }
@@ -81261,13 +81451,13 @@ class UpdateScheduler extends EventEmitter8 {
     }
     const activity = this.getSessionActivity();
     if (activity.activeSessionCount === 0) {
-      log36.info("Within scheduled window and no active sessions, triggering update");
+      log37.info("Within scheduled window and no active sessions, triggering update");
       this.triggerCountdown();
     } else if (activity.lastActivityAt) {
       const quietMs = Date.now() - activity.lastActivityAt.getTime();
       const requiredMs = this.config.idleTimeoutMinutes * 60 * 1000;
       if (quietMs >= requiredMs && !activity.anySessionBusy) {
-        log36.info("Within scheduled window and sessions quiet, triggering update");
+        log37.info("Within scheduled window and sessions quiet, triggering update");
         this.triggerCountdown();
       }
     }
@@ -81275,14 +81465,14 @@ class UpdateScheduler extends EventEmitter8 {
   checkAskCondition() {
     const threadIds = this.getActiveThreadIds();
     if (threadIds.length === 0) {
-      log36.info("No active threads, proceeding with update");
+      log37.info("No active threads, proceeding with update");
       this.triggerCountdown();
       return;
     }
     if (!this.askStartTime && this.pendingUpdate) {
       this.askStartTime = new Date;
       this.postAskMessage(threadIds, this.pendingUpdate.latestVersion).catch((err) => {
-        log36.warn(`Failed to post ask message: ${err}`);
+        log37.warn(`Failed to post ask message: ${err}`);
       });
       return;
     }
@@ -81295,12 +81485,12 @@ class UpdateScheduler extends EventEmitter8 {
         denials++;
     }
     if (approvals > threadIds.length / 2) {
-      log36.info(`Majority approved (${approvals}/${threadIds.length}), triggering update`);
+      log37.info(`Majority approved (${approvals}/${threadIds.length}), triggering update`);
       this.triggerCountdown();
       return;
     }
     if (denials > threadIds.length / 2) {
-      log36.info(`Majority denied (${denials}/${threadIds.length}), deferring update`);
+      log37.info(`Majority denied (${denials}/${threadIds.length}), deferring update`);
       this.deferUpdate(60);
       return;
     }
@@ -81308,7 +81498,7 @@ class UpdateScheduler extends EventEmitter8 {
       const elapsedMs = Date.now() - this.askStartTime.getTime();
       const timeoutMs = this.config.askTimeoutMinutes * 60 * 1000;
       if (elapsedMs >= timeoutMs) {
-        log36.info(`Ask timeout reached (${this.config.askTimeoutMinutes} min), triggering update`);
+        log37.info(`Ask timeout reached (${this.config.askTimeoutMinutes} min), triggering update`);
         this.triggerCountdown();
       }
     }
@@ -81328,7 +81518,7 @@ class UpdateScheduler extends EventEmitter8 {
         this.emit("ready", this.pendingUpdate);
       }
     }, 1000);
-    log36.info("Update countdown started (60 seconds)");
+    log37.info("Update countdown started (60 seconds)");
   }
   stopCountdown() {
     if (this.countdownTimer) {
@@ -81344,24 +81534,24 @@ import { spawn as spawn4, spawnSync } from "child_process";
 import { existsSync as existsSync14, readFileSync as readFileSync10, writeFileSync as writeFileSync7, mkdirSync as mkdirSync5 } from "fs";
 import { dirname as dirname8, resolve as resolve6 } from "path";
 import { homedir as homedir6 } from "os";
-var log37 = createLogger("installer");
+var log38 = createLogger("installer");
 function detectPackageManager() {
   const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
   const originalInstaller = detectOriginalInstaller();
   if (originalInstaller) {
-    log37.debug(`Detected original installer: ${originalInstaller}`);
+    log38.debug(`Detected original installer: ${originalInstaller}`);
     if (originalInstaller === "bun") {
       const bunCheck2 = spawnSync("bun", ["--version"], { stdio: "ignore" });
       if (bunCheck2.status === 0) {
         return { cmd: "bun", isBun: true };
       }
-      log37.warn("Originally installed with bun, but bun not found. Falling back to npm.");
+      log38.warn("Originally installed with bun, but bun not found. Falling back to npm.");
     } else {
       const npmCheck2 = spawnSync(npmCmd, ["--version"], { stdio: "ignore" });
       if (npmCheck2.status === 0) {
         return { cmd: npmCmd, isBun: false };
       }
-      log37.warn("Originally installed with npm, but npm not found. Falling back to bun.");
+      log38.warn("Originally installed with npm, but npm not found. Falling back to bun.");
     }
   }
   const bunCheck = spawnSync("bun", ["--version"], { stdio: "ignore" });
@@ -81412,7 +81602,7 @@ function loadUpdateState() {
       return JSON.parse(content);
     }
   } catch (err) {
-    log37.warn(`Failed to load update state: ${err}`);
+    log38.warn(`Failed to load update state: ${err}`);
   }
   return {};
 }
@@ -81423,9 +81613,9 @@ function saveUpdateState(state) {
       mkdirSync5(dir, { recursive: true });
     }
     writeFileSync7(STATE_PATH, JSON.stringify(state, null, 2), "utf-8");
-    log37.debug("Update state saved");
+    log38.debug("Update state saved");
   } catch (err) {
-    log37.warn(`Failed to save update state: ${err}`);
+    log38.warn(`Failed to save update state: ${err}`);
   }
 }
 function clearUpdateState() {
@@ -81434,7 +81624,7 @@ function clearUpdateState() {
       writeFileSync7(STATE_PATH, "{}", "utf-8");
     }
   } catch (err) {
-    log37.warn(`Failed to clear update state: ${err}`);
+    log38.warn(`Failed to clear update state: ${err}`);
   }
 }
 function checkJustUpdated() {
@@ -81466,11 +81656,11 @@ function clearRuntimeSettings() {
   }
 }
 async function installVersion(version) {
-  log37.info(`\uD83D\uDCE6 Installing ${PACKAGE_NAME2}@${version}...`);
+  log38.info(`\uD83D\uDCE6 Installing ${PACKAGE_NAME2}@${version}...`);
   const pm = detectPackageManager();
   if (!pm) {
     const error = "Neither bun nor npm found in PATH. Cannot install update.";
-    log37.error(`❌ ${error}`);
+    log38.error(`❌ ${error}`);
     return { success: false, error };
   }
   saveUpdateState({
@@ -81482,7 +81672,7 @@ async function installVersion(version) {
   return new Promise((resolve7) => {
     const { cmd, isBun: isBun3 } = pm;
     const args = ["install", "-g", `${PACKAGE_NAME2}@${version}`];
-    log37.debug(`Using ${isBun3 ? "bun" : "npm"} for installation`);
+    log38.debug(`Using ${isBun3 ? "bun" : "npm"} for installation`);
     const child = spawn4(cmd, args, {
       stdio: ["ignore", "pipe", "pipe"],
       env: {
@@ -81500,7 +81690,7 @@ async function installVersion(version) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        log37.info(`✅ Successfully installed ${PACKAGE_NAME2}@${version}`);
+        log38.info(`✅ Successfully installed ${PACKAGE_NAME2}@${version}`);
         saveUpdateState({
           previousVersion: VERSION,
           targetVersion: version,
@@ -81510,20 +81700,20 @@ async function installVersion(version) {
         resolve7({ success: true });
       } else {
         const errorMsg = stderr || stdout || `Exit code: ${code}`;
-        log37.error(`❌ Installation failed: ${errorMsg}`);
+        log38.error(`❌ Installation failed: ${errorMsg}`);
         clearUpdateState();
         resolve7({ success: false, error: errorMsg });
       }
     });
     child.on("error", (err) => {
-      log37.error(`❌ Failed to spawn npm: ${err}`);
+      log38.error(`❌ Failed to spawn npm: ${err}`);
       clearUpdateState();
       resolve7({ success: false, error: err.message });
     });
     setTimeout(() => {
       if (child.exitCode === null) {
         child.kill();
-        log37.error("❌ Installation timed out");
+        log38.error("❌ Installation timed out");
         clearUpdateState();
         resolve7({ success: false, error: "Installation timed out" });
       }
@@ -81569,7 +81759,7 @@ init_logger();
 import { spawn as spawn5 } from "child_process";
 import { existsSync as existsSync15, statSync as statSync4 } from "fs";
 import { delimiter, join as join11 } from "path";
-var log38 = createLogger("respawn");
+var log39 = createLogger("respawn");
 function decideRespawn(env5 = process.env, isTTY = !!process.stdout.isTTY) {
   if (env5.CLAUDE_THREADS_BIN) {
     return { kind: "exit-for-supervisor", supervisor: "claude-threads-daemon" };
@@ -81625,7 +81815,7 @@ function isFileExecutable(path10) {
 }
 function spawnReplacement(argv = process.argv.slice(2), binPath = resolveClaudeThreadsBin()) {
   if (!binPath) {
-    log38.error("Could not resolve claude-threads on PATH; self-respawn aborted");
+    log39.error("Could not resolve claude-threads on PATH; self-respawn aborted");
     return false;
   }
   if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
@@ -81646,23 +81836,23 @@ function spawnReplacement(argv = process.argv.slice(2), binPath = resolveClaudeT
       shell: useShell
     });
   } catch (err) {
-    log38.error(`spawn() threw: ${err instanceof Error ? err.message : String(err)}`);
+    log39.error(`spawn() threw: ${err instanceof Error ? err.message : String(err)}`);
     return false;
   }
   child.once("error", (err) => {
-    log38.error(`Replacement process error: ${err.message}`);
+    log39.error(`Replacement process error: ${err.message}`);
   });
   if (child.pid === undefined) {
-    log38.error("Spawn returned no pid (binary likely not executable)");
+    log39.error("Spawn returned no pid (binary likely not executable)");
     return false;
   }
   child.unref();
-  log38.info(`Spawned replacement pid=${child.pid} from ${binPath}`);
+  log39.info(`Spawned replacement pid=${child.pid} from ${binPath}`);
   return true;
 }
 
 // src/auto-update/manager.ts
-var log39 = createLogger("updater");
+var log40 = createLogger("updater");
 
 class AutoUpdateManager extends EventEmitter9 {
   config;
@@ -81685,23 +81875,23 @@ class AutoUpdateManager extends EventEmitter9 {
   }
   start() {
     if (!this.config.enabled) {
-      log39.info("Auto-update is disabled");
+      log40.info("Auto-update is disabled");
       return;
     }
     const updateResult = this.installer.checkJustUpdated();
     if (updateResult) {
-      log39.info(`\uD83C\uDF89 Updated from v${updateResult.previousVersion} to v${updateResult.currentVersion}`);
+      log40.info(`\uD83C\uDF89 Updated from v${updateResult.previousVersion} to v${updateResult.currentVersion}`);
       this.callbacks.broadcastUpdate((fmt) => `\uD83C\uDF89 ${fmt.formatBold("Bot updated")} from v${updateResult.previousVersion} to v${updateResult.currentVersion}`).catch((err) => {
-        log39.warn(`Failed to broadcast update notification: ${err}`);
+        log40.warn(`Failed to broadcast update notification: ${err}`);
       });
     }
     this.checker.start();
-    log39.info(`\uD83D\uDD04 Auto-update manager started (mode: ${this.config.autoRestartMode})`);
+    log40.info(`\uD83D\uDD04 Auto-update manager started (mode: ${this.config.autoRestartMode})`);
   }
   stop() {
     this.checker.stop();
     this.scheduler.stop();
-    log39.debug("Auto-update manager stopped");
+    log40.debug("Auto-update manager stopped");
   }
   getState() {
     return { ...this.state };
@@ -81715,10 +81905,10 @@ class AutoUpdateManager extends EventEmitter9 {
   async forceUpdate() {
     const updateInfo = this.state.updateInfo || await this.checker.check();
     if (!updateInfo) {
-      log39.info("No update available");
+      log40.info("No update available");
       return;
     }
-    log39.info("Forcing immediate update");
+    log40.info("Forcing immediate update");
     await this.performUpdate(updateInfo);
   }
   deferUpdate(minutes = 60) {
@@ -81784,11 +81974,11 @@ class AutoUpdateManager extends EventEmitter9 {
         await this.callbacks.prepareForRestart();
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
-        log39.error(`prepareForRestart failed: ${reason}`);
+        log40.error(`prepareForRestart failed: ${reason}`);
         await this.callbacks.broadcastUpdate((fmt) => `⚠️ ${fmt.formatBold("Restart aborted")}: shutdown sequence failed (${reason}). Sessions may be in an inconsistent state; please run ${fmt.formatCode("claude-threads")} manually.`).catch(() => {});
         process.exit(1);
       }
-      log39.info(`\uD83D\uDD04 Restarting for update to v${updateInfo.latestVersion}`);
+      log40.info(`\uD83D\uDD04 Restarting for update to v${updateInfo.latestVersion}`);
       process.stdout.write("\x1B[2J\x1B[H");
       process.stdout.write("\x1B[?25h");
       if (decision.kind === "self-respawn") {
@@ -81797,14 +81987,14 @@ class AutoUpdateManager extends EventEmitter9 {
           if (ok) {
             process.exit(0);
           }
-          log39.error("Self-respawn launch failed after binary resolution succeeded");
+          log40.error("Self-respawn launch failed after binary resolution succeeded");
           await this.callbacks.broadcastUpdate((fmt) => `⚠️ ${fmt.formatBold("Auto-restart failed")} after install: please run ${fmt.formatCode("claude-threads")} to bring the bot back. Sessions are persisted and will resume.`).catch(() => {});
         } else {
-          log39.error("claude-threads not found on PATH; manual restart required");
+          log40.error("claude-threads not found on PATH; manual restart required");
         }
         process.exit(0);
       }
-      log39.debug(`Restart handled by supervisor: ${decision.supervisor}`);
+      log40.debug(`Restart handled by supervisor: ${decision.supervisor}`);
       process.exit(RESTART_EXIT_CODE);
     } else {
       const errorMsg = result.error ?? "Unknown error";