claude-threads 1.33.0 → 1.33.1

package/dist/index.js

@@ -4336,10 +4336,10 @@ __export(exports_worktree, {
 import { randomUUID as randomUUID2 } from "crypto";
 import * as path from "path";
 import * as fs from "fs/promises";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 async function execGit(args, cwd) {
   const cmd = `git ${args.join(" ")}`;
-  log8.debug(`Executing: ${cmd}`);
+  log9.debug(`Executing: ${cmd}`);
   return new Promise((resolve6, reject) => {
     const proc = crossSpawn("git", args, { cwd });
     let stdout = "";
@@ -4352,15 +4352,15 @@ async function execGit(args, cwd) {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        log8.debug(`${cmd} → success`);
+        log9.debug(`${cmd} → success`);
         resolve6(stdout.trim());
       } else {
-        log8.debug(`${cmd} → failed (code=${code}): ${stderr.substring(0, 100) || stdout.substring(0, 100)}`);
+        log9.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) => {
-      log8.warn(`${cmd} → error: ${err}`);
+      log9.warn(`${cmd} → error: ${err}`);
       reject(err);
     });
   });
@@ -4370,7 +4370,7 @@ async function isGitRepository(dir) {
     await execGit(["rev-parse", "--git-dir"], dir);
     return true;
   } catch (err) {
-    log8.debug(`Not a git repository: ${dir} (${err})`);
+    log9.debug(`Not a git repository: ${dir} (${err})`);
     return false;
   }
 }
@@ -4520,7 +4520,7 @@ async function detectWorktreeInfo(workingDir) {
     const branchOutput = await execGit(["rev-parse", "--abbrev-ref", "HEAD"], workingDir);
     const branch = branchOutput?.trim();
     if (!branch || branch === "HEAD") {
-      log8.debug(`Could not detect branch for worktree at ${workingDir}`);
+      log9.debug(`Could not detect branch for worktree at ${workingDir}`);
       return null;
     }
     const toplevel = (await execGit(["rev-parse", "--show-toplevel"], workingDir))?.trim();
@@ -4528,45 +4528,45 @@ async function detectWorktreeInfo(workingDir) {
       return null;
     }
     const repoRoot = await getMainRepositoryRoot(workingDir);
-    log8.debug(`Detected worktree: path=${workingDir}, branch=${branch}, repoRoot=${repoRoot}`);
+    log9.debug(`Detected worktree: path=${workingDir}, branch=${branch}, repoRoot=${repoRoot}`);
     return {
       worktreePath: toplevel,
       branch,
       repoRoot: repoRoot || toplevel
     };
   } catch (err) {
-    log8.debug(`Failed to detect worktree info for ${workingDir}: ${err}`);
+    log9.debug(`Failed to detect worktree info for ${workingDir}: ${err}`);
     return null;
   }
 }
 async function createWorktree(repoRoot, branch, targetDir) {
-  log8.info(`Creating worktree for branch '${branch}' at ${targetDir}`);
+  log9.info(`Creating worktree for branch '${branch}' at ${targetDir}`);
   const parentDir = path.dirname(targetDir);
-  log8.debug(`Creating parent directory: ${parentDir}`);
+  log9.debug(`Creating parent directory: ${parentDir}`);
   await fs.mkdir(parentDir, { recursive: true });
   const exists = await branchExists(repoRoot, branch);
   if (exists) {
-    log8.debug(`Branch '${branch}' exists, adding worktree`);
+    log9.debug(`Branch '${branch}' exists, adding worktree`);
     await execGit(["worktree", "add", "--", targetDir, branch], repoRoot);
   } else {
-    log8.debug(`Branch '${branch}' does not exist, creating with worktree`);
+    log9.debug(`Branch '${branch}' does not exist, creating with worktree`);
     await execGit(["worktree", "add", "-b", branch, "--", targetDir], repoRoot);
   }
-  log8.info(`Worktree created successfully: ${targetDir}`);
+  log9.info(`Worktree created successfully: ${targetDir}`);
   return targetDir;
 }
 async function removeWorktree(repoRoot, worktreePath) {
-  log8.info(`Removing worktree: ${worktreePath}`);
+  log9.info(`Removing worktree: ${worktreePath}`);
   try {
     await execGit(["worktree", "remove", worktreePath], repoRoot);
-    log8.debug("Worktree removed cleanly");
+    log9.debug("Worktree removed cleanly");
   } catch (err) {
-    log8.debug(`Clean remove failed (${err}), trying force remove`);
+    log9.debug(`Clean remove failed (${err}), trying force remove`);
     await execGit(["worktree", "remove", "--force", worktreePath], repoRoot);
   }
-  log8.debug("Pruning stale worktree references");
+  log9.debug("Pruning stale worktree references");
   await execGit(["worktree", "prune"], repoRoot);
-  log8.info("Worktree removed and pruned successfully");
+  log9.info("Worktree removed and pruned successfully");
 }
 async function findWorktreeByBranch(repoRoot, branch) {
   const worktrees = await listWorktrees(repoRoot);
@@ -4609,14 +4609,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) {
-    log8.warn(`Failed to write worktree metadata store: ${err}`);
+    log9.warn(`Failed to write worktree metadata store: ${err}`);
   }
 }
 async function writeWorktreeMetadata(worktreePath, metadata) {
   const store = await readMetadataStore();
   store[worktreePath] = metadata;
   await writeMetadataStore(store);
-  log8.debug(`Wrote worktree metadata for: ${worktreePath}`);
+  log9.debug(`Wrote worktree metadata for: ${worktreePath}`);
 }
 async function readWorktreeMetadata(worktreePath) {
   const store = await readMetadataStore();
@@ -4639,16 +4639,16 @@ async function removeWorktreeMetadata(worktreePath) {
   if (store[worktreePath]) {
     delete store[worktreePath];
     await writeMetadataStore(store);
-    log8.debug(`Removed worktree metadata for: ${worktreePath}`);
+    log9.debug(`Removed worktree metadata for: ${worktreePath}`);
   }
 }
-var log8, WORKTREES_DIR, METADATA_STORE_PATH;
+var log9, WORKTREES_DIR, METADATA_STORE_PATH;
 var init_worktree = __esm(() => {
   init_spawn();
   init_logger();
-  log8 = createLogger("git-wt");
-  WORKTREES_DIR = path.join(homedir4(), ".claude-threads", "worktrees");
-  METADATA_STORE_PATH = path.join(homedir4(), ".claude-threads", "worktree-metadata.json");
+  log9 = createLogger("git-wt");
+  WORKTREES_DIR = path.join(homedir5(), ".claude-threads", "worktrees");
+  METADATA_STORE_PATH = path.join(homedir5(), ".claude-threads", "worktree-metadata.json");
 });
 
 // node_modules/graceful-fs/polyfills.js
@@ -6555,7 +6555,7 @@ var require_minimist = __commonJS((exports, module) => {
 // node_modules/rc/index.js
 var require_rc = __commonJS((exports, module) => {
   var cc = require_utils();
-  var join8 = __require("path").join;
+  var join9 = __require("path").join;
   var deepExtend = require_deep_extend();
   var etc = "/etc";
   var win = process.platform === "win32";
@@ -6581,15 +6581,15 @@ var require_rc = __commonJS((exports, module) => {
     }
     if (!win)
       [
-        join8(etc, name, "config"),
-        join8(etc, name + "rc")
+        join9(etc, name, "config"),
+        join9(etc, name + "rc")
       ].forEach(addConfigFile);
     if (home)
       [
-        join8(home, ".config", name, "config"),
-        join8(home, ".config", name),
-        join8(home, "." + name, "config"),
-        join8(home, "." + name + "rc")
+        join9(home, ".config", name, "config"),
+        join9(home, ".config", name),
+        join9(home, "." + name, "config"),
+        join9(home, "." + name + "rc")
       ].forEach(addConfigFile);
     addConfigFile(cc.find("." + name + "rc"));
     if (env3.config)
@@ -10982,7 +10982,7 @@ async function quickQuery(options) {
   if (systemPrompt) {
     args.push("--system-prompt", systemPrompt);
   }
-  log18.debug(`Quick query: model=${model}, timeout=${timeout2}ms, prompt="${prompt.substring(0, 50)}..."`);
+  log19.debug(`Quick query: model=${model}, timeout=${timeout2}ms, prompt="${prompt.substring(0, 50)}..."`);
   return new Promise((resolve6) => {
     let stdout = "";
     let stderr = "";
@@ -10996,7 +10996,7 @@ async function quickQuery(options) {
       if (!resolved) {
         resolved = true;
         proc.kill("SIGTERM");
-        log18.debug(`Quick query timed out after ${timeout2}ms`);
+        log19.debug(`Quick query timed out after ${timeout2}ms`);
         resolve6({
           success: false,
           error: "timeout",
@@ -11014,7 +11014,7 @@ async function quickQuery(options) {
       if (!resolved) {
         resolved = true;
         clearTimeout(timeoutId);
-        log18.debug(`Quick query error: ${err.message}`);
+        log19.debug(`Quick query error: ${err.message}`);
         resolve6({
           success: false,
           error: err.message,
@@ -11028,14 +11028,14 @@ async function quickQuery(options) {
         clearTimeout(timeoutId);
         const durationMs = Date.now() - startTime;
         if (code === 0 && stdout.trim()) {
-          log18.debug(`Quick query success: ${durationMs}ms, ${stdout.length} chars`);
+          log19.debug(`Quick query success: ${durationMs}ms, ${stdout.length} chars`);
           resolve6({
             success: true,
             response: stdout.trim(),
             durationMs
           });
         } else {
-          log18.debug(`Quick query failed: code=${code}, stderr=${stderr.substring(0, 100)}`);
+          log19.debug(`Quick query failed: code=${code}, stderr=${stderr.substring(0, 100)}`);
           resolve6({
             success: false,
             error: stderr || `exit code ${code}`,
@@ -11045,17 +11045,17 @@ async function quickQuery(options) {
       }
     });
     proc.stdin?.on("error", (err) => {
-      log18.debug(`quickQuery: stdin write failed (${err.code ?? err.message})`);
+      log19.debug(`quickQuery: stdin write failed (${err.code ?? err.message})`);
     });
     proc.stdin?.end(prompt);
   });
 }
-var log18;
+var log19;
 var init_quick_query = __esm(() => {
   init_spawn();
   init_version_check();
   init_logger();
-  log18 = createLogger("query");
+  log19 = createLogger("query");
 });
 
 // node_modules/kleur/index.js
@@ -52332,9 +52332,13 @@ function buildClaudeChildEnv(parentEnv, account, opts) {
     env.USERPROFILE = account.home;
     delete env.ANTHROPIC_API_KEY;
     delete env.CLAUDE_CODE_OAUTH_TOKEN;
+    delete env.ANTHROPIC_AUTH_TOKEN;
+    delete env.CLAUDE_CONFIG_DIR;
+    delete env.CLAUDE_SECURESTORAGE_CONFIG_DIR;
   } else if (account?.apiKey) {
     env.ANTHROPIC_API_KEY = account.apiKey;
     delete env.CLAUDE_CODE_OAUTH_TOKEN;
+    delete env.ANTHROPIC_AUTH_TOKEN;
   }
   return env;
 }
@@ -52835,13 +52839,349 @@ class ClaudeCli extends EventEmitter {
   }
 }
 
-// src/persistence/thread-logger.ts
+// src/persistence/session-store.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3 } from "fs";
+
+// src/persistence/atomic-file.ts
+import { chmodSync as chmodSync3, renameSync, writeFileSync as writeFileSync3 } from "fs";
+
+class SerialQueue {
+  tail = Promise.resolve();
+  run(fn) {
+    const next = this.tail.then(fn, fn);
+    this.tail = next.catch(() => {
+      return;
+    });
+    return next;
+  }
+}
+function writeFileAtomic(file, content) {
+  const tempFile = `${file}.tmp`;
+  writeFileSync3(tempFile, content, { encoding: "utf-8", mode: 384 });
+  renameSync(tempFile, file);
+  chmodSync3(file, 384);
+}
+
+// src/persistence/session-store.ts
 init_logger();
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, appendFileSync, readdirSync as readdirSync2, statSync as statSync2, unlinkSync as unlinkSync2, rmdirSync, readFileSync as readFileSync3, chmodSync as chmodSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join5, dirname as dirname3 } from "path";
-var log4 = createLogger("thread-log");
-var LOGS_BASE_DIR = join5(homedir3(), ".claude-threads", "logs");
+import { join as join5 } from "path";
+
+// src/sponsor.ts
+var SPONSOR_URL = "https://github.com/sponsors/axolotl-systems";
+var SESSION_MILESTONES = [100, 250, 500, 1000, 2500, 5000, 1e4];
+var MILESTONE_VISIBLE_MS = 24 * 60 * 60 * 1000;
+function milestoneReached(totalSessions) {
+  return SESSION_MILESTONES.includes(totalSessions) ? totalSessions : null;
+}
+function milestoneStillFresh(reachedAtIso, nowMs) {
+  const reachedAt = Date.parse(reachedAtIso);
+  if (Number.isNaN(reachedAt))
+    return false;
+  const age = nowMs - reachedAt;
+  return age >= 0 && age < MILESTONE_VISIBLE_MS;
+}
+function formatSponsorFooter(formatter) {
+  return formatter.formatItalic(`♥ Support claude-threads: ${formatter.formatLink("github.com/sponsors/axolotl-systems", SPONSOR_URL)}`);
+}
+function formatMilestoneLine(formatter, milestone) {
+  return `\uD83C\uDF89 ${formatter.formatBold(`Session #${milestone}`)} on this instance — claude-threads is free & open source ${formatter.formatLink("♥ sponsor", SPONSOR_URL)}`;
+}
+
+// src/persistence/session-store.ts
+var log4 = createLogger("persist");
+function resolveEndReason(session) {
+  if (!session.cleanedAt)
+    return;
+  return session.endReason ?? "stopped";
+}
+function isRevivable(session) {
+  return resolveEndReason(session) !== "stopped";
+}
+var STORE_VERSION = 2;
+var DEFAULT_CONFIG_DIR = join5(homedir3(), ".config", "claude-threads");
+var DEFAULT_SESSIONS_FILE = join5(DEFAULT_CONFIG_DIR, "sessions.json");
+
+class SessionStore {
+  sessionsFile;
+  configDir;
+  constructor(sessionsPath) {
+    const envPath = process.env.CLAUDE_THREADS_SESSIONS_PATH;
+    const effectivePath = sessionsPath ?? envPath;
+    if (effectivePath) {
+      this.sessionsFile = effectivePath;
+      this.configDir = join5(effectivePath, "..");
+    } else {
+      this.sessionsFile = DEFAULT_SESSIONS_FILE;
+      this.configDir = DEFAULT_CONFIG_DIR;
+    }
+    if (!existsSync4(this.configDir)) {
+      mkdirSync3(this.configDir, { recursive: true });
+    }
+  }
+  load() {
+    const sessions = new Map;
+    if (!existsSync4(this.sessionsFile)) {
+      log4.debug("No sessions file found");
+      return sessions;
+    }
+    try {
+      const data = this.loadRaw();
+      if (data.version === 1) {
+        log4.info("Migrating sessions from v1 to v2 (adding platformId)");
+        const newSessions = {};
+        for (const [_oldKey, session] of Object.entries(data.sessions)) {
+          const v1Session = session;
+          if (!v1Session.platformId) {
+            v1Session.platformId = "default";
+          }
+          const newKey = `${v1Session.platformId}:${v1Session.threadId}`;
+          newSessions[newKey] = v1Session;
+        }
+        data.sessions = newSessions;
+        data.version = 2;
+        this.writeAtomic(data);
+      } else if (data.version !== STORE_VERSION) {
+        log4.warn(`Sessions file version ${data.version} not supported, starting fresh`);
+        return sessions;
+      }
+      for (const session of Object.values(data.sessions)) {
+        if (session.cleanedAt)
+          continue;
+        const sessionId = `${session.platformId}:${session.threadId}`;
+        sessions.set(sessionId, session);
+      }
+      log4.debug(`Loaded ${sessions.size} active session(s)`);
+    } catch (err) {
+      log4.error(`Failed to load sessions: ${err}`);
+    }
+    return sessions;
+  }
+  save(sessionId, session) {
+    const data = this.loadRaw();
+    data.sessions[sessionId] = session;
+    this.writeAtomic(data);
+    const shortId = sessionId.substring(0, 20);
+    log4.debug(`Saved session ${shortId}...`);
+  }
+  remove(sessionId) {
+    const data = this.loadRaw();
+    if (data.sessions[sessionId]) {
+      delete data.sessions[sessionId];
+      this.writeAtomic(data);
+      const shortId = sessionId.substring(0, 20);
+      log4.debug(`Removed session ${shortId}...`);
+    }
+  }
+  softDelete(sessionId, reason) {
+    const data = this.loadRaw();
+    if (data.sessions[sessionId]) {
+      data.sessions[sessionId].cleanedAt = new Date().toISOString();
+      data.sessions[sessionId].endReason = reason;
+      this.writeAtomic(data);
+      const shortId = sessionId.substring(0, 20);
+      log4.debug(`Soft-deleted session ${shortId}...`);
+    }
+  }
+  cleanStale(maxAgeMs) {
+    const data = this.loadRaw();
+    const now = Date.now();
+    const staleIds = [];
+    for (const [sessionId, session] of Object.entries(data.sessions)) {
+      if (session.cleanedAt)
+        continue;
+      if (session.threadId.startsWith("dcm:"))
+        continue;
+      const lastActivity = new Date(session.lastActivityAt).getTime();
+      if (now - lastActivity > maxAgeMs) {
+        staleIds.push(sessionId);
+        session.cleanedAt = new Date().toISOString();
+        session.endReason = "stale";
+      }
+    }
+    if (staleIds.length > 0) {
+      this.writeAtomic(data);
+      log4.debug(`Soft-deleted ${staleIds.length} stale session(s)`);
+    }
+    return staleIds;
+  }
+  cleanHistory(historyRetentionMs = 3 * 24 * 60 * 60 * 1000) {
+    const data = this.loadRaw();
+    const now = Date.now();
+    let removedCount = 0;
+    for (const [sessionId, session] of Object.entries(data.sessions)) {
+      if (!session.cleanedAt)
+        continue;
+      const cleanedTime = new Date(session.cleanedAt).getTime();
+      if (now - cleanedTime > historyRetentionMs) {
+        delete data.sessions[sessionId];
+        removedCount++;
+      }
+    }
+    if (removedCount > 0) {
+      this.writeAtomic(data);
+      log4.debug(`Permanently removed ${removedCount} old session(s) from history`);
+    }
+    return removedCount;
+  }
+  getHistory(platformId, activeSessions) {
+    const data = this.loadRaw();
+    const historySessions = [];
+    for (const [sessionId, session] of Object.entries(data.sessions)) {
+      if (session.platformId !== platformId)
+        continue;
+      if (session.cleanedAt) {
+        historySessions.push(session);
+        continue;
+      }
+      if (session.lifecyclePostId && activeSessions && !activeSessions.has(sessionId)) {
+        historySessions.push(session);
+      }
+    }
+    return historySessions.sort((a, b) => {
+      const aTime = new Date(a.cleanedAt || a.lastActivityAt).getTime();
+      const bTime = new Date(b.cleanedAt || b.lastActivityAt).getTime();
+      return bTime - aTime;
+    });
+  }
+  clear() {
+    const data = this.loadRaw();
+    this.writeAtomic({ version: STORE_VERSION, sessions: {}, stickyPostIds: data.stickyPostIds });
+    log4.debug("Cleared all sessions");
+  }
+  saveStickyPostId(platformId, postId) {
+    const data = this.loadRaw();
+    if (!data.stickyPostIds) {
+      data.stickyPostIds = {};
+    }
+    data.stickyPostIds[platformId] = postId;
+    this.writeAtomic(data);
+    log4.debug(`Saved sticky post ID for ${platformId}: ${postId.substring(0, 8)}...`);
+  }
+  getStickyPostIds() {
+    const data = this.loadRaw();
+    return new Map(Object.entries(data.stickyPostIds || {}));
+  }
+  removeStickyPostId(platformId) {
+    const data = this.loadRaw();
+    if (data.stickyPostIds && data.stickyPostIds[platformId]) {
+      delete data.stickyPostIds[platformId];
+      this.writeAtomic(data);
+      log4.debug(`Removed sticky post ID for ${platformId}`);
+    }
+  }
+  getPlatformEnabledState() {
+    const data = this.loadRaw();
+    return new Map(Object.entries(data.platformEnabledState || {}));
+  }
+  isPlatformEnabled(platformId) {
+    const data = this.loadRaw();
+    return data.platformEnabledState?.[platformId] ?? true;
+  }
+  setPlatformEnabled(platformId, enabled) {
+    const data = this.loadRaw();
+    if (!data.platformEnabledState) {
+      data.platformEnabledState = {};
+    }
+    data.platformEnabledState[platformId] = enabled;
+    this.writeAtomic(data);
+    log4.debug(`Set platform ${platformId} enabled state to ${enabled}`);
+  }
+  findByThread(platformId, threadId) {
+    const sessionId = `${platformId}:${threadId}`;
+    const data = this.loadRaw();
+    return data.sessions[sessionId];
+  }
+  findByThreadIdAnyState(threadId, platformId) {
+    const data = this.loadRaw();
+    for (const session of Object.values(data.sessions)) {
+      if (session.threadId !== threadId)
+        continue;
+      if (platformId !== undefined && session.platformId !== platformId)
+        continue;
+      return session;
+    }
+    return;
+  }
+  findByPostId(platformId, postId) {
+    const data = this.loadRaw();
+    for (const session of Object.values(data.sessions)) {
+      if (session.platformId !== platformId)
+        continue;
+      if (session.lifecyclePostId === postId || session.sessionStartPostId === postId) {
+        return session;
+      }
+    }
+    return;
+  }
+  getStats() {
+    const data = this.loadRaw();
+    return data.stats ?? { totalSessionsStarted: 0 };
+  }
+  recordSessionStarted() {
+    const data = this.loadRaw();
+    const stats = data.stats ?? { totalSessionsStarted: 0 };
+    stats.totalSessionsStarted = (stats.totalSessionsStarted ?? 0) + 1;
+    const milestone = milestoneReached(stats.totalSessionsStarted);
+    if (milestone) {
+      stats.milestone = { n: milestone, reachedAt: new Date().toISOString() };
+    }
+    data.stats = stats;
+    this.writeAtomic(data);
+    return stats.totalSessionsStarted;
+  }
+  lastReadDegraded = false;
+  loadRaw() {
+    if (!existsSync4(this.sessionsFile)) {
+      this.lastReadDegraded = false;
+      return { version: STORE_VERSION, sessions: {} };
+    }
+    try {
+      const raw = readFileSync3(this.sessionsFile, "utf-8");
+      if (raw.trim() === "") {
+        this.lastReadDegraded = false;
+        return { version: STORE_VERSION, sessions: {} };
+      }
+      const data = JSON.parse(raw);
+      if (!data || typeof data !== "object") {
+        this.lastReadDegraded = true;
+        return { version: STORE_VERSION, sessions: {} };
+      }
+      if (data.sessions === undefined || data.sessions === null) {
+        this.lastReadDegraded = false;
+        data.sessions = {};
+      } else if (typeof data.sessions !== "object") {
+        this.lastReadDegraded = true;
+        data.sessions = {};
+      } else {
+        this.lastReadDegraded = false;
+      }
+      if (!data.version) {
+        data.version = STORE_VERSION;
+      }
+      return data;
+    } catch (err) {
+      log4.warn(`Failed to read ${this.sessionsFile}: ${err.message} — reads degrade to empty`);
+      this.lastReadDegraded = true;
+      return { version: STORE_VERSION, sessions: {} };
+    }
+  }
+  writeAtomic(data) {
+    if (this.lastReadDegraded) {
+      log4.error(`Refusing to write ${this.sessionsFile}: the last read of the existing file was degraded — writing would destroy persisted sessions`);
+      return;
+    }
+    writeFileAtomic(this.sessionsFile, JSON.stringify(data, null, 2));
+  }
+}
+
+// src/persistence/thread-logger.ts
+init_logger();
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, appendFileSync, readdirSync as readdirSync2, statSync as statSync2, unlinkSync as unlinkSync2, rmdirSync, readFileSync as readFileSync4, chmodSync as chmodSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join6, dirname as dirname3 } from "path";
+var log5 = createLogger("thread-log");
+var LOGS_BASE_DIR = join6(homedir4(), ".claude-threads", "logs");
 
 class ThreadLoggerImpl {
   platformId;
@@ -52861,16 +53201,16 @@ class ThreadLoggerImpl {
     this.enabled = options?.enabled ?? true;
     this.bufferSize = options?.bufferSize ?? 10;
     this.flushIntervalMs = options?.flushIntervalMs ?? 1000;
-    this.logPath = join5(LOGS_BASE_DIR, platformId, `${claudeSessionId}.jsonl`);
+    this.logPath = join6(LOGS_BASE_DIR, platformId, `${claudeSessionId}.jsonl`);
     if (this.enabled) {
       const dir = dirname3(this.logPath);
-      if (!existsSync4(dir)) {
-        mkdirSync3(dir, { recursive: true });
+      if (!existsSync5(dir)) {
+        mkdirSync4(dir, { recursive: true });
       }
       this.flushTimer = setInterval(() => {
         this.flushSync();
       }, this.flushIntervalMs);
-      log4.debug(`Thread logger initialized: ${this.logPath}`);
+      log5.debug(`Thread logger initialized: ${this.logPath}`);
     }
   }
   isEnabled() {
@@ -52984,7 +53324,7 @@ class ThreadLoggerImpl {
       this.flushTimer = null;
     }
     this.flushSync();
-    log4.debug(`Thread logger closed: ${this.logPath}`);
+    log5.debug(`Thread logger closed: ${this.logPath}`);
   }
   addEntry(entry) {
     this.buffer.push(entry);
@@ -52999,14 +53339,14 @@ class ThreadLoggerImpl {
       const lines = this.buffer.map((entry) => JSON.stringify(entry)).join(`
 `) + `
 `;
-      const isNewFile = !existsSync4(this.logPath);
+      const isNewFile = !existsSync5(this.logPath);
       appendFileSync(this.logPath, lines, { encoding: "utf8", mode: 384 });
       if (isNewFile) {
-        chmodSync3(this.logPath, 384);
+        chmodSync4(this.logPath, 384);
       }
       this.buffer = [];
     } catch (err) {
-      log4.error(`Failed to flush thread log: ${err}`);
+      log5.error(`Failed to flush thread log: ${err}`);
     }
   }
 }
@@ -53037,13 +53377,13 @@ function createThreadLogger(platformId, threadId, claudeSessionId, options) {
 function cleanupOldLogs(retentionDays = 30) {
   const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
   let deletedCount = 0;
-  if (!existsSync4(LOGS_BASE_DIR)) {
+  if (!existsSync5(LOGS_BASE_DIR)) {
     return 0;
   }
   try {
     const platformDirs = readdirSync2(LOGS_BASE_DIR);
     for (const platformId of platformDirs) {
-      const platformDir = join5(LOGS_BASE_DIR, platformId);
+      const platformDir = join6(LOGS_BASE_DIR, platformId);
       const stat = statSync2(platformDir);
       if (!stat.isDirectory())
         continue;
@@ -53051,49 +53391,49 @@ function cleanupOldLogs(retentionDays = 30) {
       for (const file of logFiles) {
         if (!file.endsWith(".jsonl"))
           continue;
-        const filePath = join5(platformDir, file);
+        const filePath = join6(platformDir, file);
         try {
           const fileStat = statSync2(filePath);
           if (fileStat.mtimeMs < cutoffMs) {
             unlinkSync2(filePath);
             deletedCount++;
-            log4.debug(`Deleted old log file: ${filePath}`);
+            log5.debug(`Deleted old log file: ${filePath}`);
           }
         } catch (err) {
-          log4.warn(`Failed to check/delete log file ${filePath}: ${err}`);
+          log5.warn(`Failed to check/delete log file ${filePath}: ${err}`);
         }
       }
       try {
         const remaining = readdirSync2(platformDir);
         if (remaining.length === 0) {
           rmdirSync(platformDir);
-          log4.debug(`Removed empty platform log directory: ${platformDir}`);
+          log5.debug(`Removed empty platform log directory: ${platformDir}`);
         }
       } catch {}
     }
     if (deletedCount > 0) {
-      log4.info(`Cleaned up ${deletedCount} old log file(s)`);
+      log5.info(`Cleaned up ${deletedCount} old log file(s)`);
     }
   } catch (err) {
-    log4.error(`Failed to clean up old logs: ${err}`);
+    log5.error(`Failed to clean up old logs: ${err}`);
   }
   return deletedCount;
 }
 function getLogFilePath(platformId, sessionId) {
-  return join5(LOGS_BASE_DIR, platformId, `${sessionId}.jsonl`);
+  return join6(LOGS_BASE_DIR, platformId, `${sessionId}.jsonl`);
 }
 function readRecentLogEntries(platformId, sessionId, maxLines = 50) {
   const logPath = getLogFilePath(platformId, sessionId);
-  log4.debug(`Reading log entries from: ${logPath}`);
-  if (!existsSync4(logPath)) {
-    log4.debug(`Log file does not exist: ${logPath}`);
+  log5.debug(`Reading log entries from: ${logPath}`);
+  if (!existsSync5(logPath)) {
+    log5.debug(`Log file does not exist: ${logPath}`);
     return [];
   }
   try {
-    const content = readFileSync3(logPath, "utf8");
+    const content = readFileSync4(logPath, "utf8");
     const lines = content.trim().split(`
 `);
-    log4.debug(`Log file has ${lines.length} lines`);
+    log5.debug(`Log file has ${lines.length} lines`);
     const recentLines = lines.slice(-maxLines);
     const entries = [];
     for (const line of recentLines) {
@@ -53103,16 +53443,16 @@ function readRecentLogEntries(platformId, sessionId, maxLines = 50) {
         entries.push(JSON.parse(line));
       } catch {}
     }
-    log4.debug(`Parsed ${entries.length} log entries`);
+    log5.debug(`Parsed ${entries.length} log entries`);
     return entries;
   } catch (err) {
-    log4.error(`Failed to read log file: ${err}`);
+    log5.error(`Failed to read log file: ${err}`);
     return [];
   }
 }
 
 // src/version.ts
-import { readFileSync as readFileSync4, existsSync as existsSync5 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync6 } from "fs";
 import { dirname as dirname4, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __dirname2 = dirname4(fileURLToPath2(import.meta.url));
@@ -53123,9 +53463,9 @@ function loadPackageJson() {
     resolve3(process.cwd(), "package.json")
   ];
   for (const candidate of candidates) {
-    if (existsSync5(candidate)) {
+    if (existsSync6(candidate)) {
       try {
-        const pkg = JSON.parse(readFileSync4(candidate, "utf-8"));
+        const pkg = JSON.parse(readFileSync5(candidate, "utf-8"));
         if (pkg.name === "claude-threads") {
           return { version: pkg.version, name: pkg.name };
         }
@@ -53536,27 +53876,6 @@ function parseCommandWithRemainder(text) {
   }
   return null;
 }
-// src/sponsor.ts
-var SPONSOR_URL = "https://github.com/sponsors/axolotl-systems";
-var SESSION_MILESTONES = [100, 250, 500, 1000, 2500, 5000, 1e4];
-var MILESTONE_VISIBLE_MS = 24 * 60 * 60 * 1000;
-function milestoneReached(totalSessions) {
-  return SESSION_MILESTONES.includes(totalSessions) ? totalSessions : null;
-}
-function milestoneStillFresh(reachedAtIso, nowMs) {
-  const reachedAt = Date.parse(reachedAtIso);
-  if (Number.isNaN(reachedAt))
-    return false;
-  const age = nowMs - reachedAt;
-  return age >= 0 && age < MILESTONE_VISIBLE_MS;
-}
-function formatSponsorFooter(formatter) {
-  return formatter.formatItalic(`♥ Support claude-threads: ${formatter.formatLink("github.com/sponsors/axolotl-systems", SPONSOR_URL)}`);
-}
-function formatMilestoneLine(formatter, milestone) {
-  return `\uD83C\uDF89 ${formatter.formatBold(`Session #${milestone}`)} on this instance — claude-threads is free & open source ${formatter.formatLink("♥ sponsor", SPONSOR_URL)}`;
-}
-
 // src/commands/help-generator.ts
 function formatCommandRows(cmd, code) {
   const rows = [];
@@ -53594,7 +53913,7 @@ ${formatter.formatBold("Reactions:")}
 }
 
 // src/changelog.ts
-import { readFileSync as readFileSync5, existsSync as existsSync6 } from "fs";
+import { readFileSync as readFileSync6, existsSync as existsSync7 } from "fs";
 import { dirname as dirname5, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var __dirname3 = dirname5(fileURLToPath3(import.meta.url));
@@ -53605,7 +53924,7 @@ function getReleaseNotes(version) {
   ];
   let changelogPath = null;
   for (const p of possiblePaths) {
-    if (existsSync6(p)) {
+    if (existsSync7(p)) {
       changelogPath = p;
       break;
     }
@@ -53614,7 +53933,7 @@ function getReleaseNotes(version) {
     return null;
   }
   try {
-    const content = readFileSync5(changelogPath, "utf-8");
+    const content = readFileSync6(changelogPath, "utf-8");
     return parseChangelog(content, version);
   } catch {
     return null;
@@ -54122,7 +54441,7 @@ async function handleDynamicSlashCommand(command, args, ctx) {
 }
 // src/commands/system-prompt-generator.ts
 init_logger();
-var log5 = createLogger("system-prompt");
+var log6 = createLogger("system-prompt");
 function formatUserCommand(cmd) {
   const cmdStr = cmd.args ? `\`!${cmd.command} ${cmd.args}\`` : `\`!${cmd.command}\``;
   const description = cmd.description;
@@ -54161,7 +54480,7 @@ async function resolveCollaborators(platform, platformId, ownerUsername, allowed
       continue;
     const email = githubEmailsStore.get(platformId, username);
     if (!email) {
-      log5.debug(`Collaborator @${username} has no registered GitHub noreply email — skipping`);
+      log6.debug(`Collaborator @${username} has no registered GitHub noreply email — skipping`);
       continue;
     }
     let name = username;
@@ -54170,7 +54489,7 @@ async function resolveCollaborators(platform, platformId, ownerUsername, allowed
       if (user)
         name = user.displayName || user.username;
     } catch (err) {
-      log5.debug(`Display name lookup failed for @${username}: ${err.message}`);
+      log6.debug(`Display name lookup failed for @${username}: ${err.message}`);
     }
     resolved.push({ username, name, email });
   }
@@ -54300,12 +54619,12 @@ ${avoidCommands.map((c) => `- \`!${c.command}\` - ${c.reason}`).join(`
 }
 // src/session/lifecycle.ts
 import { randomUUID as randomUUID7 } from "crypto";
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 
 // src/utils/keep-alive.ts
 init_logger();
 import { spawn } from "child_process";
-var log6 = createLogger("keepalive");
+var log7 = createLogger("keepalive");
 function keepAliveSpawnSpec(platform, parentPid) {
   switch (platform) {
     case "darwin":
@@ -54361,7 +54680,7 @@ class KeepAliveManager {
     if (!enabled && this.keepAliveProcess) {
       this.stopKeepAlive();
     }
-    log6.debug(`Keep-alive ${enabled ? "enabled" : "disabled"}`);
+    log7.debug(`Keep-alive ${enabled ? "enabled" : "disabled"}`);
   }
   isEnabled() {
     return this.enabled;
@@ -54371,7 +54690,7 @@ class KeepAliveManager {
   }
   sessionStarted() {
     this.activeSessionCount++;
-    log6.debug(`Session started (${this.activeSessionCount} active)`);
+    log7.debug(`Session started (${this.activeSessionCount} active)`);
     if (this.activeSessionCount === 1) {
       this.startKeepAlive();
     }
@@ -54380,7 +54699,7 @@ class KeepAliveManager {
     if (this.activeSessionCount > 0) {
       this.activeSessionCount--;
     }
-    log6.debug(`Session ended (${this.activeSessionCount} active)`);
+    log7.debug(`Session ended (${this.activeSessionCount} active)`);
     if (this.activeSessionCount === 0) {
       this.stopKeepAlive();
     }
@@ -54394,11 +54713,11 @@ class KeepAliveManager {
   }
   startKeepAlive() {
     if (!this.enabled) {
-      log6.debug("Keep-alive disabled, skipping");
+      log7.debug("Keep-alive disabled, skipping");
       return;
     }
     if (this.keepAliveProcess) {
-      log6.debug("Keep-alive already running");
+      log7.debug("Keep-alive already running");
       return;
     }
     switch (this.platform) {
@@ -54412,12 +54731,12 @@ class KeepAliveManager {
         this.startWindowsKeepAlive();
         break;
       default:
-        log6.warn(`Keep-alive not supported on ${this.platform}`);
+        log7.warn(`Keep-alive not supported on ${this.platform}`);
     }
   }
   stopKeepAlive() {
     if (this.keepAliveProcess) {
-      log6.debug("Stopping keep-alive");
+      log7.debug("Stopping keep-alive");
       this.keepAliveProcess.kill();
       this.keepAliveProcess = null;
     }
@@ -54432,18 +54751,18 @@ class KeepAliveManager {
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log6.error(`Failed to start caffeinate: ${err.message}`);
+        log7.error(`Failed to start caffeinate: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", (code) => {
         if (code !== null && code !== 0 && this.activeSessionCount > 0) {
-          log6.debug(`caffeinate exited with code ${code}`);
+          log7.debug(`caffeinate exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log6.info("Sleep prevention active (caffeinate)");
+      log7.info("Sleep prevention active (caffeinate)");
     } catch (err) {
-      log6.error(`Failed to start caffeinate: ${err}`);
+      log7.error(`Failed to start caffeinate: ${err}`);
     }
   }
   startLinuxKeepAlive() {
@@ -54456,19 +54775,19 @@ class KeepAliveManager {
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log6.debug(`systemd-inhibit not available: ${err.message}`);
+        log7.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) {
-          log6.debug(`systemd-inhibit exited with code ${code}`);
+          log7.debug(`systemd-inhibit exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log6.info("Sleep prevention active (systemd-inhibit)");
+      log7.info("Sleep prevention active (systemd-inhibit)");
     } catch (err) {
-      log6.debug(`Failed to start systemd-inhibit: ${err}`);
+      log7.debug(`Failed to start systemd-inhibit: ${err}`);
       this.startLinuxKeepAliveFallback();
     }
   }
@@ -54479,15 +54798,15 @@ class KeepAliveManager {
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log6.warn(`Linux keep-alive fallback not available: ${err.message}`);
+        log7.warn(`Linux keep-alive fallback not available: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", () => {
         this.keepAliveProcess = null;
       });
-      log6.info("Sleep prevention active (xdg-screensaver)");
+      log7.info("Sleep prevention active (xdg-screensaver)");
     } catch (err) {
-      log6.warn(`Linux keep-alive not available: ${err}`);
+      log7.warn(`Linux keep-alive not available: ${err}`);
     }
   }
   startWindowsKeepAlive() {
@@ -54499,18 +54818,18 @@ class KeepAliveManager {
         windowsHide: true
       });
       this.keepAliveProcess.on("error", (err) => {
-        log6.warn(`Windows keep-alive not available: ${err.message}`);
+        log7.warn(`Windows keep-alive not available: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", (code) => {
         if (code !== null && code !== 0 && this.activeSessionCount > 0) {
-          log6.debug(`PowerShell keep-alive exited with code ${code}`);
+          log7.debug(`PowerShell keep-alive exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log6.info("Sleep prevention active (SetThreadExecutionState)");
+      log7.info("Sleep prevention active (SetThreadExecutionState)");
     } catch (err) {
-      log6.warn(`Windows keep-alive not available: ${err}`);
+      log7.warn(`Windows keep-alive not available: ${err}`);
     }
   }
 }
@@ -54585,7 +54904,7 @@ function singleLine(text) {
 }
 
 // src/utils/error-handler/index.ts
-var log7 = createLogger("error");
+var log8 = createLogger("error");
 
 class SessionError extends Error {
   sessionId;
@@ -54611,19 +54930,19 @@ async function handleError(error, context, severity = "recoverable") {
   const sessionPart = sessionId ? ` (${formatShortId(sessionId)})` : "";
   const logMessage = `${context.action}${sessionPart}: ${message}`;
   if (severity === "recoverable") {
-    log7.warn(logMessage);
+    log8.warn(logMessage);
   } else {
-    log7.error(logMessage, error instanceof Error ? error : undefined);
+    log8.error(logMessage, error instanceof Error ? error : undefined);
   }
   if (context.details) {
-    log7.debugJson("Error details", context.details);
+    log8.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) {
-      log7.warn(`Could not notify user: ${notifyError}`);
+      log8.warn(`Could not notify user: ${notifyError}`);
     }
   }
   if (severity === "session-fatal" || severity === "system-fatal") {
@@ -54650,7 +54969,7 @@ async function logAndNotify(error, context) {
 }
 function logSilentError(context, error) {
   const message = error instanceof Error ? error.message : String(error);
-  log7.debug(`[${context}] Silently caught: ${message}`);
+  log8.debug(`[${context}] Silently caught: ${message}`);
 }
 
 // src/session/lifecycle.ts
@@ -54670,8 +54989,8 @@ function createSessionLog(baseLog) {
 init_logger();
 init_emoji();
 init_worktree();
-var log9 = createLogger("helpers");
-var sessionLog = createSessionLog(log9);
+var log10 = createLogger("helpers");
+var sessionLog = createSessionLog(log10);
 var POST_TYPES = {
   info: "",
   success: "✅",
@@ -54759,7 +55078,7 @@ function updateLastMessage(session, post2) {
 init_logger();
 import { lstat, mkdir as mkdir2, mkdtemp, rm as rm2, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 
 // src/utils/safe-filename.ts
 import { basename as basename2 } from "path";
@@ -54800,13 +55119,13 @@ function formatBytes(bytes) {
 }
 
 // src/operations/streaming/handler.ts
-var log10 = createLogger("streaming");
+var log11 = createLogger("streaming");
 var UPLOAD_ROOT_DIR = "claude-threads-uploads";
 function safeIdSegment(id) {
   return id.replace(/[^A-Za-z0-9._-]/g, "_");
 }
 function getSessionUploadDir(platformId, threadId) {
-  return join7(tmpdir3(), UPLOAD_ROOT_DIR, `${safeIdSegment(platformId)}-${safeIdSegment(threadId)}`);
+  return join8(tmpdir3(), UPLOAD_ROOT_DIR, `${safeIdSegment(platformId)}-${safeIdSegment(threadId)}`);
 }
 async function cleanupSessionUploads(platformId, threadId) {
   if (!platformId || !threadId)
@@ -54815,7 +55134,7 @@ async function cleanupSessionUploads(platformId, threadId) {
   try {
     await rm2(dir, { recursive: true, force: true });
   } catch (err) {
-    log10.debug(`Upload cleanup for ${platformId}:${threadId} failed (ignored): ${err}`);
+    log11.debug(`Upload cleanup for ${platformId}:${threadId} failed (ignored): ${err}`);
   }
 }
 function sanitizeForPrompt(value) {
@@ -54836,16 +55155,16 @@ 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" });
     }
-    log10.error(`Upload dir is a symlink, refusing all writes: ${uploadDir}`);
+    log11.error(`Upload dir is a symlink, refusing all writes: ${uploadDir}`);
     return { saved, skipped };
   }
-  const messageDir = await mkdtemp(join7(uploadDir, `${Date.now().toString(36)}-`));
+  const messageDir = await mkdtemp(join8(uploadDir, `${Date.now().toString(36)}-`));
   const usedNames = new Set;
   for (const file of files) {
     try {
       const buffer = await platform.downloadFile(file.id);
       const safeName = dedupeFilename(sanitizeFilename(file.name), usedNames);
-      const absolutePath = join7(messageDir, safeName);
+      const absolutePath = join8(messageDir, safeName);
       await writeFile2(absolutePath, buffer, { mode: 384, flag: "wx" });
       saved.push({
         originalName: file.name,
@@ -54854,11 +55173,11 @@ async function saveFilesToUploadDir(platform, uploadDir, files, debug = false) {
         size: buffer.length
       });
       if (debug) {
-        log10.debug(`Saved ${file.name} → ${absolutePath} (${formatBytes(buffer.length)})`);
+        log11.debug(`Saved ${file.name} → ${absolutePath} (${formatBytes(buffer.length)})`);
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      log10.error(`Failed to save uploaded file ${file.name}: ${message}`);
+      log11.error(`Failed to save uploaded file ${file.name}: ${message}`);
       skipped.push({
         name: file.name,
         reason: `Download failed: ${message}`
@@ -54954,7 +55273,7 @@ function buildRestartCliOptions(session, ctx) {
 // src/operations/commands/handler.ts
 import { randomUUID as randomUUID6 } from "crypto";
 import { resolve as resolve6 } from "path";
-import { existsSync as existsSync10, statSync as statSync4 } from "fs";
+import { existsSync as existsSync11, statSync as statSync4 } from "fs";
 
 // node_modules/update-notifier/update-notifier.js
 import process10 from "node:process";
@@ -55299,9 +55618,9 @@ node_default(Temp.purgeSyncAll);
 var temp_default = Temp;
 
 // node_modules/atomically/dist/index.js
-function writeFileSync3(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
+function writeFileSync4(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
   if (isString(options))
-    return writeFileSync3(filePath, data, { encoding: options });
+    return writeFileSync4(filePath, data, { encoding: options });
   const timeout = options.timeout ?? DEFAULT_TIMEOUT_SYNC;
   const retryOptions = { timeout };
   let tempDisposer = null;
@@ -55629,7 +55948,7 @@ class Configstore {
       }
       if (error.name === "SyntaxError") {
         if (this._clearInvalidConfig) {
-          writeFileSync3(this._path, "", writeFileOptions);
+          writeFileSync4(this._path, "", writeFileOptions);
           return {};
         }
         throw error;
@@ -55641,7 +55960,7 @@ class Configstore {
   set all(value) {
     try {
       import_graceful_fs.default.mkdirSync(path5.dirname(this._path), mkdirOptions);
-      writeFileSync3(this._path, JSON.stringify(value, undefined, "\t"), writeFileOptions);
+      writeFileSync4(this._path, JSON.stringify(value, undefined, "\t"), writeFileOptions);
     } catch (error) {
       handlePermissionError(error);
     }
@@ -58369,9 +58688,9 @@ init_emoji();
 
 // src/operations/bug-report/handler.ts
 import { execSync as execSync2 } from "child_process";
-import { writeFileSync as writeFileSync4, unlinkSync as unlinkSync3 } from "fs";
+import { writeFileSync as writeFileSync5, unlinkSync as unlinkSync3 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // node_modules/@redactpii/node/lib/index.mjs
 class Redactor {
@@ -58952,9 +59271,9 @@ async function createGitHubIssue(title, body, workingDir) {
   if (!ghStatus.installed || !ghStatus.authenticated) {
     throw new Error(ghStatus.error);
   }
-  const bodyFile = join8(tmpdir4(), `bug-body-${Date.now()}.md`);
+  const bodyFile = join9(tmpdir4(), `bug-body-${Date.now()}.md`);
   try {
-    writeFileSync4(bodyFile, body, "utf-8");
+    writeFileSync5(bodyFile, body, "utf-8");
     const cmd = `gh issue create --repo "${GITHUB_REPO}" --title "${escapeShell(title)}" --body-file "${bodyFile}"`;
     const result = execSync2(cmd, {
       cwd: workingDir,
@@ -59099,8 +59418,8 @@ function formatUptime(startedAt) {
 
 // src/operations/commands/guards.ts
 init_logger();
-var log11 = createLogger("commands");
-var sessionLog2 = createSessionLog(log11);
+var log12 = createLogger("commands");
+var sessionLog2 = createSessionLog(log12);
 function auditCommand(session, command, detail, username) {
   auditLog(session.platformId, {
     threadId: session.threadId,
@@ -63026,7 +63345,7 @@ class BugReportExecutor extends BaseExecutor {
 // src/operations/executors/worktree-prompt.ts
 init_emoji();
 init_logger();
-var log12 = createLogger("wt-prompt");
+var log13 = createLogger("wt-prompt");
 // src/operations/message-manager.ts
 init_logger();
 
@@ -63106,7 +63425,7 @@ function formatRelativeTime(date) {
   return `${diffMin} min ago`;
 }
 // src/operations/message-manager.ts
-var log13 = createLogger("msg-mgr");
+var log14 = createLogger("msg-mgr");
 
 class MessageManager {
   platform;
@@ -63199,7 +63518,7 @@ class MessageManager {
     });
   }
   async handleEvent(event) {
-    const logger = log13.forSession(this.sessionId);
+    const logger = log14.forSession(this.sessionId);
     const transformCtx = {
       sessionId: this.sessionId,
       formatter: this.platform.getFormatter(),
@@ -63253,7 +63572,7 @@ class MessageManager {
     }
   }
   async executeOperation(op) {
-    const logger = log13.forSession(this.sessionId);
+    const logger = log14.forSession(this.sessionId);
     const ctx = this.getExecutorContext();
     try {
       if (isContentOp(op)) {
@@ -63321,7 +63640,7 @@ class MessageManager {
       threadId: this.threadId,
       platform: this.platform,
       formatter: this.platform.getFormatter(),
-      logger: log13.forSession(this.sessionId),
+      logger: log14.forSession(this.sessionId),
       postTracker: this.postTracker,
       contentBreaker: this.contentBreaker,
       threadLogger: this.session.threadLogger,
@@ -63550,13 +63869,13 @@ class MessageManager {
     return this.systemExecutor.postSuccess(message, this.getExecutorContext());
   }
   async prepareForUserMessage() {
-    const logger = log13.forSession(this.sessionId);
+    const logger = log14.forSession(this.sessionId);
     logger.debug("Preparing for new user message");
     await this.closeCurrentPost();
     await this.bumpTaskList();
   }
   async handleUserMessage(message, files, username, displayName) {
-    const logger = log13.forSession(this.sessionId);
+    const logger = log14.forSession(this.sessionId);
     if (!this.session.claude.isRunning()) {
       logger.debug("Claude not running, ignoring user message");
       return false;
@@ -63599,7 +63918,7 @@ class MessageManager {
     ];
   }
   async handleReaction(postId, emoji, user, action) {
-    const logger = log13.forSession(this.sessionId);
+    const logger = log14.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()) {
@@ -63697,7 +64016,7 @@ class MessageManager {
 }
 // src/operations/sticky-message/handler.ts
 init_logger();
-var log14 = createLogger("sticky");
+var log15 = createLogger("sticky");
 var botStartedAt = new Date;
 function getPendingPrompts(session) {
   const prompts = [];
@@ -63772,21 +64091,21 @@ function initialize(store) {
     stickyPostIds.set(platformId, postId);
   }
   if (persistedIds.size > 0) {
-    log14.info(`\uD83D\uDCCC Restored ${persistedIds.size} sticky post ID(s) from persistence`);
+    log15.info(`\uD83D\uDCCC Restored ${persistedIds.size} sticky post ID(s) from persistence`);
   }
 }
 function setPlatformPaused(platformId, paused) {
   if (paused) {
     pausedPlatforms.set(platformId, true);
-    log14.debug(`Platform ${platformId} marked as paused`);
+    log15.debug(`Platform ${platformId} marked as paused`);
   } else {
     pausedPlatforms.delete(platformId);
-    log14.debug(`Platform ${platformId} marked as active`);
+    log15.debug(`Platform ${platformId} marked as active`);
   }
 }
 function setShuttingDown(shuttingDown) {
   isShuttingDown = shuttingDown;
-  log14.debug(`Bot shutdown state: ${shuttingDown}`);
+  log15.debug(`Bot shutdown state: ${shuttingDown}`);
 }
 function getTaskContent(session) {
   const taskState = session.messageManager?.getTaskListState();
@@ -63844,7 +64163,7 @@ function formatHistoryEntry(session, formatter, getThreadLink) {
   const topic = getHistorySessionTopic(session, formatter);
   const threadLink = formatter.formatLink(topic, getThreadLink(session.threadId));
   const displayName = session.startedByDisplayName || session.startedBy;
-  const isTimedOut = !session.cleanedAt && session.lifecyclePostId;
+  const isTimedOut = isRevivable(session) && session.lifecyclePostId;
   const lastActivity = new Date(session.lastActivityAt);
   const time = formatRelativeTimeShort(lastActivity);
   const prStr = session.pullRequestUrl ? ` · ${formatPullRequestLink(session.pullRequestUrl, formatter)}` : "";
@@ -64119,12 +64438,12 @@ async function validateLastMessageIds(platform, sessions) {
     try {
       const post2 = await platform.getPost(lastMessageId);
       if (!post2) {
-        log14.debug(`lastMessageId ${lastMessageId.substring(0, 8)} for session ${session.sessionId} was deleted, clearing`);
+        log15.debug(`lastMessageId ${lastMessageId.substring(0, 8)} for session ${session.sessionId} was deleted, clearing`);
         session.lastMessageId = undefined;
         session.lastMessageTs = undefined;
       }
     } catch (err) {
-      log14.debug(`Failed to validate lastMessageId for session ${session.sessionId}, clearing: ${err}`);
+      log15.debug(`Failed to validate lastMessageId for session ${session.sessionId}, clearing: ${err}`);
       session.lastMessageId = undefined;
       session.lastMessageTs = undefined;
     }
@@ -64141,7 +64460,7 @@ async function updateStickyMessageImpl(platform, sessions, config) {
       hiddenCleanupDone.add(platform.platformId);
       const existing = stickyPostIds.get(platform.platformId);
       if (existing) {
-        log14.info(`sticky[${platform.platformId}] hidden mode: removing leftover ${formatShortId(existing)}`);
+        log15.info(`sticky[${platform.platformId}] hidden mode: removing leftover ${formatShortId(existing)}`);
         try {
           await platform.unpinPost(existing);
         } catch {}
@@ -64161,63 +64480,63 @@ async function updateStickyMessageImpl(platform, sessions, config) {
     return;
   }
   const platformSessions = [...sessions.values()].filter((s) => s.platformId === platform.platformId);
-  log14.debug(`updateStickyMessage for ${platform.platformId}, ${platformSessions.length} sessions`);
+  log15.debug(`updateStickyMessage for ${platform.platformId}, ${platformSessions.length} sessions`);
   for (const s of platformSessions) {
-    log14.debug(`  - ${s.sessionId}: title="${s.sessionTitle}" firstPrompt="${s.firstPrompt?.substring(0, 30)}..."`);
+    log15.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;
-  log14.debug(`existingPostId: ${existingPostId || "(none)"}, needsBump: ${shouldBump}`);
+  log15.debug(`existingPostId: ${existingPostId || "(none)"}, needsBump: ${shouldBump}`);
   try {
     if (existingPostId && !shouldBump) {
-      log14.debug(`Updating existing post in place...`);
+      log15.debug(`Updating existing post in place...`);
       try {
         await platform.updatePost(existingPostId, content);
         try {
           await platform.pinPost(existingPostId);
-          log14.debug(`Re-pinned post`);
+          log15.debug(`Re-pinned post`);
         } catch (pinErr) {
-          log14.debug(`Re-pin failed (might already be pinned): ${pinErr}`);
+          log15.debug(`Re-pin failed (might already be pinned): ${pinErr}`);
         }
-        log14.debug(`Updated successfully`);
+        log15.debug(`Updated successfully`);
         return;
       } catch (err) {
-        log14.debug(`Update failed, will create new: ${err}`);
+        log15.debug(`Update failed, will create new: ${err}`);
       }
     }
     needsBump.set(platform.platformId, false);
     if (existingPostId) {
-      log14.debug(`Unpinning and deleting existing post ${existingPostId.substring(0, 8)}...`);
+      log15.debug(`Unpinning and deleting existing post ${existingPostId.substring(0, 8)}...`);
       try {
         await platform.unpinPost(existingPostId);
-        log14.debug(`Unpinned successfully`);
+        log15.debug(`Unpinned successfully`);
       } catch (err) {
-        log14.debug(`Unpin failed (probably already unpinned): ${err}`);
+        log15.debug(`Unpin failed (probably already unpinned): ${err}`);
       }
       try {
         await platform.deletePost(existingPostId);
-        log14.debug(`Deleted successfully`);
+        log15.debug(`Deleted successfully`);
       } catch (err) {
-        log14.debug(`Delete failed (probably already deleted): ${err}`);
+        log15.debug(`Delete failed (probably already deleted): ${err}`);
       }
       stickyPostIds.delete(platform.platformId);
     }
-    log14.debug(`Creating new post...`);
+    log15.debug(`Creating new post...`);
     const post2 = await platform.createPost(content);
     stickyPostIds.set(platform.platformId, post2.id);
     try {
       await platform.pinPost(post2.id);
-      log14.debug(`Pinned post successfully`);
+      log15.debug(`Pinned post successfully`);
     } catch (err) {
-      log14.debug(`Failed to pin post: ${err}`);
+      log15.debug(`Failed to pin post: ${err}`);
     }
     if (sessionStore) {
       sessionStore.saveStickyPostId(platform.platformId, post2.id);
     }
-    log14.info(`\uD83D\uDCCC Created sticky message for ${platform.platformId}: ${formatShortId(post2.id)}`);
+    log15.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()) {
@@ -64233,10 +64552,10 @@ async function updateStickyMessageImpl(platform, sessions, config) {
     }
     const botUser = await platform.getBotUser();
     cleanupOldStickyMessages(platform, botUser.id, false, excludePostIds).catch((err) => {
-      log14.debug(`Background cleanup failed: ${err}`);
+      log15.debug(`Background cleanup failed: ${err}`);
     });
   } catch (err) {
-    log14.error(`Failed to update sticky message for ${platform.platformId}`, err instanceof Error ? err : undefined);
+    log15.error(`Failed to update sticky message for ${platform.platformId}`, err instanceof Error ? err : undefined);
   }
 }
 async function updateAllStickyMessages(platforms, sessions, config, overheadByPlatform) {
@@ -64264,7 +64583,7 @@ async function cleanupOldStickyMessages(platform, botUserId, forceRun = false, e
   if (!forceRun) {
     const lastRun = lastCleanupTime.get(platformId) || 0;
     if (now - lastRun < CLEANUP_THROTTLE_MS) {
-      log14.debug(`Cleanup throttled for ${platformId} (last run ${Math.round((now - lastRun) / 1000)}s ago)`);
+      log15.debug(`Cleanup throttled for ${platformId} (last run ${Math.round((now - lastRun) / 1000)}s ago)`);
       return;
     }
   }
@@ -64274,69 +64593,47 @@ 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) {
-      log14.debug(`No recent pinned posts to check (${pinnedPostIds.length} total, current: ${currentStickyId?.substring(0, 8) || "(none)"})`);
+      log15.debug(`No recent pinned posts to check (${pinnedPostIds.length} total, current: ${currentStickyId?.substring(0, 8) || "(none)"})`);
       return;
     }
-    log14.debug(`Checking ${recentPinnedIds.length} recent pinned posts (of ${pinnedPostIds.length} total)`);
+    log15.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) {
-          log14.debug(`Cleaning up old sticky: ${postId.substring(0, 8)}...`);
+          log15.debug(`Cleaning up old sticky: ${postId.substring(0, 8)}...`);
           try {
             await platform.unpinPost(postId);
             await platform.deletePost(postId);
-            log14.info(`\uD83E\uDDF9 Cleaned up old sticky message: ${postId.substring(0, 8)}...`);
+            log15.info(`\uD83E\uDDF9 Cleaned up old sticky message: ${postId.substring(0, 8)}...`);
           } catch (err) {
-            log14.debug(`Failed to cleanup ${postId}: ${err}`);
+            log15.debug(`Failed to cleanup ${postId}: ${err}`);
           }
         }
       } catch (err) {
-        log14.debug(`Could not check post ${postId}: ${err}`);
+        log15.debug(`Could not check post ${postId}: ${err}`);
       }
     }
   } catch (err) {
-    log14.error(`Failed to cleanup old sticky messages`, err instanceof Error ? err : undefined);
+    log15.error(`Failed to cleanup old sticky messages`, err instanceof Error ? err : undefined);
   }
 }
 // src/memory/store.ts
 import { createHash } from "crypto";
 import {
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync6,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync7,
   realpathSync
 } from "fs";
-import { homedir as homedir5 } from "os";
-import { basename as basename3, dirname as dirname7, join as join9, sep as sep2 } from "path";
-
-// src/persistence/atomic-file.ts
-import { chmodSync as chmodSync4, renameSync, writeFileSync as writeFileSync5 } from "fs";
-
-class SerialQueue {
-  tail = Promise.resolve();
-  run(fn) {
-    const next = this.tail.then(fn, fn);
-    this.tail = next.catch(() => {
-      return;
-    });
-    return next;
-  }
-}
-function writeFileAtomic(file, content) {
-  const tempFile = `${file}.tmp`;
-  writeFileSync5(tempFile, content, { encoding: "utf-8", mode: 384 });
-  renameSync(tempFile, file);
-  chmodSync4(file, 384);
-}
-
-// src/memory/store.ts
+import { homedir as homedir6 } from "os";
+import { basename as basename3, dirname as dirname7, join as join10, sep as sep2 } from "path";
 init_logger();
 init_worktree();
-var log15 = createLogger("memory");
-var DEFAULT_ROOT = join9(homedir5(), ".config", "claude-threads", "memory");
+var log16 = createLogger("memory");
+var DEFAULT_ROOT = join10(homedir6(), ".config", "claude-threads", "memory");
 var CHANNEL_BLOCK_MAX_LINES = 200;
 var CHANNEL_BLOCK_MAX_BYTES = 25 * 1024;
 var CHANNEL_FILE_MAX_ENTRIES = 400;
@@ -64401,10 +64698,10 @@ class MemoryStore {
     return this.root;
   }
   channelMemoryPath(platformId) {
-    return join9(this.root, platformSegment(platformId), "channel", "MEMORY.md");
+    return join10(this.root, platformSegment(platformId), "channel", "MEMORY.md");
   }
   repoMemoryDir(platformId, repoKey) {
-    const dir = join9(this.root, platformSegment(platformId), "repos", repoKey);
+    const dir = join10(this.root, platformSegment(platformId), "repos", repoKey);
     this.ensureDir(dir);
     return dir;
   }
@@ -64451,7 +64748,7 @@ class MemoryStore {
       if (result.added.length > 0) {
         this.enforceFileCap(lines);
         this.writeLines(platformId, lines);
-        log15.debug(`Channel memory for ${platformId}: +${result.added.length} entries` + (result.duplicates.length ? ` (${result.duplicates.length} duplicates skipped)` : ""));
+        log16.debug(`Channel memory for ${platformId}: +${result.added.length} entries` + (result.duplicates.length ? ` (${result.duplicates.length} duplicates skipped)` : ""));
       }
       return result;
     });
@@ -64490,14 +64787,14 @@ class MemoryStore {
       }
       lines.splice(target.lineIndex, 1);
       this.writeLines(platformId, lines);
-      log15.debug(`Channel memory for ${platformId}: removed one entry`);
+      log16.debug(`Channel memory for ${platformId}: removed one entry`);
       return { ok: true, removed: target.entry };
     });
   }
   clearChannel(platformId) {
     return this.runExclusive(platformId, () => {
       this.writeLines(platformId, []);
-      log15.debug(`Channel memory for ${platformId}: cleared`);
+      log16.debug(`Channel memory for ${platformId}: cleared`);
     });
   }
   buildChannelMemoryBlock(platformId) {
@@ -64505,7 +64802,7 @@ class MemoryStore {
     try {
       lines = this.loadLines(platformId);
     } catch (err) {
-      log15.warn(`Failed to read channel memory for ${platformId}: ${err.message}`);
+      log16.warn(`Failed to read channel memory for ${platformId}: ${err.message}`);
       return null;
     }
     if (lines.length === 0)
@@ -64538,9 +64835,9 @@ _(older entries omitted — \`!memory\` shows all)_` : rendered;
   }
   loadLines(platformId) {
     const file = this.channelMemoryPath(platformId);
-    if (!existsSync7(file))
+    if (!existsSync8(file))
       return [];
-    const raw = readFileSync6(file, "utf-8");
+    const raw = readFileSync7(file, "utf-8");
     const lines = [];
     for (const line of raw.split(`
 `)) {
@@ -64580,8 +64877,8 @@ _(older entries omitted — \`!memory\` shows all)_` : rendered;
     writeFileAtomic(file, content);
   }
   ensureDir(dir) {
-    if (!existsSync7(dir)) {
-      mkdirSync4(dir, { recursive: true, mode: 448 });
+    if (!existsSync8(dir)) {
+      mkdirSync5(dir, { recursive: true, mode: 448 });
     }
   }
 }
@@ -64592,15 +64889,15 @@ async function resolveSessionMemory(memoryStore, memoryConfig, platformId, worki
     const repoKey = await resolveRepoKey(workingDir, worktreeRepoRoot);
     return { autoMemoryDir: memoryStore.repoMemoryDir(platformId, repoKey) };
   } catch (err) {
-    log15.warn(`Failed to resolve repo memory dir for ${platformId}: ${err.message}`);
+    log16.warn(`Failed to resolve repo memory dir for ${platformId}: ${err.message}`);
     return null;
   }
 }
 
 // src/operations/commands/memory.ts
 init_logger();
-var log16 = createLogger("commands");
-var sessionLog3 = createSessionLog(log16);
+var log17 = createLogger("commands");
+var sessionLog3 = createSessionLog(log17);
 async function requireChannelMemory(session, ctx) {
   const memoryConfig = ctx.ops.getPlatformMemoryConfig(session.platformId);
   if (memoryConfig.enabled && memoryConfig.channelLayer)
@@ -64723,15 +65020,15 @@ init_emoji();
 
 // src/persistence/routines-store.ts
 init_logger();
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 
 // src/persistence/platform-list-store.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync7, statSync as statSync3 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join10 } from "path";
-var STORES_CONFIG_DIR = join10(homedir6(), ".config", "claude-threads");
-var STORE_VERSION = 1;
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync8, statSync as statSync3 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join11 } from "path";
+var STORES_CONFIG_DIR = join11(homedir7(), ".config", "claude-threads");
+var STORE_VERSION2 = 1;
 
 class PlatformListStore {
   file;
@@ -64743,12 +65040,12 @@ class PlatformListStore {
     this.collectionKey = collectionKey;
     if (filePath) {
       this.file = filePath;
-      this.configDir = join10(filePath, "..");
+      this.configDir = join11(filePath, "..");
     } else {
       this.file = defaultFile;
       this.configDir = STORES_CONFIG_DIR;
     }
-    mkdirSync5(this.configDir, { recursive: true, mode: 448 });
+    mkdirSync6(this.configDir, { recursive: true, mode: 448 });
   }
   list(platformId) {
     return structuredClone(this.loadRaw().items[platformId] ?? []);
@@ -64804,18 +65101,18 @@ class PlatformListStore {
     return this.queue.run(fn);
   }
   loadRaw(forWrite = false) {
-    if (!existsSync8(this.file)) {
+    if (!existsSync9(this.file)) {
       this.cache = null;
-      return { version: STORE_VERSION, items: {} };
+      return { version: STORE_VERSION2, items: {} };
     }
     try {
       const stat = statSync3(this.file);
       if (this.cache && this.cache.mtimeMs === stat.mtimeMs && this.cache.size === stat.size) {
         return this.cache.data;
       }
-      const raw = readFileSync7(this.file, "utf-8");
+      const raw = readFileSync8(this.file, "utf-8");
       if (raw.trim() === "") {
-        const data2 = { version: STORE_VERSION, items: {} };
+        const data2 = { version: STORE_VERSION2, items: {} };
         this.cache = { mtimeMs: stat.mtimeMs, size: stat.size, data: data2 };
         return data2;
       }
@@ -64828,14 +65125,14 @@ class PlatformListStore {
           throw new Error(`refusing to write over unreadable ${this.file}: ${problem}`);
         }
         this.warn(`Failed to read ${this.file}: ${problem} — starting empty`);
-        return { version: STORE_VERSION, items: {} };
+        return { version: STORE_VERSION2, items: {} };
       }
       const items = rawItems ?? {};
       for (const list of Object.values(items)) {
         for (const item of list)
           this.applyItemDefaults(item);
       }
-      const data = { version: parsed?.version ?? STORE_VERSION, items };
+      const data = { version: parsed?.version ?? STORE_VERSION2, items };
       this.cache = { mtimeMs: stat.mtimeMs, size: stat.size, data };
       return data;
     } catch (err) {
@@ -64844,7 +65141,7 @@ class PlatformListStore {
         throw new Error(`refusing to write over unreadable ${this.file}: ${err.message}`, { cause: err });
       }
       this.warn(`Failed to read ${this.file}: ${err.message} — starting empty`);
-      return { version: STORE_VERSION, items: {} };
+      return { version: STORE_VERSION2, items: {} };
     }
   }
   writeAtomic(data) {
@@ -64867,8 +65164,8 @@ class PlatformListStore {
 }
 
 // src/persistence/routines-store.ts
-var log17 = createLogger("routines");
-var DEFAULT_FILE = join11(STORES_CONFIG_DIR, "routines.yaml");
+var log18 = createLogger("routines");
+var DEFAULT_FILE = join12(STORES_CONFIG_DIR, "routines.yaml");
 var MAX_CONSECUTIVE_FAILURES = 3;
 var DEFAULT_MAX_ROUTINES = 10;
 var SCHEDULE_PRESETS = ["hourly", "daily", "weekdays", "weekly"];
@@ -64928,10 +65225,10 @@ class RoutinesStore extends PlatformListStore {
     r.requireApproval = r.requireApproval ?? true;
   }
   warn(message) {
-    log17.warn(message);
+    log18.warn(message);
   }
   onRemoved(platformId, routine) {
-    log17.info(`Routine "${routine.name}" removed from ${platformId}`);
+    log18.info(`Routine "${routine.name}" removed from ${platformId}`);
   }
   async add(platformId, routine, maxRoutines = DEFAULT_MAX_ROUTINES) {
     const result = await this.addItem(platformId, maxRoutines, "routine", () => {
@@ -64955,7 +65252,7 @@ class RoutinesStore extends PlatformListStore {
     });
     if (!result.ok)
       return result;
-    log17.info(`Routine "${result.item.name}" created on ${platformId} by @${result.item.createdBy}`);
+    log18.info(`Routine "${result.item.name}" created on ${platformId} by @${result.item.createdBy}`);
     return { ok: true, routine: result.item };
   }
   update(platformId, id, patch) {
@@ -64995,7 +65292,7 @@ async function parseJsonViaHaiku(opts) {
 }
 
 // src/routines/parser.ts
-var log19 = createLogger("routines");
+var log20 = createLogger("routines");
 var PARSE_TIMEOUT_MS = 15000;
 function hostTimezone() {
   return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
@@ -65049,7 +65346,7 @@ function parseRoutineRequest(request, defaultTimezone = hostTimezone()) {
   return parseJsonViaHaiku({
     prompt: buildParsePrompt(request, defaultTimezone),
     timeoutMs: PARSE_TIMEOUT_MS,
-    logDebug: (m) => log19.debug(`Routine parse: ${m}`),
+    logDebug: (m) => log20.debug(`Routine parse: ${m}`),
     unusableMessage: 'could not understand the schedule — try e.g. "every weekday at 9:00, <task>"',
     validate: (raw) => validateParsedRoutine(raw, defaultTimezone)
   });
@@ -65057,10 +65354,10 @@ function parseRoutineRequest(request, defaultTimezone = hostTimezone()) {
 
 // src/persistence/watches-store.ts
 init_logger();
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
-var log20 = createLogger("watches");
-var DEFAULT_FILE2 = join12(STORES_CONFIG_DIR, "watches.yaml");
+var log21 = createLogger("watches");
+var DEFAULT_FILE2 = join13(STORES_CONFIG_DIR, "watches.yaml");
 var MAX_CONSECUTIVE_WATCH_FAILURES = 3;
 var DEFAULT_MAX_WATCHES = 10;
 var MIN_KEYWORDS = 1;
@@ -65086,10 +65383,10 @@ class WatchesStore extends PlatformListStore {
     w.keywords = Array.isArray(w.keywords) ? w.keywords.filter((k) => typeof k === "string").map((k) => singleLine(k).toLowerCase()).filter((k) => k.length > 0) : [];
   }
   warn(message) {
-    log20.warn(message);
+    log21.warn(message);
   }
   onRemoved(platformId, watch) {
-    log20.info(`Watch "${watch.name}" removed from ${platformId}`);
+    log21.info(`Watch "${watch.name}" removed from ${platformId}`);
   }
   async add(platformId, watch, maxWatches = DEFAULT_MAX_WATCHES) {
     const result = await this.addItem(platformId, maxWatches, "watch", () => {
@@ -65116,7 +65413,7 @@ class WatchesStore extends PlatformListStore {
     });
     if (!result.ok)
       return result;
-    log20.info(`Watch "${result.item.name}" created on ${platformId} by @${result.item.createdBy}`);
+    log21.info(`Watch "${result.item.name}" created on ${platformId} by @${result.item.createdBy}`);
     return { ok: true, watch: result.item };
   }
   update(platformId, id, patch) {
@@ -65126,7 +65423,7 @@ class WatchesStore extends PlatformListStore {
 
 // src/watches/parser.ts
 init_logger();
-var log21 = createLogger("watches");
+var log22 = createLogger("watches");
 var PARSE_TIMEOUT_MS2 = 30000;
 function buildWatchParsePrompt(request) {
   return `Parse this event-trigger ("watch") request from a chat user into JSON.
@@ -65161,7 +65458,7 @@ function parseWatchRequest(request) {
   return parseJsonViaHaiku({
     prompt: buildWatchParsePrompt(request),
     timeoutMs: PARSE_TIMEOUT_MS2,
-    logDebug: (m) => log21.debug(`Watch parse: ${m}`),
+    logDebug: (m) => log22.debug(`Watch parse: ${m}`),
     unusableMessage: "the parsing model returned an unusable answer — try rephrasing",
     validate: validateParsedWatch
   });
@@ -65169,8 +65466,8 @@ function parseWatchRequest(request) {
 
 // src/operations/commands/automation.ts
 init_logger();
-var log22 = createLogger("commands");
-var sessionLog4 = createSessionLog(log22);
+var log23 = createLogger("commands");
+var sessionLog4 = createSessionLog(log23);
 async function refuseInDirectChannelMode(session, message) {
   if (!session.platform.directChannelMode?.enabled)
     return false;
@@ -65424,7 +65721,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) {
@@ -65473,7 +65770,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),
@@ -65487,14 +65784,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 [];
   }
 }
@@ -65503,8 +65800,8 @@ async function suggestBranchNames(workingDir, userMessage) {
 init_worktree();
 import { randomUUID as randomUUID5 } from "crypto";
 init_logger();
-var log24 = createLogger("worktree");
-var sessionLog5 = createSessionLog(log24);
+var log25 = createLogger("worktree");
+var sessionLog5 = createSessionLog(log25);
 function displayBranchName(name) {
   return name.replace(/[`\r\n]/g, "").slice(0, 100);
 }
@@ -66099,8 +66396,8 @@ async function cleanupWorktreeCommand(session, username, hasOtherSessionsUsingWo
 }
 // src/operations/events/handler.ts
 init_logger();
-var log25 = createLogger("events");
-var sessionLog6 = createSessionLog(log25);
+var log26 = createLogger("events");
+var sessionLog6 = createSessionLog(log26);
 function detectAndExecuteClaudeCommands(text, session, ctx) {
   const parsed = parseClaudeCommand(text);
   if (parsed && isClaudeAllowedCommand(parsed.command)) {
@@ -66443,7 +66740,7 @@ function updateUsageFromStatusLine(session) {
 }
 // src/operations/monitor/handler.ts
 init_logger();
-var log26 = createLogger("monitor");
+var log27 = createLogger("monitor");
 var DEFAULT_INTERVAL_MS = 60 * 1000;
 
 class SessionMonitor {
@@ -66465,14 +66762,14 @@ class SessionMonitor {
   }
   start() {
     if (this.isRunning) {
-      log26.debug("Session monitor already running");
+      log27.debug("Session monitor already running");
       return;
     }
     this.isRunning = true;
-    log26.debug(`Session monitor started (interval: ${this.intervalMs / 1000}s)`);
+    log27.debug(`Session monitor started (interval: ${this.intervalMs / 1000}s)`);
     this.timer = setInterval(() => {
       this.runCheck().catch((err) => {
-        log26.error(`Error during session monitoring: ${err}`);
+        log27.error(`Error during session monitoring: ${err}`);
       });
     }, this.intervalMs);
   }
@@ -66482,7 +66779,7 @@ class SessionMonitor {
       this.timer = null;
     }
     this.isRunning = false;
-    log26.debug("Session monitor stopped");
+    log27.debug("Session monitor stopped");
   }
   async runCheck() {
     await cleanupIdleSessions(this.sessionTimeoutMs, this.sessionWarningMs, this.getContext());
@@ -66502,8 +66799,8 @@ function createSessionContext(config, state, ops) {
 // src/operations/context-prompt/handler.ts
 init_emoji();
 init_logger();
-var log27 = createLogger("context");
-var sessionLog7 = createSessionLog(log27);
+var log28 = createLogger("context");
+var sessionLog7 = createSessionLog(log28);
 var CONTEXT_PROMPT_TIMEOUT_MS = 30000;
 var CONTEXT_OPTIONS = [3, 5, 10];
 var AUTO_INCLUDE_LIMIT = 25;
@@ -66725,7 +67022,7 @@ async function offerContextPrompt(session, queuedPrompt, queuedFiles, ctx, exclu
 // src/operations/suggestions/tag.ts
 init_quick_query();
 init_logger();
-var log28 = createLogger("tags");
+var log29 = createLogger("tags");
 var SUGGESTION_TIMEOUT2 = 15000;
 var MAX_TAGS = 3;
 var VALID_TAGS = [
@@ -66757,7 +67054,7 @@ function parseTags(response) {
   return [...new Set(tags)].slice(0, MAX_TAGS);
 }
 async function suggestSessionTags(userMessage) {
-  log28.debug(`Suggesting tags for: "${userMessage.substring(0, 50)}..."`);
+  log29.debug(`Suggesting tags for: "${userMessage.substring(0, 50)}..."`);
   try {
     const result = await quickQuery({
       prompt: buildTagPrompt(userMessage),
@@ -66765,21 +67062,21 @@ async function suggestSessionTags(userMessage) {
       timeout: SUGGESTION_TIMEOUT2
     });
     if (!result.success || !result.response) {
-      log28.debug(`Tag suggestion failed: ${result.error || "no response"}`);
+      log29.debug(`Tag suggestion failed: ${result.error || "no response"}`);
       return [];
     }
     const tags = parseTags(result.response);
-    log28.debug(`Got tags: ${tags.join(", ")} (${result.durationMs}ms)`);
+    log29.debug(`Got tags: ${tags.join(", ")} (${result.durationMs}ms)`);
     return tags;
   } catch (err) {
-    log28.debug(`Tag suggestion error: ${err}`);
+    log29.debug(`Tag suggestion error: ${err}`);
     return [];
   }
 }
 // src/operations/suggestions/title.ts
 init_quick_query();
 init_logger();
-var log29 = createLogger("title");
+var log30 = createLogger("title");
 var SUGGESTION_TIMEOUT3 = 15000;
 var MIN_TITLE_LENGTH = 3;
 var MAX_TITLE_LENGTH = 50;
@@ -66843,32 +67140,32 @@ function parseMetadata(response) {
   const titleMatch = response.match(/TITLE:\s*(.+)/i);
   const descMatch = response.match(/DESC:\s*(.+)/i);
   if (!titleMatch || !descMatch) {
-    log29.debug("Failed to parse title/description from response");
+    log30.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) {
-    log29.debug(`Title too short: ${title.length} chars`);
+    log30.debug(`Title too short: ${title.length} chars`);
     return null;
   }
   if (title.length > MAX_TITLE_LENGTH) {
-    log29.debug(`Title too long (${title.length} chars), truncating`);
+    log30.debug(`Title too long (${title.length} chars), truncating`);
     title = truncateAtWord(title, MAX_TITLE_LENGTH);
   }
   if (description.length < MIN_DESC_LENGTH) {
-    log29.debug(`Description too short: ${description.length} chars`);
+    log30.debug(`Description too short: ${description.length} chars`);
     return null;
   }
   if (description.length > MAX_DESC_LENGTH) {
-    log29.debug(`Description too long (${description.length} chars), truncating`);
+    log30.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);
-  log29.debug(`Suggesting title for: "${logContext}..."`);
+  log30.debug(`Suggesting title for: "${logContext}..."`);
   try {
     const result = await quickQuery({
       prompt: buildTitlePrompt(context),
@@ -66876,16 +67173,16 @@ async function suggestSessionMetadata(context) {
       timeout: SUGGESTION_TIMEOUT3
     });
     if (!result.success || !result.response) {
-      log29.debug(`Title suggestion failed: ${result.error || "no response"}`);
+      log30.debug(`Title suggestion failed: ${result.error || "no response"}`);
       return null;
     }
     const metadata = parseMetadata(result.response);
     if (metadata) {
-      log29.debug(`Got title: "${metadata.title}" (${result.durationMs}ms)`);
+      log30.debug(`Got title: "${metadata.title}" (${result.durationMs}ms)`);
     }
     return metadata;
   } catch (err) {
-    log29.debug(`Title suggestion error: ${err}`);
+    log30.debug(`Title suggestion error: ${err}`);
     return null;
   }
 }
@@ -66893,15 +67190,15 @@ async function suggestSessionMetadata(context) {
 init_quick_query();
 
 // src/persistence/github-emails-store.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync8 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join13 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync9 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join14 } from "path";
 init_logger();
-var log30 = createLogger("gh-emails");
-var DEFAULT_CONFIG_DIR = join13(homedir7(), ".config", "claude-threads");
-var DEFAULT_FILE3 = join13(DEFAULT_CONFIG_DIR, "github-emails.yaml");
+var log31 = createLogger("gh-emails");
+var DEFAULT_CONFIG_DIR2 = join14(homedir8(), ".config", "claude-threads");
+var DEFAULT_FILE3 = join14(DEFAULT_CONFIG_DIR2, "github-emails.yaml");
 var NOREPLY_REGEX = /^\d+\+[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})@users\.noreply\.github\.com$/;
-var STORE_VERSION2 = 1;
+var STORE_VERSION3 = 1;
 function isValidGitHubNoreplyEmail(s) {
   return NOREPLY_REGEX.test(s);
 }
@@ -66914,13 +67211,13 @@ class GitHubEmailsStore {
     const effective = filePath ?? envPath;
     if (effective) {
       this.file = effective;
-      this.configDir = join13(effective, "..");
+      this.configDir = join14(effective, "..");
     } else {
       this.file = DEFAULT_FILE3;
-      this.configDir = DEFAULT_CONFIG_DIR;
+      this.configDir = DEFAULT_CONFIG_DIR2;
     }
-    if (!existsSync9(this.configDir)) {
-      mkdirSync6(this.configDir, { recursive: true });
+    if (!existsSync10(this.configDir)) {
+      mkdirSync7(this.configDir, { recursive: true });
     }
   }
   get(platformId, username) {
@@ -66937,7 +67234,7 @@ class GitHubEmailsStore {
     }
     data.emails[platformId][username] = email;
     this.writeAtomic(data);
-    log30.debug(`Stored GitHub email for ${platformId}/${username}`);
+    log31.debug(`Stored GitHub email for ${platformId}/${username}`);
   }
   delete(platformId, username) {
     const data = this.loadRaw();
@@ -66949,40 +67246,40 @@ class GitHubEmailsStore {
       delete data.emails[platformId];
     }
     this.writeAtomic(data);
-    log30.debug(`Removed GitHub email for ${platformId}/${username}`);
+    log31.debug(`Removed GitHub email for ${platformId}/${username}`);
     return true;
   }
   lastReadDegraded = false;
   loadRaw() {
-    if (!existsSync9(this.file)) {
+    if (!existsSync10(this.file)) {
       this.lastReadDegraded = false;
-      return { version: STORE_VERSION2, emails: {} };
+      return { version: STORE_VERSION3, emails: {} };
     }
     try {
-      const raw = readFileSync8(this.file, "utf-8");
+      const raw = readFileSync9(this.file, "utf-8");
       if (raw.trim() === "") {
         this.lastReadDegraded = false;
-        return { version: STORE_VERSION2, emails: {} };
+        return { version: STORE_VERSION3, emails: {} };
       }
       const parsed = yaml.load(raw);
       if (!parsed || typeof parsed !== "object") {
         this.lastReadDegraded = true;
-        return { version: STORE_VERSION2, emails: {} };
+        return { version: STORE_VERSION3, emails: {} };
       }
       const missing = parsed.emails === undefined || parsed.emails === null;
       const valid = !missing && typeof parsed.emails === "object";
       this.lastReadDegraded = !missing && !valid;
       const emails = valid ? parsed.emails : {};
-      return { version: parsed.version ?? STORE_VERSION2, emails };
+      return { version: parsed.version ?? STORE_VERSION3, emails };
     } catch (err) {
-      log30.warn(`Failed to read ${this.file}: ${err.message} — reads degrade to empty`);
+      log31.warn(`Failed to read ${this.file}: ${err.message} — reads degrade to empty`);
       this.lastReadDegraded = true;
-      return { version: STORE_VERSION2, emails: {} };
+      return { version: STORE_VERSION3, emails: {} };
     }
   }
   writeAtomic(data) {
     if (this.lastReadDegraded) {
-      log30.error(`Refusing to write ${this.file}: the last read of the existing file was degraded — writing would destroy stored emails`);
+      log31.error(`Refusing to write ${this.file}: the last read of the existing file was degraded — writing would destroy stored emails`);
       return;
     }
     writeFileAtomic(this.file, yaml.dump(data, { sortKeys: true, lineWidth: -1 }));
@@ -66990,8 +67287,8 @@ class GitHubEmailsStore {
 }
 
 // src/operations/commands/handler.ts
-var log31 = createLogger("commands");
-var sessionLog8 = createSessionLog(log31);
+var log32 = createLogger("commands");
+var sessionLog8 = createSessionLog(log32);
 function sessionAccountOption(session, ctx) {
   if (!session.claudeAccountId)
     return;
@@ -67160,7 +67457,7 @@ async function changeDirectory(session, newDir, username, ctx) {
   const expandedDir = newDir.startsWith("~") ? newDir.replace("~", process.env.HOME || "") : newDir;
   const absoluteDir = resolve6(expandedDir);
   const formatter = session.platform.getFormatter();
-  if (!existsSync10(absoluteDir)) {
+  if (!existsSync11(absoluteDir)) {
     await postError(session, `Directory does not exist: ${formatter.formatCode(newDir)}`);
     sessionLog8(session).warn(`\uD83D\uDCC2 Directory does not exist: ${newDir}`);
     return;
@@ -67658,8 +67955,8 @@ async function handleBugReportApproval(session, isApproved, username) {
 
 // src/session/metadata-suggestions.ts
 init_logger();
-var log32 = createLogger("session");
-var sessionLog9 = createSessionLog(log32);
+var log33 = createLogger("session");
+var sessionLog9 = createSessionLog(log33);
 var METADATA_RETRY_DELAY_MS = 2000;
 var METADATA_MAX_RETRIES = 2;
 async function attemptMetadataFetch(session, prompt, ctx, attempt = 1, options = {}) {
@@ -67799,7 +68096,7 @@ init_worktree();
 // src/memory/distiller.ts
 init_quick_query();
 init_logger();
-var log33 = createLogger("memory");
+var log34 = createLogger("memory");
 var MIN_THREAD_MESSAGES = 4;
 var DISTILL_MESSAGE_LIMIT = 30;
 var MESSAGE_CHAR_CAP = 500;
@@ -67843,21 +68140,21 @@ function scheduleDistillation(session, ctx, reason) {
     return;
   }
   if (session.unattended) {
-    log33.debug(`Skipping distillation for unattended session ${session.platformId}:${session.threadId}`);
+    log34.debug(`Skipping distillation for unattended session ${session.platformId}:${session.threadId}`);
     return;
   }
   if (isDcmThreadId(session.threadId)) {
-    log33.debug(`Skipping distillation for DCM session ${session.platformId}:${session.threadId}`);
+    log34.debug(`Skipping distillation for DCM session ${session.platformId}:${session.threadId}`);
     return;
   }
   const { platformId, threadId, platform } = session;
   const store = ctx.state.memoryStore;
   distillThread(store, platformId, threadId, platform).then((added) => {
     if (added > 0) {
-      log33.debug(`Distilled ${added} memory entries from ${platformId}:${threadId} (${reason})`);
+      log34.debug(`Distilled ${added} memory entries from ${platformId}:${threadId} (${reason})`);
     }
   }).catch((err) => {
-    log33.debug(`Distillation failed for ${platformId}:${threadId}: ${err.message}`);
+    log34.debug(`Distillation failed for ${platformId}:${threadId}: ${err.message}`);
   });
 }
 async function distillThread(store, platformId, threadId, platform) {
@@ -67974,7 +68271,8 @@ class SessionRegistry {
     return this.sessionStore.findByThread(platformId, threadId);
   }
   getPersistedByThreadId(threadId, platformId) {
-    return this.sessionStore.findByThreadIdAnyState(threadId, platformId);
+    const persisted = this.sessionStore.findByThreadIdAnyState(threadId, platformId);
+    return persisted && isRevivable(persisted) ? persisted : undefined;
   }
   getSessionStore() {
     return this.sessionStore;
@@ -67999,8 +68297,8 @@ class SessionRegistry {
 
 // src/operations/agent-actions/handler.ts
 init_logger();
-var log34 = createLogger("agent-actions");
-var sessionLog10 = createSessionLog(log34);
+var log35 = createLogger("agent-actions");
+var sessionLog10 = createSessionLog(log35);
 var AGENT_MEMORY_WRITES_PER_SESSION = 5;
 var LIST_LIMIT = 100;
 async function handleAgentAction(session, ctx, request, signal) {
@@ -68264,8 +68562,8 @@ function listWatches(session, ctx) {
 }
 
 // src/session/lifecycle.ts
-var log35 = createLogger("lifecycle");
-var sessionLog11 = createSessionLog(log35);
+var log36 = createLogger("lifecycle");
+var sessionLog11 = createSessionLog(log36);
 function mutableSessions(ctx) {
   return ctx.state.sessions;
 }
@@ -68429,14 +68727,6 @@ function handleRateLimit(session, hit, ctx) {
   sessionLog11(session).warn(`Rate limit on account "${session.claudeAccountId}" — cooling for ~${minutes}min`);
   post(session, "warning", `⚠️ Claude account \`${session.claudeAccountId}\` hit a rate limit. ` + `New sessions will use another account until it resets (~${minutes}min).`);
 }
-function findPersistedByThreadId(persisted, threadId, platformId) {
-  for (const session of persisted.values()) {
-    if (session.threadId === threadId && session.platformId === platformId) {
-      return session;
-    }
-  }
-  return;
-}
 async function createSessionDecisionBridge(ref, ctx) {
   try {
     return await DecisionBridgeServer.create(async (request, signal) => {
@@ -68454,7 +68744,7 @@ async function createSessionDecisionBridge(ref, ctx) {
       return messageManager.handleBridgeRequest(request, signal);
     });
   } catch (err) {
-    log35.warn(`Decision bridge unavailable — falling back to legacy MCP prompts: ${err}`);
+    log36.warn(`Decision bridge unavailable — falling back to legacy MCP prompts: ${err}`);
     return null;
   }
 }
@@ -68611,7 +68901,7 @@ function resumeSessionHeaderMode(persisted, platformConfigured) {
 function resolveSessionHeaderMode(configured, replyToPostId, platformId) {
   const mode = configured ?? DEFAULT_OVERHEAD_VISIBILITY;
   if (mode === "hidden" && !replyToPostId) {
-    log35.error(`sessionHeader: hidden requires a replyToPostId for ${platformId}; ` + `downgrading this session to 'minimal' so the header post is still short.`);
+    log36.error(`sessionHeader: hidden requires a replyToPostId for ${platformId}; ` + `downgrading this session to 'minimal' so the header post is still short.`);
     return "minimal";
   }
   return mode;
@@ -68651,7 +68941,7 @@ async function startSessionImpl(options, username, displayName, replyToPostId, p
     throw new Error(`Platform '${platformId}' not found. Call addPlatform() first.`);
   }
   if (!isAuthorizedForSession({ username, platform, sessionAllowedUsers: undefined })) {
-    log35.warn(`auth.denied.startSession: @${username || "unknown"} not authorized to start session in ${threadId.substring(0, 8)}...`);
+    log36.warn(`auth.denied.startSession: @${username || "unknown"} not authorized to start session in ${threadId.substring(0, 8)}...`);
     return;
   }
   const activeOrPending = ctx.state.sessions.size + pendingStartsCount;
@@ -68690,7 +68980,7 @@ async function startSessionImpl(options, username, displayName, replyToPostId, p
     const { resolve: resolve7 } = await import("path");
     const requestedDir = initialOptions.workingDir.startsWith("~") ? initialOptions.workingDir.replace("~", process.env.HOME || "") : initialOptions.workingDir;
     const resolvedDir = resolve7(requestedDir);
-    if (!existsSync11(resolvedDir)) {
+    if (!existsSync12(resolvedDir)) {
       const msg = `❌ Directory does not exist: ${formatter.formatCode(initialOptions.workingDir)}`;
       if (startPost) {
         await platform.updatePost(startPost.id, msg);
@@ -68712,17 +69002,17 @@ async function startSessionImpl(options, username, displayName, replyToPostId, p
       return;
     }
     workingDir = resolvedDir;
-    log35.info(`Starting session in directory: ${workingDir} (from !cd command)`);
+    log36.info(`Starting session in directory: ${workingDir} (from !cd command)`);
   }
   if (initialOptions?.permissionMode) {
     permissionMode = initialOptions.permissionMode;
     forceInteractivePermissions = permissionMode === "default";
     sessionPermissionModeOverride = permissionMode;
-    log35.info(`Starting session with permission mode "${permissionMode}" (from !permissions command)`);
+    log36.info(`Starting session with permission mode "${permissionMode}" (from !permissions command)`);
   } else if (initialOptions?.forceInteractivePermissions) {
     forceInteractivePermissions = true;
     permissionMode = "default";
-    log35.info(`Starting session with interactive permissions (from !permissions command)`);
+    log36.info(`Starting session with interactive permissions (from !permissions command)`);
   }
   const userAttribution = ctx.config.userAttribution ?? true;
   const memoryConfig = ctx.ops.getPlatformMemoryConfig(platformId);
@@ -68736,7 +69026,7 @@ async function startSessionImpl(options, username, displayName, replyToPostId, p
     balanceByUsage: true
   });
   if (claudeAccount) {
-    log35.info(`Session ${sessionId.substring(0, 20)} reserved Claude account "${claudeAccount.id}"`);
+    log36.info(`Session ${sessionId.substring(0, 20)} reserved Claude account "${claudeAccount.id}"`);
   }
   const bridgeSessionRef = {};
   const decisionBridge = await createSessionDecisionBridge(bridgeSessionRef, ctx);
@@ -68877,7 +69167,7 @@ async function resumeSession(state, ctx, resumedBy) {
     const sessionKey = compositeSessionId(state.platformId, state.threadId);
     const sessions = ctx.state?.sessions;
     if (sessions?.has(sessionKey)) {
-      log35.debug(`Session ${state.threadId.substring(0, 8)}... already active, skipping resume`);
+      log36.debug(`Session ${state.threadId.substring(0, 8)}... already active, skipping resume`);
       return;
     }
     const inFlight = _inFlightSessionStarts.get(sessionKey);
@@ -68904,35 +69194,35 @@ async function resumeSessionImpl(state, ctx, resumedBy) {
       !state.claudeSessionId && "claudeSessionId",
       !state.workingDir && "workingDir"
     ].filter(Boolean).join(", ");
-    log35.warn(`Skipping session with missing required fields: ${missing}`);
+    log36.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) {
-    log35.warn(`Platform ${state.platformId} not registered, skipping resume for ${shortId}...`);
+    log36.warn(`Platform ${state.platformId} not registered, skipping resume for ${shortId}...`);
     return;
   }
   if (isDcmThreadId(state.threadId) && !platform.directChannelMode?.enabled) {
-    log35.warn(`Direct channel mode disabled for ${state.platformId}, dropping persisted DCM session`);
+    log36.warn(`Direct channel mode disabled for ${state.platformId}, dropping persisted DCM session`);
     ctx.state.sessionStore.remove(`${state.platformId}:${state.threadId}`);
     return;
   }
   if (!isDcmThreadId(state.threadId)) {
     const threadPost = await platform.getPost(state.threadId);
     if (!threadPost) {
-      log35.warn(`Thread ${shortId}... deleted, skipping resume`);
+      log36.warn(`Thread ${shortId}... deleted, skipping resume`);
       ctx.state.sessionStore.remove(`${state.platformId}:${state.threadId}`);
       return;
     }
   }
   if (ctx.state.sessions.size >= ctx.config.maxSessions) {
-    log35.warn(`Max sessions reached, skipping resume for ${shortId}...`);
+    log36.warn(`Max sessions reached, skipping resume for ${shortId}...`);
     return;
   }
-  if (!existsSync11(state.workingDir)) {
-    log35.warn(`Working directory ${state.workingDir} no longer exists, skipping resume for ${shortId}...`);
+  if (!existsSync12(state.workingDir)) {
+    log36.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 = {
@@ -68958,7 +69248,7 @@ Please start a new session.`), { action: "Post resume failure notification" });
   const appendSystemPrompt = await buildAppendSystemPrompt(platform, state.platformId, state.workingDir, state.threadId, state.startedBy, [...sessionAllowedUserSet(state)], CHAT_PLATFORM_PROMPT, ctx.state.githubEmailsStore, memoryConfig.enabled && memoryConfig.channelLayer ? ctx.state.memoryStore : null, { userAttribution });
   const claudeAccount = ctx.ops.acquireClaudeAccount(state.claudeAccountId, state.threadId);
   if (state.claudeAccountId && !claudeAccount) {
-    log35.warn(`Persisted session referenced Claude account "${state.claudeAccountId}" ` + `which is no longer configured — resuming under default env`);
+    log36.warn(`Persisted session referenced Claude account "${state.claudeAccountId}" ` + `which is no longer configured — resuming under default env`);
   }
   const resumeBridgeRef = {};
   const resumeBridge = await createSessionDecisionBridge(resumeBridgeRef, ctx);
@@ -69043,7 +69333,7 @@ Please start a new session.`), { action: "Post resume failure notification" });
         worktreePath: detected.worktreePath,
         branch: detected.branch
       };
-      log35.info(`Auto-detected worktree info for resumed session: branch=${detected.branch}`);
+      log36.info(`Auto-detected worktree info for resumed session: branch=${detected.branch}`);
     }
   }
   session.messageManager = createMessageManager(session, ctx);
@@ -69110,7 +69400,7 @@ ${sessionFormatter.formatItalic("Reconnected to Claude session. You can continue
     await postResumeCoAuthorOnboarding(session, ctx);
     ctx.ops.persistSession(session);
   } catch (err) {
-    log35.error(`Failed to resume session ${shortId}`, err instanceof Error ? err : undefined);
+    log36.error(`Failed to resume session ${shortId}`, err instanceof Error ? err : undefined);
     auditSessionEnd(session, "resume-failed");
     session.messageManager?.dispose();
     session.decisionBridge?.close();
@@ -69163,31 +69453,40 @@ async function sendFollowUp(session, message, files, ctx, username, displayName,
   await session.messageManager.handleUserMessage(message, files, username, displayName);
 }
 async function resumePausedSession(threadId, message, files, ctx, username, platformId) {
-  const persisted = ctx.state.sessionStore.load();
-  const state = findPersistedByThreadId(persisted, threadId, platformId);
+  const state = ctx.state.sessionStore.findByThreadIdAnyState(threadId, platformId);
   if (!state) {
-    log35.debug(`No persisted session found for ${threadId.substring(0, 8)}...`);
+    log36.debug(`No persisted session found for ${threadId.substring(0, 8)}...`);
+    return;
+  }
+  if (!isRevivable(state)) {
+    log36.debug(`Not resuming stopped session ${threadId.substring(0, 8)}... — it ended`);
     return;
   }
   const shortId = threadId.substring(0, 8);
   const platform = ctx.state.platforms.get(state.platformId);
   if (!platform) {
-    log35.warn(`auth.denied.resume: platform '${state.platformId}' not found for ${shortId}...`);
+    log36.warn(`auth.denied.resume: platform '${state.platformId}' not found for ${shortId}...`);
     return;
   }
   const sessionAllowedUsers = sessionAllowedUserSet(state);
   if (!isAuthorizedForSession({ username, platform, sessionAllowedUsers })) {
-    log35.warn(`auth.denied.resume: @${username || "unknown"} not authorized to resume ${shortId}...`);
+    log36.warn(`auth.denied.resume: @${username || "unknown"} not authorized to resume ${shortId}...`);
     return;
   }
-  log35.info(`\uD83D\uDD04 Resuming paused session ${shortId}... for new message`);
+  if (state.cleanedAt) {
+    log36.info(`\uD83E\uDEA6 Reviving soft-deleted session ${shortId}... (resumed by @${username})`);
+    delete state.cleanedAt;
+    delete state.endReason;
+    ctx.state.sessionStore.save(compositeSessionId(state.platformId, state.threadId), state);
+  }
+  log36.info(`\uD83D\uDD04 Resuming paused session ${shortId}... for new message`);
   await resumeSession(state, ctx, username);
-  const session = ctx.ops.findSessionByThreadId(threadId);
+  const session = ctx.state.sessions.get(compositeSessionId(state.platformId, state.threadId));
   if (session && session.claude.isRunning() && session.messageManager) {
     session.messageCount++;
     await session.messageManager.handleUserMessage(message, files, username);
   } else {
-    log35.warn(`Failed to resume session ${shortId}..., could not send message`);
+    log36.warn(`Failed to resume session ${shortId}..., could not send message`);
   }
 }
 async function handleExit(sessionId, code, ctx, source) {
@@ -69195,7 +69494,7 @@ async function handleExit(sessionId, code, ctx, source) {
   const shortId = sessionId.substring(0, 8);
   sessionLog11(session).debug(`handleExit called code=${code} isShuttingDown=${ctx.state.isShuttingDown}`);
   if (!session) {
-    log35.debug(`Session ${shortId}... not found (already cleaned up)`);
+    log36.debug(`Session ${shortId}... not found (already cleaned up)`);
     return;
   }
   if (source && session.claude !== source) {
@@ -69402,7 +69701,7 @@ async function cleanupIdleSessions(timeoutMs, warningMs, ctx) {
 
 // src/platform/dm-discovery-runtime.ts
 function createDmDiscoveryRuntime(deps) {
-  const { platforms, session, log: log36 } = deps;
+  const { platforms, session, log: log37 } = deps;
   const graceMs = deps.graceMs ?? 30000;
   const orphanTtlMs = deps.orphanTtlMs ?? 10 * 60000;
   const instanceByChannel = new Map;
@@ -69448,7 +69747,7 @@ function createDmDiscoveryRuntime(deps) {
     configureAuditLog(dmId, false);
     if (deps.isEnabled?.(dmId) !== false)
       deps.removeUiRow?.(dmId);
-    log36("info", `\uD83E\uDDF9 DM instance ${dmId} torn down (${reason})`);
+    log37("info", `\uD83E\uDDF9 DM instance ${dmId} torn down (${reason})`);
   };
   const register = (parentCfg, channelId, partnerUsernames) => {
     const dmConfig = deriveDmPlatformConfig(parentCfg, channelId, partnerUsernames);
@@ -69477,10 +69776,10 @@ function createDmDiscoveryRuntime(deps) {
       }
       const dmId = dmPlatformId(parentConfig.id, post2.channelId);
       if (deps.isEnabled && !deps.isEnabled(dmId)) {
-        log36("info", `Ignoring DM for disabled instance ${dmId}`);
+        log37("info", `Ignoring DM for disabled instance ${dmId}`);
         return;
       }
-      log36("info", `\uD83D\uDCE9 New DM conversation with @${username} — spawning ${dmId}`);
+      log37("info", `\uD83D\uDCE9 New DM conversation with @${username} — spawning ${dmId}`);
       const dmClient = register(parentConfig, post2.channelId, [username]);
       connecting.add(dmId);
       dmClient.connect().then(() => {
@@ -69490,7 +69789,7 @@ function createDmDiscoveryRuntime(deps) {
       }).catch((err) => {
         if (platforms.get(dmId) !== dmClient)
           return;
-        log36("error", `Failed to connect DM instance ${dmId}, discarding: ${err}`);
+        log37("error", `Failed to connect DM instance ${dmId}, discarding: ${err}`);
         (async () => {
           const threadId = dcmThreadId(dmId);
           const inFlightDeadline = Date.now() + 30000;
@@ -69499,7 +69798,7 @@ function createDmDiscoveryRuntime(deps) {
             if (!inFlight)
               break;
             if (Date.now() > inFlightDeadline) {
-              log36("warn", `In-flight session start for ${dmId} did not settle within 30s — proceeding with teardown`);
+              log37("warn", `In-flight session start for ${dmId} did not settle within 30s — proceeding with teardown`);
               break;
             }
             await Promise.race([
@@ -69514,7 +69813,7 @@ function createDmDiscoveryRuntime(deps) {
               try {
                 await session.cancelSession(threadId, dmClient.getBotName());
               } catch (cancelErr) {
-                log36("warn", `Failed to cancel stranded DM session ${threadId} (will be reaped by idle cleanup): ${cancelErr}`);
+                log37("warn", `Failed to cancel stranded DM session ${threadId} (will be reaped by idle cleanup): ${cancelErr}`);
               }
             }
           }
@@ -69524,7 +69823,7 @@ function createDmDiscoveryRuntime(deps) {
               return;
             if (!session.registry.findByThreadId(threadId))
               return;
-            log36("warn", `Sweeping session stranded on removed DM platform ${dmId}`);
+            log37("warn", `Sweeping session stranded on removed DM platform ${dmId}`);
             session.cancelSession(threadId, dmClient.getBotName()).catch(() => {});
           }, 2000);
         })();
@@ -69555,21 +69854,21 @@ function createDmDiscoveryRuntime(deps) {
         continue;
       const parentCfg = platformConfigs.filter((p) => p.type === "mattermost" && !!p.directMessages && pid.startsWith(`${p.id}${DM_PLATFORM_SEP}`)).sort((a, b) => b.id.length - a.id.length)[0];
       if (!parentCfg) {
-        log36("warn", `Skipping persisted DM session for ${pid} (parent missing, renamed, or directMessages off)`);
+        log37("warn", `Skipping persisted DM session for ${pid} (parent missing, renamed, or directMessages off)`);
         continue;
       }
       const channelId = pid.slice(parentCfg.id.length + DM_PLATFORM_SEP.length);
       if (instanceByChannel.has(channelId)) {
-        log36("warn", `Skipping persisted DM session for ${pid} (channel already owned by ${instanceByChannel.get(channelId)})`);
+        log37("warn", `Skipping persisted DM session for ${pid} (channel already owned by ${instanceByChannel.get(channelId)})`);
         continue;
       }
       if (!isEnabled(pid)) {
-        log36("info", `Skipping disabled DM instance ${pid}`);
+        log37("info", `Skipping disabled DM instance ${pid}`);
         skippedDisabled.push({ platformId: pid, channelId });
         continue;
       }
       const partners = persisted.sessionAllowedUsers && persisted.sessionAllowedUsers.length > 0 ? persisted.sessionAllowedUsers : [persisted.startedBy].filter((u) => !!u);
-      log36("info", `♻️ Reconstructing DM instance ${pid}`);
+      log37("info", `♻️ Reconstructing DM instance ${pid}`);
       register(parentCfg, channelId, partners);
       connecting.add(pid);
       reconstructed.set(pid, channelId);
@@ -69610,8 +69909,8 @@ function createDmDiscoveryRuntime(deps) {
 
 // src/onboarding.ts
 var import_prompts = __toESM(require_prompts3(), 1);
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
-import { join as join14, dirname as dirname8 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
+import { join as join15, dirname as dirname8 } from "path";
 import { spawn as spawn3 } from "child_process";
 import { fileURLToPath as fileURLToPath6 } from "url";
 
@@ -69676,7 +69975,7 @@ function overheadVisibilityChoiceIndex(mode) {
   return OVERHEAD_VISIBILITY_CHOICES.findIndex((c) => c.value === mode);
 }
 var __dirname6 = dirname8(fileURLToPath6(import.meta.url));
-var SLACK_MANIFEST_PATH = join14(__dirname6, "..", "docs", "slack-app-manifest.yaml");
+var SLACK_MANIFEST_PATH = join15(__dirname6, "..", "docs", "slack-app-manifest.yaml");
 var onCancel = () => {
   console.log("");
   console.log(dim("  Setup cancelled."));
@@ -69731,7 +70030,7 @@ async function showPlatformInstructions(platformType) {
   } else {
     let manifest;
     try {
-      manifest = readFileSync9(SLACK_MANIFEST_PATH, "utf-8");
+      manifest = readFileSync10(SLACK_MANIFEST_PATH, "utf-8");
     } catch {
       console.log("");
       console.log(dim("  ⚠️  Could not find Slack manifest file."));
@@ -69835,9 +70134,9 @@ async function runOnboarding(reconfigure = false) {
   console.log(dim("  ─────────────────────────────────"));
   console.log("");
   let existingConfig = null;
-  if (reconfigure && existsSync12(CONFIG_PATH)) {
+  if (reconfigure && existsSync13(CONFIG_PATH)) {
     try {
-      const content = readFileSync9(CONFIG_PATH, "utf-8");
+      const content = readFileSync10(CONFIG_PATH, "utf-8");
       existingConfig = yaml.load(content);
       console.log(dim("  Reconfiguring existing setup."));
     } catch {
@@ -70980,7 +71279,7 @@ async function setupSlackPlatform(id, existing) {
 // src/platform/base-client.ts
 init_logger();
 import { EventEmitter as EventEmitter3 } from "events";
-var log36 = createLogger("base-client");
+var log37 = createLogger("base-client");
 
 class BasePlatformClient extends EventEmitter3 {
   closeSocket(ws) {
@@ -71042,7 +71341,7 @@ class BasePlatformClient extends EventEmitter3 {
       try {
         await this.addReaction(post2.id, emoji);
       } catch (err) {
-        log36.warn(`Failed to add reaction ${emoji}: ${err}`);
+        log37.warn(`Failed to add reaction ${emoji}: ${err}`);
       }
     }
     return post2;
@@ -71069,7 +71368,7 @@ class BasePlatformClient extends EventEmitter3 {
     this.heartbeatInterval = setInterval(() => {
       const silentFor = Date.now() - this.lastMessageAt;
       if (silentFor > this.HEARTBEAT_TIMEOUT_MS) {
-        log36.warn(`Connection dead (no activity for ${Math.round(silentFor / 1000)}s), reconnecting...`);
+        log37.warn(`Connection dead (no activity for ${Math.round(silentFor / 1000)}s), reconnecting...`);
         this.stopHeartbeat();
         this.scheduleReconnect();
         return;
@@ -71089,7 +71388,7 @@ class BasePlatformClient extends EventEmitter3 {
       this.reconnectTimeout = null;
     }
     if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      log36.error("Max reconnection attempts reached");
+      log37.error("Max reconnection attempts reached");
       return;
     }
     this.forceCloseConnection();
@@ -71116,7 +71415,7 @@ class BasePlatformClient extends EventEmitter3 {
     this.emit("connected");
     if (this.isReconnecting) {
       this.recoverMissedMessages().catch((err) => {
-        log36.warn(`Failed to recover missed messages: ${err}`);
+        log37.warn(`Failed to recover missed messages: ${err}`);
       });
     }
     this.isReconnecting = false;
@@ -71150,7 +71449,7 @@ init_logger();
 // src/platform/mattermost/upload.ts
 init_logger();
 import { readFile as readFile3 } from "fs/promises";
-var log37 = createLogger("mm-upload");
+var log38 = createLogger("mm-upload");
 async function uploadFileMattermost(args) {
   const { url, token, channelId, threadId, filePath, filename, caption } = args;
   const buffer = await readFile3(filePath);
@@ -71158,7 +71457,7 @@ async function uploadFileMattermost(args) {
   const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
   const formData = new FormData;
   formData.append("files", new Blob([arrayBuffer]), filename);
-  log37.debug(`POST /files (${buffer.length} bytes, ${filename})`);
+  log38.debug(`POST /files (${buffer.length} bytes, ${filename})`);
   const uploadResponse = await fetch(uploadUrl, {
     method: "POST",
     headers: {
@@ -71182,7 +71481,7 @@ async function uploadFileMattermost(args) {
     root_id: resolvePostThreadId(threadId),
     file_ids: [fileInfo.id]
   };
-  log37.debug(`POST /posts (file_ids=[${fileInfo.id}])`);
+  log38.debug(`POST /posts (file_ids=[${fileInfo.id}])`);
   const postResponse = await fetch(postUrl, {
     method: "POST",
     headers: {
@@ -71269,7 +71568,7 @@ ${code}
 }
 
 // src/platform/mattermost/client.ts
-var log38 = createLogger("mattermost");
+var log39 = createLogger("mattermost");
 
 class MattermostClient extends BasePlatformClient {
   platformId;
@@ -71359,7 +71658,7 @@ class MattermostClient extends BasePlatformClient {
     const hasFileIds = fileIds && fileIds.length > 0;
     const hasFileMetadata = post2.metadata?.files && post2.metadata.files.length > 0;
     if (hasFileIds && !hasFileMetadata) {
-      log38.debug(`Post ${formatShortId(post2.id)} has ${fileIds.length} file(s), fetching metadata`);
+      log39.debug(`Post ${formatShortId(post2.id)} has ${fileIds.length} file(s), fetching metadata`);
       try {
         const files = [];
         for (const fileId of fileIds) {
@@ -71367,7 +71666,7 @@ class MattermostClient extends BasePlatformClient {
             const file = await this.api("GET", `/files/${fileId}/info`);
             files.push(file);
           } catch (err) {
-            log38.warn(`Failed to fetch file info for ${fileId}: ${err}`);
+            log39.warn(`Failed to fetch file info for ${fileId}: ${err}`);
           }
         }
         if (files.length > 0) {
@@ -71375,10 +71674,10 @@ class MattermostClient extends BasePlatformClient {
             ...post2.metadata,
             files
           };
-          log38.debug(`Enriched post ${formatShortId(post2.id)} with ${files.length} file(s)`);
+          log39.debug(`Enriched post ${formatShortId(post2.id)} with ${files.length} file(s)`);
         }
       } catch (err) {
-        log38.warn(`Failed to fetch file metadata for post ${formatShortId(post2.id)}: ${err}`);
+        log39.warn(`Failed to fetch file metadata for post ${formatShortId(post2.id)}: ${err}`);
       }
     }
   }
@@ -71388,7 +71687,7 @@ class MattermostClient extends BasePlatformClient {
       const user = await this.getUser(post2.user_id);
       this.emit("direct_message", this.normalizePlatformPost(post2), user);
     } catch (err) {
-      log38.warn(`Failed to emit direct message: ${err}`);
+      log39.warn(`Failed to emit direct message: ${err}`);
     }
   }
   MAX_RETRIES = 6;
@@ -71396,7 +71695,7 @@ class MattermostClient extends BasePlatformClient {
   RETRY_DELAY_CAP_MS = 2000;
   async api(method, path10, body, retryCount = 0, options) {
     const url = `${this.url}/api/v4${path10}`;
-    log38.debug(`API ${method} ${path10}`);
+    log39.debug(`API ${method} ${path10}`);
     const response = await fetch(url, {
       method,
       headers: {
@@ -71409,19 +71708,19 @@ class MattermostClient extends BasePlatformClient {
       const text = await response.text();
       if (response.status === 500 && retryCount < this.MAX_RETRIES) {
         const delay2 = this.retryDelayMs(retryCount);
-        log38.warn(`API ${method} ${path10} failed with 500, retrying in ${delay2}ms (attempt ${retryCount + 1}/${this.MAX_RETRIES})`);
+        log39.warn(`API ${method} ${path10} failed with 500, retrying in ${delay2}ms (attempt ${retryCount + 1}/${this.MAX_RETRIES})`);
         await new Promise((resolve7) => setTimeout(resolve7, delay2));
         return this.api(method, path10, body, retryCount + 1, options);
       }
       const isSilent = options?.silent?.includes(response.status);
       if (isSilent) {
-        log38.debug(`API ${method} ${path10} failed: ${response.status} (expected)`);
+        log39.debug(`API ${method} ${path10} failed: ${response.status} (expected)`);
       } else {
-        log38.warn(`API ${method} ${path10} failed: ${response.status} ${text.substring(0, 100)}`);
+        log39.warn(`API ${method} ${path10} failed: ${response.status} ${text.substring(0, 100)}`);
       }
       throw new Error(`Mattermost API error ${response.status}: ${text}`);
     }
-    log38.debug(`API ${method} ${path10} → ${response.status}`);
+    log39.debug(`API ${method} ${path10} → ${response.status}`);
     return response.json();
   }
   retryDelayMs(retryCount) {
@@ -71437,28 +71736,28 @@ class MattermostClient extends BasePlatformClient {
   async getUser(userId) {
     const cached = this.userCache.get(userId);
     if (cached) {
-      log38.debug(`User ${userId} found in cache: @${cached.username}`);
+      log39.debug(`User ${userId} found in cache: @${cached.username}`);
       return this.normalizePlatformUser(cached);
     }
     try {
       const user = await this.api("GET", `/users/${userId}`);
       this.userCache.set(userId, user);
-      log38.debug(`User ${userId} fetched: @${user.username}`);
+      log39.debug(`User ${userId} fetched: @${user.username}`);
       return this.normalizePlatformUser(user);
     } catch (err) {
-      log38.warn(`Failed to get user ${userId}: ${err}`);
+      log39.warn(`Failed to get user ${userId}: ${err}`);
       return null;
     }
   }
   async getUserByUsername(username) {
     try {
-      log38.debug(`Looking up user by username: @${username}`);
+      log39.debug(`Looking up user by username: @${username}`);
       const user = await this.api("GET", `/users/username/${username}`);
       this.userCache.set(user.id, user);
-      log38.debug(`User @${username} found: ${user.id}`);
+      log39.debug(`User @${username} found: ${user.id}`);
       return this.normalizePlatformUser(user);
     } catch (err) {
-      log38.warn(`User @${username} not found: ${err}`);
+      log39.warn(`User @${username} not found: ${err}`);
       return null;
     }
   }
@@ -71480,7 +71779,7 @@ class MattermostClient extends BasePlatformClient {
     return this.normalizePlatformPost(post2);
   }
   async addReaction(postId, emojiName) {
-    log38.debug(`Adding reaction :${emojiName}: to post ${postId.substring(0, 8)}`);
+    log39.debug(`Adding reaction :${emojiName}: to post ${postId.substring(0, 8)}`);
     await this.api("POST", "/reactions", {
       user_id: this.botUserId,
       post_id: postId,
@@ -71488,11 +71787,11 @@ class MattermostClient extends BasePlatformClient {
     });
   }
   async removeReaction(postId, emojiName) {
-    log38.debug(`Removing reaction :${emojiName}: from post ${postId.substring(0, 8)}`);
+    log39.debug(`Removing reaction :${emojiName}: from post ${postId.substring(0, 8)}`);
     await this.api("DELETE", `/users/${this.botUserId}/posts/${postId}/reactions/${emojiName}`);
   }
   async downloadFile(fileId) {
-    log38.debug(`Downloading file ${fileId}`);
+    log39.debug(`Downloading file ${fileId}`);
     const url = `${this.url}/api/v4/files/${fileId}`;
     const response = await fetch(url, {
       headers: {
@@ -71500,11 +71799,11 @@ class MattermostClient extends BasePlatformClient {
       }
     });
     if (!response.ok) {
-      log38.warn(`Failed to download file ${fileId}: ${response.status}`);
+      log39.warn(`Failed to download file ${fileId}: ${response.status}`);
       throw new Error(`Failed to download file ${fileId}: ${response.status}`);
     }
     const arrayBuffer = await response.arrayBuffer();
-    log38.debug(`Downloaded file ${fileId}: ${arrayBuffer.byteLength} bytes`);
+    log39.debug(`Downloaded file ${fileId}: ${arrayBuffer.byteLength} bytes`);
     return Buffer.from(arrayBuffer);
   }
   async getFileInfo(fileId) {
@@ -71526,24 +71825,24 @@ class MattermostClient extends BasePlatformClient {
   }
   async getPost(postId) {
     try {
-      log38.debug(`Fetching post ${postId.substring(0, 8)}`);
+      log39.debug(`Fetching post ${postId.substring(0, 8)}`);
       const post2 = await this.api("GET", `/posts/${postId}`);
       return this.normalizePlatformPost(post2);
     } catch (err) {
-      log38.debug(`Post ${postId.substring(0, 8)} not found: ${err}`);
+      log39.debug(`Post ${postId.substring(0, 8)} not found: ${err}`);
       return null;
     }
   }
   async deletePost(postId) {
-    log38.debug(`Deleting post ${postId.substring(0, 8)}`);
+    log39.debug(`Deleting post ${postId.substring(0, 8)}`);
     await this.api("DELETE", `/posts/${postId}`);
   }
   async pinPost(postId) {
-    log38.debug(`Pinning post ${postId.substring(0, 8)}`);
+    log39.debug(`Pinning post ${postId.substring(0, 8)}`);
     await this.api("POST", `/posts/${postId}/pin`);
   }
   async unpinPost(postId) {
-    log38.debug(`Unpinning post ${postId.substring(0, 8)}`);
+    log39.debug(`Unpinning post ${postId.substring(0, 8)}`);
     try {
       await this.api("POST", `/posts/${postId}/unpin`, undefined, 0, { silent: [403, 404] });
     } catch (err) {
@@ -71578,7 +71877,7 @@ class MattermostClient extends BasePlatformClient {
       }
       return messages;
     } catch (err) {
-      log38.warn(`Failed to get thread history for ${threadId}: ${err}`);
+      log39.warn(`Failed to get thread history for ${threadId}: ${err}`);
       return [];
     }
   }
@@ -71597,7 +71896,7 @@ class MattermostClient extends BasePlatformClient {
       posts.sort((a, b) => (a.createAt ?? 0) - (b.createAt ?? 0));
       return posts;
     } catch (err) {
-      log38.warn(`Failed to get channel posts after ${afterPostId}: ${err}`);
+      log39.warn(`Failed to get channel posts after ${afterPostId}: ${err}`);
       return [];
     }
   }
@@ -71710,13 +72009,13 @@ class MattermostClient extends BasePlatformClient {
     if (!this.lastProcessedPostId) {
       return;
     }
-    log38.info(`Recovering missed messages after post ${this.lastProcessedPostId}...`);
+    log39.info(`Recovering missed messages after post ${this.lastProcessedPostId}...`);
     const missedPosts = await this.getChannelPostsAfter(this.lastProcessedPostId);
     if (missedPosts.length === 0) {
-      log38.info("No missed messages to recover");
+      log39.info("No missed messages to recover");
       return;
     }
-    log38.info(`Recovered ${missedPosts.length} missed message(s)`);
+    log39.info(`Recovered ${missedPosts.length} missed message(s)`);
     for (const post2 of missedPosts) {
       this.lastProcessedPostId = post2.id;
       const user = await this.getUser(post2.userId);
@@ -71776,7 +72075,7 @@ init_logger();
 // src/platform/slack/upload.ts
 init_logger();
 import { readFile as readFile4 } from "fs/promises";
-var log39 = createLogger("slack-upload");
+var log40 = createLogger("slack-upload");
 var DEFAULT_API_URL = "https://slack.com/api";
 async function uploadFileSlack(args) {
   const { botToken, channelId, threadTs, filePath, filename, caption } = args;
@@ -71784,7 +72083,7 @@ async function uploadFileSlack(args) {
   const buffer = await readFile4(filePath);
   const params = new URLSearchParams({ filename, length: String(buffer.length) });
   const step1Url = `${apiUrl}/files.getUploadURLExternal?${params.toString()}`;
-  log39.debug(`GET files.getUploadURLExternal (${buffer.length} bytes, ${filename})`);
+  log40.debug(`GET files.getUploadURLExternal (${buffer.length} bytes, ${filename})`);
   const step1Response = await fetch(step1Url, {
     method: "GET",
     headers: {
@@ -71802,7 +72101,7 @@ async function uploadFileSlack(args) {
   const uploadUrl = step1Data.upload_url;
   const fileId = step1Data.file_id;
   const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
-  log39.debug(`POST <upload_url>`);
+  log40.debug(`POST <upload_url>`);
   const step2Response = await fetch(uploadUrl, {
     method: "POST",
     headers: {
@@ -71822,7 +72121,7 @@ async function uploadFileSlack(args) {
   if (caption !== undefined) {
     step3Body.initial_comment = caption;
   }
-  log39.debug(`POST files.completeUploadExternal (file_id=${fileId}, thread_ts=${threadTs})`);
+  log40.debug(`POST files.completeUploadExternal (file_id=${fileId}, thread_ts=${threadTs})`);
   const step3Response = await fetch(`${apiUrl}/files.completeUploadExternal`, {
     method: "POST",
     headers: {
@@ -71840,7 +72139,7 @@ async function uploadFileSlack(args) {
     throw new Error(`Slack completeUploadExternal error: ${step3Data.error || "unknown"}`);
   }
   if (!step3Data.ts) {
-    log39.warn(`Slack completeUploadExternal returned no ts; using fileId ${fileId} as postId. ` + `Do not use this id for updatePost/addReaction.`);
+    log40.warn(`Slack completeUploadExternal returned no ts; using fileId ${fileId} as postId. ` + `Do not use this id for updatePost/addReaction.`);
   }
   return { fileId, postId: step3Data.ts ?? fileId };
 }
@@ -71915,7 +72214,7 @@ ${code}
 }
 
 // src/platform/slack/client.ts
-var log40 = createLogger("slack");
+var log41 = createLogger("slack");
 
 class SlackClient extends BasePlatformClient {
   platformId;
@@ -71984,7 +72283,7 @@ class SlackClient extends BasePlatformClient {
       return;
     for (const secondary of this.channelClients.values()) {
       secondary.recoverMissedMessages().catch((err) => {
-        log40.warn(`Failed to recover missed messages for ${secondary.platformId}: ${err}`);
+        log41.warn(`Failed to recover missed messages for ${secondary.platformId}: ${err}`);
       });
     }
   }
@@ -72052,13 +72351,13 @@ class SlackClient extends BasePlatformClient {
       const now = Date.now();
       if (now < this.rateLimitRetryAfter) {
         const waitTime = this.rateLimitRetryAfter - now;
-        log40.debug(`Rate limited, waiting ${waitTime}ms`);
+        log41.debug(`Rate limited, waiting ${waitTime}ms`);
         await new Promise((resolve7) => setTimeout(resolve7, waitTime));
       }
       this.rateLimitDelay = 0;
     }
     const url = `${this.apiUrl}/${endpoint}`;
-    log40.debug(`API ${method} ${endpoint}`);
+    log41.debug(`API ${method} ${endpoint}`);
     const headers = {
       Authorization: `Bearer ${this.botToken}`,
       "Content-Type": "application/json; charset=utf-8"
@@ -72070,25 +72369,25 @@ class SlackClient extends BasePlatformClient {
     });
     if (response.status === 429) {
       if (retryCount >= this.MAX_RATE_LIMIT_RETRIES) {
-        log40.error(`Rate limit max retries (${this.MAX_RATE_LIMIT_RETRIES}) exceeded for ${endpoint}`);
+        log41.error(`Rate limit max retries (${this.MAX_RATE_LIMIT_RETRIES}) exceeded for ${endpoint}`);
         throw new Error(`Slack API rate limit exceeded after ${this.MAX_RATE_LIMIT_RETRIES} retries`);
       }
       const retryAfter = parseInt(response.headers.get("Retry-After") || "5", 10);
       this.rateLimitDelay = retryAfter * 1000;
       this.rateLimitRetryAfter = Date.now() + this.rateLimitDelay;
-      log40.warn(`Rate limited by Slack, retrying after ${retryAfter}s (attempt ${retryCount + 1}/${this.MAX_RATE_LIMIT_RETRIES})`);
+      log41.warn(`Rate limited by Slack, retrying after ${retryAfter}s (attempt ${retryCount + 1}/${this.MAX_RATE_LIMIT_RETRIES})`);
       await new Promise((resolve7) => setTimeout(resolve7, this.rateLimitDelay));
       return this.api(method, endpoint, body, retryCount + 1);
     }
     if (!response.ok) {
       const text = await response.text();
-      log40.warn(`API ${method} ${endpoint} failed: ${response.status} ${text.substring(0, 100)}`);
+      log41.warn(`API ${method} ${endpoint} failed: ${response.status} ${text.substring(0, 100)}`);
       throw new Error(`Slack API error ${response.status}: ${text}`);
     }
     const data = await response.json();
     if (!data.ok) {
       if (!expectedErrors.includes(data.error || "")) {
-        log40.warn(`API ${method} ${endpoint} error: ${data.error}`);
+        log41.warn(`API ${method} ${endpoint} error: ${data.error}`);
       }
       throw new Error(`Slack API error: ${data.error}`);
     }
@@ -72096,7 +72395,7 @@ class SlackClient extends BasePlatformClient {
   }
   async appApi(method, endpoint, body) {
     const url = `${this.apiUrl}/${endpoint}`;
-    log40.debug(`App API ${method} ${endpoint}`);
+    log41.debug(`App API ${method} ${endpoint}`);
     const headers = {
       Authorization: `Bearer ${this.appToken}`,
       "Content-Type": "application/json; charset=utf-8"
@@ -72287,7 +72586,7 @@ class SlackClient extends BasePlatformClient {
           this.emit("channel_post", post2, user);
         }
       }).catch((err) => {
-        log40.warn(`Failed to get user for message event: ${err}`);
+        log41.warn(`Failed to get user for message event: ${err}`);
         this.emit("message", post2, null);
       });
     }
@@ -72307,7 +72606,7 @@ class SlackClient extends BasePlatformClient {
       this.getUser(event.user || "").then((user) => {
         this.emit("reaction", reaction, user);
       }).catch((err) => {
-        log40.warn(`Failed to get user for reaction event: ${err}`);
+        log41.warn(`Failed to get user for reaction event: ${err}`);
         this.emit("reaction", reaction, null);
       });
     }
@@ -72327,7 +72626,7 @@ class SlackClient extends BasePlatformClient {
       this.getUser(event.user || "").then((user) => {
         this.emit("reaction_removed", reaction, user);
       }).catch((err) => {
-        log40.warn(`Failed to get user for reaction_removed event: ${err}`);
+        log41.warn(`Failed to get user for reaction_removed event: ${err}`);
         this.emit("reaction_removed", reaction, null);
       });
     }
@@ -72341,15 +72640,15 @@ class SlackClient extends BasePlatformClient {
     if (!this.lastProcessedTs) {
       return;
     }
-    log40.info(`Recovering missed messages after ts ${this.lastProcessedTs}...`);
+    log41.info(`Recovering missed messages after ts ${this.lastProcessedTs}...`);
     try {
       const response = await this.api("GET", `conversations.history?channel=${this.channelId}&oldest=${this.lastProcessedTs}&inclusive=false&limit=100`);
       const messages = response.messages || [];
       if (messages.length === 0) {
-        log40.info("No missed messages to recover");
+        log41.info("No missed messages to recover");
         return;
       }
-      log40.info(`Recovered ${messages.length} missed message(s)`);
+      log41.info(`Recovered ${messages.length} missed message(s)`);
       const sortedMessages = messages.sort((a, b) => parseFloat(a.ts) - parseFloat(b.ts));
       for (const message of sortedMessages) {
         if (this.isBotAuthored(message)) {
@@ -72364,7 +72663,7 @@ class SlackClient extends BasePlatformClient {
         }
       }
     } catch (err) {
-      log40.warn(`Failed to recover missed messages: ${err}`);
+      log41.warn(`Failed to recover missed messages: ${err}`);
     }
   }
   async fetchBotUser() {
@@ -72389,17 +72688,17 @@ class SlackClient extends BasePlatformClient {
     }
     const cached = this.userCache.get(userId);
     if (cached) {
-      log40.debug(`User ${userId} found in cache: @${cached.name}`);
+      log41.debug(`User ${userId} found in cache: @${cached.name}`);
       return this.normalizePlatformUser(cached);
     }
     try {
       const response = await this.api("GET", `users.info?user=${userId}`);
       this.userCache.set(userId, response.user);
       this.usernameToIdCache.set(response.user.name, userId);
-      log40.debug(`User ${userId} fetched: @${response.user.name}`);
+      log41.debug(`User ${userId} fetched: @${response.user.name}`);
       return this.normalizePlatformUser(response.user);
     } catch (err) {
-      log40.warn(`Failed to get user ${userId}: ${err}`);
+      log41.warn(`Failed to get user ${userId}: ${err}`);
       return null;
     }
   }
@@ -72409,7 +72708,7 @@ class SlackClient extends BasePlatformClient {
       return this.getUser(cachedId);
     }
     try {
-      log40.debug(`Looking up user by username: @${username}`);
+      log41.debug(`Looking up user by username: @${username}`);
       let cursor;
       do {
         const params = cursor ? `cursor=${cursor}&limit=200` : "limit=200";
@@ -72418,16 +72717,16 @@ class SlackClient extends BasePlatformClient {
           this.userCache.set(user.id, user);
           this.usernameToIdCache.set(user.name, user.id);
           if (user.name === username) {
-            log40.debug(`User @${username} found: ${user.id}`);
+            log41.debug(`User @${username} found: ${user.id}`);
             return this.normalizePlatformUser(user);
           }
         }
         cursor = response.response_metadata?.next_cursor;
       } while (cursor);
-      log40.warn(`User @${username} not found`);
+      log41.warn(`User @${username} not found`);
       return null;
     } catch (err) {
-      log40.warn(`Failed to lookup user @${username}: ${err}`);
+      log41.warn(`Failed to lookup user @${username}: ${err}`);
       return null;
     }
   }
@@ -72515,19 +72814,19 @@ class SlackClient extends BasePlatformClient {
       }
       return null;
     } catch (err) {
-      log40.debug(`Post ${postId.substring(0, 12)} not found: ${err}`);
+      log41.debug(`Post ${postId.substring(0, 12)} not found: ${err}`);
       return null;
     }
   }
   async deletePost(postId) {
-    log40.debug(`Deleting post ${postId.substring(0, 12)}`);
+    log41.debug(`Deleting post ${postId.substring(0, 12)}`);
     await this.api("POST", "chat.delete", {
       channel: this.channelId,
       ts: postId
     });
   }
   async pinPost(postId) {
-    log40.debug(`Pinning post ${postId.substring(0, 12)}`);
+    log41.debug(`Pinning post ${postId.substring(0, 12)}`);
     try {
       await this.api("POST", "pins.add", {
         channel: this.channelId,
@@ -72535,14 +72834,14 @@ class SlackClient extends BasePlatformClient {
       }, 0, ["already_pinned"]);
     } catch (err) {
       if (err instanceof Error && err.message.includes("already_pinned")) {
-        log40.debug(`Post ${postId.substring(0, 12)} already pinned`);
+        log41.debug(`Post ${postId.substring(0, 12)} already pinned`);
         return;
       }
       throw err;
     }
   }
   async unpinPost(postId) {
-    log40.debug(`Unpinning post ${postId.substring(0, 12)}`);
+    log41.debug(`Unpinning post ${postId.substring(0, 12)}`);
     try {
       await this.api("POST", "pins.remove", {
         channel: this.channelId,
@@ -72550,7 +72849,7 @@ class SlackClient extends BasePlatformClient {
       }, 0, ["no_pin"]);
     } catch (err) {
       if (err instanceof Error && err.message.includes("no_pin")) {
-        log40.debug(`Post ${postId.substring(0, 12)} was not pinned`);
+        log41.debug(`Post ${postId.substring(0, 12)} was not pinned`);
         return;
       }
       throw err;
@@ -72568,7 +72867,7 @@ class SlackClient extends BasePlatformClient {
     if (message.length <= maxLength) {
       return message;
     }
-    log40.warn(`Truncating message from ${message.length} to ~${maxLength} chars`);
+    log41.warn(`Truncating message from ${message.length} to ~${maxLength} chars`);
     return truncateMessageSafely(message, maxLength, "_... (truncated)_");
   }
   async getThreadHistory(threadId, options) {
@@ -72592,7 +72891,7 @@ class SlackClient extends BasePlatformClient {
         if (!cursor)
           break;
         if (page === MAX_PAGES - 1 && options?.limit) {
-          log40.warn(`Thread ${threadId} exceeds ${MAX_PAGES * 1000} messages — walk stopped early, the NEWEST messages are missing from context`);
+          log41.warn(`Thread ${threadId} exceeds ${MAX_PAGES * 1000} messages — walk stopped early, the NEWEST messages are missing from context`);
         }
       }
       const kept = filtered;
@@ -72609,13 +72908,13 @@ class SlackClient extends BasePlatformClient {
       }
       return messages;
     } catch (err) {
-      log40.warn(`Failed to get thread history for ${threadId}: ${err}`);
+      log41.warn(`Failed to get thread history for ${threadId}: ${err}`);
       return [];
     }
   }
   async addReaction(postId, emojiName) {
     const name = getEmojiName(emojiName);
-    log40.debug(`Adding reaction :${name}: to post ${postId.substring(0, 12)}`);
+    log41.debug(`Adding reaction :${name}: to post ${postId.substring(0, 12)}`);
     await this.api("POST", "reactions.add", {
       channel: this.channelId,
       timestamp: postId,
@@ -72624,7 +72923,7 @@ class SlackClient extends BasePlatformClient {
   }
   async removeReaction(postId, emojiName) {
     const name = getEmojiName(emojiName);
-    log40.debug(`Removing reaction :${name}: from post ${postId.substring(0, 12)}`);
+    log41.debug(`Removing reaction :${name}: from post ${postId.substring(0, 12)}`);
     await this.api("POST", "reactions.remove", {
       channel: this.channelId,
       timestamp: postId,
@@ -72650,7 +72949,7 @@ class SlackClient extends BasePlatformClient {
   }
   sendTyping(_threadId) {}
   async downloadFile(fileId) {
-    log40.debug(`Downloading file ${fileId}`);
+    log41.debug(`Downloading file ${fileId}`);
     const fileInfo = await this.api("GET", `files.info?file=${fileId}`);
     const downloadUrl = fileInfo.file.url_private_download || fileInfo.file.url_private;
     if (!downloadUrl) {
@@ -72662,11 +72961,11 @@ class SlackClient extends BasePlatformClient {
       }
     });
     if (!response.ok) {
-      log40.warn(`Failed to download file ${fileId}: ${response.status}`);
+      log41.warn(`Failed to download file ${fileId}: ${response.status}`);
       throw new Error(`Failed to download file ${fileId}: ${response.status}`);
     }
     const arrayBuffer = await response.arrayBuffer();
-    log40.debug(`Downloaded file ${fileId}: ${arrayBuffer.byteLength} bytes`);
+    log41.debug(`Downloaded file ${fileId}: ${arrayBuffer.byteLength} bytes`);
     return Buffer.from(arrayBuffer);
   }
   async getFileInfo(fileId) {
@@ -73465,285 +73764,6 @@ function slackMessageToMcpPost(message, channelId, username) {
 // src/session/manager.ts
 import { EventEmitter as EventEmitter4 } from "events";
 
-// src/persistence/session-store.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync10 } from "fs";
-init_logger();
-import { homedir as homedir8 } from "os";
-import { join as join15 } from "path";
-var log41 = createLogger("persist");
-var STORE_VERSION3 = 2;
-var DEFAULT_CONFIG_DIR2 = join15(homedir8(), ".config", "claude-threads");
-var DEFAULT_SESSIONS_FILE = join15(DEFAULT_CONFIG_DIR2, "sessions.json");
-
-class SessionStore {
-  sessionsFile;
-  configDir;
-  constructor(sessionsPath) {
-    const envPath = process.env.CLAUDE_THREADS_SESSIONS_PATH;
-    const effectivePath = sessionsPath ?? envPath;
-    if (effectivePath) {
-      this.sessionsFile = effectivePath;
-      this.configDir = join15(effectivePath, "..");
-    } else {
-      this.sessionsFile = DEFAULT_SESSIONS_FILE;
-      this.configDir = DEFAULT_CONFIG_DIR2;
-    }
-    if (!existsSync13(this.configDir)) {
-      mkdirSync7(this.configDir, { recursive: true });
-    }
-  }
-  load() {
-    const sessions = new Map;
-    if (!existsSync13(this.sessionsFile)) {
-      log41.debug("No sessions file found");
-      return sessions;
-    }
-    try {
-      const data = this.loadRaw();
-      if (data.version === 1) {
-        log41.info("Migrating sessions from v1 to v2 (adding platformId)");
-        const newSessions = {};
-        for (const [_oldKey, session] of Object.entries(data.sessions)) {
-          const v1Session = session;
-          if (!v1Session.platformId) {
-            v1Session.platformId = "default";
-          }
-          const newKey = `${v1Session.platformId}:${v1Session.threadId}`;
-          newSessions[newKey] = v1Session;
-        }
-        data.sessions = newSessions;
-        data.version = 2;
-        this.writeAtomic(data);
-      } else if (data.version !== STORE_VERSION3) {
-        log41.warn(`Sessions file version ${data.version} not supported, starting fresh`);
-        return sessions;
-      }
-      for (const session of Object.values(data.sessions)) {
-        if (session.cleanedAt)
-          continue;
-        const sessionId = `${session.platformId}:${session.threadId}`;
-        sessions.set(sessionId, session);
-      }
-      log41.debug(`Loaded ${sessions.size} active session(s)`);
-    } catch (err) {
-      log41.error(`Failed to load sessions: ${err}`);
-    }
-    return sessions;
-  }
-  save(sessionId, session) {
-    const data = this.loadRaw();
-    data.sessions[sessionId] = session;
-    this.writeAtomic(data);
-    const shortId = sessionId.substring(0, 20);
-    log41.debug(`Saved session ${shortId}...`);
-  }
-  remove(sessionId) {
-    const data = this.loadRaw();
-    if (data.sessions[sessionId]) {
-      delete data.sessions[sessionId];
-      this.writeAtomic(data);
-      const shortId = sessionId.substring(0, 20);
-      log41.debug(`Removed session ${shortId}...`);
-    }
-  }
-  softDelete(sessionId) {
-    const data = this.loadRaw();
-    if (data.sessions[sessionId]) {
-      data.sessions[sessionId].cleanedAt = new Date().toISOString();
-      this.writeAtomic(data);
-      const shortId = sessionId.substring(0, 20);
-      log41.debug(`Soft-deleted session ${shortId}...`);
-    }
-  }
-  cleanStale(maxAgeMs) {
-    const data = this.loadRaw();
-    const now = Date.now();
-    const staleIds = [];
-    for (const [sessionId, session] of Object.entries(data.sessions)) {
-      if (session.cleanedAt)
-        continue;
-      const lastActivity = new Date(session.lastActivityAt).getTime();
-      if (now - lastActivity > maxAgeMs) {
-        staleIds.push(sessionId);
-        session.cleanedAt = new Date().toISOString();
-      }
-    }
-    if (staleIds.length > 0) {
-      this.writeAtomic(data);
-      log41.debug(`Soft-deleted ${staleIds.length} stale session(s)`);
-    }
-    return staleIds;
-  }
-  cleanHistory(historyRetentionMs = 3 * 24 * 60 * 60 * 1000) {
-    const data = this.loadRaw();
-    const now = Date.now();
-    let removedCount = 0;
-    for (const [sessionId, session] of Object.entries(data.sessions)) {
-      if (!session.cleanedAt)
-        continue;
-      const cleanedTime = new Date(session.cleanedAt).getTime();
-      if (now - cleanedTime > historyRetentionMs) {
-        delete data.sessions[sessionId];
-        removedCount++;
-      }
-    }
-    if (removedCount > 0) {
-      this.writeAtomic(data);
-      log41.debug(`Permanently removed ${removedCount} old session(s) from history`);
-    }
-    return removedCount;
-  }
-  getHistory(platformId, activeSessions) {
-    const data = this.loadRaw();
-    const historySessions = [];
-    for (const [sessionId, session] of Object.entries(data.sessions)) {
-      if (session.platformId !== platformId)
-        continue;
-      if (session.cleanedAt) {
-        historySessions.push(session);
-        continue;
-      }
-      if (session.lifecyclePostId && activeSessions && !activeSessions.has(sessionId)) {
-        historySessions.push(session);
-      }
-    }
-    return historySessions.sort((a, b) => {
-      const aTime = new Date(a.cleanedAt || a.lastActivityAt).getTime();
-      const bTime = new Date(b.cleanedAt || b.lastActivityAt).getTime();
-      return bTime - aTime;
-    });
-  }
-  clear() {
-    const data = this.loadRaw();
-    this.writeAtomic({ version: STORE_VERSION3, sessions: {}, stickyPostIds: data.stickyPostIds });
-    log41.debug("Cleared all sessions");
-  }
-  saveStickyPostId(platformId, postId) {
-    const data = this.loadRaw();
-    if (!data.stickyPostIds) {
-      data.stickyPostIds = {};
-    }
-    data.stickyPostIds[platformId] = postId;
-    this.writeAtomic(data);
-    log41.debug(`Saved sticky post ID for ${platformId}: ${postId.substring(0, 8)}...`);
-  }
-  getStickyPostIds() {
-    const data = this.loadRaw();
-    return new Map(Object.entries(data.stickyPostIds || {}));
-  }
-  removeStickyPostId(platformId) {
-    const data = this.loadRaw();
-    if (data.stickyPostIds && data.stickyPostIds[platformId]) {
-      delete data.stickyPostIds[platformId];
-      this.writeAtomic(data);
-      log41.debug(`Removed sticky post ID for ${platformId}`);
-    }
-  }
-  getPlatformEnabledState() {
-    const data = this.loadRaw();
-    return new Map(Object.entries(data.platformEnabledState || {}));
-  }
-  isPlatformEnabled(platformId) {
-    const data = this.loadRaw();
-    return data.platformEnabledState?.[platformId] ?? true;
-  }
-  setPlatformEnabled(platformId, enabled) {
-    const data = this.loadRaw();
-    if (!data.platformEnabledState) {
-      data.platformEnabledState = {};
-    }
-    data.platformEnabledState[platformId] = enabled;
-    this.writeAtomic(data);
-    log41.debug(`Set platform ${platformId} enabled state to ${enabled}`);
-  }
-  findByThread(platformId, threadId) {
-    const sessionId = `${platformId}:${threadId}`;
-    const data = this.loadRaw();
-    return data.sessions[sessionId];
-  }
-  findByThreadIdAnyState(threadId, platformId) {
-    const data = this.loadRaw();
-    for (const session of Object.values(data.sessions)) {
-      if (session.threadId !== threadId)
-        continue;
-      if (platformId !== undefined && session.platformId !== platformId)
-        continue;
-      return session;
-    }
-    return;
-  }
-  findByPostId(platformId, postId) {
-    const data = this.loadRaw();
-    for (const session of Object.values(data.sessions)) {
-      if (session.platformId !== platformId)
-        continue;
-      if (session.lifecyclePostId === postId || session.sessionStartPostId === postId) {
-        return session;
-      }
-    }
-    return;
-  }
-  getStats() {
-    const data = this.loadRaw();
-    return data.stats ?? { totalSessionsStarted: 0 };
-  }
-  recordSessionStarted() {
-    const data = this.loadRaw();
-    const stats = data.stats ?? { totalSessionsStarted: 0 };
-    stats.totalSessionsStarted = (stats.totalSessionsStarted ?? 0) + 1;
-    const milestone = milestoneReached(stats.totalSessionsStarted);
-    if (milestone) {
-      stats.milestone = { n: milestone, reachedAt: new Date().toISOString() };
-    }
-    data.stats = stats;
-    this.writeAtomic(data);
-    return stats.totalSessionsStarted;
-  }
-  lastReadDegraded = false;
-  loadRaw() {
-    if (!existsSync13(this.sessionsFile)) {
-      this.lastReadDegraded = false;
-      return { version: STORE_VERSION3, sessions: {} };
-    }
-    try {
-      const raw = readFileSync10(this.sessionsFile, "utf-8");
-      if (raw.trim() === "") {
-        this.lastReadDegraded = false;
-        return { version: STORE_VERSION3, sessions: {} };
-      }
-      const data = JSON.parse(raw);
-      if (!data || typeof data !== "object") {
-        this.lastReadDegraded = true;
-        return { version: STORE_VERSION3, sessions: {} };
-      }
-      if (data.sessions === undefined || data.sessions === null) {
-        this.lastReadDegraded = false;
-        data.sessions = {};
-      } else if (typeof data.sessions !== "object") {
-        this.lastReadDegraded = true;
-        data.sessions = {};
-      } else {
-        this.lastReadDegraded = false;
-      }
-      if (!data.version) {
-        data.version = STORE_VERSION3;
-      }
-      return data;
-    } catch (err) {
-      log41.warn(`Failed to read ${this.sessionsFile}: ${err.message} — reads degrade to empty`);
-      this.lastReadDegraded = true;
-      return { version: STORE_VERSION3, sessions: {} };
-    }
-  }
-  writeAtomic(data) {
-    if (this.lastReadDegraded) {
-      log41.error(`Refusing to write ${this.sessionsFile}: the last read of the existing file was degraded — writing would destroy persisted sessions`);
-      return;
-    }
-    writeFileAtomic(this.sessionsFile, JSON.stringify(data, null, 2));
-  }
-}
-
 // src/watches/evaluator.ts
 init_quick_query();
 
@@ -74817,6 +74837,10 @@ async function tryResumeFromReaction(deps, platformId, postId, username) {
   const persistedSession = deps.sessionStore.findByPostId(platformId, postId);
   if (!persistedSession)
     return false;
+  if (!isRevivable(persistedSession)) {
+    log50.debug(`Ignoring resume reaction on stopped session ${persistedSession.threadId.substring(0, 8)}...`);
+    return false;
+  }
   const sessionId = `${platformId}:${persistedSession.threadId}`;
   if (deps.registry.hasById(sessionId))
     return false;
@@ -75318,7 +75342,7 @@ class SessionManager extends EventEmitter4 {
     this.sessionStore.save(session.sessionId, state);
   }
   unpersistSession(sessionId) {
-    this.sessionStore.softDelete(sessionId);
+    this.sessionStore.softDelete(sessionId, "stopped");
   }
   async updateSessionHeader(session) {
     await updateSessionHeader(session, this.getContext());
@@ -75560,7 +75584,7 @@ class SessionManager extends EventEmitter4 {
     const persisted = this.registry.getPersistedByThreadId(threadId, platformId);
     if (persisted) {
       const sessionId = `${persisted.platformId}:${persisted.threadId}`;
-      this.sessionStore.softDelete(sessionId);
+      this.sessionStore.softDelete(sessionId, "stopped");
     }
   }
   async killSession(threadId, unpersist = true) {
@@ -85501,6 +85525,7 @@ init_logger();
 // src/message-handler.ts
 init_logger();
 var ackLog = createLogger("ack");
+var PAUSED_SAFE_COMMANDS = new Set(["help", "release-notes", "usage"]);
 var BOLD = String.raw`(?:\*{1,2}|_{1,2})?`;
 var STATUS_POST_PATTERNS = [
   /^⚠️\s+\S+ is not authorized\b/u,
@@ -85675,7 +85700,30 @@ async function handleMessage(client, session, post2, user, options) {
               await client.createPost(`\uD83D\uDED1 ${formatter.formatBold("Session cancelled")} by ${formatter.formatUserMention(username)}`, threadRoot);
             }
           }
+          return;
+        }
+        if (!client.isUserAllowed(username)) {
+          logger?.debug?.(`!${pausedParsed.command} from unauthorized @${username} in paused thread ${threadRoot} — dropped`);
+          return;
+        }
+        if (!PAUSED_SAFE_COMMANDS.has(pausedParsed.command)) {
+          logger?.debug?.(`!${pausedParsed.command} from @${username} needs an active session; thread ${threadRoot} is paused — dropped`);
+          return;
         }
+        const immediateCtx = {
+          commandContext: "first-message",
+          threadId: threadRoot,
+          username,
+          client,
+          sessionManager: session,
+          formatter,
+          isAllowed: true,
+          files: post2.metadata?.files
+        };
+        const immediate = await executeCommand(pausedParsed.command, pausedParsed.args, immediateCtx);
+        if (immediate.handled)
+          return;
+        logger?.debug?.(`!${pausedParsed.command} from @${username} needs an active session; thread ${threadRoot} is paused — dropped`);
         return;
       }
       const persistedSession = session.getPersistedSession(threadRoot, platformId);
@@ -85735,6 +85783,14 @@ async function handleMessage(client, session, post2, user, options) {
       isAllowed: true,
       files
     };
+    const firstMessageCommand = parseCommand(prompt);
+    if (firstMessageCommand && !firstMessageCommand.args?.trim()) {
+      const def = COMMAND_REGISTRY.find((c) => c.command === firstMessageCommand.command);
+      if (def && !def.worksInFirstMessage) {
+        logger?.debug?.(`!${firstMessageCommand.command} needs an active session; ${threadRoot} has none — dropped`);
+        return;
+      }
+    }
     let continueProcessing = true;
     while (continueProcessing) {
       continueProcessing = false;