claude-threads 1.27.0 → 1.28.0

package/dist/index.js

@@ -4153,10 +4153,10 @@ __export(exports_worktree, {
 import { randomUUID as randomUUID2 } from "crypto";
 import * as path from "path";
 import * as fs from "fs/promises";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 async function execGit(args, cwd) {
   const cmd = `git ${args.join(" ")}`;
-  log7.debug(`Executing: ${cmd}`);
+  log8.debug(`Executing: ${cmd}`);
   return new Promise((resolve6, reject) => {
     const proc = crossSpawn("git", args, { cwd });
     let stdout = "";
@@ -4169,15 +4169,15 @@ async function execGit(args, cwd) {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        log7.debug(`${cmd} → success`);
+        log8.debug(`${cmd} → success`);
         resolve6(stdout.trim());
       } else {
-        log7.debug(`${cmd} → failed (code=${code}): ${stderr.substring(0, 100) || stdout.substring(0, 100)}`);
+        log8.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) => {
-      log7.warn(`${cmd} → error: ${err}`);
+      log8.warn(`${cmd} → error: ${err}`);
       reject(err);
     });
   });
@@ -4187,7 +4187,7 @@ async function isGitRepository(dir) {
     await execGit(["rev-parse", "--git-dir"], dir);
     return true;
   } catch (err) {
-    log7.debug(`Not a git repository: ${dir} (${err})`);
+    log8.debug(`Not a git repository: ${dir} (${err})`);
     return false;
   }
 }
@@ -4337,49 +4337,49 @@ async function detectWorktreeInfo(workingDir) {
     const branchOutput = await execGit(["rev-parse", "--abbrev-ref", "HEAD"], workingDir);
     const branch = branchOutput?.trim();
     if (!branch) {
-      log7.debug(`Could not detect branch for worktree at ${workingDir}`);
+      log8.debug(`Could not detect branch for worktree at ${workingDir}`);
       return null;
     }
     const repoRoot = await getMainRepositoryRoot(workingDir);
-    log7.debug(`Detected worktree: path=${workingDir}, branch=${branch}, repoRoot=${repoRoot}`);
+    log8.debug(`Detected worktree: path=${workingDir}, branch=${branch}, repoRoot=${repoRoot}`);
     return {
       worktreePath: workingDir,
       branch,
       repoRoot: repoRoot || workingDir
     };
   } catch (err) {
-    log7.debug(`Failed to detect worktree info for ${workingDir}: ${err}`);
+    log8.debug(`Failed to detect worktree info for ${workingDir}: ${err}`);
     return null;
   }
 }
 async function createWorktree(repoRoot, branch, targetDir) {
-  log7.info(`Creating worktree for branch '${branch}' at ${targetDir}`);
+  log8.info(`Creating worktree for branch '${branch}' at ${targetDir}`);
   const parentDir = path.dirname(targetDir);
-  log7.debug(`Creating parent directory: ${parentDir}`);
+  log8.debug(`Creating parent directory: ${parentDir}`);
   await fs.mkdir(parentDir, { recursive: true });
   const exists = await branchExists(repoRoot, branch);
   if (exists) {
-    log7.debug(`Branch '${branch}' exists, adding worktree`);
+    log8.debug(`Branch '${branch}' exists, adding worktree`);
     await execGit(["worktree", "add", targetDir, branch], repoRoot);
   } else {
-    log7.debug(`Branch '${branch}' does not exist, creating with worktree`);
+    log8.debug(`Branch '${branch}' does not exist, creating with worktree`);
     await execGit(["worktree", "add", "-b", branch, targetDir], repoRoot);
   }
-  log7.info(`Worktree created successfully: ${targetDir}`);
+  log8.info(`Worktree created successfully: ${targetDir}`);
   return targetDir;
 }
 async function removeWorktree(repoRoot, worktreePath) {
-  log7.info(`Removing worktree: ${worktreePath}`);
+  log8.info(`Removing worktree: ${worktreePath}`);
   try {
     await execGit(["worktree", "remove", worktreePath], repoRoot);
-    log7.debug("Worktree removed cleanly");
+    log8.debug("Worktree removed cleanly");
   } catch (err) {
-    log7.debug(`Clean remove failed (${err}), trying force remove`);
+    log8.debug(`Clean remove failed (${err}), trying force remove`);
     await execGit(["worktree", "remove", "--force", worktreePath], repoRoot);
   }
-  log7.debug("Pruning stale worktree references");
+  log8.debug("Pruning stale worktree references");
   await execGit(["worktree", "prune"], repoRoot);
-  log7.info("Worktree removed and pruned successfully");
+  log8.info("Worktree removed and pruned successfully");
 }
 async function findWorktreeByBranch(repoRoot, branch) {
   const worktrees = await listWorktrees(repoRoot);
@@ -4420,14 +4420,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) {
-    log7.warn(`Failed to write worktree metadata store: ${err}`);
+    log8.warn(`Failed to write worktree metadata store: ${err}`);
   }
 }
 async function writeWorktreeMetadata(worktreePath, metadata) {
   const store = await readMetadataStore();
   store[worktreePath] = metadata;
   await writeMetadataStore(store);
-  log7.debug(`Wrote worktree metadata for: ${worktreePath}`);
+  log8.debug(`Wrote worktree metadata for: ${worktreePath}`);
 }
 async function readWorktreeMetadata(worktreePath) {
   const store = await readMetadataStore();
@@ -4450,16 +4450,16 @@ async function removeWorktreeMetadata(worktreePath) {
   if (store[worktreePath]) {
     delete store[worktreePath];
     await writeMetadataStore(store);
-    log7.debug(`Removed worktree metadata for: ${worktreePath}`);
+    log8.debug(`Removed worktree metadata for: ${worktreePath}`);
   }
 }
-var log7, WORKTREES_DIR, METADATA_STORE_PATH;
+var log8, WORKTREES_DIR, METADATA_STORE_PATH;
 var init_worktree = __esm(() => {
   init_spawn();
   init_logger();
-  log7 = createLogger("git-wt");
-  WORKTREES_DIR = path.join(homedir3(), ".claude-threads", "worktrees");
-  METADATA_STORE_PATH = path.join(homedir3(), ".claude-threads", "worktree-metadata.json");
+  log8 = createLogger("git-wt");
+  WORKTREES_DIR = path.join(homedir4(), ".claude-threads", "worktrees");
+  METADATA_STORE_PATH = path.join(homedir4(), ".claude-threads", "worktree-metadata.json");
 });
 
 // node_modules/graceful-fs/polyfills.js
@@ -4935,14 +4935,14 @@ GFS4: `);
       return close;
     }(fs2.close);
     fs2.closeSync = function(fs$closeSync) {
-      function closeSync(fd) {
+      function closeSync2(fd) {
         fs$closeSync.apply(fs2, arguments);
         resetQueue();
       }
-      Object.defineProperty(closeSync, previousSymbol, {
+      Object.defineProperty(closeSync2, previousSymbol, {
         value: fs$closeSync
       });
-      return closeSync;
+      return closeSync2;
     }(fs2.closeSync);
     if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
       process.on("exit", function() {
@@ -6366,7 +6366,7 @@ var require_minimist = __commonJS((exports, module) => {
 // node_modules/rc/index.js
 var require_rc = __commonJS((exports, module) => {
   var cc = require_utils();
-  var join7 = __require("path").join;
+  var join8 = __require("path").join;
   var deepExtend = require_deep_extend();
   var etc = "/etc";
   var win = process.platform === "win32";
@@ -6392,15 +6392,15 @@ var require_rc = __commonJS((exports, module) => {
     }
     if (!win)
       [
-        join7(etc, name, "config"),
-        join7(etc, name + "rc")
+        join8(etc, name, "config"),
+        join8(etc, name + "rc")
       ].forEach(addConfigFile);
     if (home)
       [
-        join7(home, ".config", name, "config"),
-        join7(home, ".config", name),
-        join7(home, "." + name, "config"),
-        join7(home, "." + name + "rc")
+        join8(home, ".config", name, "config"),
+        join8(home, ".config", name),
+        join8(home, "." + name, "config"),
+        join8(home, "." + name + "rc")
       ].forEach(addConfigFile);
     addConfigFile(cc.find("." + name + "rc"));
     if (env3.config)
@@ -6888,14 +6888,14 @@ GFS4: `);
       return close;
     }(fs4.close);
     fs4.closeSync = function(fs$closeSync) {
-      function closeSync(fd) {
+      function closeSync2(fd) {
         fs$closeSync.apply(fs4, arguments);
         resetQueue();
       }
-      Object.defineProperty(closeSync, previousSymbol, {
+      Object.defineProperty(closeSync2, previousSymbol, {
         value: fs$closeSync
       });
-      return closeSync;
+      return closeSync2;
     }(fs4.closeSync);
     if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
       process.on("exit", function() {
@@ -20451,7 +20451,7 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
       return hook.checkDCE ? true : false;
     }
     function setIsStrictModeForDevtools(newIsStrictMode) {
-      typeof log43 === "function" && unstable_setDisableYieldValue2(newIsStrictMode);
+      typeof log44 === "function" && unstable_setDisableYieldValue2(newIsStrictMode);
       if (injectedHook && typeof injectedHook.setStrictMode === "function")
         try {
           injectedHook.setStrictMode(rendererID, newIsStrictMode);
@@ -28535,7 +28535,7 @@ Check the render method of %s.`, getComponentNameFromFiber(current) || "Unknown"
     var fiberStack = [];
     var index$jscomp$0 = -1, emptyContextObject = {};
     Object.freeze(emptyContextObject);
-    var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback, log$1 = Math.log, LN2 = Math.LN2, nextTransitionUpdateLane = 256, nextTransitionDeferredLane = 262144, nextRetryLane = 4194304, scheduleCallback$3 = Scheduler.unstable_scheduleCallback, cancelCallback$1 = Scheduler.unstable_cancelCallback, shouldYield = Scheduler.unstable_shouldYield, requestPaint = Scheduler.unstable_requestPaint, now$1 = Scheduler.unstable_now, ImmediatePriority = Scheduler.unstable_ImmediatePriority, UserBlockingPriority = Scheduler.unstable_UserBlockingPriority, NormalPriority$1 = Scheduler.unstable_NormalPriority, IdlePriority = Scheduler.unstable_IdlePriority, log43 = Scheduler.log, unstable_setDisableYieldValue2 = Scheduler.unstable_setDisableYieldValue, rendererID = null, injectedHook = null, hasLoggedError = false, isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined", lastResetTime = 0;
+    var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback, log$1 = Math.log, LN2 = Math.LN2, nextTransitionUpdateLane = 256, nextTransitionDeferredLane = 262144, nextRetryLane = 4194304, scheduleCallback$3 = Scheduler.unstable_scheduleCallback, cancelCallback$1 = Scheduler.unstable_cancelCallback, shouldYield = Scheduler.unstable_shouldYield, requestPaint = Scheduler.unstable_requestPaint, now$1 = Scheduler.unstable_now, ImmediatePriority = Scheduler.unstable_ImmediatePriority, UserBlockingPriority = Scheduler.unstable_UserBlockingPriority, NormalPriority$1 = Scheduler.unstable_NormalPriority, IdlePriority = Scheduler.unstable_IdlePriority, log44 = Scheduler.log, unstable_setDisableYieldValue2 = Scheduler.unstable_setDisableYieldValue, rendererID = null, injectedHook = null, hasLoggedError = false, isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined", lastResetTime = 0;
     if (typeof performance === "object" && typeof performance.now === "function") {
       var localPerformance = performance;
       var getCurrentTime = function() {
@@ -48059,6 +48059,107 @@ var {
   Help
 } = import__.default;
 
+// src/persistence/audit-log.ts
+init_logger();
+import { chmodSync, closeSync, constants as fsConstants, fchmodSync, lstatSync, mkdirSync, openSync, writeSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var log = createLogger("audit");
+var DETAIL_MAX = 500;
+var enabledPlatforms = new Set;
+var preparedDirs = new Set;
+var openFds = new Map;
+function auditDir() {
+  return process.env.CLAUDE_THREADS_AUDIT_DIR || join(homedir(), ".claude-threads", "audit");
+}
+function configureAuditLog(platformId, enabled) {
+  if (enabled)
+    enabledPlatforms.add(platformId);
+  else
+    enabledPlatforms.delete(platformId);
+}
+function isAuditEnabled(platformId) {
+  return enabledPlatforms.has(platformId);
+}
+function openAuditFd(platformId) {
+  const cached = openFds.get(platformId);
+  if (cached !== undefined)
+    return cached;
+  const dir = auditDir();
+  if (!preparedDirs.has(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    chmodSync(dir, 448);
+    preparedDirs.add(dir);
+  }
+  const file = join(dir, `${encodeURIComponent(platformId)}.jsonl`);
+  try {
+    const st = lstatSync(file);
+    if (st.isSymbolicLink() || !st.isFile()) {
+      throw new Error(`audit path exists but is not a regular file: ${file}`);
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT")
+      throw err;
+  }
+  const noFollow = typeof fsConstants.O_NOFOLLOW === "number" ? fsConstants.O_NOFOLLOW : 0;
+  const fd = openSync(file, fsConstants.O_WRONLY | fsConstants.O_APPEND | fsConstants.O_CREAT | noFollow, 384);
+  try {
+    fchmodSync(fd, 384);
+  } catch {}
+  openFds.set(platformId, fd);
+  return fd;
+}
+function auditLog(platformId, entry) {
+  if (!enabledPlatforms.has(platformId))
+    return;
+  try {
+    const full = {
+      ts: new Date().toISOString(),
+      platformId,
+      ...entry,
+      ...entry.detail !== undefined ? { detail: entry.detail.slice(0, DETAIL_MAX) } : {}
+    };
+    writeSync(openAuditFd(platformId), JSON.stringify(full) + `
+`);
+  } catch (err) {
+    const fd = openFds.get(platformId);
+    if (fd !== undefined) {
+      openFds.delete(platformId);
+      try {
+        closeSync(fd);
+      } catch {}
+    }
+    log.warn(`audit write failed for ${platformId}: ${err}`);
+  }
+}
+function auditDetailForTool(tool, input) {
+  if (!input)
+    return;
+  const str = (v) => typeof v === "string" ? v : undefined;
+  switch (tool) {
+    case "Bash":
+      return str(input.command);
+    case "Edit":
+    case "Write":
+    case "Read":
+    case "NotebookEdit":
+      return str(input.file_path);
+    case "Grep":
+    case "Glob":
+      return str(input.pattern);
+    case "WebFetch":
+    case "WebSearch":
+      return str(input.url) ?? str(input.query);
+    default: {
+      try {
+        return JSON.stringify(input);
+      } catch {
+        return;
+      }
+    }
+  }
+}
+
 // src/platform/dm-discovery.ts
 var DM_PLATFORM_SEP = "--dm-";
 function dmPlatformId(parentId, channelId) {
@@ -48079,7 +48180,7 @@ function deriveDmPlatformConfig(parent, channelId, partnerUsernames) {
 
 // src/session/lifecycle-fsm.ts
 init_logger();
-var log = createLogger("fsm");
+var log2 = createLogger("fsm");
 var ALLOWED_TRANSITIONS = {
   starting: new Set(["active", "paused", "interrupted", "cancelling", "restarting"]),
   active: new Set([
@@ -48118,7 +48219,7 @@ function checkTransition(from, to, sessionId) {
   if (process.env.CLAUDE_THREADS_FSM_STRICT === "1") {
     throw new Error(`${msg} (sessionId=${sessionId})`);
   }
-  log.warn(msg, payload);
+  log2.warn(msg, payload);
 }
 
 // src/session/timer-manager.ts
@@ -48183,9 +48284,9 @@ function getSessionStatus(session) {
 }
 
 // src/config/index.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync as mkdirSync2, chmodSync as chmodSync2 } from "fs";
 import { resolve, dirname } from "path";
-import { homedir } from "os";
+import { homedir as homedir2 } from "os";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
 function getDefaultExportFromCjs(x) {
@@ -51357,6 +51458,14 @@ function resolveRoutinesEnabled(value, fieldPath) {
   console.warn(`Invalid ${fieldPath ?? "routines"} config: expected boolean, got ${JSON.stringify(value)} — routines stay enabled`);
   return true;
 }
+function resolveAuditLogEnabled(value, fieldPath) {
+  if (value === true)
+    return true;
+  if (value === undefined || value === null || value === false)
+    return false;
+  console.warn(`Invalid ${fieldPath ?? "auditLog"} config: expected boolean, got ${JSON.stringify(value)} — audit log stays off`);
+  return false;
+}
 var LIMITS_DEFAULTS = {
   maxSessions: 5,
   sessionTimeoutMinutes: 30,
@@ -51425,7 +51534,7 @@ function effectivePermissionMode(input) {
 }
 
 // src/config/index.ts
-var CONFIG_PATH = resolve(homedir(), ".config", "claude-threads", "config.yaml");
+var CONFIG_PATH = resolve(homedir2(), ".config", "claude-threads", "config.yaml");
 function loadConfigWithMigration() {
   if (existsSync(CONFIG_PATH)) {
     const content = readFileSync(CONFIG_PATH, "utf-8");
@@ -51436,7 +51545,7 @@ function loadConfigWithMigration() {
 function saveConfig(config, path = CONFIG_PATH) {
   const configDir = dirname(path);
   if (!existsSync(configDir)) {
-    mkdirSync(configDir, { recursive: true, mode: 448 });
+    mkdirSync2(configDir, { recursive: true, mode: 448 });
   }
   const yamlContent = yaml.dump(config, {
     indent: 2,
@@ -51446,8 +51555,8 @@ function saveConfig(config, path = CONFIG_PATH) {
   });
   writeFileSync(path, yamlContent, { encoding: "utf-8", mode: 384 });
   try {
-    chmodSync(configDir, 448);
-    chmodSync(path, 384);
+    chmodSync2(configDir, 448);
+    chmodSync2(path, 384);
   } catch {}
 }
 function configExists() {
@@ -51563,7 +51672,9 @@ var EMOJI_UNICODE_TO_NAME = {
   "\uD83D\uDC64": "bust_in_silhouette",
   "\uD83D\uDCCB": "clipboard",
   "\uD83D\uDD3D": "small_red_triangle_down",
-  "\uD83C\uDD95": "new"
+  "\uD83C\uDD95": "new",
+  "\uD83D\uDC40": "eyes",
+  "❤️": "heart"
 };
 function getEmojiName(emoji) {
   const mapped = EMOJI_UNICODE_TO_NAME[emoji];
@@ -51638,6 +51749,27 @@ function resolveDirectChannelMode(cfg) {
 function resolveApprovals(configured, isDcmSession) {
   return configured ?? (isDcmSession ? "owner" : "all_users");
 }
+function normalizeAckReaction(value, fieldPath) {
+  if (value === undefined || value === null)
+    return;
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "string" && value.trim().length > 0) {
+    const name = getEmojiName(value.trim());
+    if (!/^[a-z0-9_+':.-]+$/i.test(name)) {
+      console.warn(`Invalid ${fieldPath}: unknown emoji ${JSON.stringify(value)} — use its shortcode name (e.g. "eyes"); ack reaction disabled`);
+      return;
+    }
+    return name;
+  }
+  console.warn(`Invalid ${fieldPath}: expected boolean or emoji name, got ${JSON.stringify(value)} — ack reaction disabled`);
+  return;
+}
+function resolveAckReaction(configured) {
+  if (!configured)
+    return null;
+  return typeof configured === "string" ? configured : "eyes";
+}
 
 // src/session/authorization.ts
 function isAuthorizedForSession(check) {
@@ -51654,7 +51786,7 @@ function isAuthorizedForSession(check) {
 // src/mcp/decision-bridge.ts
 import { createServer, createConnection } from "node:net";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 import { randomUUID } from "node:crypto";
 import { mkdtempSync } from "node:fs";
 import { rm } from "node:fs/promises";
@@ -51665,8 +51797,8 @@ function bridgeSocketPath() {
   if (process.platform === "win32") {
     return `\\\\.\\pipe\\ctb-${randomUUID()}`;
   }
-  const dir = mkdtempSync(join(tmpdir(), "ctb-"));
-  return join(dir, "b.sock");
+  const dir = mkdtempSync(join2(tmpdir(), "ctb-"));
+  return join2(dir, "b.sock");
 }
 
 class DecisionBridgeServer {
@@ -51736,7 +51868,7 @@ class DecisionBridgeServer {
       });
     } catch (err) {
       if (process.platform !== "win32") {
-        await rm(join(path, ".."), { recursive: true, force: true }).catch(() => {});
+        await rm(join2(path, ".."), { recursive: true, force: true }).catch(() => {});
       }
       throw err;
     }
@@ -51749,7 +51881,7 @@ class DecisionBridgeServer {
       socket.destroy();
     await new Promise((resolve2) => this.server.close(() => resolve2()));
     if (process.platform !== "win32") {
-      await rm(join(this.path, ".."), { recursive: true, force: true }).catch(() => {});
+      await rm(join2(this.path, ".."), { recursive: true, force: true }).catch(() => {});
     }
   }
 }
@@ -51762,18 +51894,18 @@ import { resolve as resolve2, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 import { existsSync as existsSync3, readFileSync as readFileSync2, watchFile, unwatchFile, unlinkSync, statSync, readdirSync, writeFileSync as writeFileSync2 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
 // src/claude/version-check.ts
 var import_semver = __toESM(require_semver2(), 1);
 import { execSync } from "child_process";
 import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 var COMMON_CLAUDE_PATHS = process.platform === "win32" ? [
-  ...process.env.APPDATA ? [join2(process.env.APPDATA, "npm", "claude.cmd")] : [],
-  ...process.env.LOCALAPPDATA ? [join2(process.env.LOCALAPPDATA, "npm", "claude.cmd")] : [],
-  ...process.env.NVM_SYMLINK ? [join2(process.env.NVM_SYMLINK, "claude.cmd")] : [],
-  ...process.env.USERPROFILE ? [join2(process.env.USERPROFILE, ".bun", "bin", "claude.cmd")] : []
+  ...process.env.APPDATA ? [join3(process.env.APPDATA, "npm", "claude.cmd")] : [],
+  ...process.env.LOCALAPPDATA ? [join3(process.env.LOCALAPPDATA, "npm", "claude.cmd")] : [],
+  ...process.env.NVM_SYMLINK ? [join3(process.env.NVM_SYMLINK, "claude.cmd")] : [],
+  ...process.env.USERPROFILE ? [join3(process.env.USERPROFILE, ".bun", "bin", "claude.cmd")] : []
 ] : [
   "/usr/local/bin/claude",
   "/opt/homebrew/bin/claude",
@@ -52032,25 +52164,25 @@ function parseRateLimitEvent(event, now = Date.now()) {
 }
 
 // src/claude/cli.ts
-var log2 = createLogger("claude");
+var log3 = createLogger("claude");
 function cleanupBrowserBridgeSockets() {
   try {
     const tempDir = tmpdir2();
     const files = readdirSync(tempDir);
     for (const file of files) {
       if (file.startsWith("claude-mcp-browser-bridge-")) {
-        const filePath = join3(tempDir, file);
+        const filePath = join4(tempDir, file);
         try {
           const stats = statSync(filePath);
           if (stats.isSocket()) {
             unlinkSync(filePath);
-            log2.debug(`Removed stale browser bridge socket: ${file}`);
+            log3.debug(`Removed stale browser bridge socket: ${file}`);
           }
         } catch {}
       }
     }
   } catch (err) {
-    log2.debug(`Browser bridge cleanup failed: ${err}`);
+    log3.debug(`Browser bridge cleanup failed: ${err}`);
   }
 }
 function buildClaudeChildEnv(parentEnv, account, opts) {
@@ -52109,7 +52241,7 @@ function materializeMcpConfig(config, sessionId, opts = {}) {
     return { mode: "inline", value: JSON.stringify(config) };
   }
   const dir = opts.tmpDirOverride ?? tmpdir2();
-  const path = join3(dir, `claude-threads-mcp-${sessionId ?? process.pid}-${Date.now()}.json`);
+  const path = join4(dir, `claude-threads-mcp-${sessionId ?? process.pid}-${Date.now()}.json`);
   writeFileSync2(path, JSON.stringify(config), { mode: 384 });
   return { mode: "file", path };
 }
@@ -52292,7 +52424,7 @@ class ClaudeCli extends EventEmitter {
     }
     let statusLineCommand;
     if (this.options.sessionId) {
-      this.statusFilePath = join3(tmpdir2(), `claude-threads-status-${this.options.sessionId}.json`);
+      this.statusFilePath = join4(tmpdir2(), `claude-threads-status-${this.options.sessionId}.json`);
       const statusLineWriterPath = this.getStatusLineWriterPath();
       const runtime = runtimeForScriptPath(statusLineWriterPath);
       statusLineCommand = `${runtime} ${statusLineWriterPath} ${this.options.sessionId}`;
@@ -52563,11 +52695,11 @@ class ClaudeCli extends EventEmitter {
 
 // src/persistence/thread-logger.ts
 init_logger();
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, appendFileSync, readdirSync as readdirSync2, statSync as statSync2, unlinkSync as unlinkSync2, rmdirSync, readFileSync as readFileSync3, chmodSync as chmodSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join4, dirname as dirname3 } from "path";
-var log3 = createLogger("thread-log");
-var LOGS_BASE_DIR = join4(homedir2(), ".claude-threads", "logs");
+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");
 
 class ThreadLoggerImpl {
   platformId;
@@ -52587,16 +52719,16 @@ class ThreadLoggerImpl {
     this.enabled = options?.enabled ?? true;
     this.bufferSize = options?.bufferSize ?? 10;
     this.flushIntervalMs = options?.flushIntervalMs ?? 1000;
-    this.logPath = join4(LOGS_BASE_DIR, platformId, `${claudeSessionId}.jsonl`);
+    this.logPath = join5(LOGS_BASE_DIR, platformId, `${claudeSessionId}.jsonl`);
     if (this.enabled) {
       const dir = dirname3(this.logPath);
       if (!existsSync4(dir)) {
-        mkdirSync2(dir, { recursive: true });
+        mkdirSync3(dir, { recursive: true });
       }
       this.flushTimer = setInterval(() => {
         this.flushSync();
       }, this.flushIntervalMs);
-      log3.debug(`Thread logger initialized: ${this.logPath}`);
+      log4.debug(`Thread logger initialized: ${this.logPath}`);
     }
   }
   isEnabled() {
@@ -52710,7 +52842,7 @@ class ThreadLoggerImpl {
       this.flushTimer = null;
     }
     this.flushSync();
-    log3.debug(`Thread logger closed: ${this.logPath}`);
+    log4.debug(`Thread logger closed: ${this.logPath}`);
   }
   addEntry(entry) {
     this.buffer.push(entry);
@@ -52728,11 +52860,11 @@ class ThreadLoggerImpl {
       const isNewFile = !existsSync4(this.logPath);
       appendFileSync(this.logPath, lines, { encoding: "utf8", mode: 384 });
       if (isNewFile) {
-        chmodSync2(this.logPath, 384);
+        chmodSync3(this.logPath, 384);
       }
       this.buffer = [];
     } catch (err) {
-      log3.error(`Failed to flush thread log: ${err}`);
+      log4.error(`Failed to flush thread log: ${err}`);
     }
   }
 }
@@ -52769,7 +52901,7 @@ function cleanupOldLogs(retentionDays = 30) {
   try {
     const platformDirs = readdirSync2(LOGS_BASE_DIR);
     for (const platformId of platformDirs) {
-      const platformDir = join4(LOGS_BASE_DIR, platformId);
+      const platformDir = join5(LOGS_BASE_DIR, platformId);
       const stat = statSync2(platformDir);
       if (!stat.isDirectory())
         continue;
@@ -52777,49 +52909,49 @@ function cleanupOldLogs(retentionDays = 30) {
       for (const file of logFiles) {
         if (!file.endsWith(".jsonl"))
           continue;
-        const filePath = join4(platformDir, file);
+        const filePath = join5(platformDir, file);
         try {
           const fileStat = statSync2(filePath);
           if (fileStat.mtimeMs < cutoffMs) {
             unlinkSync2(filePath);
             deletedCount++;
-            log3.debug(`Deleted old log file: ${filePath}`);
+            log4.debug(`Deleted old log file: ${filePath}`);
           }
         } catch (err) {
-          log3.warn(`Failed to check/delete log file ${filePath}: ${err}`);
+          log4.warn(`Failed to check/delete log file ${filePath}: ${err}`);
         }
       }
       try {
         const remaining = readdirSync2(platformDir);
         if (remaining.length === 0) {
           rmdirSync(platformDir);
-          log3.debug(`Removed empty platform log directory: ${platformDir}`);
+          log4.debug(`Removed empty platform log directory: ${platformDir}`);
         }
       } catch {}
     }
     if (deletedCount > 0) {
-      log3.info(`Cleaned up ${deletedCount} old log file(s)`);
+      log4.info(`Cleaned up ${deletedCount} old log file(s)`);
     }
   } catch (err) {
-    log3.error(`Failed to clean up old logs: ${err}`);
+    log4.error(`Failed to clean up old logs: ${err}`);
   }
   return deletedCount;
 }
 function getLogFilePath(platformId, sessionId) {
-  return join4(LOGS_BASE_DIR, platformId, `${sessionId}.jsonl`);
+  return join5(LOGS_BASE_DIR, platformId, `${sessionId}.jsonl`);
 }
 function readRecentLogEntries(platformId, sessionId, maxLines = 50) {
   const logPath = getLogFilePath(platformId, sessionId);
-  log3.debug(`Reading log entries from: ${logPath}`);
+  log4.debug(`Reading log entries from: ${logPath}`);
   if (!existsSync4(logPath)) {
-    log3.debug(`Log file does not exist: ${logPath}`);
+    log4.debug(`Log file does not exist: ${logPath}`);
     return [];
   }
   try {
     const content = readFileSync3(logPath, "utf8");
     const lines = content.trim().split(`
 `);
-    log3.debug(`Log file has ${lines.length} lines`);
+    log4.debug(`Log file has ${lines.length} lines`);
     const recentLines = lines.slice(-maxLines);
     const entries = [];
     for (const line of recentLines) {
@@ -52829,10 +52961,10 @@ function readRecentLogEntries(platformId, sessionId, maxLines = 50) {
         entries.push(JSON.parse(line));
       } catch {}
     }
-    log3.debug(`Parsed ${entries.length} log entries`);
+    log4.debug(`Parsed ${entries.length} log entries`);
     return entries;
   } catch (err) {
-    log3.error(`Failed to read log file: ${err}`);
+    log4.error(`Failed to read log file: ${err}`);
     return [];
   }
 }
@@ -53799,7 +53931,7 @@ async function handleDynamicSlashCommand(command, args, ctx) {
 }
 // src/commands/system-prompt-generator.ts
 init_logger();
-var log4 = createLogger("system-prompt");
+var log5 = createLogger("system-prompt");
 function formatUserCommand(cmd) {
   const cmdStr = cmd.args ? `\`!${cmd.command} ${cmd.args}\`` : `\`!${cmd.command}\``;
   const description = cmd.description;
@@ -53838,7 +53970,7 @@ async function resolveCollaborators(platform, platformId, ownerUsername, allowed
       continue;
     const email = githubEmailsStore.get(platformId, username);
     if (!email) {
-      log4.debug(`Collaborator @${username} has no registered GitHub noreply email — skipping`);
+      log5.debug(`Collaborator @${username} has no registered GitHub noreply email — skipping`);
       continue;
     }
     let name = username;
@@ -53847,7 +53979,7 @@ async function resolveCollaborators(platform, platformId, ownerUsername, allowed
       if (user)
         name = user.displayName || user.username;
     } catch (err) {
-      log4.debug(`Display name lookup failed for @${username}: ${err.message}`);
+      log5.debug(`Display name lookup failed for @${username}: ${err.message}`);
     }
     resolved.push({ username, name, email });
   }
@@ -53976,7 +54108,7 @@ import { existsSync as existsSync11 } from "fs";
 // src/utils/keep-alive.ts
 init_logger();
 import { spawn } from "child_process";
-var log5 = createLogger("keepalive");
+var log6 = createLogger("keepalive");
 function keepAliveSpawnSpec(platform, parentPid) {
   switch (platform) {
     case "darwin":
@@ -54032,7 +54164,7 @@ class KeepAliveManager {
     if (!enabled && this.keepAliveProcess) {
       this.stopKeepAlive();
     }
-    log5.debug(`Keep-alive ${enabled ? "enabled" : "disabled"}`);
+    log6.debug(`Keep-alive ${enabled ? "enabled" : "disabled"}`);
   }
   isEnabled() {
     return this.enabled;
@@ -54042,7 +54174,7 @@ class KeepAliveManager {
   }
   sessionStarted() {
     this.activeSessionCount++;
-    log5.debug(`Session started (${this.activeSessionCount} active)`);
+    log6.debug(`Session started (${this.activeSessionCount} active)`);
     if (this.activeSessionCount === 1) {
       this.startKeepAlive();
     }
@@ -54051,7 +54183,7 @@ class KeepAliveManager {
     if (this.activeSessionCount > 0) {
       this.activeSessionCount--;
     }
-    log5.debug(`Session ended (${this.activeSessionCount} active)`);
+    log6.debug(`Session ended (${this.activeSessionCount} active)`);
     if (this.activeSessionCount === 0) {
       this.stopKeepAlive();
     }
@@ -54065,11 +54197,11 @@ class KeepAliveManager {
   }
   startKeepAlive() {
     if (!this.enabled) {
-      log5.debug("Keep-alive disabled, skipping");
+      log6.debug("Keep-alive disabled, skipping");
       return;
     }
     if (this.keepAliveProcess) {
-      log5.debug("Keep-alive already running");
+      log6.debug("Keep-alive already running");
       return;
     }
     switch (this.platform) {
@@ -54083,12 +54215,12 @@ class KeepAliveManager {
         this.startWindowsKeepAlive();
         break;
       default:
-        log5.warn(`Keep-alive not supported on ${this.platform}`);
+        log6.warn(`Keep-alive not supported on ${this.platform}`);
     }
   }
   stopKeepAlive() {
     if (this.keepAliveProcess) {
-      log5.debug("Stopping keep-alive");
+      log6.debug("Stopping keep-alive");
       this.keepAliveProcess.kill();
       this.keepAliveProcess = null;
     }
@@ -54103,18 +54235,18 @@ class KeepAliveManager {
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log5.error(`Failed to start caffeinate: ${err.message}`);
+        log6.error(`Failed to start caffeinate: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", (code) => {
         if (code !== null && code !== 0 && this.activeSessionCount > 0) {
-          log5.debug(`caffeinate exited with code ${code}`);
+          log6.debug(`caffeinate exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log5.info("Sleep prevention active (caffeinate)");
+      log6.info("Sleep prevention active (caffeinate)");
     } catch (err) {
-      log5.error(`Failed to start caffeinate: ${err}`);
+      log6.error(`Failed to start caffeinate: ${err}`);
     }
   }
   startLinuxKeepAlive() {
@@ -54127,19 +54259,19 @@ class KeepAliveManager {
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log5.debug(`systemd-inhibit not available: ${err.message}`);
+        log6.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) {
-          log5.debug(`systemd-inhibit exited with code ${code}`);
+          log6.debug(`systemd-inhibit exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log5.info("Sleep prevention active (systemd-inhibit)");
+      log6.info("Sleep prevention active (systemd-inhibit)");
     } catch (err) {
-      log5.debug(`Failed to start systemd-inhibit: ${err}`);
+      log6.debug(`Failed to start systemd-inhibit: ${err}`);
       this.startLinuxKeepAliveFallback();
     }
   }
@@ -54150,15 +54282,15 @@ class KeepAliveManager {
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log5.warn(`Linux keep-alive fallback not available: ${err.message}`);
+        log6.warn(`Linux keep-alive fallback not available: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", () => {
         this.keepAliveProcess = null;
       });
-      log5.info("Sleep prevention active (xdg-screensaver)");
+      log6.info("Sleep prevention active (xdg-screensaver)");
     } catch (err) {
-      log5.warn(`Linux keep-alive not available: ${err}`);
+      log6.warn(`Linux keep-alive not available: ${err}`);
     }
   }
   startWindowsKeepAlive() {
@@ -54170,18 +54302,18 @@ class KeepAliveManager {
         windowsHide: true
       });
       this.keepAliveProcess.on("error", (err) => {
-        log5.warn(`Windows keep-alive not available: ${err.message}`);
+        log6.warn(`Windows keep-alive not available: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", (code) => {
         if (code !== null && code !== 0 && this.activeSessionCount > 0) {
-          log5.debug(`PowerShell keep-alive exited with code ${code}`);
+          log6.debug(`PowerShell keep-alive exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log5.info("Sleep prevention active (SetThreadExecutionState)");
+      log6.info("Sleep prevention active (SetThreadExecutionState)");
     } catch (err) {
-      log5.warn(`Windows keep-alive not available: ${err}`);
+      log6.warn(`Windows keep-alive not available: ${err}`);
     }
   }
 }
@@ -54249,7 +54381,7 @@ function truncateAtWord(str2, maxLength) {
 }
 
 // src/utils/error-handler/index.ts
-var log6 = createLogger("error");
+var log7 = createLogger("error");
 
 class SessionError extends Error {
   sessionId;
@@ -54275,19 +54407,19 @@ async function handleError(error, context, severity = "recoverable") {
   const sessionPart = sessionId ? ` (${formatShortId(sessionId)})` : "";
   const logMessage = `${context.action}${sessionPart}: ${message}`;
   if (severity === "recoverable") {
-    log6.warn(logMessage);
+    log7.warn(logMessage);
   } else {
-    log6.error(logMessage, error instanceof Error ? error : undefined);
+    log7.error(logMessage, error instanceof Error ? error : undefined);
   }
   if (context.details) {
-    log6.debugJson("Error details", context.details);
+    log7.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) {
-      log6.warn(`Could not notify user: ${notifyError}`);
+      log7.warn(`Could not notify user: ${notifyError}`);
     }
   }
   if (severity === "session-fatal" || severity === "system-fatal") {
@@ -54314,7 +54446,7 @@ async function logAndNotify(error, context) {
 }
 function logSilentError(context, error) {
   const message = error instanceof Error ? error.message : String(error);
-  log6.debug(`[${context}] Silently caught: ${message}`);
+  log7.debug(`[${context}] Silently caught: ${message}`);
 }
 
 // src/session/lifecycle.ts
@@ -54334,8 +54466,8 @@ function createSessionLog(baseLog) {
 init_logger();
 init_emoji();
 init_worktree();
-var log8 = createLogger("helpers");
-var sessionLog = createSessionLog(log8);
+var log9 = createLogger("helpers");
+var sessionLog = createSessionLog(log9);
 var POST_TYPES = {
   info: "",
   success: "✅",
@@ -54423,7 +54555,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 join6 } from "path";
+import { join as join7 } from "path";
 
 // src/utils/safe-filename.ts
 import { basename as basename2 } from "path";
@@ -54464,13 +54596,13 @@ function formatBytes(bytes) {
 }
 
 // src/operations/streaming/handler.ts
-var log9 = createLogger("streaming");
+var log10 = 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 join6(tmpdir3(), UPLOAD_ROOT_DIR, `${safeIdSegment(platformId)}-${safeIdSegment(threadId)}`);
+  return join7(tmpdir3(), UPLOAD_ROOT_DIR, `${safeIdSegment(platformId)}-${safeIdSegment(threadId)}`);
 }
 async function cleanupSessionUploads(platformId, threadId) {
   if (!platformId || !threadId)
@@ -54479,7 +54611,7 @@ async function cleanupSessionUploads(platformId, threadId) {
   try {
     await rm2(dir, { recursive: true, force: true });
   } catch (err) {
-    log9.debug(`Upload cleanup for ${platformId}:${threadId} failed (ignored): ${err}`);
+    log10.debug(`Upload cleanup for ${platformId}:${threadId} failed (ignored): ${err}`);
   }
 }
 function sanitizeForPrompt(value) {
@@ -54500,16 +54632,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" });
     }
-    log9.error(`Upload dir is a symlink, refusing all writes: ${uploadDir}`);
+    log10.error(`Upload dir is a symlink, refusing all writes: ${uploadDir}`);
     return { saved, skipped };
   }
-  const messageDir = await mkdtemp(join6(uploadDir, `${Date.now().toString(36)}-`));
+  const messageDir = await mkdtemp(join7(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 = join6(messageDir, safeName);
+      const absolutePath = join7(messageDir, safeName);
       await writeFile2(absolutePath, buffer, { mode: 384, flag: "wx" });
       saved.push({
         originalName: file.name,
@@ -54518,11 +54650,11 @@ async function saveFilesToUploadDir(platform, uploadDir, files, debug = false) {
         size: buffer.length
       });
       if (debug) {
-        log9.debug(`Saved ${file.name} → ${absolutePath} (${formatBytes(buffer.length)})`);
+        log10.debug(`Saved ${file.name} → ${absolutePath} (${formatBytes(buffer.length)})`);
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      log9.error(`Failed to save uploaded file ${file.name}: ${message}`);
+      log10.error(`Failed to save uploaded file ${file.name}: ${message}`);
       skipped.push({
         name: file.name,
         reason: `Download failed: ${message}`
@@ -58024,7 +58156,7 @@ init_emoji();
 import { execSync as execSync2 } from "child_process";
 import { writeFileSync as writeFileSync4, unlinkSync as unlinkSync3 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 
 // node_modules/@redactpii/node/lib/index.mjs
 class Redactor {
@@ -58604,7 +58736,7 @@ async function createGitHubIssue(title, body, workingDir) {
   if (!ghStatus.installed || !ghStatus.authenticated) {
     throw new Error(ghStatus.error);
   }
-  const bodyFile = join7(tmpdir4(), `bug-body-${Date.now()}.md`);
+  const bodyFile = join8(tmpdir4(), `bug-body-${Date.now()}.md`);
   try {
     writeFileSync4(bodyFile, body, "utf-8");
     const cmd = `gh issue create --repo "${GITHUB_REPO}" --title "${escapeShell(title)}" --body-file "${bodyFile}"`;
@@ -62155,14 +62287,29 @@ class QuestionApprovalExecutor extends BaseExecutor {
       return false;
     }
     if (this.state.pendingApproval?.postId === postId) {
+      const approvalType = this.state.pendingApproval.type;
+      const auditDecision = (approved) => {
+        if (approvalType !== "plan")
+          return;
+        auditLog(ctx.platform.platformId, {
+          threadId: ctx.threadId,
+          sessionId: ctx.sessionId,
+          actor: user,
+          kind: "plan_approval",
+          approved,
+          detail: "via reaction"
+        });
+      };
       if (isApprovalEmoji(emoji)) {
         ctx.logger.debug(`Approval reaction from @${user}: approved`);
+        auditDecision(true);
         const handled = await this.handleApprovalResponse(postId, true, ctx);
         ctx.logger.debug(`QuestionApprovalExecutor: approval outcome=approved, handled=${handled}`);
         return handled;
       }
       if (isDenialEmoji(emoji)) {
         ctx.logger.debug(`Approval reaction from @${user}: denied`);
+        auditDecision(false);
         const handled = await this.handleApprovalResponse(postId, false, ctx);
         ctx.logger.debug(`QuestionApprovalExecutor: approval outcome=denied, handled=${handled}`);
         return handled;
@@ -62620,7 +62767,7 @@ class BugReportExecutor extends BaseExecutor {
 // src/operations/executors/worktree-prompt.ts
 init_emoji();
 init_logger();
-var log10 = createLogger("wt-prompt");
+var log11 = createLogger("wt-prompt");
 // src/operations/message-manager.ts
 init_logger();
 
@@ -62700,7 +62847,7 @@ function formatRelativeTime(date) {
   return `${diffMin} min ago`;
 }
 // src/operations/message-manager.ts
-var log11 = createLogger("msg-mgr");
+var log12 = createLogger("msg-mgr");
 
 class MessageManager {
   platform;
@@ -62793,7 +62940,7 @@ class MessageManager {
     });
   }
   async handleEvent(event) {
-    const logger = log11.forSession(this.sessionId);
+    const logger = log12.forSession(this.sessionId);
     const transformCtx = {
       sessionId: this.sessionId,
       formatter: this.platform.getFormatter(),
@@ -62847,7 +62994,7 @@ class MessageManager {
     }
   }
   async executeOperation(op) {
-    const logger = log11.forSession(this.sessionId);
+    const logger = log12.forSession(this.sessionId);
     const ctx = this.getExecutorContext();
     try {
       if (isContentOp(op)) {
@@ -62915,7 +63062,7 @@ class MessageManager {
       threadId: this.threadId,
       platform: this.platform,
       formatter: this.platform.getFormatter(),
-      logger: log11.forSession(this.sessionId),
+      logger: log12.forSession(this.sessionId),
       postTracker: this.postTracker,
       contentBreaker: this.contentBreaker,
       threadLogger: this.session.threadLogger,
@@ -63135,13 +63282,13 @@ class MessageManager {
     return this.systemExecutor.postSuccess(message, this.getExecutorContext());
   }
   async prepareForUserMessage() {
-    const logger = log11.forSession(this.sessionId);
+    const logger = log12.forSession(this.sessionId);
     logger.debug("Preparing for new user message");
     await this.closeCurrentPost();
     await this.bumpTaskList();
   }
   async handleUserMessage(message, files, username, displayName) {
-    const logger = log11.forSession(this.sessionId);
+    const logger = log12.forSession(this.sessionId);
     if (!this.session.claude.isRunning()) {
       logger.debug("Claude not running, ignoring user message");
       return false;
@@ -63184,7 +63331,7 @@ class MessageManager {
     ];
   }
   async handleReaction(postId, emoji, user, action) {
-    const logger = log11.forSession(this.sessionId);
+    const logger = log12.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()) {
@@ -63282,7 +63429,7 @@ class MessageManager {
 }
 // src/operations/sticky-message/handler.ts
 init_logger();
-var log12 = createLogger("sticky");
+var log13 = createLogger("sticky");
 var botStartedAt = new Date;
 function getPendingPrompts(session) {
   const prompts = [];
@@ -63357,21 +63504,21 @@ function initialize(store) {
     stickyPostIds.set(platformId, postId);
   }
   if (persistedIds.size > 0) {
-    log12.info(`\uD83D\uDCCC Restored ${persistedIds.size} sticky post ID(s) from persistence`);
+    log13.info(`\uD83D\uDCCC Restored ${persistedIds.size} sticky post ID(s) from persistence`);
   }
 }
 function setPlatformPaused(platformId, paused) {
   if (paused) {
     pausedPlatforms.set(platformId, true);
-    log12.debug(`Platform ${platformId} marked as paused`);
+    log13.debug(`Platform ${platformId} marked as paused`);
   } else {
     pausedPlatforms.delete(platformId);
-    log12.debug(`Platform ${platformId} marked as active`);
+    log13.debug(`Platform ${platformId} marked as active`);
   }
 }
 function setShuttingDown(shuttingDown) {
   isShuttingDown = shuttingDown;
-  log12.debug(`Bot shutdown state: ${shuttingDown}`);
+  log13.debug(`Bot shutdown state: ${shuttingDown}`);
 }
 function getTaskContent(session) {
   const taskState = session.messageManager?.getTaskListState();
@@ -63704,12 +63851,12 @@ async function validateLastMessageIds(platform, sessions) {
     try {
       const post2 = await platform.getPost(lastMessageId);
       if (!post2) {
-        log12.debug(`lastMessageId ${lastMessageId.substring(0, 8)} for session ${session.sessionId} was deleted, clearing`);
+        log13.debug(`lastMessageId ${lastMessageId.substring(0, 8)} for session ${session.sessionId} was deleted, clearing`);
         session.lastMessageId = undefined;
         session.lastMessageTs = undefined;
       }
     } catch (err) {
-      log12.debug(`Failed to validate lastMessageId for session ${session.sessionId}, clearing: ${err}`);
+      log13.debug(`Failed to validate lastMessageId for session ${session.sessionId}, clearing: ${err}`);
       session.lastMessageId = undefined;
       session.lastMessageTs = undefined;
     }
@@ -63726,7 +63873,7 @@ async function updateStickyMessageImpl(platform, sessions, config) {
       hiddenCleanupDone.add(platform.platformId);
       const existing = stickyPostIds.get(platform.platformId);
       if (existing) {
-        log12.info(`sticky[${platform.platformId}] hidden mode: removing leftover ${formatShortId(existing)}`);
+        log13.info(`sticky[${platform.platformId}] hidden mode: removing leftover ${formatShortId(existing)}`);
         try {
           await platform.unpinPost(existing);
         } catch {}
@@ -63746,63 +63893,63 @@ async function updateStickyMessageImpl(platform, sessions, config) {
     return;
   }
   const platformSessions = [...sessions.values()].filter((s) => s.platformId === platform.platformId);
-  log12.debug(`updateStickyMessage for ${platform.platformId}, ${platformSessions.length} sessions`);
+  log13.debug(`updateStickyMessage for ${platform.platformId}, ${platformSessions.length} sessions`);
   for (const s of platformSessions) {
-    log12.debug(`  - ${s.sessionId}: title="${s.sessionTitle}" firstPrompt="${s.firstPrompt?.substring(0, 30)}..."`);
+    log13.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;
-  log12.debug(`existingPostId: ${existingPostId || "(none)"}, needsBump: ${shouldBump}`);
+  log13.debug(`existingPostId: ${existingPostId || "(none)"}, needsBump: ${shouldBump}`);
   try {
     if (existingPostId && !shouldBump) {
-      log12.debug(`Updating existing post in place...`);
+      log13.debug(`Updating existing post in place...`);
       try {
         await platform.updatePost(existingPostId, content);
         try {
           await platform.pinPost(existingPostId);
-          log12.debug(`Re-pinned post`);
+          log13.debug(`Re-pinned post`);
         } catch (pinErr) {
-          log12.debug(`Re-pin failed (might already be pinned): ${pinErr}`);
+          log13.debug(`Re-pin failed (might already be pinned): ${pinErr}`);
         }
-        log12.debug(`Updated successfully`);
+        log13.debug(`Updated successfully`);
         return;
       } catch (err) {
-        log12.debug(`Update failed, will create new: ${err}`);
+        log13.debug(`Update failed, will create new: ${err}`);
       }
     }
     needsBump.set(platform.platformId, false);
     if (existingPostId) {
-      log12.debug(`Unpinning and deleting existing post ${existingPostId.substring(0, 8)}...`);
+      log13.debug(`Unpinning and deleting existing post ${existingPostId.substring(0, 8)}...`);
       try {
         await platform.unpinPost(existingPostId);
-        log12.debug(`Unpinned successfully`);
+        log13.debug(`Unpinned successfully`);
       } catch (err) {
-        log12.debug(`Unpin failed (probably already unpinned): ${err}`);
+        log13.debug(`Unpin failed (probably already unpinned): ${err}`);
       }
       try {
         await platform.deletePost(existingPostId);
-        log12.debug(`Deleted successfully`);
+        log13.debug(`Deleted successfully`);
       } catch (err) {
-        log12.debug(`Delete failed (probably already deleted): ${err}`);
+        log13.debug(`Delete failed (probably already deleted): ${err}`);
       }
       stickyPostIds.delete(platform.platformId);
     }
-    log12.debug(`Creating new post...`);
+    log13.debug(`Creating new post...`);
     const post2 = await platform.createPost(content);
     stickyPostIds.set(platform.platformId, post2.id);
     try {
       await platform.pinPost(post2.id);
-      log12.debug(`Pinned post successfully`);
+      log13.debug(`Pinned post successfully`);
     } catch (err) {
-      log12.debug(`Failed to pin post: ${err}`);
+      log13.debug(`Failed to pin post: ${err}`);
     }
     if (sessionStore) {
       sessionStore.saveStickyPostId(platform.platformId, post2.id);
     }
-    log12.info(`\uD83D\uDCCC Created sticky message for ${platform.platformId}: ${formatShortId(post2.id)}`);
+    log13.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()) {
@@ -63818,10 +63965,10 @@ async function updateStickyMessageImpl(platform, sessions, config) {
     }
     const botUser = await platform.getBotUser();
     cleanupOldStickyMessages(platform, botUser.id, false, excludePostIds).catch((err) => {
-      log12.debug(`Background cleanup failed: ${err}`);
+      log13.debug(`Background cleanup failed: ${err}`);
     });
   } catch (err) {
-    log12.error(`Failed to update sticky message for ${platform.platformId}`, err instanceof Error ? err : undefined);
+    log13.error(`Failed to update sticky message for ${platform.platformId}`, err instanceof Error ? err : undefined);
   }
 }
 async function updateAllStickyMessages(platforms, sessions, config, overheadByPlatform) {
@@ -63849,7 +63996,7 @@ async function cleanupOldStickyMessages(platform, botUserId, forceRun = false, e
   if (!forceRun) {
     const lastRun = lastCleanupTime.get(platformId) || 0;
     if (now - lastRun < CLEANUP_THROTTLE_MS) {
-      log12.debug(`Cleanup throttled for ${platformId} (last run ${Math.round((now - lastRun) / 1000)}s ago)`);
+      log13.debug(`Cleanup throttled for ${platformId} (last run ${Math.round((now - lastRun) / 1000)}s ago)`);
       return;
     }
   }
@@ -63859,31 +64006,31 @@ 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) {
-      log12.debug(`No recent pinned posts to check (${pinnedPostIds.length} total, current: ${currentStickyId?.substring(0, 8) || "(none)"})`);
+      log13.debug(`No recent pinned posts to check (${pinnedPostIds.length} total, current: ${currentStickyId?.substring(0, 8) || "(none)"})`);
       return;
     }
-    log12.debug(`Checking ${recentPinnedIds.length} recent pinned posts (of ${pinnedPostIds.length} total)`);
+    log13.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) {
-          log12.debug(`Cleaning up old sticky: ${postId.substring(0, 8)}...`);
+          log13.debug(`Cleaning up old sticky: ${postId.substring(0, 8)}...`);
           try {
             await platform.unpinPost(postId);
             await platform.deletePost(postId);
-            log12.info(`\uD83E\uDDF9 Cleaned up old sticky message: ${postId.substring(0, 8)}...`);
+            log13.info(`\uD83E\uDDF9 Cleaned up old sticky message: ${postId.substring(0, 8)}...`);
           } catch (err) {
-            log12.debug(`Failed to cleanup ${postId}: ${err}`);
+            log13.debug(`Failed to cleanup ${postId}: ${err}`);
           }
         }
       } catch (err) {
-        log12.debug(`Could not check post ${postId}: ${err}`);
+        log13.debug(`Could not check post ${postId}: ${err}`);
       }
     }
   } catch (err) {
-    log12.error(`Failed to cleanup old sticky messages`, err instanceof Error ? err : undefined);
+    log13.error(`Failed to cleanup old sticky messages`, err instanceof Error ? err : undefined);
   }
 }
 // src/memory/store.ts
@@ -63891,18 +64038,18 @@ init_logger();
 init_worktree();
 import { createHash } from "crypto";
 import {
-  chmodSync as chmodSync3,
+  chmodSync as chmodSync4,
   existsSync as existsSync7,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync4,
   readFileSync as readFileSync6,
   renameSync,
   realpathSync,
   writeFileSync as writeFileSync5
 } from "fs";
-import { homedir as homedir4 } from "os";
-import { basename as basename3, dirname as dirname7, join as join8, sep as sep2 } from "path";
-var log13 = createLogger("memory");
-var DEFAULT_ROOT = join8(homedir4(), ".config", "claude-threads", "memory");
+import { homedir as homedir5 } from "os";
+import { basename as basename3, dirname as dirname7, join as join9, sep as sep2 } from "path";
+var log14 = createLogger("memory");
+var DEFAULT_ROOT = join9(homedir5(), ".config", "claude-threads", "memory");
 var CHANNEL_BLOCK_MAX_LINES = 200;
 var CHANNEL_BLOCK_MAX_BYTES = 25 * 1024;
 var CHANNEL_FILE_MAX_ENTRIES = 400;
@@ -63965,10 +64112,10 @@ class MemoryStore {
     return this.root;
   }
   channelMemoryPath(platformId) {
-    return join8(this.root, platformSegment(platformId), "channel", "MEMORY.md");
+    return join9(this.root, platformSegment(platformId), "channel", "MEMORY.md");
   }
   repoMemoryDir(platformId, repoKey) {
-    const dir = join8(this.root, platformSegment(platformId), "repos", repoKey);
+    const dir = join9(this.root, platformSegment(platformId), "repos", repoKey);
     this.ensureDir(dir);
     return dir;
   }
@@ -64015,7 +64162,7 @@ class MemoryStore {
       if (result.added.length > 0) {
         this.enforceFileCap(lines);
         this.writeLines(platformId, lines);
-        log13.debug(`Channel memory for ${platformId}: +${result.added.length} entries` + (result.duplicates.length ? ` (${result.duplicates.length} duplicates skipped)` : ""));
+        log14.debug(`Channel memory for ${platformId}: +${result.added.length} entries` + (result.duplicates.length ? ` (${result.duplicates.length} duplicates skipped)` : ""));
       }
       return result;
     });
@@ -64054,14 +64201,14 @@ class MemoryStore {
       }
       lines.splice(target.lineIndex, 1);
       this.writeLines(platformId, lines);
-      log13.debug(`Channel memory for ${platformId}: removed one entry`);
+      log14.debug(`Channel memory for ${platformId}: removed one entry`);
       return { ok: true, removed: target.entry };
     });
   }
   clearChannel(platformId) {
     return this.runExclusive(platformId, () => {
       this.writeLines(platformId, []);
-      log13.debug(`Channel memory for ${platformId}: cleared`);
+      log14.debug(`Channel memory for ${platformId}: cleared`);
     });
   }
   buildChannelMemoryBlock(platformId) {
@@ -64069,7 +64216,7 @@ class MemoryStore {
     try {
       lines = this.loadLines(platformId);
     } catch (err) {
-      log13.warn(`Failed to read channel memory for ${platformId}: ${err.message}`);
+      log14.warn(`Failed to read channel memory for ${platformId}: ${err.message}`);
       return null;
     }
     if (lines.length === 0)
@@ -64144,11 +64291,11 @@ _(older entries omitted — \`!memory\` shows all)_` : rendered;
     const tempFile = `${file}.tmp`;
     writeFileSync5(tempFile, content, { encoding: "utf-8", mode: 384 });
     renameSync(tempFile, file);
-    chmodSync3(file, 384);
+    chmodSync4(file, 384);
   }
   ensureDir(dir) {
     if (!existsSync7(dir)) {
-      mkdirSync3(dir, { recursive: true, mode: 448 });
+      mkdirSync4(dir, { recursive: true, mode: 448 });
     }
   }
 }
@@ -64159,7 +64306,7 @@ async function resolveSessionMemory(memoryStore, memoryConfig, platformId, worki
     const repoKey = await resolveRepoKey(workingDir, worktreeRepoRoot);
     return { autoMemoryDir: memoryStore.repoMemoryDir(platformId, repoKey) };
   } catch (err) {
-    log13.warn(`Failed to resolve repo memory dir for ${platformId}: ${err.message}`);
+    log14.warn(`Failed to resolve repo memory dir for ${platformId}: ${err.message}`);
     return null;
   }
 }
@@ -64167,7 +64314,7 @@ async function resolveSessionMemory(memoryStore, memoryConfig, platformId, worki
 // src/claude/quick-query.ts
 init_spawn();
 init_logger();
-var log14 = createLogger("query");
+var log15 = createLogger("query");
 async function quickQuery(options) {
   const {
     prompt,
@@ -64182,7 +64329,7 @@ async function quickQuery(options) {
   if (systemPrompt) {
     args.push("--system-prompt", systemPrompt);
   }
-  log14.debug(`Quick query: model=${model}, timeout=${timeout2}ms, prompt="${prompt.substring(0, 50)}..."`);
+  log15.debug(`Quick query: model=${model}, timeout=${timeout2}ms, prompt="${prompt.substring(0, 50)}..."`);
   return new Promise((resolve6) => {
     let stdout = "";
     let stderr = "";
@@ -64196,7 +64343,7 @@ async function quickQuery(options) {
       if (!resolved) {
         resolved = true;
         proc.kill("SIGTERM");
-        log14.debug(`Quick query timed out after ${timeout2}ms`);
+        log15.debug(`Quick query timed out after ${timeout2}ms`);
         resolve6({
           success: false,
           error: "timeout",
@@ -64214,7 +64361,7 @@ async function quickQuery(options) {
       if (!resolved) {
         resolved = true;
         clearTimeout(timeoutId);
-        log14.debug(`Quick query error: ${err.message}`);
+        log15.debug(`Quick query error: ${err.message}`);
         resolve6({
           success: false,
           error: err.message,
@@ -64228,14 +64375,14 @@ async function quickQuery(options) {
         clearTimeout(timeoutId);
         const durationMs = Date.now() - startTime;
         if (code === 0 && stdout.trim()) {
-          log14.debug(`Quick query success: ${durationMs}ms, ${stdout.length} chars`);
+          log15.debug(`Quick query success: ${durationMs}ms, ${stdout.length} chars`);
           resolve6({
             success: true,
             response: stdout.trim(),
             durationMs
           });
         } else {
-          log14.debug(`Quick query failed: code=${code}, stderr=${stderr.substring(0, 100)}`);
+          log15.debug(`Quick query failed: code=${code}, stderr=${stderr.substring(0, 100)}`);
           resolve6({
             success: false,
             error: stderr || `exit code ${code}`,
@@ -64254,7 +64401,7 @@ init_logger();
 import { exec as exec3 } from "child_process";
 import { promisify as promisify3 } from "util";
 var execAsync2 = promisify3(exec3);
-var log15 = createLogger("branch");
+var log16 = createLogger("branch");
 var SUGGESTION_TIMEOUT = 15000;
 var MAX_SUGGESTIONS = 3;
 async function getCurrentBranch3(workingDir) {
@@ -64303,7 +64450,7 @@ function parseBranchSuggestions(response) {
   return lines.slice(0, MAX_SUGGESTIONS);
 }
 async function suggestBranchNames(workingDir, userMessage) {
-  log15.debug(`Suggesting branch names for: "${userMessage.substring(0, 50)}..."`);
+  log16.debug(`Suggesting branch names for: "${userMessage.substring(0, 50)}..."`);
   try {
     const [currentBranch, recentCommits] = await Promise.all([
       getCurrentBranch3(workingDir),
@@ -64317,14 +64464,14 @@ async function suggestBranchNames(workingDir, userMessage) {
       workingDir
     });
     if (!result.success || !result.response) {
-      log15.debug(`Branch suggestion failed: ${result.error || "no response"}`);
+      log16.debug(`Branch suggestion failed: ${result.error || "no response"}`);
       return [];
     }
     const suggestions = parseBranchSuggestions(result.response);
-    log15.debug(`Got ${suggestions.length} branch suggestions: ${suggestions.join(", ")}`);
+    log16.debug(`Got ${suggestions.length} branch suggestions: ${suggestions.join(", ")}`);
     return suggestions;
   } catch (err) {
-    log15.debug(`Branch suggestion error: ${err}`);
+    log16.debug(`Branch suggestion error: ${err}`);
     return [];
   }
 }
@@ -64333,8 +64480,8 @@ async function suggestBranchNames(workingDir, userMessage) {
 init_worktree();
 import { randomUUID as randomUUID3 } from "crypto";
 init_logger();
-var log16 = createLogger("worktree");
-var sessionLog2 = createSessionLog(log16);
+var log17 = createLogger("worktree");
+var sessionLog2 = createSessionLog(log17);
 function parseWorktreeError(error) {
   const message = error instanceof Error ? error.message : String(error);
   const lowerMessage = message.toLowerCase();
@@ -64860,6 +65007,14 @@ async function removeWorktreeCommand(session, branchOrPath, username) {
   }
   try {
     await removeWorktree(repoRoot, target.path);
+    auditLog(session.platformId, {
+      threadId: session.threadId,
+      sessionId: session.sessionId,
+      actor: username,
+      kind: "command",
+      tool: "worktree remove",
+      detail: target.path
+    });
     const shortPath = shortenPath(target.path, undefined, { path: target.path, branch: target.branch });
     await post(session, "success", `Removed worktree \`${target.branch}\` at \`${shortPath}\``);
     sessionLog2(session).info(`\uD83D\uDDD1️ Removed worktree ${target.branch} at ${shortPath}`);
@@ -64916,8 +65071,8 @@ async function cleanupWorktreeCommand(session, username, hasOtherSessionsUsingWo
 }
 // src/operations/events/handler.ts
 init_logger();
-var log17 = createLogger("events");
-var sessionLog3 = createSessionLog(log17);
+var log18 = createLogger("events");
+var sessionLog3 = createSessionLog(log18);
 function detectAndExecuteClaudeCommands(text, session, ctx) {
   const parsed = parseClaudeCommand(text);
   if (parsed && isClaudeAllowedCommand(parsed.command)) {
@@ -64980,6 +65135,34 @@ function isSidechainEvent(event) {
 }
 function handleEventPreProcessing(session, event, ctx) {
   session.threadLogger?.logEvent(event);
+  try {
+    if (isAuditEnabled(session.platformId)) {
+      const subagent = isSidechainEvent(event) || undefined;
+      const record = (name, input) => auditLog(session.platformId, {
+        threadId: session.threadId,
+        sessionId: session.sessionId,
+        actor: session.lastActorUsername ?? session.startedBy,
+        kind: "tool_use",
+        tool: name,
+        detail: auditDetailForTool(name, input),
+        subagent
+      });
+      if (event.type === "assistant") {
+        const msg = event.message;
+        if (Array.isArray(msg?.content)) {
+          for (const block of msg.content) {
+            if ((block.type === "tool_use" || block.type === "server_tool_use") && block.name) {
+              record(block.name, block.input);
+            }
+          }
+        }
+      } else if (event.type === "tool_use") {
+        const tool = event.tool_use;
+        if (tool?.name)
+          record(tool.name, tool.input);
+      }
+    }
+  } catch {}
   resetSessionActivity(session);
   if (!session.lifecycle.hasClaudeResponded && (event.type === "assistant" || event.type === "tool_use")) {
     markClaudeResponded(session);
@@ -65232,7 +65415,7 @@ function updateUsageFromStatusLine(session) {
 }
 // src/operations/monitor/handler.ts
 init_logger();
-var log18 = createLogger("monitor");
+var log19 = createLogger("monitor");
 var DEFAULT_INTERVAL_MS = 60 * 1000;
 
 class SessionMonitor {
@@ -65254,14 +65437,14 @@ class SessionMonitor {
   }
   start() {
     if (this.isRunning) {
-      log18.debug("Session monitor already running");
+      log19.debug("Session monitor already running");
       return;
     }
     this.isRunning = true;
-    log18.debug(`Session monitor started (interval: ${this.intervalMs / 1000}s)`);
+    log19.debug(`Session monitor started (interval: ${this.intervalMs / 1000}s)`);
     this.timer = setInterval(() => {
       this.runCheck().catch((err) => {
-        log18.error(`Error during session monitoring: ${err}`);
+        log19.error(`Error during session monitoring: ${err}`);
       });
     }, this.intervalMs);
   }
@@ -65271,7 +65454,7 @@ class SessionMonitor {
       this.timer = null;
     }
     this.isRunning = false;
-    log18.debug("Session monitor stopped");
+    log19.debug("Session monitor stopped");
   }
   async runCheck() {
     await cleanupIdleSessions(this.sessionTimeoutMs, this.sessionWarningMs, this.getContext());
@@ -65291,8 +65474,8 @@ function createSessionContext(config, state, ops) {
 // src/operations/context-prompt/handler.ts
 init_emoji();
 init_logger();
-var log19 = createLogger("context");
-var sessionLog4 = createSessionLog(log19);
+var log20 = createLogger("context");
+var sessionLog4 = createSessionLog(log20);
 var CONTEXT_PROMPT_TIMEOUT_MS = 30000;
 var CONTEXT_OPTIONS = [3, 5, 10];
 var contextPromptTimeouts = new Map;
@@ -65522,7 +65705,7 @@ async function offerContextPrompt(session, queuedPrompt, queuedFiles, ctx, exclu
 }
 // src/operations/suggestions/tag.ts
 init_logger();
-var log20 = createLogger("tags");
+var log21 = createLogger("tags");
 var SUGGESTION_TIMEOUT2 = 15000;
 var MAX_TAGS = 3;
 var VALID_TAGS = [
@@ -65554,7 +65737,7 @@ function parseTags(response) {
   return [...new Set(tags)].slice(0, MAX_TAGS);
 }
 async function suggestSessionTags(userMessage) {
-  log20.debug(`Suggesting tags for: "${userMessage.substring(0, 50)}..."`);
+  log21.debug(`Suggesting tags for: "${userMessage.substring(0, 50)}..."`);
   try {
     const result = await quickQuery({
       prompt: buildTagPrompt(userMessage),
@@ -65562,20 +65745,20 @@ async function suggestSessionTags(userMessage) {
       timeout: SUGGESTION_TIMEOUT2
     });
     if (!result.success || !result.response) {
-      log20.debug(`Tag suggestion failed: ${result.error || "no response"}`);
+      log21.debug(`Tag suggestion failed: ${result.error || "no response"}`);
       return [];
     }
     const tags = parseTags(result.response);
-    log20.debug(`Got tags: ${tags.join(", ")} (${result.durationMs}ms)`);
+    log21.debug(`Got tags: ${tags.join(", ")} (${result.durationMs}ms)`);
     return tags;
   } catch (err) {
-    log20.debug(`Tag suggestion error: ${err}`);
+    log21.debug(`Tag suggestion error: ${err}`);
     return [];
   }
 }
 // src/operations/suggestions/title.ts
 init_logger();
-var log21 = createLogger("title");
+var log22 = createLogger("title");
 var SUGGESTION_TIMEOUT3 = 15000;
 var MIN_TITLE_LENGTH = 3;
 var MAX_TITLE_LENGTH = 50;
@@ -65639,32 +65822,32 @@ function parseMetadata(response) {
   const titleMatch = response.match(/TITLE:\s*(.+)/i);
   const descMatch = response.match(/DESC:\s*(.+)/i);
   if (!titleMatch || !descMatch) {
-    log21.debug("Failed to parse title/description from response");
+    log22.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) {
-    log21.debug(`Title too short: ${title.length} chars`);
+    log22.debug(`Title too short: ${title.length} chars`);
     return null;
   }
   if (title.length > MAX_TITLE_LENGTH) {
-    log21.debug(`Title too long (${title.length} chars), truncating`);
+    log22.debug(`Title too long (${title.length} chars), truncating`);
     title = truncateAtWord(title, MAX_TITLE_LENGTH);
   }
   if (description.length < MIN_DESC_LENGTH) {
-    log21.debug(`Description too short: ${description.length} chars`);
+    log22.debug(`Description too short: ${description.length} chars`);
     return null;
   }
   if (description.length > MAX_DESC_LENGTH) {
-    log21.debug(`Description too long (${description.length} chars), truncating`);
+    log22.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);
-  log21.debug(`Suggesting title for: "${logContext}..."`);
+  log22.debug(`Suggesting title for: "${logContext}..."`);
   try {
     const result = await quickQuery({
       prompt: buildTitlePrompt(context),
@@ -65672,27 +65855,27 @@ async function suggestSessionMetadata(context) {
       timeout: SUGGESTION_TIMEOUT3
     });
     if (!result.success || !result.response) {
-      log21.debug(`Title suggestion failed: ${result.error || "no response"}`);
+      log22.debug(`Title suggestion failed: ${result.error || "no response"}`);
       return null;
     }
     const metadata = parseMetadata(result.response);
     if (metadata) {
-      log21.debug(`Got title: "${metadata.title}" (${result.durationMs}ms)`);
+      log22.debug(`Got title: "${metadata.title}" (${result.durationMs}ms)`);
     }
     return metadata;
   } catch (err) {
-    log21.debug(`Title suggestion error: ${err}`);
+    log22.debug(`Title suggestion error: ${err}`);
     return null;
   }
 }
 // src/persistence/github-emails-store.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync6, renameSync as renameSync2, chmodSync as chmodSync4 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join9 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync6, renameSync as renameSync2, chmodSync as chmodSync5 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join10 } from "path";
 init_logger();
-var log22 = createLogger("gh-emails");
-var DEFAULT_CONFIG_DIR = join9(homedir5(), ".config", "claude-threads");
-var DEFAULT_FILE = join9(DEFAULT_CONFIG_DIR, "github-emails.yaml");
+var log23 = createLogger("gh-emails");
+var DEFAULT_CONFIG_DIR = join10(homedir6(), ".config", "claude-threads");
+var DEFAULT_FILE = join10(DEFAULT_CONFIG_DIR, "github-emails.yaml");
 var NOREPLY_REGEX = /^\d+\+[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})@users\.noreply\.github\.com$/;
 var STORE_VERSION = 1;
 function isValidGitHubNoreplyEmail(s) {
@@ -65707,13 +65890,13 @@ class GitHubEmailsStore {
     const effective = filePath ?? envPath;
     if (effective) {
       this.file = effective;
-      this.configDir = join9(effective, "..");
+      this.configDir = join10(effective, "..");
     } else {
       this.file = DEFAULT_FILE;
       this.configDir = DEFAULT_CONFIG_DIR;
     }
     if (!existsSync8(this.configDir)) {
-      mkdirSync4(this.configDir, { recursive: true });
+      mkdirSync5(this.configDir, { recursive: true });
     }
   }
   get(platformId, username) {
@@ -65730,7 +65913,7 @@ class GitHubEmailsStore {
     }
     data.emails[platformId][username] = email;
     this.writeAtomic(data);
-    log22.debug(`Stored GitHub email for ${platformId}/${username}`);
+    log23.debug(`Stored GitHub email for ${platformId}/${username}`);
   }
   delete(platformId, username) {
     const data = this.loadRaw();
@@ -65742,7 +65925,7 @@ class GitHubEmailsStore {
       delete data.emails[platformId];
     }
     this.writeAtomic(data);
-    log22.debug(`Removed GitHub email for ${platformId}/${username}`);
+    log23.debug(`Removed GitHub email for ${platformId}/${username}`);
     return true;
   }
   loadRaw() {
@@ -65758,7 +65941,7 @@ class GitHubEmailsStore {
       const emails = parsed.emails && typeof parsed.emails === "object" ? parsed.emails : {};
       return { version: parsed.version ?? STORE_VERSION, emails };
     } catch (err) {
-      log22.warn(`Failed to read ${this.file}: ${err.message} — starting empty`);
+      log23.warn(`Failed to read ${this.file}: ${err.message} — starting empty`);
       return { version: STORE_VERSION, emails: {} };
     }
   }
@@ -65767,19 +65950,19 @@ class GitHubEmailsStore {
     const yamlText = yaml.dump(data, { sortKeys: true, lineWidth: -1 });
     writeFileSync6(tempFile, yamlText, { encoding: "utf-8", mode: 384 });
     renameSync2(tempFile, this.file);
-    chmodSync4(this.file, 384);
+    chmodSync5(this.file, 384);
   }
 }
 
 // src/persistence/routines-store.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync8 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join10 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync8 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join11 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 init_logger();
 
 // src/persistence/atomic-file.ts
-import { chmodSync as chmodSync5, renameSync as renameSync3, writeFileSync as writeFileSync7 } from "fs";
+import { chmodSync as chmodSync6, renameSync as renameSync3, writeFileSync as writeFileSync7 } from "fs";
 
 class SerialQueue {
   tail = Promise.resolve();
@@ -65795,13 +65978,13 @@ function writeFileAtomic(file, content) {
   const tempFile = `${file}.tmp`;
   writeFileSync7(tempFile, content, { encoding: "utf-8", mode: 384 });
   renameSync3(tempFile, file);
-  chmodSync5(file, 384);
+  chmodSync6(file, 384);
 }
 
 // src/persistence/routines-store.ts
-var log23 = createLogger("routines");
-var DEFAULT_CONFIG_DIR2 = join10(homedir6(), ".config", "claude-threads");
-var DEFAULT_FILE2 = join10(DEFAULT_CONFIG_DIR2, "routines.yaml");
+var log24 = createLogger("routines");
+var DEFAULT_CONFIG_DIR2 = join11(homedir7(), ".config", "claude-threads");
+var DEFAULT_FILE2 = join11(DEFAULT_CONFIG_DIR2, "routines.yaml");
 var STORE_VERSION2 = 1;
 var MAX_CONSECUTIVE_FAILURES = 3;
 var DEFAULT_MAX_ROUTINES = 10;
@@ -65860,13 +66043,13 @@ class RoutinesStore {
     const effective = filePath ?? process.env.CLAUDE_THREADS_ROUTINES_PATH;
     if (effective) {
       this.file = effective;
-      this.configDir = join10(effective, "..");
+      this.configDir = join11(effective, "..");
     } else {
       this.file = DEFAULT_FILE2;
       this.configDir = DEFAULT_CONFIG_DIR2;
     }
     if (!existsSync9(this.configDir)) {
-      mkdirSync5(this.configDir, { recursive: true, mode: 448 });
+      mkdirSync6(this.configDir, { recursive: true, mode: 448 });
     }
   }
   list(platformId) {
@@ -65900,7 +66083,7 @@ class RoutinesStore {
       };
       data.routines[platformId] = [...existing, full];
       this.writeAtomic(data);
-      log23.info(`Routine "${full.name}" created on ${platformId} by @${full.createdBy}`);
+      log24.info(`Routine "${full.name}" created on ${platformId} by @${full.createdBy}`);
       return { ok: true, routine: full };
     });
   }
@@ -65927,7 +66110,7 @@ class RoutinesStore {
       if (routines.length === 0)
         delete data.routines[platformId];
       this.writeAtomic(data);
-      log23.info(`Routine "${removed.name}" removed from ${platformId}`);
+      log24.info(`Routine "${removed.name}" removed from ${platformId}`);
       return removed;
     });
   }
@@ -65952,7 +66135,7 @@ class RoutinesStore {
       }
       return { version: parsed.version ?? STORE_VERSION2, routines };
     } catch (err) {
-      log23.warn(`Failed to read ${this.file}: ${err.message} — starting empty`);
+      log24.warn(`Failed to read ${this.file}: ${err.message} — starting empty`);
       return { version: STORE_VERSION2, routines: {} };
     }
   }
@@ -65963,7 +66146,7 @@ class RoutinesStore {
 
 // src/routines/parser.ts
 init_logger();
-var log24 = createLogger("routines");
+var log25 = createLogger("routines");
 var PARSE_TIMEOUT_MS = 15000;
 function hostTimezone() {
   return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
@@ -66032,7 +66215,7 @@ async function parseRoutineRequest(request, defaultTimezone = hostTimezone()) {
     timeout: PARSE_TIMEOUT_MS
   });
   if (!result.success || !result.response) {
-    log24.debug(`Routine parse quickQuery failed: ${result.error ?? "no response"}`);
+    log25.debug(`Routine parse quickQuery failed: ${result.error ?? "no response"}`);
     return { ok: false, error: "could not reach the parsing model — try again in a moment" };
   }
   const raw = extractJsonObject(result.response);
@@ -66043,8 +66226,8 @@ async function parseRoutineRequest(request, defaultTimezone = hostTimezone()) {
 }
 
 // src/operations/commands/handler.ts
-var log25 = createLogger("commands");
-var sessionLog5 = createSessionLog(log25);
+var log26 = createLogger("commands");
+var sessionLog5 = createSessionLog(log26);
 function sessionAccountOption(session, ctx) {
   if (!session.claudeAccountId)
     return;
@@ -66088,6 +66271,16 @@ async function restartClaudeSession(session, cliOptions, ctx, actionName) {
     return false;
   }
 }
+function auditCommand(session, command, detail, username) {
+  auditLog(session.platformId, {
+    threadId: session.threadId,
+    sessionId: session.sessionId,
+    actor: username,
+    kind: "command",
+    tool: command,
+    detail
+  });
+}
 async function requireSessionOwner(session, username, action) {
   const formatter = session.platform.getFormatter();
   if (session.startedBy !== username && !session.platform.isUserAllowed(username)) {
@@ -66123,6 +66316,7 @@ function formatContextBar(percent) {
 }
 async function cancelSession(session, username, ctx) {
   sessionLog5(session).info(`\uD83D\uDED1 Cancelled by @${username}`);
+  auditCommand(session, "stop", undefined, username);
   session.threadLogger?.logCommand("stop", undefined, username);
   transitionTo(session, "cancelling");
   const formatter = session.platform.getFormatter();
@@ -66161,6 +66355,14 @@ async function approvePendingPlan(session, username, ctx) {
     return;
   }
   const { postId } = pendingApproval;
+  auditLog(session.platformId, {
+    threadId: session.threadId,
+    sessionId: session.sessionId,
+    actor: username,
+    kind: "plan_approval",
+    approved: true,
+    detail: "via !approve"
+  });
   sessionLog5(session).info(`✅ Plan approved by @${username} via command`);
   const viaBridge = session.messageManager?.resolveBridgePlan(true) ?? false;
   const formatter = session.platform.getFormatter();
@@ -66231,6 +66433,7 @@ async function changeDirectory(session, newDir, username, ctx) {
   const worktreeContext = session.worktreeInfo ? { path: session.worktreeInfo.worktreePath, branch: session.worktreeInfo.branch } : undefined;
   const shortDir = shortenPath(absoluteDir, undefined, worktreeContext);
   sessionLog5(session).info(`\uD83D\uDCC2 Changing directory to ${shortDir}`);
+  auditCommand(session, "cd", absoluteDir, username);
   session.threadLogger?.logCommand("cd", absoluteDir, username);
   const previousDir = session.workingDir;
   const workSummary = await generateWorkSummary(session);
@@ -66313,6 +66516,7 @@ async function inviteUser(session, invitedUser, invitedBy, ctx) {
   session.sessionAllowedUsers.add(invitedUser);
   await post(session, "success", `${formatter.formatUserMention(invitedUser)} can now participate in this session (invited by ${formatter.formatUserMention(invitedBy)})`);
   sessionLog5(session).info(`\uD83D\uDC4B @${invitedUser} invited by @${invitedBy}`);
+  auditCommand(session, "invite", invitedUser, invitedBy);
   session.threadLogger?.logCommand("invite", invitedUser, invitedBy);
   await updateSessionHeader(session, ctx);
   ctx.ops.persistSession(session);
@@ -66343,6 +66547,7 @@ async function kickUser(session, kickedUser, kickedBy, ctx) {
   if (session.sessionAllowedUsers.delete(kickedUser)) {
     await post(session, "user", `${formatter.formatUserMention(kickedUser)} removed from this session by ${formatter.formatUserMention(kickedBy)}`);
     sessionLog5(session).info(`\uD83D\uDEAB @${kickedUser} kicked by @${kickedBy}`);
+    auditCommand(session, "kick", kickedUser, kickedBy);
     session.threadLogger?.logCommand("kick", kickedUser, kickedBy);
     await updateSessionHeader(session, ctx);
     ctx.ops.persistSession(session);
@@ -66499,6 +66704,7 @@ async function forgetMemory(session, selector, username, ctx) {
     await ctx.state.memoryStore.clearChannel(session.platformId);
     await post(session, "success", `\uD83E\uDDE0 Channel memory cleared (${count} ${count === 1 ? "entry" : "entries"} removed). Running sessions keep their copy until their next restart.`);
     sessionLog5(session).info(`\uD83E\uDDE0 @${username} cleared channel memory (${count} entries)`);
+    auditCommand(session, "memory", "forget all", username);
     session.threadLogger?.logCommand("memory", "forget all", username);
     return;
   }
@@ -66507,6 +66713,7 @@ async function forgetMemory(session, selector, username, ctx) {
   if (result.ok) {
     await post(session, "success", `\uD83E\uDDE0 Forgot: ${formatter.formatItalic(result.removed.text)}`);
     sessionLog5(session).info(`\uD83E\uDDE0 @${username} removed a channel memory entry`);
+    auditCommand(session, "memory", "forget", username);
     session.threadLogger?.logCommand("memory", "forget", username);
     return;
   }
@@ -66646,6 +66853,7 @@ async function manageRoutines(session, args, username, ctx) {
     }
   }
   sessionLog5(session).info(`\uD83D\uDD58 @${username}: !routines ${lowered} ${indexArg} ("${routine.name}")`);
+  auditCommand(session, "routines", `${lowered} ${indexArg}`, username);
   session.threadLogger?.logCommand("routines", `${lowered} ${indexArg}`, username);
 }
 async function setSessionPermissionMode(session, username, mode, ctx) {
@@ -66655,6 +66863,7 @@ async function setSessionPermissionMode(session, username, mode, ctx) {
   session.permissionModeOverride = mode;
   session.forceInteractivePermissions = mode === "default";
   sessionLog5(session).info(`\uD83D\uDD10 Setting permission mode to "${mode}"`);
+  auditCommand(session, "permissions", mode, username);
   session.threadLogger?.logCommand("permissions", mode, username);
   const canResume = session.lifecycle.hasClaudeResponded;
   const memoryConfig = ctx.ops.getPlatformMemoryConfig(session.platformId);
@@ -66948,7 +67157,7 @@ init_worktree();
 
 // src/memory/distiller.ts
 init_logger();
-var log26 = createLogger("memory");
+var log27 = createLogger("memory");
 var MIN_THREAD_MESSAGES = 4;
 var DISTILL_MESSAGE_LIMIT = 30;
 var MESSAGE_CHAR_CAP = 500;
@@ -66992,17 +67201,17 @@ function scheduleDistillation(session, ctx, reason) {
     return;
   }
   if (isDcmThreadId(session.threadId)) {
-    log26.debug(`Skipping distillation for DCM session ${session.platformId}:${session.threadId}`);
+    log27.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) {
-      log26.debug(`Distilled ${added} memory entries from ${platformId}:${threadId} (${reason})`);
+      log27.debug(`Distilled ${added} memory entries from ${platformId}:${threadId} (${reason})`);
     }
   }).catch((err) => {
-    log26.debug(`Distillation failed for ${platformId}:${threadId}: ${err.message}`);
+    log27.debug(`Distillation failed for ${platformId}:${threadId}: ${err.message}`);
   });
 }
 async function distillThread(store, platformId, threadId, platform) {
@@ -67029,8 +67238,8 @@ async function distillThread(store, platformId, threadId, platform) {
 }
 
 // src/session/lifecycle.ts
-var log27 = createLogger("lifecycle");
-var sessionLog6 = createSessionLog(log27);
+var log28 = createLogger("lifecycle");
+var sessionLog6 = createSessionLog(log28);
 function mutableSessions(ctx) {
   return ctx.state.sessions;
 }
@@ -67046,7 +67255,22 @@ function mutablePostIndex(ctx) {
 function cleanupSessionTimers(session) {
   clearAllTimers(session.timers);
 }
-async function closeThreadLogger(session, action, details) {
+function auditSessionEnd(session, reason) {
+  if (session.auditEndRecorded)
+    return;
+  session.auditEndRecorded = true;
+  auditLog(session.platformId, {
+    threadId: session.threadId,
+    sessionId: session.sessionId,
+    actor: session.lastActorUsername ?? session.startedBy,
+    kind: "session_end",
+    detail: reason
+  });
+}
+async function closeThreadLogger(session, action, details, auditReason) {
+  if (auditReason ?? action) {
+    auditSessionEnd(session, auditReason ?? action);
+  }
   if (session.threadLogger) {
     if (action) {
       session.threadLogger.logLifecycle(action, details);
@@ -67071,12 +67295,15 @@ async function cleanupSession(session, ctx, options = {}) {
     action,
     details,
     closeLogger: doCloseLogger = true,
-    cleanupPostIndex: doCleanupPostIndex = true
+    cleanupPostIndex: doCleanupPostIndex = true,
+    auditReason
   } = options;
   ctx.ops.stopTyping(session);
   cleanupSessionTimers(session);
   if (doCloseLogger) {
-    await closeThreadLogger(session, action, details);
+    await closeThreadLogger(session, action, details, auditReason);
+  } else if (auditReason ?? action) {
+    auditSessionEnd(session, auditReason ?? action);
   }
   session.messageManager?.dispose();
   session.decisionBridge?.close();
@@ -67096,7 +67323,9 @@ function releaseAccountIfHeld(session, ctx) {
     session.claudeAccountId = undefined;
   }
 }
-function removeFromRegistry(session, ctx) {
+function removeFromRegistry(session, ctx, auditReason) {
+  if (auditReason)
+    auditSessionEnd(session, auditReason);
   session.messageManager?.dispose();
   session.decisionBridge?.close();
   session.decisionBridge = undefined;
@@ -67135,7 +67364,7 @@ async function createSessionDecisionBridge(ref) {
       return messageManager.handleBridgeRequest(request, signal);
     });
   } catch (err) {
-    log27.warn(`Decision bridge unavailable — falling back to legacy MCP prompts: ${err}`);
+    log28.warn(`Decision bridge unavailable — falling back to legacy MCP prompts: ${err}`);
     return null;
   }
 }
@@ -67204,6 +67433,14 @@ function createMessageManager(session, ctx) {
     }
   });
   messageManager.events.on("routine-prompt:complete", async ({ approved, parsed, requestedBy, postId }) => {
+    auditLog(session.platformId, {
+      threadId: session.threadId,
+      sessionId: session.sessionId,
+      actor: requestedBy,
+      kind: "command",
+      tool: "routine",
+      detail: `${approved ? "created" : "discarded"}: ${parsed.name}`
+    });
     session.threadLogger?.logCommand("routine", approved ? "created" : "discarded", requestedBy);
     if (!approved) {
       sessionLog6(session).info(`\uD83D\uDD58 Routine "${parsed.name}" discarded before saving`);
@@ -67422,7 +67659,7 @@ function resumeSessionHeaderMode(persisted, platformConfigured) {
 function resolveSessionHeaderMode(configured, replyToPostId, platformId) {
   const mode = configured ?? DEFAULT_OVERHEAD_VISIBILITY;
   if (mode === "hidden" && !replyToPostId) {
-    log27.error(`sessionHeader: hidden requires a replyToPostId for ${platformId}; ` + `downgrading this session to 'minimal' so the header post is still short.`);
+    log28.error(`sessionHeader: hidden requires a replyToPostId for ${platformId}; ` + `downgrading this session to 'minimal' so the header post is still short.`);
     return "minimal";
   }
   return mode;
@@ -67462,7 +67699,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 })) {
-    log27.warn(`auth.denied.startSession: @${username || "unknown"} not authorized to start session in ${threadId.substring(0, 8)}...`);
+    log28.warn(`auth.denied.startSession: @${username || "unknown"} not authorized to start session in ${threadId.substring(0, 8)}...`);
     return;
   }
   const activeOrPending = ctx.state.sessions.size + pendingStartsCount;
@@ -67523,17 +67760,17 @@ async function startSessionImpl(options, username, displayName, replyToPostId, p
       return;
     }
     workingDir = resolvedDir;
-    log27.info(`Starting session in directory: ${workingDir} (from !cd command)`);
+    log28.info(`Starting session in directory: ${workingDir} (from !cd command)`);
   }
   if (initialOptions?.permissionMode) {
     permissionMode = initialOptions.permissionMode;
     forceInteractivePermissions = permissionMode === "default";
     sessionPermissionModeOverride = permissionMode;
-    log27.info(`Starting session with permission mode "${permissionMode}" (from !permissions command)`);
+    log28.info(`Starting session with permission mode "${permissionMode}" (from !permissions command)`);
   } else if (initialOptions?.forceInteractivePermissions) {
     forceInteractivePermissions = true;
     permissionMode = "default";
-    log27.info(`Starting session with interactive permissions (from !permissions command)`);
+    log28.info(`Starting session with interactive permissions (from !permissions command)`);
   }
   const userAttribution = ctx.config.userAttribution ?? true;
   const memoryConfig = ctx.ops.getPlatformMemoryConfig(platformId);
@@ -67547,7 +67784,7 @@ async function startSessionImpl(options, username, displayName, replyToPostId, p
     balanceByUsage: true
   });
   if (claudeAccount) {
-    log27.info(`Session ${sessionId.substring(0, 20)} reserved Claude account "${claudeAccount.id}"`);
+    log28.info(`Session ${sessionId.substring(0, 20)} reserved Claude account "${claudeAccount.id}"`);
   }
   const bridgeSessionRef = {};
   const decisionBridge = await createSessionDecisionBridge(bridgeSessionRef);
@@ -67612,6 +67849,12 @@ async function startSessionImpl(options, username, displayName, replyToPostId, p
   session.decisionBridge = decisionBridge ?? undefined;
   session.messageManager = createMessageManager(session, ctx);
   bridgeSessionRef.current = session;
+  auditLog(session.platformId, {
+    threadId: session.threadId,
+    sessionId: session.sessionId,
+    actor: session.startedBy,
+    kind: "session_start"
+  });
   session.threadLogger?.logLifecycle("start", {
     username,
     workingDir: ctx.config.workingDir
@@ -67636,6 +67879,7 @@ async function startSessionImpl(options, username, displayName, replyToPostId, p
     claude.start();
   } catch (err) {
     await logAndNotify(err, { action: "Start Claude", session });
+    auditSessionEnd(session, "start-failed");
     ctx.ops.stopTyping(session);
     session.messageManager?.dispose();
     session.decisionBridge?.close();
@@ -67670,12 +67914,12 @@ async function startSessionImpl(options, username, displayName, replyToPostId, p
   claude.sendMessage(formatUserTurn(content, username, shouldAttribute(session.userAttribution, session.sessionAllowedUsers.size)));
   await postSkippedFilesFeedback(session.platform, actualThreadId, skipped);
 }
-async function resumeSession(state, ctx) {
+async function resumeSession(state, ctx, resumedBy) {
   if (state.threadId && state.platformId) {
     const sessionKey = `${state.platformId}:${state.threadId}`;
     const sessions = ctx.state?.sessions;
     if (sessions?.has(sessionKey)) {
-      log27.debug(`Session ${state.threadId.substring(0, 8)}... already active, skipping resume`);
+      log28.debug(`Session ${state.threadId.substring(0, 8)}... already active, skipping resume`);
       return;
     }
     const inFlight = _inFlightSessionStarts.get(sessionKey);
@@ -67683,7 +67927,7 @@ async function resumeSession(state, ctx) {
       await inFlight.catch(() => {});
       return;
     }
-    const attempt = resumeSessionImpl(state, ctx);
+    const attempt = resumeSessionImpl(state, ctx, resumedBy);
     _inFlightSessionStarts.set(sessionKey, attempt);
     try {
       await attempt;
@@ -67692,9 +67936,9 @@ async function resumeSession(state, ctx) {
     }
     return;
   }
-  await resumeSessionImpl(state, ctx);
+  await resumeSessionImpl(state, ctx, resumedBy);
 }
-async function resumeSessionImpl(state, ctx) {
+async function resumeSessionImpl(state, ctx, resumedBy) {
   if (!state.threadId || !state.platformId || !state.claudeSessionId || !state.workingDir) {
     const missing = [
       !state.threadId && "threadId",
@@ -67702,35 +67946,35 @@ async function resumeSessionImpl(state, ctx) {
       !state.claudeSessionId && "claudeSessionId",
       !state.workingDir && "workingDir"
     ].filter(Boolean).join(", ");
-    log27.warn(`Skipping session with missing required fields: ${missing}`);
+    log28.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) {
-    log27.warn(`Platform ${state.platformId} not registered, skipping resume for ${shortId}...`);
+    log28.warn(`Platform ${state.platformId} not registered, skipping resume for ${shortId}...`);
     return;
   }
   if (isDcmThreadId(state.threadId) && !platform.directChannelMode?.enabled) {
-    log27.warn(`Direct channel mode disabled for ${state.platformId}, dropping persisted DCM session`);
+    log28.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) {
-      log27.warn(`Thread ${shortId}... deleted, skipping resume`);
+      log28.warn(`Thread ${shortId}... deleted, skipping resume`);
       ctx.state.sessionStore.remove(`${state.platformId}:${state.threadId}`);
       return;
     }
   }
   if (ctx.state.sessions.size >= ctx.config.maxSessions) {
-    log27.warn(`Max sessions reached, skipping resume for ${shortId}...`);
+    log28.warn(`Max sessions reached, skipping resume for ${shortId}...`);
     return;
   }
   if (!existsSync11(state.workingDir)) {
-    log27.warn(`Working directory ${state.workingDir} no longer exists, skipping resume for ${shortId}...`);
+    log28.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 = {
@@ -67756,7 +68000,7 @@ Please start a new session.`), { action: "Post resume failure notification" });
   const appendSystemPrompt = await buildAppendSystemPrompt(platform, state.platformId, state.workingDir, state.threadId, state.startedBy, state.sessionAllowedUsers || [state.startedBy], CHAT_PLATFORM_PROMPT, ctx.state.githubEmailsStore, memoryConfig.enabled && memoryConfig.channelLayer ? ctx.state.memoryStore : null, { userAttribution });
   const claudeAccount = ctx.ops.acquireClaudeAccount(state.claudeAccountId, state.threadId);
   if (state.claudeAccountId && !claudeAccount) {
-    log27.warn(`Persisted session referenced Claude account "${state.claudeAccountId}" ` + `which is no longer configured — resuming under default env`);
+    log28.warn(`Persisted session referenced Claude account "${state.claudeAccountId}" ` + `which is no longer configured — resuming under default env`);
   }
   const resumeBridgeRef = {};
   const resumeBridge = await createSessionDecisionBridge(resumeBridgeRef);
@@ -67839,7 +68083,7 @@ Please start a new session.`), { action: "Post resume failure notification" });
         worktreePath: detected.worktreePath,
         branch: detected.branch
       };
-      log27.info(`Auto-detected worktree info for resumed session: branch=${detected.branch}`);
+      log28.info(`Auto-detected worktree info for resumed session: branch=${detected.branch}`);
     }
   }
   session.messageManager = createMessageManager(session, ctx);
@@ -67858,6 +68102,14 @@ Please start a new session.`), { action: "Post resume failure notification" });
       pendingApproval: persistedWithInteractive.pendingApproval
     });
   }
+  if (resumedBy)
+    session.lastActorUsername = resumedBy;
+  auditLog(session.platformId, {
+    threadId: session.threadId,
+    sessionId: session.sessionId,
+    actor: resumedBy ?? session.startedBy,
+    kind: "session_resume"
+  });
   session.threadLogger?.logLifecycle("resume", {
     username: state.startedBy,
     workingDir: state.workingDir
@@ -67898,7 +68150,8 @@ ${sessionFormatter.formatItalic("Reconnected to Claude session. You can continue
     await postResumeCoAuthorOnboarding(session, ctx);
     ctx.ops.persistSession(session);
   } catch (err) {
-    log27.error(`Failed to resume session ${shortId}`, err instanceof Error ? err : undefined);
+    log28.error(`Failed to resume session ${shortId}`, err instanceof Error ? err : undefined);
+    auditSessionEnd(session, "resume-failed");
     session.messageManager?.dispose();
     session.decisionBridge?.close();
     session.decisionBridge = undefined;
@@ -67931,6 +68184,8 @@ async function sendFollowUp(session, message, files, ctx, username, displayName,
       return;
     }
   }
+  if (username && !options?.system)
+    session.lastActorUsername = username;
   if (session.needsContextPromptOnNextMessage) {
     session.needsContextPromptOnNextMessage = false;
     await session.messageManager?.prepareForUserMessage();
@@ -67951,28 +68206,28 @@ async function resumePausedSession(threadId, message, files, ctx, username) {
   const persisted = ctx.state.sessionStore.load();
   const state = findPersistedByThreadId(persisted, threadId);
   if (!state) {
-    log27.debug(`No persisted session found for ${threadId.substring(0, 8)}...`);
+    log28.debug(`No persisted session found for ${threadId.substring(0, 8)}...`);
     return;
   }
   const shortId = threadId.substring(0, 8);
   const platform = ctx.state.platforms.get(state.platformId);
   if (!platform) {
-    log27.warn(`auth.denied.resume: platform '${state.platformId}' not found for ${shortId}...`);
+    log28.warn(`auth.denied.resume: platform '${state.platformId}' not found for ${shortId}...`);
     return;
   }
   const sessionAllowedUsers = new Set(state.sessionAllowedUsers || [state.startedBy].filter(Boolean));
   if (!isAuthorizedForSession({ username, platform, sessionAllowedUsers })) {
-    log27.warn(`auth.denied.resume: @${username || "unknown"} not authorized to resume ${shortId}...`);
+    log28.warn(`auth.denied.resume: @${username || "unknown"} not authorized to resume ${shortId}...`);
     return;
   }
-  log27.info(`\uD83D\uDD04 Resuming paused session ${shortId}... for new message`);
-  await resumeSession(state, ctx);
+  log28.info(`\uD83D\uDD04 Resuming paused session ${shortId}... for new message`);
+  await resumeSession(state, ctx, username);
   const session = ctx.ops.findSessionByThreadId(threadId);
   if (session && session.claude.isRunning() && session.messageManager) {
     session.messageCount++;
     await session.messageManager.handleUserMessage(message, files, username);
   } else {
-    log27.warn(`Failed to resume session ${shortId}..., could not send message`);
+    log28.warn(`Failed to resume session ${shortId}..., could not send message`);
   }
 }
 async function handleExit(sessionId, code, ctx, source) {
@@ -67980,7 +68235,7 @@ async function handleExit(sessionId, code, ctx, source) {
   const shortId = sessionId.substring(0, 8);
   sessionLog6(session).debug(`handleExit called code=${code} isShuttingDown=${ctx.state.isShuttingDown}`);
   if (!session) {
-    log27.debug(`Session ${shortId}... not found (already cleaned up)`);
+    log28.debug(`Session ${shortId}... not found (already cleaned up)`);
     return;
   }
   if (source && session.claude !== source) {
@@ -68001,7 +68256,8 @@ async function handleExit(sessionId, code, ctx, source) {
     await cleanupSession(session, ctx, {
       action: "exit",
       details: { reason: "shutdown", exitCode: code },
-      cleanupPostIndex: false
+      cleanupPostIndex: false,
+      auditReason: "shutdown"
     });
     return;
   }
@@ -68009,7 +68265,7 @@ async function handleExit(sessionId, code, ctx, source) {
     sessionLog6(session).debug(`Exited after interrupt, preserving for resume`);
     ctx.ops.stopTyping(session);
     cleanupSessionTimers(session);
-    await closeThreadLogger(session, "interrupt", { exitCode: code });
+    await closeThreadLogger(session, "interrupt", { exitCode: code }, "pause");
     const message = session.lifecycle.hasClaudeResponded ? `ℹ️ Session paused. Send a new message to continue.` : `ℹ️ Session ended before Claude could respond. Send a new message to start fresh.`;
     const pausePost = await withErrorHandling(() => post(session, "info", message), { action: "Post session pause notification", session });
     if (session.lifecycle.hasClaudeResponded) {
@@ -68020,7 +68276,7 @@ async function handleExit(sessionId, code, ctx, source) {
       }
       ctx.ops.persistSession(session);
     }
-    removeFromRegistry(session, ctx);
+    removeFromRegistry(session, ctx, "pause");
     sessionLog6(session).info(`⏸ Session paused`);
     await ctx.ops.updateStickyMessage();
     return;
@@ -68030,7 +68286,8 @@ async function handleExit(sessionId, code, ctx, source) {
     sessionLog6(session).debug(`Exited before Claude responded, not persisting`);
     await cleanupSession(session, ctx, {
       action: "exit",
-      details: { reason: "early_exit", exitCode: code }
+      details: { reason: "early_exit", exitCode: code },
+      auditReason: "early-exit"
     });
     const earlyExitFormatter = session.platform.getFormatter();
     await withErrorHandling(() => post(session, "warning", `${earlyExitFormatter.formatBold("Session ended")} before Claude could respond (exit code ${code}). Please start a new session.`), { action: "Post early exit notification", session });
@@ -68044,6 +68301,7 @@ async function handleExit(sessionId, code, ctx, source) {
     const isPermanent = session.claude.isPermanentFailure();
     const permanentReason = session.claude.getPermanentFailureReason();
     sessionLog6(session).debug(`Resumed session failed with code ${code}, attempt ${session.lifecycle.resumeFailCount}/${MAX_RESUME_FAILURES}, permanent=${isPermanent}`);
+    auditSessionEnd(session, code === null ? "exit" : `exit:${code}`);
     await cleanupSession(session, ctx, {
       closeLogger: false,
       cleanupPostIndex: false
@@ -68079,7 +68337,7 @@ Please start a new session.`), { action: "Post session permanent failure", sessi
   scheduleDistillation(session, ctx, "exit");
   ctx.ops.stopTyping(session);
   cleanupSessionTimers(session);
-  await closeThreadLogger(session, "exit", { exitCode: code });
+  await closeThreadLogger(session, "exit", { exitCode: code }, code === 0 || code === null ? "exit" : `exit:${code}`);
   const exitTaskState = session.messageManager?.getTaskListState();
   if (exitTaskState?.postId) {
     await session.platform.unpinPost(exitTaskState.postId).catch(() => {});
@@ -68092,7 +68350,7 @@ Please start a new session.`), { action: "Post session permanent failure", sessi
   if (session.worktreeInfo) {
     ctx.ops.unregisterWorktreeUser(session.worktreeInfo.worktreePath, session.sessionId);
   }
-  removeFromRegistry(session, ctx);
+  removeFromRegistry(session, ctx, code === 0 ? "exit" : `exit:${code}`);
   if (code === 0 || code === null) {
     ctx.ops.unpersistSession(session.sessionId);
   } else {
@@ -68101,7 +68359,7 @@ Please start a new session.`), { action: "Post session permanent failure", sessi
   sessionLog6(session).info(`■ Session ended`);
   await ctx.ops.updateStickyMessage();
 }
-async function killSession(session, unpersist, ctx) {
+async function killSession(session, unpersist, ctx, auditCause = "kill") {
   if (!unpersist) {
     transitionTo(session, "restarting");
   }
@@ -68109,7 +68367,7 @@ async function killSession(session, unpersist, ctx) {
     scheduleDistillation(session, ctx, "stop");
   }
   ctx.ops.stopTyping(session);
-  await closeThreadLogger(session, "kill", { unpersist });
+  await closeThreadLogger(session, "kill", { unpersist }, auditCause);
   session.claude.kill();
   const killTaskState = session.messageManager?.getTaskListState();
   if (killTaskState?.postId) {
@@ -68118,7 +68376,7 @@ async function killSession(session, unpersist, ctx) {
   if (unpersist && session.worktreeInfo) {
     ctx.ops.unregisterWorktreeUser(session.worktreeInfo.worktreePath, session.sessionId);
   }
-  removeFromRegistry(session, ctx);
+  removeFromRegistry(session, ctx, auditCause);
   if (unpersist) {
     ctx.ops.unpersistSession(session.sessionId);
   }
@@ -68132,6 +68390,7 @@ async function killAllSessions(ctx) {
     if (ctx.state.isShuttingDown) {
       ctx.ops.persistSession(session);
     }
+    auditSessionEnd(session, ctx.state.isShuttingDown ? "shutdown" : "kill");
     killPromises.push(session.claude.kill());
   }
   await Promise.all(killPromises);
@@ -68162,7 +68421,7 @@ async function cleanupIdleSessions(timeoutMs, warningMs, ctx) {
       transitionTo(session, "paused");
       ctx.ops.persistSession(session);
       scheduleDistillation(session, ctx, "timeout");
-      await killSession(session, false, ctx);
+      await killSession(session, false, ctx, "timeout");
       continue;
     }
     const warningThresholdMs = timeoutMs - warningMs;
@@ -68183,7 +68442,7 @@ async function cleanupIdleSessions(timeoutMs, warningMs, ctx) {
 
 // src/platform/dm-discovery-runtime.ts
 function createDmDiscoveryRuntime(deps) {
-  const { platforms, session, log: log28 } = deps;
+  const { platforms, session, log: log29 } = deps;
   const graceMs = deps.graceMs ?? 30000;
   const orphanTtlMs = deps.orphanTtlMs ?? 10 * 60000;
   const instanceByChannel = new Map;
@@ -68226,9 +68485,10 @@ function createDmDiscoveryRuntime(deps) {
     session.removePlatform(dmId);
     if (client)
       Promise.resolve(client.disconnect()).catch(() => {});
+    configureAuditLog(dmId, false);
     if (deps.isEnabled?.(dmId) !== false)
       deps.removeUiRow?.(dmId);
-    log28("info", `\uD83E\uDDF9 DM instance ${dmId} torn down (${reason})`);
+    log29("info", `\uD83E\uDDF9 DM instance ${dmId} torn down (${reason})`);
   };
   const register = (parentCfg, channelId, partnerUsernames) => {
     const dmConfig = deriveDmPlatformConfig(parentCfg, channelId, partnerUsernames);
@@ -68257,10 +68517,10 @@ function createDmDiscoveryRuntime(deps) {
       }
       const dmId = dmPlatformId(parentConfig.id, post2.channelId);
       if (deps.isEnabled && !deps.isEnabled(dmId)) {
-        log28("info", `Ignoring DM for disabled instance ${dmId}`);
+        log29("info", `Ignoring DM for disabled instance ${dmId}`);
         return;
       }
-      log28("info", `\uD83D\uDCE9 New DM conversation with @${username} — spawning ${dmId}`);
+      log29("info", `\uD83D\uDCE9 New DM conversation with @${username} — spawning ${dmId}`);
       const dmClient = register(parentConfig, post2.channelId, [username]);
       connecting.add(dmId);
       dmClient.connect().then(() => {
@@ -68270,7 +68530,7 @@ function createDmDiscoveryRuntime(deps) {
       }).catch((err) => {
         if (platforms.get(dmId) !== dmClient)
           return;
-        log28("error", `Failed to connect DM instance ${dmId}, discarding: ${err}`);
+        log29("error", `Failed to connect DM instance ${dmId}, discarding: ${err}`);
         (async () => {
           const threadId = `dcm:${dmId}`;
           const inFlightDeadline = Date.now() + 30000;
@@ -68279,7 +68539,7 @@ function createDmDiscoveryRuntime(deps) {
             if (!inFlight)
               break;
             if (Date.now() > inFlightDeadline) {
-              log28("warn", `In-flight session start for ${dmId} did not settle within 30s — proceeding with teardown`);
+              log29("warn", `In-flight session start for ${dmId} did not settle within 30s — proceeding with teardown`);
               break;
             }
             await Promise.race([
@@ -68294,7 +68554,7 @@ function createDmDiscoveryRuntime(deps) {
               try {
                 await session.cancelSession(threadId, dmClient.getBotName());
               } catch (cancelErr) {
-                log28("warn", `Failed to cancel stranded DM session ${threadId} (will be reaped by idle cleanup): ${cancelErr}`);
+                log29("warn", `Failed to cancel stranded DM session ${threadId} (will be reaped by idle cleanup): ${cancelErr}`);
               }
             }
           }
@@ -68304,7 +68564,7 @@ function createDmDiscoveryRuntime(deps) {
               return;
             if (!session.registry.findByThreadId(threadId))
               return;
-            log28("warn", `Sweeping session stranded on removed DM platform ${dmId}`);
+            log29("warn", `Sweeping session stranded on removed DM platform ${dmId}`);
             session.cancelSession(threadId, dmClient.getBotName()).catch(() => {});
           }, 2000);
         })();
@@ -68335,21 +68595,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) {
-        log28("warn", `Skipping persisted DM session for ${pid} (parent missing, renamed, or directMessages off)`);
+        log29("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)) {
-        log28("warn", `Skipping persisted DM session for ${pid} (channel already owned by ${instanceByChannel.get(channelId)})`);
+        log29("warn", `Skipping persisted DM session for ${pid} (channel already owned by ${instanceByChannel.get(channelId)})`);
         continue;
       }
       if (!isEnabled(pid)) {
-        log28("info", `Skipping disabled DM instance ${pid}`);
+        log29("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);
-      log28("info", `♻️ Reconstructing DM instance ${pid}`);
+      log29("info", `♻️ Reconstructing DM instance ${pid}`);
       register(parentCfg, channelId, partners);
       connecting.add(pid);
       reconstructed.set(pid, channelId);
@@ -68391,7 +68651,7 @@ 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 join11, dirname as dirname8 } from "path";
+import { join as join12, dirname as dirname8 } from "path";
 import { spawn as spawn3 } from "child_process";
 import { fileURLToPath as fileURLToPath6 } from "url";
 
@@ -68455,7 +68715,7 @@ function overheadVisibilityChoiceIndex(mode) {
   return OVERHEAD_VISIBILITY_CHOICES.findIndex((c) => c.value === mode);
 }
 var __dirname6 = dirname8(fileURLToPath6(import.meta.url));
-var SLACK_MANIFEST_PATH = join11(__dirname6, "..", "docs", "slack-app-manifest.yaml");
+var SLACK_MANIFEST_PATH = join12(__dirname6, "..", "docs", "slack-app-manifest.yaml");
 var onCancel = () => {
   console.log("");
   console.log(dim("  Setup cancelled."));
@@ -69781,7 +70041,7 @@ async function setupSlackPlatform(id, existing) {
 // src/platform/base-client.ts
 init_logger();
 import { EventEmitter as EventEmitter3 } from "events";
-var log28 = createLogger("base-client");
+var log29 = createLogger("base-client");
 
 class BasePlatformClient extends EventEmitter3 {
   allowedUsers = [];
@@ -69814,7 +70074,7 @@ class BasePlatformClient extends EventEmitter3 {
       try {
         await this.addReaction(post2.id, emoji);
       } catch (err) {
-        log28.warn(`Failed to add reaction ${emoji}: ${err}`);
+        log29.warn(`Failed to add reaction ${emoji}: ${err}`);
       }
     }
     return post2;
@@ -69841,7 +70101,7 @@ class BasePlatformClient extends EventEmitter3 {
     this.heartbeatInterval = setInterval(() => {
       const silentFor = Date.now() - this.lastMessageAt;
       if (silentFor > this.HEARTBEAT_TIMEOUT_MS) {
-        log28.warn(`Connection dead (no activity for ${Math.round(silentFor / 1000)}s), reconnecting...`);
+        log29.warn(`Connection dead (no activity for ${Math.round(silentFor / 1000)}s), reconnecting...`);
         this.stopHeartbeat();
         this.scheduleReconnect();
         return;
@@ -69861,7 +70121,7 @@ class BasePlatformClient extends EventEmitter3 {
       this.reconnectTimeout = null;
     }
     if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      log28.error("Max reconnection attempts reached");
+      log29.error("Max reconnection attempts reached");
       return;
     }
     this.forceCloseConnection();
@@ -69888,7 +70148,7 @@ class BasePlatformClient extends EventEmitter3 {
     this.emit("connected");
     if (this.isReconnecting) {
       this.recoverMissedMessages().catch((err) => {
-        log28.warn(`Failed to recover missed messages: ${err}`);
+        log29.warn(`Failed to recover missed messages: ${err}`);
       });
     }
     this.isReconnecting = false;
@@ -69922,7 +70182,7 @@ init_logger();
 // src/platform/mattermost/upload.ts
 init_logger();
 import { readFile as readFile3 } from "fs/promises";
-var log29 = createLogger("mm-upload");
+var log30 = createLogger("mm-upload");
 async function uploadFileMattermost(args) {
   const { url, token, channelId, threadId, filePath, filename, caption } = args;
   const buffer = await readFile3(filePath);
@@ -69930,7 +70190,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);
-  log29.debug(`POST /files (${buffer.length} bytes, ${filename})`);
+  log30.debug(`POST /files (${buffer.length} bytes, ${filename})`);
   const uploadResponse = await fetch(uploadUrl, {
     method: "POST",
     headers: {
@@ -69954,7 +70214,7 @@ async function uploadFileMattermost(args) {
     root_id: resolvePostThreadId(threadId),
     file_ids: [fileInfo.id]
   };
-  log29.debug(`POST /posts (file_ids=[${fileInfo.id}])`);
+  log30.debug(`POST /posts (file_ids=[${fileInfo.id}])`);
   const postResponse = await fetch(postUrl, {
     method: "POST",
     headers: {
@@ -70041,7 +70301,7 @@ ${code}
 }
 
 // src/platform/mattermost/client.ts
-var log30 = createLogger("mattermost");
+var log31 = createLogger("mattermost");
 
 class MattermostClient extends BasePlatformClient {
   platformId;
@@ -70049,6 +70309,7 @@ class MattermostClient extends BasePlatformClient {
   displayName;
   directChannelMode;
   approvals;
+  ackReaction;
   ws = null;
   url;
   token;
@@ -70072,6 +70333,7 @@ class MattermostClient extends BasePlatformClient {
     this.outboundFiles = platformConfig.outboundFiles;
     this.directChannelMode = resolveDirectChannelMode(platformConfig.directChannelMode);
     this.approvals = platformConfig.approvals;
+    this.ackReaction = normalizeAckReaction(platformConfig.ackReaction, `platforms[${platformConfig.id}].ackReaction`);
   }
   normalizePlatformUser(mattermostUser) {
     const displayName = mattermostUser.first_name || mattermostUser.nickname || mattermostUser.username;
@@ -70129,7 +70391,7 @@ class MattermostClient extends BasePlatformClient {
     const hasFileIds = fileIds && fileIds.length > 0;
     const hasFileMetadata = post2.metadata?.files && post2.metadata.files.length > 0;
     if (hasFileIds && !hasFileMetadata) {
-      log30.debug(`Post ${formatShortId(post2.id)} has ${fileIds.length} file(s), fetching metadata`);
+      log31.debug(`Post ${formatShortId(post2.id)} has ${fileIds.length} file(s), fetching metadata`);
       try {
         const files = [];
         for (const fileId of fileIds) {
@@ -70137,7 +70399,7 @@ class MattermostClient extends BasePlatformClient {
             const file = await this.api("GET", `/files/${fileId}/info`);
             files.push(file);
           } catch (err) {
-            log30.warn(`Failed to fetch file info for ${fileId}: ${err}`);
+            log31.warn(`Failed to fetch file info for ${fileId}: ${err}`);
           }
         }
         if (files.length > 0) {
@@ -70145,10 +70407,10 @@ class MattermostClient extends BasePlatformClient {
             ...post2.metadata,
             files
           };
-          log30.debug(`Enriched post ${formatShortId(post2.id)} with ${files.length} file(s)`);
+          log31.debug(`Enriched post ${formatShortId(post2.id)} with ${files.length} file(s)`);
         }
       } catch (err) {
-        log30.warn(`Failed to fetch file metadata for post ${formatShortId(post2.id)}: ${err}`);
+        log31.warn(`Failed to fetch file metadata for post ${formatShortId(post2.id)}: ${err}`);
       }
     }
   }
@@ -70158,7 +70420,7 @@ class MattermostClient extends BasePlatformClient {
       const user = await this.getUser(post2.user_id);
       this.emit("direct_message", this.normalizePlatformPost(post2), user);
     } catch (err) {
-      log30.warn(`Failed to emit direct message: ${err}`);
+      log31.warn(`Failed to emit direct message: ${err}`);
     }
   }
   MAX_RETRIES = 6;
@@ -70166,7 +70428,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}`;
-    log30.debug(`API ${method} ${path10}`);
+    log31.debug(`API ${method} ${path10}`);
     const response = await fetch(url, {
       method,
       headers: {
@@ -70179,19 +70441,19 @@ class MattermostClient extends BasePlatformClient {
       const text = await response.text();
       if (response.status === 500 && retryCount < this.MAX_RETRIES) {
         const delay2 = this.retryDelayMs(retryCount);
-        log30.warn(`API ${method} ${path10} failed with 500, retrying in ${delay2}ms (attempt ${retryCount + 1}/${this.MAX_RETRIES})`);
+        log31.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) {
-        log30.debug(`API ${method} ${path10} failed: ${response.status} (expected)`);
+        log31.debug(`API ${method} ${path10} failed: ${response.status} (expected)`);
       } else {
-        log30.warn(`API ${method} ${path10} failed: ${response.status} ${text.substring(0, 100)}`);
+        log31.warn(`API ${method} ${path10} failed: ${response.status} ${text.substring(0, 100)}`);
       }
       throw new Error(`Mattermost API error ${response.status}: ${text}`);
     }
-    log30.debug(`API ${method} ${path10} → ${response.status}`);
+    log31.debug(`API ${method} ${path10} → ${response.status}`);
     return response.json();
   }
   retryDelayMs(retryCount) {
@@ -70207,28 +70469,28 @@ class MattermostClient extends BasePlatformClient {
   async getUser(userId) {
     const cached = this.userCache.get(userId);
     if (cached) {
-      log30.debug(`User ${userId} found in cache: @${cached.username}`);
+      log31.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);
-      log30.debug(`User ${userId} fetched: @${user.username}`);
+      log31.debug(`User ${userId} fetched: @${user.username}`);
       return this.normalizePlatformUser(user);
     } catch (err) {
-      log30.warn(`Failed to get user ${userId}: ${err}`);
+      log31.warn(`Failed to get user ${userId}: ${err}`);
       return null;
     }
   }
   async getUserByUsername(username) {
     try {
-      log30.debug(`Looking up user by username: @${username}`);
+      log31.debug(`Looking up user by username: @${username}`);
       const user = await this.api("GET", `/users/username/${username}`);
       this.userCache.set(user.id, user);
-      log30.debug(`User @${username} found: ${user.id}`);
+      log31.debug(`User @${username} found: ${user.id}`);
       return this.normalizePlatformUser(user);
     } catch (err) {
-      log30.warn(`User @${username} not found: ${err}`);
+      log31.warn(`User @${username} not found: ${err}`);
       return null;
     }
   }
@@ -70250,7 +70512,7 @@ class MattermostClient extends BasePlatformClient {
     return this.normalizePlatformPost(post2);
   }
   async addReaction(postId, emojiName) {
-    log30.debug(`Adding reaction :${emojiName}: to post ${postId.substring(0, 8)}`);
+    log31.debug(`Adding reaction :${emojiName}: to post ${postId.substring(0, 8)}`);
     await this.api("POST", "/reactions", {
       user_id: this.botUserId,
       post_id: postId,
@@ -70258,11 +70520,11 @@ class MattermostClient extends BasePlatformClient {
     });
   }
   async removeReaction(postId, emojiName) {
-    log30.debug(`Removing reaction :${emojiName}: from post ${postId.substring(0, 8)}`);
+    log31.debug(`Removing reaction :${emojiName}: from post ${postId.substring(0, 8)}`);
     await this.api("DELETE", `/users/${this.botUserId}/posts/${postId}/reactions/${emojiName}`);
   }
   async downloadFile(fileId) {
-    log30.debug(`Downloading file ${fileId}`);
+    log31.debug(`Downloading file ${fileId}`);
     const url = `${this.url}/api/v4/files/${fileId}`;
     const response = await fetch(url, {
       headers: {
@@ -70270,11 +70532,11 @@ class MattermostClient extends BasePlatformClient {
       }
     });
     if (!response.ok) {
-      log30.warn(`Failed to download file ${fileId}: ${response.status}`);
+      log31.warn(`Failed to download file ${fileId}: ${response.status}`);
       throw new Error(`Failed to download file ${fileId}: ${response.status}`);
     }
     const arrayBuffer = await response.arrayBuffer();
-    log30.debug(`Downloaded file ${fileId}: ${arrayBuffer.byteLength} bytes`);
+    log31.debug(`Downloaded file ${fileId}: ${arrayBuffer.byteLength} bytes`);
     return Buffer.from(arrayBuffer);
   }
   async getFileInfo(fileId) {
@@ -70296,24 +70558,24 @@ class MattermostClient extends BasePlatformClient {
   }
   async getPost(postId) {
     try {
-      log30.debug(`Fetching post ${postId.substring(0, 8)}`);
+      log31.debug(`Fetching post ${postId.substring(0, 8)}`);
       const post2 = await this.api("GET", `/posts/${postId}`);
       return this.normalizePlatformPost(post2);
     } catch (err) {
-      log30.debug(`Post ${postId.substring(0, 8)} not found: ${err}`);
+      log31.debug(`Post ${postId.substring(0, 8)} not found: ${err}`);
       return null;
     }
   }
   async deletePost(postId) {
-    log30.debug(`Deleting post ${postId.substring(0, 8)}`);
+    log31.debug(`Deleting post ${postId.substring(0, 8)}`);
     await this.api("DELETE", `/posts/${postId}`);
   }
   async pinPost(postId) {
-    log30.debug(`Pinning post ${postId.substring(0, 8)}`);
+    log31.debug(`Pinning post ${postId.substring(0, 8)}`);
     await this.api("POST", `/posts/${postId}/pin`);
   }
   async unpinPost(postId) {
-    log30.debug(`Unpinning post ${postId.substring(0, 8)}`);
+    log31.debug(`Unpinning post ${postId.substring(0, 8)}`);
     try {
       await this.api("POST", `/posts/${postId}/unpin`, undefined, 0, { silent: [403, 404] });
     } catch (err) {
@@ -70357,7 +70619,7 @@ class MattermostClient extends BasePlatformClient {
       }
       return messages;
     } catch (err) {
-      log30.warn(`Failed to get thread history for ${threadId}: ${err}`);
+      log31.warn(`Failed to get thread history for ${threadId}: ${err}`);
       return [];
     }
   }
@@ -70376,7 +70638,7 @@ class MattermostClient extends BasePlatformClient {
       posts.sort((a, b) => (a.createAt ?? 0) - (b.createAt ?? 0));
       return posts;
     } catch (err) {
-      log30.warn(`Failed to get channel posts after ${afterPostId}: ${err}`);
+      log31.warn(`Failed to get channel posts after ${afterPostId}: ${err}`);
       return [];
     }
   }
@@ -70512,13 +70774,13 @@ class MattermostClient extends BasePlatformClient {
     if (!this.lastProcessedPostId) {
       return;
     }
-    log30.info(`Recovering missed messages after post ${this.lastProcessedPostId}...`);
+    log31.info(`Recovering missed messages after post ${this.lastProcessedPostId}...`);
     const missedPosts = await this.getChannelPostsAfter(this.lastProcessedPostId);
     if (missedPosts.length === 0) {
-      log30.info("No missed messages to recover");
+      log31.info("No missed messages to recover");
       return;
     }
-    log30.info(`Recovered ${missedPosts.length} missed message(s)`);
+    log31.info(`Recovered ${missedPosts.length} missed message(s)`);
     for (const post2 of missedPosts) {
       this.lastProcessedPostId = post2.id;
       const user = await this.getUser(post2.userId);
@@ -70578,7 +70840,7 @@ init_logger();
 // src/platform/slack/upload.ts
 init_logger();
 import { readFile as readFile4 } from "fs/promises";
-var log31 = createLogger("slack-upload");
+var log32 = createLogger("slack-upload");
 var DEFAULT_API_URL = "https://slack.com/api";
 async function uploadFileSlack(args) {
   const { botToken, channelId, threadTs, filePath, filename, caption } = args;
@@ -70586,7 +70848,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()}`;
-  log31.debug(`GET files.getUploadURLExternal (${buffer.length} bytes, ${filename})`);
+  log32.debug(`GET files.getUploadURLExternal (${buffer.length} bytes, ${filename})`);
   const step1Response = await fetch(step1Url, {
     method: "GET",
     headers: {
@@ -70604,7 +70866,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);
-  log31.debug(`POST <upload_url>`);
+  log32.debug(`POST <upload_url>`);
   const step2Response = await fetch(uploadUrl, {
     method: "POST",
     headers: {
@@ -70624,7 +70886,7 @@ async function uploadFileSlack(args) {
   if (caption !== undefined) {
     step3Body.initial_comment = caption;
   }
-  log31.debug(`POST files.completeUploadExternal (file_id=${fileId}, thread_ts=${threadTs})`);
+  log32.debug(`POST files.completeUploadExternal (file_id=${fileId}, thread_ts=${threadTs})`);
   const step3Response = await fetch(`${apiUrl}/files.completeUploadExternal`, {
     method: "POST",
     headers: {
@@ -70642,7 +70904,7 @@ async function uploadFileSlack(args) {
     throw new Error(`Slack completeUploadExternal error: ${step3Data.error || "unknown"}`);
   }
   if (!step3Data.ts) {
-    log31.warn(`Slack completeUploadExternal returned no ts; using fileId ${fileId} as postId. ` + `Do not use this id for updatePost/addReaction.`);
+    log32.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 };
 }
@@ -70717,7 +70979,7 @@ ${code}
 }
 
 // src/platform/slack/client.ts
-var log32 = createLogger("slack");
+var log33 = createLogger("slack");
 
 class SlackClient extends BasePlatformClient {
   platformId;
@@ -70725,6 +70987,7 @@ class SlackClient extends BasePlatformClient {
   displayName;
   directChannelMode;
   approvals;
+  ackReaction;
   ws = null;
   botToken;
   appToken;
@@ -70757,6 +71020,7 @@ class SlackClient extends BasePlatformClient {
     this.outboundFiles = platformConfig.outboundFiles;
     this.directChannelMode = resolveDirectChannelMode(platformConfig.directChannelMode);
     this.approvals = platformConfig.approvals;
+    this.ackReaction = normalizeAckReaction(platformConfig.ackReaction, `platforms[${platformConfig.id}].ackReaction`);
   }
   normalizePlatformUser(slackUser) {
     const displayName = slackUser.profile?.display_name || slackUser.profile?.real_name || slackUser.real_name || slackUser.name;
@@ -70796,13 +71060,13 @@ class SlackClient extends BasePlatformClient {
       const now = Date.now();
       if (now < this.rateLimitRetryAfter) {
         const waitTime = this.rateLimitRetryAfter - now;
-        log32.debug(`Rate limited, waiting ${waitTime}ms`);
+        log33.debug(`Rate limited, waiting ${waitTime}ms`);
         await new Promise((resolve7) => setTimeout(resolve7, waitTime));
       }
       this.rateLimitDelay = 0;
     }
     const url = `${this.apiUrl}/${endpoint}`;
-    log32.debug(`API ${method} ${endpoint}`);
+    log33.debug(`API ${method} ${endpoint}`);
     const headers = {
       Authorization: `Bearer ${this.botToken}`,
       "Content-Type": "application/json; charset=utf-8"
@@ -70814,25 +71078,25 @@ class SlackClient extends BasePlatformClient {
     });
     if (response.status === 429) {
       if (retryCount >= this.MAX_RATE_LIMIT_RETRIES) {
-        log32.error(`Rate limit max retries (${this.MAX_RATE_LIMIT_RETRIES}) exceeded for ${endpoint}`);
+        log33.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;
-      log32.warn(`Rate limited by Slack, retrying after ${retryAfter}s (attempt ${retryCount + 1}/${this.MAX_RATE_LIMIT_RETRIES})`);
+      log33.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();
-      log32.warn(`API ${method} ${endpoint} failed: ${response.status} ${text.substring(0, 100)}`);
+      log33.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 || "")) {
-        log32.warn(`API ${method} ${endpoint} error: ${data.error}`);
+        log33.warn(`API ${method} ${endpoint} error: ${data.error}`);
       }
       throw new Error(`Slack API error: ${data.error}`);
     }
@@ -70840,7 +71104,7 @@ class SlackClient extends BasePlatformClient {
   }
   async appApi(method, endpoint, body) {
     const url = `${this.apiUrl}/${endpoint}`;
-    log32.debug(`App API ${method} ${endpoint}`);
+    log33.debug(`App API ${method} ${endpoint}`);
     const headers = {
       Authorization: `Bearer ${this.appToken}`,
       "Content-Type": "application/json; charset=utf-8"
@@ -70903,7 +71167,7 @@ class SlackClient extends BasePlatformClient {
             this.onConnectionEstablished();
             if (this.isReconnecting && this.lastProcessedTs) {
               this.recoverMissedMessages().catch((err) => {
-                log32.warn(`Failed to recover missed messages: ${err}`);
+                log33.warn(`Failed to recover missed messages: ${err}`);
               });
             }
             doResolve();
@@ -71000,7 +71264,7 @@ class SlackClient extends BasePlatformClient {
           this.emit("channel_post", post2, user);
         }
       }).catch((err) => {
-        log32.warn(`Failed to get user for message event: ${err}`);
+        log33.warn(`Failed to get user for message event: ${err}`);
         this.emit("message", post2, null);
       });
     }
@@ -71020,7 +71284,7 @@ class SlackClient extends BasePlatformClient {
       this.getUser(event.user || "").then((user) => {
         this.emit("reaction", reaction, user);
       }).catch((err) => {
-        log32.warn(`Failed to get user for reaction event: ${err}`);
+        log33.warn(`Failed to get user for reaction event: ${err}`);
         this.emit("reaction", reaction, null);
       });
     }
@@ -71040,7 +71304,7 @@ class SlackClient extends BasePlatformClient {
       this.getUser(event.user || "").then((user) => {
         this.emit("reaction_removed", reaction, user);
       }).catch((err) => {
-        log32.warn(`Failed to get user for reaction_removed event: ${err}`);
+        log33.warn(`Failed to get user for reaction_removed event: ${err}`);
         this.emit("reaction_removed", reaction, null);
       });
     }
@@ -71077,15 +71341,15 @@ class SlackClient extends BasePlatformClient {
     if (!this.lastProcessedTs) {
       return;
     }
-    log32.info(`Recovering missed messages after ts ${this.lastProcessedTs}...`);
+    log33.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) {
-        log32.info("No missed messages to recover");
+        log33.info("No missed messages to recover");
         return;
       }
-      log32.info(`Recovered ${messages.length} missed message(s)`);
+      log33.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 (message.user === this.botUserId || message.bot_id) {
@@ -71100,7 +71364,7 @@ class SlackClient extends BasePlatformClient {
         }
       }
     } catch (err) {
-      log32.warn(`Failed to recover missed messages: ${err}`);
+      log33.warn(`Failed to recover missed messages: ${err}`);
     }
   }
   async fetchBotUser() {
@@ -71124,17 +71388,17 @@ class SlackClient extends BasePlatformClient {
     }
     const cached = this.userCache.get(userId);
     if (cached) {
-      log32.debug(`User ${userId} found in cache: @${cached.name}`);
+      log33.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);
-      log32.debug(`User ${userId} fetched: @${response.user.name}`);
+      log33.debug(`User ${userId} fetched: @${response.user.name}`);
       return this.normalizePlatformUser(response.user);
     } catch (err) {
-      log32.warn(`Failed to get user ${userId}: ${err}`);
+      log33.warn(`Failed to get user ${userId}: ${err}`);
       return null;
     }
   }
@@ -71144,7 +71408,7 @@ class SlackClient extends BasePlatformClient {
       return this.getUser(cachedId);
     }
     try {
-      log32.debug(`Looking up user by username: @${username}`);
+      log33.debug(`Looking up user by username: @${username}`);
       let cursor;
       do {
         const params = cursor ? `cursor=${cursor}&limit=200` : "limit=200";
@@ -71153,16 +71417,16 @@ class SlackClient extends BasePlatformClient {
           this.userCache.set(user.id, user);
           this.usernameToIdCache.set(user.name, user.id);
           if (user.name === username) {
-            log32.debug(`User @${username} found: ${user.id}`);
+            log33.debug(`User @${username} found: ${user.id}`);
             return this.normalizePlatformUser(user);
           }
         }
         cursor = response.response_metadata?.next_cursor;
       } while (cursor);
-      log32.warn(`User @${username} not found`);
+      log33.warn(`User @${username} not found`);
       return null;
     } catch (err) {
-      log32.warn(`Failed to lookup user @${username}: ${err}`);
+      log33.warn(`Failed to lookup user @${username}: ${err}`);
       return null;
     }
   }
@@ -71250,19 +71514,19 @@ class SlackClient extends BasePlatformClient {
       }
       return null;
     } catch (err) {
-      log32.debug(`Post ${postId.substring(0, 12)} not found: ${err}`);
+      log33.debug(`Post ${postId.substring(0, 12)} not found: ${err}`);
       return null;
     }
   }
   async deletePost(postId) {
-    log32.debug(`Deleting post ${postId.substring(0, 12)}`);
+    log33.debug(`Deleting post ${postId.substring(0, 12)}`);
     await this.api("POST", "chat.delete", {
       channel: this.channelId,
       ts: postId
     });
   }
   async pinPost(postId) {
-    log32.debug(`Pinning post ${postId.substring(0, 12)}`);
+    log33.debug(`Pinning post ${postId.substring(0, 12)}`);
     try {
       await this.api("POST", "pins.add", {
         channel: this.channelId,
@@ -71270,14 +71534,14 @@ class SlackClient extends BasePlatformClient {
       }, 0, ["already_pinned"]);
     } catch (err) {
       if (err instanceof Error && err.message.includes("already_pinned")) {
-        log32.debug(`Post ${postId.substring(0, 12)} already pinned`);
+        log33.debug(`Post ${postId.substring(0, 12)} already pinned`);
         return;
       }
       throw err;
     }
   }
   async unpinPost(postId) {
-    log32.debug(`Unpinning post ${postId.substring(0, 12)}`);
+    log33.debug(`Unpinning post ${postId.substring(0, 12)}`);
     try {
       await this.api("POST", "pins.remove", {
         channel: this.channelId,
@@ -71285,7 +71549,7 @@ class SlackClient extends BasePlatformClient {
       }, 0, ["no_pin"]);
     } catch (err) {
       if (err instanceof Error && err.message.includes("no_pin")) {
-        log32.debug(`Post ${postId.substring(0, 12)} was not pinned`);
+        log33.debug(`Post ${postId.substring(0, 12)} was not pinned`);
         return;
       }
       throw err;
@@ -71303,7 +71567,7 @@ class SlackClient extends BasePlatformClient {
     if (message.length <= maxLength) {
       return message;
     }
-    log32.warn(`Truncating message from ${message.length} to ~${maxLength} chars`);
+    log33.warn(`Truncating message from ${message.length} to ~${maxLength} chars`);
     return truncateMessageSafely(message, maxLength, "_... (truncated)_");
   }
   async getThreadHistory(threadId, options) {
@@ -71330,13 +71594,13 @@ class SlackClient extends BasePlatformClient {
       }
       return messages;
     } catch (err) {
-      log32.warn(`Failed to get thread history for ${threadId}: ${err}`);
+      log33.warn(`Failed to get thread history for ${threadId}: ${err}`);
       return [];
     }
   }
   async addReaction(postId, emojiName) {
     const name = getEmojiName(emojiName);
-    log32.debug(`Adding reaction :${name}: to post ${postId.substring(0, 12)}`);
+    log33.debug(`Adding reaction :${name}: to post ${postId.substring(0, 12)}`);
     await this.api("POST", "reactions.add", {
       channel: this.channelId,
       timestamp: postId,
@@ -71345,7 +71609,7 @@ class SlackClient extends BasePlatformClient {
   }
   async removeReaction(postId, emojiName) {
     const name = getEmojiName(emojiName);
-    log32.debug(`Removing reaction :${name}: from post ${postId.substring(0, 12)}`);
+    log33.debug(`Removing reaction :${name}: from post ${postId.substring(0, 12)}`);
     await this.api("POST", "reactions.remove", {
       channel: this.channelId,
       timestamp: postId,
@@ -71371,7 +71635,7 @@ class SlackClient extends BasePlatformClient {
   }
   sendTyping(_threadId) {}
   async downloadFile(fileId) {
-    log32.debug(`Downloading file ${fileId}`);
+    log33.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) {
@@ -71383,11 +71647,11 @@ class SlackClient extends BasePlatformClient {
       }
     });
     if (!response.ok) {
-      log32.warn(`Failed to download file ${fileId}: ${response.status}`);
+      log33.warn(`Failed to download file ${fileId}: ${response.status}`);
       throw new Error(`Failed to download file ${fileId}: ${response.status}`);
     }
     const arrayBuffer = await response.arrayBuffer();
-    log32.debug(`Downloaded file ${fileId}: ${arrayBuffer.byteLength} bytes`);
+    log33.debug(`Downloaded file ${fileId}: ${arrayBuffer.byteLength} bytes`);
     return Buffer.from(arrayBuffer);
   }
   async getFileInfo(fileId) {
@@ -72188,13 +72452,13 @@ import { EventEmitter as EventEmitter4 } from "events";
 
 // src/persistence/session-store.ts
 init_logger();
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync8, renameSync as renameSync4, chmodSync as chmodSync6 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join12 } from "path";
-var log33 = createLogger("persist");
+import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync8, renameSync as renameSync4, chmodSync as chmodSync7 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join13 } from "path";
+var log34 = createLogger("persist");
 var STORE_VERSION3 = 2;
-var DEFAULT_CONFIG_DIR3 = join12(homedir7(), ".config", "claude-threads");
-var DEFAULT_SESSIONS_FILE = join12(DEFAULT_CONFIG_DIR3, "sessions.json");
+var DEFAULT_CONFIG_DIR3 = join13(homedir8(), ".config", "claude-threads");
+var DEFAULT_SESSIONS_FILE = join13(DEFAULT_CONFIG_DIR3, "sessions.json");
 
 class SessionStore {
   sessionsFile;
@@ -72204,25 +72468,25 @@ class SessionStore {
     const effectivePath = sessionsPath ?? envPath;
     if (effectivePath) {
       this.sessionsFile = effectivePath;
-      this.configDir = join12(effectivePath, "..");
+      this.configDir = join13(effectivePath, "..");
     } else {
       this.sessionsFile = DEFAULT_SESSIONS_FILE;
       this.configDir = DEFAULT_CONFIG_DIR3;
     }
     if (!existsSync13(this.configDir)) {
-      mkdirSync6(this.configDir, { recursive: true });
+      mkdirSync7(this.configDir, { recursive: true });
     }
   }
   load() {
     const sessions = new Map;
     if (!existsSync13(this.sessionsFile)) {
-      log33.debug("No sessions file found");
+      log34.debug("No sessions file found");
       return sessions;
     }
     try {
       const data = this.loadRaw();
       if (data.version === 1) {
-        log33.info("Migrating sessions from v1 to v2 (adding platformId)");
+        log34.info("Migrating sessions from v1 to v2 (adding platformId)");
         const newSessions = {};
         for (const [_oldKey, session] of Object.entries(data.sessions)) {
           const v1Session = session;
@@ -72236,7 +72500,7 @@ class SessionStore {
         data.version = 2;
         this.writeAtomic(data);
       } else if (data.version !== STORE_VERSION3) {
-        log33.warn(`Sessions file version ${data.version} not supported, starting fresh`);
+        log34.warn(`Sessions file version ${data.version} not supported, starting fresh`);
         return sessions;
       }
       for (const session of Object.values(data.sessions)) {
@@ -72245,9 +72509,9 @@ class SessionStore {
         const sessionId = `${session.platformId}:${session.threadId}`;
         sessions.set(sessionId, session);
       }
-      log33.debug(`Loaded ${sessions.size} active session(s)`);
+      log34.debug(`Loaded ${sessions.size} active session(s)`);
     } catch (err) {
-      log33.error(`Failed to load sessions: ${err}`);
+      log34.error(`Failed to load sessions: ${err}`);
     }
     return sessions;
   }
@@ -72256,7 +72520,7 @@ class SessionStore {
     data.sessions[sessionId] = session;
     this.writeAtomic(data);
     const shortId = sessionId.substring(0, 20);
-    log33.debug(`Saved session ${shortId}...`);
+    log34.debug(`Saved session ${shortId}...`);
   }
   remove(sessionId) {
     const data = this.loadRaw();
@@ -72264,7 +72528,7 @@ class SessionStore {
       delete data.sessions[sessionId];
       this.writeAtomic(data);
       const shortId = sessionId.substring(0, 20);
-      log33.debug(`Removed session ${shortId}...`);
+      log34.debug(`Removed session ${shortId}...`);
     }
   }
   softDelete(sessionId) {
@@ -72273,7 +72537,7 @@ class SessionStore {
       data.sessions[sessionId].cleanedAt = new Date().toISOString();
       this.writeAtomic(data);
       const shortId = sessionId.substring(0, 20);
-      log33.debug(`Soft-deleted session ${shortId}...`);
+      log34.debug(`Soft-deleted session ${shortId}...`);
     }
   }
   cleanStale(maxAgeMs) {
@@ -72291,7 +72555,7 @@ class SessionStore {
     }
     if (staleIds.length > 0) {
       this.writeAtomic(data);
-      log33.debug(`Soft-deleted ${staleIds.length} stale session(s)`);
+      log34.debug(`Soft-deleted ${staleIds.length} stale session(s)`);
     }
     return staleIds;
   }
@@ -72310,7 +72574,7 @@ class SessionStore {
     }
     if (removedCount > 0) {
       this.writeAtomic(data);
-      log33.debug(`Permanently removed ${removedCount} old session(s) from history`);
+      log34.debug(`Permanently removed ${removedCount} old session(s) from history`);
     }
     return removedCount;
   }
@@ -72337,7 +72601,7 @@ class SessionStore {
   clear() {
     const data = this.loadRaw();
     this.writeAtomic({ version: STORE_VERSION3, sessions: {}, stickyPostIds: data.stickyPostIds });
-    log33.debug("Cleared all sessions");
+    log34.debug("Cleared all sessions");
   }
   saveStickyPostId(platformId, postId) {
     const data = this.loadRaw();
@@ -72346,7 +72610,7 @@ class SessionStore {
     }
     data.stickyPostIds[platformId] = postId;
     this.writeAtomic(data);
-    log33.debug(`Saved sticky post ID for ${platformId}: ${postId.substring(0, 8)}...`);
+    log34.debug(`Saved sticky post ID for ${platformId}: ${postId.substring(0, 8)}...`);
   }
   getStickyPostIds() {
     const data = this.loadRaw();
@@ -72357,7 +72621,7 @@ class SessionStore {
     if (data.stickyPostIds && data.stickyPostIds[platformId]) {
       delete data.stickyPostIds[platformId];
       this.writeAtomic(data);
-      log33.debug(`Removed sticky post ID for ${platformId}`);
+      log34.debug(`Removed sticky post ID for ${platformId}`);
     }
   }
   getPlatformEnabledState() {
@@ -72375,7 +72639,7 @@ class SessionStore {
     }
     data.platformEnabledState[platformId] = enabled;
     this.writeAtomic(data);
-    log33.debug(`Set platform ${platformId} enabled state to ${enabled}`);
+    log34.debug(`Set platform ${platformId} enabled state to ${enabled}`);
   }
   findByThread(platformId, threadId) {
     const sessionId = `${platformId}:${threadId}`;
@@ -72439,13 +72703,13 @@ class SessionStore {
     const tempFile = `${this.sessionsFile}.tmp`;
     writeFileSync8(tempFile, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
     renameSync4(tempFile, this.sessionsFile);
-    chmodSync6(this.sessionsFile, 384);
+    chmodSync7(this.sessionsFile, 384);
   }
 }
 
 // src/routines/scheduler.ts
 init_logger();
-var log34 = createLogger("routines");
+var log35 = createLogger("routines");
 var DEFAULT_INTERVAL_MS2 = 60 * 1000;
 var FIRE_WINDOW_MS = 5 * 60 * 1000;
 var WEEKDAY_TO_ISO = {
@@ -72533,11 +72797,11 @@ class RoutineScheduler {
     if (this.timer)
       return;
     const safeTick = () => this.tick(new Date).catch((err) => {
-      log34.error(`Routine scheduler tick failed: ${err.message}`);
+      log35.error(`Routine scheduler tick failed: ${err.message}`);
     });
     this.timer = setInterval(safeTick, this.intervalMs);
     safeTick();
-    log34.debug(`Routine scheduler started (interval: ${this.intervalMs / 1000}s)`);
+    log35.debug(`Routine scheduler started (interval: ${this.intervalMs / 1000}s)`);
   }
   stop() {
     if (this.timer) {
@@ -72568,7 +72832,7 @@ class RoutineScheduler {
     try {
       status = await this.opts.fireRoutine(platformId, routine);
     } catch (err) {
-      log34.warn(`Routine "${routine.name}" (${platformId}) failed: ${err.message}`);
+      log35.warn(`Routine "${routine.name}" (${platformId}) failed: ${err.message}`);
       status = "failed";
     }
     try {
@@ -72592,7 +72856,7 @@ class RoutineScheduler {
         }
       }
     } catch (err) {
-      log34.error(`Routine "${routine.name}" (${platformId}) bookkeeping failed: ${err.message}`);
+      log35.error(`Routine "${routine.name}" (${platformId}) bookkeeping failed: ${err.message}`);
     }
     return status;
   }
@@ -72600,20 +72864,20 @@ class RoutineScheduler {
 
 // src/routines/runner.ts
 init_logger();
-var log35 = createLogger("routines");
+var log36 = createLogger("routines");
 async function fireRoutine(routine, platformId, ctx) {
   const platforms = ctx.state.platforms;
   const platform = platforms.get(platformId);
   if (!platform) {
-    log35.debug(`Routine "${routine.name}": platform ${platformId} not registered — skipping`);
+    log36.debug(`Routine "${routine.name}": platform ${platformId} not registered — skipping`);
     return "skipped";
   }
   if (!isAuthorizedForSession({ username: routine.createdBy, platform, sessionAllowedUsers: undefined })) {
-    log35.warn(`Routine "${routine.name}": creator @${routine.createdBy} no longer authorized on ${platformId}`);
+    log36.warn(`Routine "${routine.name}": creator @${routine.createdBy} no longer authorized on ${platformId}`);
     return "unauthorized";
   }
   if (ctx.state.sessions.size >= ctx.config.maxSessions) {
-    log35.debug(`Routine "${routine.name}": at MAX_SESSIONS — skipping this tick`);
+    log36.debug(`Routine "${routine.name}": at MAX_SESSIONS — skipping this tick`);
     return "skipped";
   }
   const formatter = platform.getFormatter();
@@ -72626,7 +72890,7 @@ ${routine.prompt}`,
     skipWorktreePrompt: true
   }, routine.createdBy, undefined, rootPost.id, platformId, ctx);
   if (!ctx.state.sessions.has(ctx.ops.getSessionId(platformId, rootPost.id))) {
-    log35.debug(`Routine "${routine.name}": startSession declined to start a session — skipping this tick`);
+    log36.debug(`Routine "${routine.name}": startSession declined to start a session — skipping this tick`);
     return "skipped";
   }
   return "ok";
@@ -72638,7 +72902,7 @@ init_logger();
 // src/claude/usage-probe.ts
 init_spawn();
 init_logger();
-var log36 = createLogger("usage-probe");
+var log37 = createLogger("usage-probe");
 var DEFAULT_USAGE_PROBE_TIMEOUT_MS = 30000;
 function parseUsageOutput(text) {
   if (!text)
@@ -72691,12 +72955,12 @@ async function probeAccountUsage(account, opts = {}) {
         stdio: ["ignore", "pipe", "pipe"]
       });
     } catch (err) {
-      log36.warn(`Failed to spawn /usage probe for "${account.id}": ${err}`);
+      log37.warn(`Failed to spawn /usage probe for "${account.id}": ${err}`);
       resolve7(null);
       return;
     }
     const timer = setTimeout(() => {
-      log36.warn(`/usage probe for "${account.id}" timed out after ${timeoutMs}ms`);
+      log37.warn(`/usage probe for "${account.id}" timed out after ${timeoutMs}ms`);
       try {
         child.kill("SIGKILL");
       } catch {}
@@ -72708,13 +72972,13 @@ async function probeAccountUsage(account, opts = {}) {
     });
     child.stderr?.on("data", () => {});
     child.on("error", (err) => {
-      log36.warn(`/usage probe for "${account.id}" errored: ${err}`);
+      log37.warn(`/usage probe for "${account.id}" errored: ${err}`);
       finish(null);
     });
     child.on("close", () => {
       const usage = extractUsage(stdout);
       if (!usage) {
-        log36.debug(`/usage probe for "${account.id}" returned no parseable usage`);
+        log37.debug(`/usage probe for "${account.id}" returned no parseable usage`);
       }
       finish(usage);
     });
@@ -72735,7 +72999,7 @@ function extractUsage(stdout) {
 }
 
 // src/claude/account-pool.ts
-var log37 = createLogger("account-pool");
+var log38 = createLogger("account-pool");
 var ACTIVE_SESSION_LOAD_PENALTY = 5;
 function hashThreadId(threadId) {
   let h = 2166136261;
@@ -72758,11 +73022,11 @@ class AccountPool {
     this.accounts = (accounts ?? []).filter((acc) => {
       const hasAuth = !!acc.home || !!acc.apiKey;
       if (!hasAuth) {
-        log37.warn(`Claude account ${acc.id} has neither home nor apiKey — ignoring`);
+        log38.warn(`Claude account ${acc.id} has neither home nor apiKey — ignoring`);
         return false;
       }
       if (acc.home && acc.apiKey) {
-        log37.warn(`Claude account ${acc.id} has both home and apiKey set — must choose one; ignoring`);
+        log38.warn(`Claude account ${acc.id} has both home and apiKey set — must choose one; ignoring`);
         return false;
       }
       return true;
@@ -72792,7 +73056,7 @@ class AccountPool {
         this.incrementActive(preferred.id);
         return preferred;
       }
-      log37.warn(`Preferred account "${preferredId}" not in pool — falling back to usage balancing`);
+      log38.warn(`Preferred account "${preferredId}" not in pool — falling back to usage balancing`);
     }
     const now = Date.now();
     const n = this.accounts.length;
@@ -72806,7 +73070,7 @@ class AccountPool {
     }
     const chosen = this.selectLeastLoaded(now);
     if (!chosen) {
-      log37.warn(`All ${n} accounts are in rate-limit cooldown`);
+      log38.warn(`All ${n} accounts are in rate-limit cooldown`);
       return null;
     }
     this.incrementActive(chosen.id);
@@ -72853,19 +73117,19 @@ class AccountPool {
       return;
     this.usage.set(accountId, usage);
     if (usage) {
-      log37.debug(`Account "${accountId}" usage: ${usageLoadScore(usage)}% (load score)`);
+      log38.debug(`Account "${accountId}" usage: ${usageLoadScore(usage)}% (load score)`);
     }
   }
   markCooling(accountId, untilEpochMs) {
     if (!this.byId.has(accountId)) {
-      log37.warn(`markCooling called for unknown account "${accountId}"`);
+      log38.warn(`markCooling called for unknown account "${accountId}"`);
       return;
     }
     const existing = this.coolingUntil.get(accountId) ?? 0;
     if (untilEpochMs > existing) {
       this.coolingUntil.set(accountId, untilEpochMs);
       const minutes = Math.ceil((untilEpochMs - Date.now()) / 60000);
-      log37.info(`Account "${accountId}" cooling for ~${minutes}min`);
+      log38.info(`Account "${accountId}" cooling for ~${minutes}min`);
     }
   }
   get(accountId) {
@@ -72894,9 +73158,9 @@ class AccountPool {
 init_logger();
 import { existsSync as existsSync14 } from "fs";
 import { readdir, rm as rm3 } from "fs/promises";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 init_worktree();
-var log38 = createLogger("cleanup");
+var log39 = createLogger("cleanup");
 var DEFAULT_CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
 var MAX_WORKTREE_AGE_MS = 24 * 60 * 60 * 1000;
 
@@ -72919,17 +73183,17 @@ class CleanupScheduler {
   }
   start() {
     if (this.isRunning) {
-      log38.debug("Cleanup scheduler already running");
+      log39.debug("Cleanup scheduler already running");
       return;
     }
     this.isRunning = true;
-    log38.info(`Cleanup scheduler started (interval: ${Math.round(this.intervalMs / 60000)}min)`);
+    log39.info(`Cleanup scheduler started (interval: ${Math.round(this.intervalMs / 60000)}min)`);
     this.runCleanup().catch((err) => {
-      log38.warn(`Initial cleanup failed: ${err}`);
+      log39.warn(`Initial cleanup failed: ${err}`);
     });
     this.timer = setInterval(() => {
       this.runCleanup().catch((err) => {
-        log38.warn(`Periodic cleanup failed: ${err}`);
+        log39.warn(`Periodic cleanup failed: ${err}`);
       });
     }, this.intervalMs);
   }
@@ -72939,11 +73203,11 @@ class CleanupScheduler {
       this.timer = null;
     }
     this.isRunning = false;
-    log38.debug("Cleanup scheduler stopped");
+    log39.debug("Cleanup scheduler stopped");
   }
   async runCleanup() {
     const startTime = Date.now();
-    log38.debug("Running background cleanup...");
+    log39.debug("Running background cleanup...");
     const stats = {
       logsDeleted: 0,
       worktreesCleaned: 0,
@@ -72969,9 +73233,9 @@ class CleanupScheduler {
     const elapsed = Date.now() - startTime;
     const totalCleaned = stats.logsDeleted + stats.worktreesCleaned + stats.metadataCleaned;
     if (totalCleaned > 0 || stats.errors.length > 0) {
-      log38.info(`Cleanup completed in ${elapsed}ms: ` + `${stats.logsDeleted} logs, ${stats.worktreesCleaned} worktrees, ${stats.metadataCleaned} metadata` + (stats.errors.length > 0 ? ` (${stats.errors.length} errors)` : ""));
+      log39.info(`Cleanup completed in ${elapsed}ms: ` + `${stats.logsDeleted} logs, ${stats.worktreesCleaned} worktrees, ${stats.metadataCleaned} metadata` + (stats.errors.length > 0 ? ` (${stats.errors.length} errors)` : ""));
     } else {
-      log38.debug(`Cleanup completed in ${elapsed}ms (nothing to clean)`);
+      log39.debug(`Cleanup completed in ${elapsed}ms (nothing to clean)`);
     }
     return stats;
   }
@@ -72984,7 +73248,7 @@ class CleanupScheduler {
         const deleted = cleanupOldLogs(this.logRetentionDays);
         resolve7(deleted);
       } catch (err) {
-        log38.warn(`Log cleanup error: ${err}`);
+        log39.warn(`Log cleanup error: ${err}`);
         resolve7(0);
       }
     });
@@ -72993,7 +73257,7 @@ class CleanupScheduler {
     const worktreesDir = getWorktreesDir();
     const result = { cleaned: 0, metadata: 0 };
     if (!existsSync14(worktreesDir)) {
-      log38.debug("No worktrees directory exists, nothing to clean");
+      log39.debug("No worktrees directory exists, nothing to clean");
       return result;
     }
     const persisted = this.sessionStore.load();
@@ -73009,9 +73273,9 @@ class CleanupScheduler {
       for (const entry of entries) {
         if (!entry.isDirectory())
           continue;
-        const worktreePath = join13(worktreesDir, entry.name);
+        const worktreePath = join14(worktreesDir, entry.name);
         if (activeWorktrees.has(worktreePath)) {
-          log38.debug(`Worktree in use by persisted session, skipping: ${entry.name}`);
+          log39.debug(`Worktree in use by persisted session, skipping: ${entry.name}`);
           continue;
         }
         const meta = await readWorktreeMetadata(worktreePath);
@@ -73021,7 +73285,7 @@ class CleanupScheduler {
           const lastActivity = new Date(meta.lastActivityAt).getTime();
           const age = now - lastActivity;
           if (meta.sessionId && age < this.maxWorktreeAgeMs) {
-            log38.debug(`Worktree has active session (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
+            log39.debug(`Worktree has active session (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
             continue;
           }
           const merged = age >= this.maxWorktreeAgeMs ? await isBranchMerged(meta.repoRoot, meta.branch).catch(() => false) : false;
@@ -73032,7 +73296,7 @@ class CleanupScheduler {
             shouldCleanup = true;
             cleanupReason = `inactive for ${Math.round(age / 3600000)}h`;
           } else {
-            log38.debug(`Worktree recent (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
+            log39.debug(`Worktree recent (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
             continue;
           }
         } else {
@@ -73041,7 +73305,7 @@ class CleanupScheduler {
         }
         if (!shouldCleanup)
           continue;
-        log38.info(`Cleaning worktree (${cleanupReason}): ${entry.name}`);
+        log39.info(`Cleaning worktree (${cleanupReason}): ${entry.name}`);
         try {
           if (meta?.repoRoot) {
             await removeWorktree(meta.repoRoot, worktreePath);
@@ -73052,19 +73316,19 @@ class CleanupScheduler {
           await removeWorktreeMetadata(worktreePath);
           result.metadata++;
         } catch (err) {
-          log38.warn(`Failed to clean orphaned worktree ${entry.name}: ${err}`);
+          log39.warn(`Failed to clean orphaned worktree ${entry.name}: ${err}`);
           try {
             await rm3(worktreePath, { recursive: true, force: true });
             result.cleaned++;
             await removeWorktreeMetadata(worktreePath);
             result.metadata++;
           } catch (rmErr) {
-            log38.error(`Failed to force remove worktree ${entry.name}: ${rmErr}`);
+            log39.error(`Failed to force remove worktree ${entry.name}: ${rmErr}`);
           }
         }
       }
     } catch (err) {
-      log38.warn(`Failed to scan worktrees directory: ${err}`);
+      log39.warn(`Failed to scan worktrees directory: ${err}`);
     }
     return result;
   }
@@ -73072,8 +73336,8 @@ class CleanupScheduler {
 // src/operations/plugin/handler.ts
 init_spawn();
 init_logger();
-var log39 = createLogger("plugin");
-var sessionLog7 = createSessionLog(log39);
+var log40 = createLogger("plugin");
+var sessionLog7 = createSessionLog(log40);
 async function buildPluginRestartCliOptions(session, ctx) {
   const account = session.claudeAccountId ? ctx.ops.getClaudeAccount(session.claudeAccountId) : undefined;
   const memoryConfig = ctx.ops.getPlatformMemoryConfig(session.platformId);
@@ -73115,7 +73379,7 @@ async function runPluginCommand(args, cwd, timeout2 = 60000) {
     });
     proc.on("error", (err) => {
       resolve7({ stdout, stderr, exitCode: 1 });
-      log39.error(`Plugin command error: ${err.message}`);
+      log40.error(`Plugin command error: ${err.message}`);
     });
   });
 }
@@ -73137,6 +73401,14 @@ async function handlePluginInstall(session, pluginName, username, ctx) {
   const formatter = session.platform.getFormatter();
   await post(session, "info", `\uD83D\uDCE6 Installing plugin: ${formatter.formatCode(pluginName)}...`);
   sessionLog7(session).info(`Installing plugin: ${pluginName} (requested by @${username})`);
+  auditLog(session.platformId, {
+    threadId: session.threadId,
+    sessionId: session.sessionId,
+    actor: username,
+    kind: "command",
+    tool: "plugin install",
+    detail: pluginName
+  });
   session.threadLogger?.logCommand("plugin install", pluginName, username);
   const result = await runPluginCommand(["install", pluginName], session.workingDir);
   if (result.exitCode !== 0) {
@@ -73160,6 +73432,14 @@ async function handlePluginUninstall(session, pluginName, username, ctx) {
   const formatter = session.platform.getFormatter();
   await post(session, "info", `\uD83D\uDDD1️ Uninstalling plugin: ${formatter.formatCode(pluginName)}...`);
   sessionLog7(session).info(`Uninstalling plugin: ${pluginName} (requested by @${username})`);
+  auditLog(session.platformId, {
+    threadId: session.threadId,
+    sessionId: session.sessionId,
+    actor: username,
+    kind: "command",
+    tool: "plugin uninstall",
+    detail: pluginName
+  });
   session.threadLogger?.logCommand("plugin uninstall", pluginName, username);
   const result = await runPluginCommand(["uninstall", pluginName], session.workingDir);
   if (result.exitCode !== 0) {
@@ -73289,7 +73569,7 @@ class SessionRegistry {
 // src/session/reaction-router.ts
 init_emoji();
 init_logger();
-var log40 = createLogger("manager");
+var log41 = createLogger("manager");
 async function handleReaction(deps, platformId, postId, emojiName, username, action) {
   const normalizedEmoji = normalizeEmojiName(emojiName);
   if (action === "added" && isResumeEmoji(normalizedEmoji)) {
@@ -73304,7 +73584,7 @@ async function handleReaction(deps, platformId, postId, emojiName, username, act
     return;
   const ownerScoped = resolveApprovals(session.platform.approvals, isDcmThreadId(session.threadId)) === "owner";
   if (!session.sessionAllowedUsers.has(username) && (ownerScoped || !session.platform.isUserAllowed(username))) {
-    log40.info(`\uD83D\uDEAB rejected reaction from unauthorized user`, {
+    log41.info(`\uD83D\uDEAB rejected reaction from unauthorized user`, {
       event: "reaction.rejected",
       platformId,
       sessionId: session.sessionId,
@@ -73342,8 +73622,8 @@ async function tryResumeFromReaction(deps, platformId, postId, username) {
     return false;
   }
   const shortId = persistedSession.threadId.substring(0, 8);
-  log40.info(`\uD83D\uDD04 Resuming session ${shortId}... via emoji reaction by @${username}`);
-  await resumeSession(persistedSession, deps.getContext());
+  log41.info(`\uD83D\uDD04 Resuming session ${shortId}... via emoji reaction by @${username}`);
+  await resumeSession(persistedSession, deps.getContext(), username);
   return true;
 }
 async function dispatch(deps, session, postId, emojiName, username, action) {
@@ -73372,7 +73652,7 @@ async function dispatch(deps, session, postId, emojiName, username, action) {
     }
     if (session.lastError?.postId === postId && isBugReportEmoji(emojiName)) {
       if (session.startedBy === username || session.platform.isUserAllowed(username) || session.sessionAllowedUsers.has(username)) {
-        log40.info(`\uD83D\uDC1B @${username} triggered bug report from error reaction`);
+        log41.info(`\uD83D\uDC1B @${username} triggered bug report from error reaction`);
         await reportBug(session, undefined, username, deps.getContext(), session.lastError);
         return;
       }
@@ -73387,7 +73667,7 @@ async function dispatch(deps, session, postId, emojiName, username, action) {
 
 // src/session/manager.ts
 init_logger();
-var log41 = createLogger("manager");
+var log42 = createLogger("manager");
 var USAGE_PROBE_TIMEOUT_MS = 1e4;
 var USAGE_REFRESH_DEADLINE_MS = 5000;
 var USAGE_CACHE_TTL_MS = 15000;
@@ -73497,7 +73777,7 @@ class SessionManager extends EventEmitter4 {
       markNeedsBump(platformId);
       this.updateStickyMessage();
     });
-    log41.info(`\uD83D\uDCE1 Platform "${platformId}" registered`);
+    log42.info(`\uD83D\uDCE1 Platform "${platformId}" registered`);
   }
   removePlatform(platformId) {
     this.platforms.delete(platformId);
@@ -73517,7 +73797,7 @@ class SessionManager extends EventEmitter4 {
     if (users) {
       users.add(sessionId);
     }
-    log41.debug(`Registered session ${sessionId.substring(0, 20)} as worktree user for ${worktreePath}`);
+    log42.debug(`Registered session ${sessionId.substring(0, 20)} as worktree user for ${worktreePath}`);
   }
   unregisterWorktreeUser(worktreePath, sessionId) {
     const users = this.worktreeUsers.get(worktreePath);
@@ -73723,7 +74003,7 @@ class SessionManager extends EventEmitter4 {
     try {
       this.persistSessionUnsafe(session);
     } catch (err) {
-      log41.error(`Failed to persist session ${session.sessionId}: ${err}`);
+      log42.error(`Failed to persist session ${session.sessionId}: ${err}`);
     }
   }
   persistSessionUnsafe(session) {
@@ -73839,11 +74119,11 @@ class SessionManager extends EventEmitter4 {
       }
     }
     if (sessionsToKill.length === 0) {
-      log41.info(`No active sessions to pause for platform ${platformId}`);
+      log42.info(`No active sessions to pause for platform ${platformId}`);
       await this.updateStickyMessage();
       return;
     }
-    log41.info(`⏸️ Pausing ${sessionsToKill.length} session(s) for platform ${platformId}`);
+    log42.info(`⏸️ Pausing ${sessionsToKill.length} session(s) for platform ${platformId}`);
     for (const session of sessionsToKill) {
       try {
         const fmt = session.platform.getFormatter();
@@ -73859,9 +74139,9 @@ class SessionManager extends EventEmitter4 {
         session.claude.kill();
         this.registry.unregister(session.sessionId);
         this.emitSessionRemove(session.sessionId);
-        log41.info(`⏸️ Paused session ${session.threadId.substring(0, 8)}`);
+        log42.info(`⏸️ Paused session ${session.threadId.substring(0, 8)}`);
       } catch (err) {
-        log41.warn(`Failed to pause session ${session.threadId}: ${err}`);
+        log42.warn(`Failed to pause session ${session.threadId}: ${err}`);
       }
     }
     for (const session of sessionsToKill) {
@@ -73882,17 +74162,17 @@ class SessionManager extends EventEmitter4 {
       sessionsToResume.push(state);
     }
     if (sessionsToResume.length === 0) {
-      log41.info(`No paused sessions to resume for platform ${platformId}`);
+      log42.info(`No paused sessions to resume for platform ${platformId}`);
       await this.updateStickyMessage();
       return;
     }
-    log41.info(`▶️ Resuming ${sessionsToResume.length} paused session(s) for platform ${platformId}`);
+    log42.info(`▶️ Resuming ${sessionsToResume.length} paused session(s) for platform ${platformId}`);
     for (const state of sessionsToResume) {
       try {
         await resumeSession(state, this.getContext());
-        log41.info(`▶️ Resumed session ${state.threadId.substring(0, 8)}`);
+        log42.info(`▶️ Resumed session ${state.threadId.substring(0, 8)}`);
       } catch (err) {
-        log41.warn(`Failed to resume session ${state.threadId}: ${err}`);
+        log42.warn(`Failed to resume session ${state.threadId}: ${err}`);
       }
     }
     await this.updateStickyMessage();
@@ -73931,14 +74211,14 @@ class SessionManager extends EventEmitter4 {
     const sessionTimeoutMs = this.limits.sessionTimeoutMinutes * 60 * 1000;
     const staleIds = this.sessionStore.cleanStale(sessionTimeoutMs * 2);
     if (staleIds.length > 0) {
-      log41.info(`\uD83E\uDDF9 Soft-deleted ${staleIds.length} stale session(s) (kept for history)`);
+      log42.info(`\uD83E\uDDF9 Soft-deleted ${staleIds.length} stale session(s) (kept for history)`);
     }
     const removedCount = this.sessionStore.cleanHistory();
     if (removedCount > 0) {
-      log41.info(`\uD83D\uDDD1️ Permanently removed ${removedCount} old session(s) from history`);
+      log42.info(`\uD83D\uDDD1️ Permanently removed ${removedCount} old session(s) from history`);
     }
     const persisted = this.sessionStore.load();
-    log41.info(`\uD83D\uDCC2 Loaded ${persisted.size} session(s) from persistence`);
+    log42.info(`\uD83D\uDCC2 Loaded ${persisted.size} session(s) from persistence`);
     const excludePostIdsByPlatform = new Map;
     for (const session of persisted.values()) {
       const platformId = session.platformId;
@@ -73958,10 +74238,10 @@ class SessionManager extends EventEmitter4 {
       const excludePostIds = excludePostIdsByPlatform.get(platform.platformId);
       platform.getBotUser().then((botUser) => {
         cleanupOldStickyMessages(platform, botUser.id, true, excludePostIds).catch((err) => {
-          log41.warn(`Failed to cleanup old sticky messages for ${platform.platformId}: ${err}`);
+          log42.warn(`Failed to cleanup old sticky messages for ${platform.platformId}: ${err}`);
         });
       }).catch((err) => {
-        log41.warn(`Failed to get bot user for cleanup on ${platform.platformId}: ${err}`);
+        log42.warn(`Failed to get bot user for cleanup on ${platform.platformId}: ${err}`);
       });
     }
     if (persisted.size > 0) {
@@ -73975,10 +74255,10 @@ class SessionManager extends EventEmitter4 {
         }
       }
       if (pausedToSkip.length > 0) {
-        log41.info(`⏸️ ${pausedToSkip.length} session(s) remain paused (waiting for user message)`);
+        log42.info(`⏸️ ${pausedToSkip.length} session(s) remain paused (waiting for user message)`);
       }
       if (activeToResume.length > 0) {
-        log41.info(`\uD83D\uDD04 Attempting to resume ${activeToResume.length} active session(s)...`);
+        log42.info(`\uD83D\uDD04 Attempting to resume ${activeToResume.length} active session(s)...`);
         for (const state of activeToResume) {
           await resumeSession(state, this.getContext());
         }
@@ -74456,7 +74736,7 @@ Mention me to start a session in this worktree.`, threadId);
         const message = messageBuilder(formatter);
         await post(session, "info", message);
       } catch (err) {
-        log41.warn(`Failed to broadcast to session ${session.threadId}: ${err}`);
+        log42.warn(`Failed to broadcast to session ${session.threadId}: ${err}`);
       }
     }
   }
@@ -74475,7 +74755,7 @@ Mention me to start a session in this worktree.`, threadId);
         session.messageManager?.setPendingUpdatePrompt({ postId: post2.id });
         this.registerPost(post2.id, session.threadId);
       } catch (err) {
-        log41.warn(`Failed to post ask message to ${threadId}: ${err}`);
+        log42.warn(`Failed to post ask message to ${threadId}: ${err}`);
       }
     }
   }
@@ -82070,29 +82350,29 @@ function SessionLog({ logs, maxLines = 20 }) {
   return /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
     flexDirection: "column",
     flexShrink: 0,
-    children: displayLogs.map((log42) => /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
+    children: displayLogs.map((log43) => /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
       flexShrink: 0,
       children: [
         /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
-          color: getColorForLevel(log42.level),
+          color: getColorForLevel(log43.level),
           dimColor: true,
           wrap: "truncate",
           children: [
             "[",
-            padComponent(log42.component),
+            padComponent(log43.component),
             "]"
           ]
         }, undefined, true, undefined, this),
         /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
-          color: getColorForLevel(log42.level),
+          color: getColorForLevel(log43.level),
           wrap: "truncate",
           children: [
             " ",
-            log42.message
+            log43.message
           ]
         }, undefined, true, undefined, this)
       ]
-    }, log42.id, true, undefined, this))
+    }, log43.id, true, undefined, this))
   }, undefined, false, undefined, this);
 }
 // src/ui/components/Footer.tsx
@@ -82616,7 +82896,7 @@ function LogPanel({ logs, maxLines = 10, focused = false }) {
   const scrollRef = import_react59.default.useRef(null);
   const { stdout } = use_stdout_default();
   const isDebug = process.env.DEBUG === "1";
-  const displayLogs = logs.filter((log42) => isDebug || log42.level !== "debug");
+  const displayLogs = logs.filter((log43) => isDebug || log43.level !== "debug");
   const visibleLogs = displayLogs.slice(-Math.max(maxLines * 3, 100));
   import_react59.default.useEffect(() => {
     const handleResize = () => scrollRef.current?.remeasure();
@@ -82656,25 +82936,25 @@ function LogPanel({ logs, maxLines = 10, focused = false }) {
     overflow: "hidden",
     children: /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(ScrollView, {
       ref: scrollRef,
-      children: visibleLogs.map((log42) => /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
+      children: visibleLogs.map((log43) => /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
         children: [
           /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
             dimColor: true,
             children: [
               "[",
-              padComponent2(log42.component),
+              padComponent2(log43.component),
               "]"
             ]
           }, undefined, true, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
-            color: getLevelColor(log42.level),
+            color: getLevelColor(log43.level),
             children: [
               " ",
-              log42.message
+              log43.message
             ]
           }, undefined, true, undefined, this)
         ]
-      }, log42.id, true, undefined, this))
+      }, log43.id, true, undefined, this))
     }, undefined, false, undefined, this)
   }, undefined, false, undefined, this);
 }
@@ -83200,10 +83480,10 @@ function useAppState(initialConfig) {
     });
   }, []);
   const getLogsForSession = import_react60.useCallback((sessionId) => {
-    return state.logs.filter((log42) => log42.sessionId === sessionId);
+    return state.logs.filter((log43) => log43.sessionId === sessionId);
   }, [state.logs]);
   const getGlobalLogs = import_react60.useCallback(() => {
-    return state.logs.filter((log42) => !log42.sessionId);
+    return state.logs.filter((log43) => !log43.sessionId);
   }, [state.logs]);
   const togglePlatformEnabled = import_react60.useCallback((platformId) => {
     let newEnabled = false;
@@ -84006,6 +84286,16 @@ async function startUI(options) {
 init_logger();
 
 // src/message-handler.ts
+init_logger();
+var ackLog = createLogger("ack");
+function ackReceipt(client, postId) {
+  const emoji = resolveAckReaction(client.ackReaction);
+  if (!emoji)
+    return;
+  Promise.resolve(client.addReaction(postId, emoji)).catch((err) => {
+    ackLog.debug(`ack reaction '${emoji}' failed on ${postId}: ${err}`);
+  });
+}
 async function handleMessage(client, session, post2, user, options) {
   const { platformId, logger, onKill } = options;
   const dcm = resolveDirectChannelMode(options.directChannelMode);
@@ -84020,6 +84310,12 @@ async function handleMessage(client, session, post2, user, options) {
         await client.createPost(`⛔ Only authorized users can use ${formatter.formatCode("!kill")}`, threadRoot);
         return;
       }
+      auditLog(platformId, {
+        threadId: threadRoot,
+        actor: username,
+        kind: "command",
+        tool: "kill"
+      });
       const activeCount = session.registry.getActiveThreadIds().length;
       try {
         await client.createPost(`\uD83D\uDD34 ${formatter.formatBold("EMERGENCY SHUTDOWN")} initiated by ${formatter.formatUserMention(username)} - killing ${activeCount} active session${activeCount !== 1 ? "s" : ""}`, threadRoot);
@@ -84103,8 +84399,10 @@ async function handleMessage(client, session, post2, user, options) {
         return;
       }
       const files2 = post2.metadata?.files;
-      if (content || files2?.length)
+      if (content || files2?.length) {
+        ackReceipt(client, post2.id);
         await session.sendFollowUp(threadRoot, content, files2, username, user?.displayName);
+      }
       return;
     }
     const hasPausedSession = session.registry.getPersistedByThreadId(threadRoot) !== undefined;
@@ -84121,6 +84419,13 @@ async function handleMessage(client, session, post2, user, options) {
           if (persistedSession2) {
             const allowedUsers = new Set(persistedSession2.sessionAllowedUsers);
             if (allowedUsers.has(username) || client.isUserAllowed(username)) {
+              auditLog(platformId, {
+                threadId: threadRoot,
+                actor: username,
+                kind: "command",
+                tool: "stop",
+                detail: "paused session cancelled"
+              });
               session.cancelPausedSession(threadRoot);
               await client.createPost(`\uD83D\uDED1 ${formatter.formatBold("Session cancelled")} by ${formatter.formatUserMention(username)}`, threadRoot);
             }
@@ -84142,6 +84447,7 @@ async function handleMessage(client, session, post2, user, options) {
       }
       const files2 = post2.metadata?.files;
       if (content || files2?.length) {
+        ackReceipt(client, post2.id);
         await session.resumePausedSession(threadRoot, content, files2, username);
       }
       return;
@@ -84210,6 +84516,7 @@ async function handleMessage(client, session, post2, user, options) {
       await client.createPost(`Mention me with your request`, threadRoot);
       return;
     }
+    ackReceipt(client, post2.id);
     if (worktreeBranch) {
       await session.startSessionWithWorktree({ prompt, files }, worktreeBranch, username, threadRoot, platformId, user?.displayName, post2.id, initialOptions);
       return;
@@ -84233,7 +84540,7 @@ import { EventEmitter as EventEmitter9 } from "events";
 // src/auto-update/checker.ts
 init_logger();
 import { EventEmitter as EventEmitter7 } from "events";
-var log42 = createLogger("checker");
+var log43 = createLogger("checker");
 var PACKAGE_NAME = "claude-threads";
 function compareVersions(a, b) {
   const partsA = a.replace(/^v/, "").split(".").map(Number);
@@ -84256,13 +84563,13 @@ async function fetchLatestVersion() {
       }
     });
     if (!response.ok) {
-      log42.warn(`Failed to fetch latest version: HTTP ${response.status}`);
+      log43.warn(`Failed to fetch latest version: HTTP ${response.status}`);
       return null;
     }
     const data = await response.json();
     return data.version ?? null;
   } catch (err) {
-    log42.warn(`Failed to fetch latest version: ${err}`);
+    log43.warn(`Failed to fetch latest version: ${err}`);
     return null;
   }
 }
@@ -84279,38 +84586,38 @@ class UpdateChecker extends EventEmitter7 {
   }
   start() {
     if (!this.config.enabled) {
-      log42.debug("Auto-update disabled, not starting checker");
+      log43.debug("Auto-update disabled, not starting checker");
       return;
     }
     setTimeout(() => {
       this.check().catch((err) => {
-        log42.warn(`Initial update check failed: ${err}`);
+        log43.warn(`Initial update check failed: ${err}`);
       });
     }, 5000);
     const intervalMs = this.config.checkIntervalMinutes * 60 * 1000;
     this.checkInterval = setInterval(() => {
       this.check().catch((err) => {
-        log42.warn(`Periodic update check failed: ${err}`);
+        log43.warn(`Periodic update check failed: ${err}`);
       });
     }, intervalMs);
-    log42.info(`\uD83D\uDD04 Update checker started (every ${this.config.checkIntervalMinutes} minutes)`);
+    log43.info(`\uD83D\uDD04 Update checker started (every ${this.config.checkIntervalMinutes} minutes)`);
   }
   stop() {
     if (this.checkInterval) {
       clearInterval(this.checkInterval);
       this.checkInterval = null;
     }
-    log42.debug("Update checker stopped");
+    log43.debug("Update checker stopped");
   }
   async check() {
     if (this.isChecking) {
-      log42.debug("Check already in progress, skipping");
+      log43.debug("Check already in progress, skipping");
       return this.lastUpdateInfo;
     }
     this.isChecking = true;
     this.emit("check:start");
     try {
-      log42.debug("Checking for updates...");
+      log43.debug("Checking for updates...");
       const latestVersion2 = await fetchLatestVersion();
       if (!latestVersion2) {
         this.emit("check:complete", false);
@@ -84327,18 +84634,18 @@ class UpdateChecker extends EventEmitter7 {
           detectedAt: new Date
         };
         if (!this.lastUpdateInfo || this.lastUpdateInfo.latestVersion !== latestVersion2) {
-          log42.info(`\uD83C\uDD95 Update available: v${currentVersion} → v${latestVersion2}`);
+          log43.info(`\uD83C\uDD95 Update available: v${currentVersion} → v${latestVersion2}`);
           this.lastUpdateInfo = updateInfo;
           this.emit("update", updateInfo);
         }
         this.emit("check:complete", true);
         return updateInfo;
       }
-      log42.debug(`Up to date (v${currentVersion})`);
+      log43.debug(`Up to date (v${currentVersion})`);
       this.emit("check:complete", false);
       return null;
     } catch (err) {
-      log42.warn(`Update check failed: ${err}`);
+      log43.warn(`Update check failed: ${err}`);
       this.emit("check:error", err);
       return null;
     } finally {
@@ -84409,7 +84716,7 @@ function isInScheduledWindow(window2) {
 }
 
 // src/auto-update/scheduler.ts
-var log43 = createLogger("scheduler");
+var log44 = createLogger("scheduler");
 
 class UpdateScheduler extends EventEmitter8 {
   config;
@@ -84433,7 +84740,7 @@ class UpdateScheduler extends EventEmitter8 {
   scheduleUpdate(updateInfo) {
     this.pendingUpdate = updateInfo;
     if (this.config.autoRestartMode === "immediate") {
-      log43.info("Immediate mode: triggering update now");
+      log44.info("Immediate mode: triggering update now");
       this.emit("ready", updateInfo);
       return;
     }
@@ -84446,19 +84753,19 @@ class UpdateScheduler extends EventEmitter8 {
     this.scheduledRestartAt = null;
     this.askApprovals.clear();
     this.askStartTime = null;
-    log43.debug("Update schedule cancelled");
+    log44.debug("Update schedule cancelled");
   }
   deferUpdate(minutes) {
     const deferUntil = new Date(Date.now() + minutes * 60 * 1000);
     this.scheduledRestartAt = null;
     this.idleStartTime = null;
     this.emit("deferred", deferUntil);
-    log43.info(`Update deferred until ${deferUntil.toLocaleTimeString()}`);
+    log44.info(`Update deferred until ${deferUntil.toLocaleTimeString()}`);
     return deferUntil;
   }
   recordAskResponse(threadId, approved) {
     this.askApprovals.set(threadId, approved);
-    log43.debug(`Thread ${threadId.substring(0, 8)} ${approved ? "approved" : "denied"} update`);
+    log44.debug(`Thread ${threadId.substring(0, 8)} ${approved ? "approved" : "denied"} update`);
     this.checkAskCondition();
   }
   getScheduledRestartAt() {
@@ -84479,7 +84786,7 @@ class UpdateScheduler extends EventEmitter8 {
       return;
     this.checkCondition();
     this.checkTimer = setInterval(() => this.checkCondition(), 1e4);
-    log43.debug(`Started checking for ${this.config.autoRestartMode} condition`);
+    log44.debug(`Started checking for ${this.config.autoRestartMode} condition`);
   }
   stopChecking() {
     if (this.checkTimer) {
@@ -84510,17 +84817,17 @@ class UpdateScheduler extends EventEmitter8 {
     if (activity.activeSessionCount === 0) {
       if (!this.idleStartTime) {
         this.idleStartTime = new Date;
-        log43.debug("No active sessions, starting idle timer");
+        log44.debug("No active sessions, starting idle timer");
       }
       const idleMs = Date.now() - this.idleStartTime.getTime();
       const requiredMs = this.config.idleTimeoutMinutes * 60 * 1000;
       if (idleMs >= requiredMs) {
-        log43.info(`Idle for ${this.config.idleTimeoutMinutes} minutes, triggering update`);
+        log44.info(`Idle for ${this.config.idleTimeoutMinutes} minutes, triggering update`);
         this.triggerCountdown();
       }
     } else {
       if (this.idleStartTime) {
-        log43.debug("Sessions became active, resetting idle timer");
+        log44.debug("Sessions became active, resetting idle timer");
         this.idleStartTime = null;
       }
     }
@@ -84531,7 +84838,7 @@ class UpdateScheduler extends EventEmitter8 {
       const quietMs = Date.now() - activity.lastActivityAt.getTime();
       const requiredMs = this.config.quietTimeoutMinutes * 60 * 1000;
       if (quietMs >= requiredMs && !activity.anySessionBusy) {
-        log43.info(`Sessions quiet for ${this.config.quietTimeoutMinutes} minutes, triggering update`);
+        log44.info(`Sessions quiet for ${this.config.quietTimeoutMinutes} minutes, triggering update`);
         this.triggerCountdown();
       }
     } else if (activity.activeSessionCount === 0) {
@@ -84541,7 +84848,7 @@ class UpdateScheduler extends EventEmitter8 {
       const idleMs = Date.now() - this.idleStartTime.getTime();
       const requiredMs = this.config.quietTimeoutMinutes * 60 * 1000;
       if (idleMs >= requiredMs) {
-        log43.info("No sessions and quiet timeout reached, triggering update");
+        log44.info("No sessions and quiet timeout reached, triggering update");
         this.triggerCountdown();
       }
     }
@@ -84552,13 +84859,13 @@ class UpdateScheduler extends EventEmitter8 {
     }
     const activity = this.getSessionActivity();
     if (activity.activeSessionCount === 0) {
-      log43.info("Within scheduled window and no active sessions, triggering update");
+      log44.info("Within scheduled window and no active sessions, triggering update");
       this.triggerCountdown();
     } else if (activity.lastActivityAt) {
       const quietMs = Date.now() - activity.lastActivityAt.getTime();
       const requiredMs = this.config.idleTimeoutMinutes * 60 * 1000;
       if (quietMs >= requiredMs && !activity.anySessionBusy) {
-        log43.info("Within scheduled window and sessions quiet, triggering update");
+        log44.info("Within scheduled window and sessions quiet, triggering update");
         this.triggerCountdown();
       }
     }
@@ -84566,14 +84873,14 @@ class UpdateScheduler extends EventEmitter8 {
   checkAskCondition() {
     const threadIds = this.getActiveThreadIds();
     if (threadIds.length === 0) {
-      log43.info("No active threads, proceeding with update");
+      log44.info("No active threads, proceeding with update");
       this.triggerCountdown();
       return;
     }
     if (!this.askStartTime && this.pendingUpdate) {
       this.askStartTime = new Date;
       this.postAskMessage(threadIds, this.pendingUpdate.latestVersion).catch((err) => {
-        log43.warn(`Failed to post ask message: ${err}`);
+        log44.warn(`Failed to post ask message: ${err}`);
       });
       return;
     }
@@ -84586,12 +84893,12 @@ class UpdateScheduler extends EventEmitter8 {
         denials++;
     }
     if (approvals > threadIds.length / 2) {
-      log43.info(`Majority approved (${approvals}/${threadIds.length}), triggering update`);
+      log44.info(`Majority approved (${approvals}/${threadIds.length}), triggering update`);
       this.triggerCountdown();
       return;
     }
     if (denials > threadIds.length / 2) {
-      log43.info(`Majority denied (${denials}/${threadIds.length}), deferring update`);
+      log44.info(`Majority denied (${denials}/${threadIds.length}), deferring update`);
       this.deferUpdate(60);
       return;
     }
@@ -84599,7 +84906,7 @@ class UpdateScheduler extends EventEmitter8 {
       const elapsedMs = Date.now() - this.askStartTime.getTime();
       const timeoutMs = this.config.askTimeoutMinutes * 60 * 1000;
       if (elapsedMs >= timeoutMs) {
-        log43.info(`Ask timeout reached (${this.config.askTimeoutMinutes} min), triggering update`);
+        log44.info(`Ask timeout reached (${this.config.askTimeoutMinutes} min), triggering update`);
         this.triggerCountdown();
       }
     }
@@ -84619,7 +84926,7 @@ class UpdateScheduler extends EventEmitter8 {
         this.emit("ready", this.pendingUpdate);
       }
     }, 1000);
-    log43.info("Update countdown started (60 seconds)");
+    log44.info("Update countdown started (60 seconds)");
   }
   stopCountdown() {
     if (this.countdownTimer) {
@@ -84632,27 +84939,27 @@ class UpdateScheduler extends EventEmitter8 {
 // src/auto-update/installer.ts
 init_logger();
 import { spawn as spawn4, spawnSync } from "child_process";
-import { existsSync as existsSync16, readFileSync as readFileSync12, writeFileSync as writeFileSync9, mkdirSync as mkdirSync7 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync12, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8 } from "fs";
 import { dirname as dirname9, resolve as resolve7 } from "path";
-import { homedir as homedir8 } from "os";
-var log44 = createLogger("installer");
+import { homedir as homedir9 } from "os";
+var log45 = createLogger("installer");
 function detectPackageManager() {
   const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
   const originalInstaller = detectOriginalInstaller();
   if (originalInstaller) {
-    log44.debug(`Detected original installer: ${originalInstaller}`);
+    log45.debug(`Detected original installer: ${originalInstaller}`);
     if (originalInstaller === "bun") {
       const bunCheck2 = spawnSync("bun", ["--version"], { stdio: "ignore" });
       if (bunCheck2.status === 0) {
         return { cmd: "bun", isBun: true };
       }
-      log44.warn("Originally installed with bun, but bun not found. Falling back to npm.");
+      log45.warn("Originally installed with bun, but bun not found. Falling back to npm.");
     } else {
       const npmCheck2 = spawnSync(npmCmd, ["--version"], { stdio: "ignore" });
       if (npmCheck2.status === 0) {
         return { cmd: npmCmd, isBun: false };
       }
-      log44.warn("Originally installed with npm, but npm not found. Falling back to bun.");
+      log45.warn("Originally installed with npm, but npm not found. Falling back to bun.");
     }
   }
   const bunCheck = spawnSync("bun", ["--version"], { stdio: "ignore" });
@@ -84674,7 +84981,7 @@ function normalizePath(p) {
 function detectOriginalInstaller() {
   try {
     const scriptPath = normalizePath(process.argv[1] || "");
-    const bunGlobalDir = normalizePath(process.env.BUN_INSTALL || resolve7(homedir8(), ".bun"));
+    const bunGlobalDir = normalizePath(process.env.BUN_INSTALL || resolve7(homedir9(), ".bun"));
     if (scriptPath.startsWith(bunGlobalDir)) {
       return "bun";
     }
@@ -84694,7 +85001,7 @@ function detectOriginalInstaller() {
     return null;
   }
 }
-var STATE_PATH = resolve7(homedir8(), ".config", "claude-threads", UPDATE_STATE_FILENAME);
+var STATE_PATH = resolve7(homedir9(), ".config", "claude-threads", UPDATE_STATE_FILENAME);
 var PACKAGE_NAME2 = "claude-threads";
 function loadUpdateState() {
   try {
@@ -84703,7 +85010,7 @@ function loadUpdateState() {
       return JSON.parse(content);
     }
   } catch (err) {
-    log44.warn(`Failed to load update state: ${err}`);
+    log45.warn(`Failed to load update state: ${err}`);
   }
   return {};
 }
@@ -84711,12 +85018,12 @@ function saveUpdateState(state) {
   try {
     const dir = dirname9(STATE_PATH);
     if (!existsSync16(dir)) {
-      mkdirSync7(dir, { recursive: true });
+      mkdirSync8(dir, { recursive: true });
     }
     writeFileSync9(STATE_PATH, JSON.stringify(state, null, 2), "utf-8");
-    log44.debug("Update state saved");
+    log45.debug("Update state saved");
   } catch (err) {
-    log44.warn(`Failed to save update state: ${err}`);
+    log45.warn(`Failed to save update state: ${err}`);
   }
 }
 function clearUpdateState() {
@@ -84725,7 +85032,7 @@ function clearUpdateState() {
       writeFileSync9(STATE_PATH, "{}", "utf-8");
     }
   } catch (err) {
-    log44.warn(`Failed to clear update state: ${err}`);
+    log45.warn(`Failed to clear update state: ${err}`);
   }
 }
 function checkJustUpdated() {
@@ -84757,11 +85064,11 @@ function clearRuntimeSettings() {
   }
 }
 async function installVersion(version) {
-  log44.info(`\uD83D\uDCE6 Installing ${PACKAGE_NAME2}@${version}...`);
+  log45.info(`\uD83D\uDCE6 Installing ${PACKAGE_NAME2}@${version}...`);
   const pm = detectPackageManager();
   if (!pm) {
     const error = "Neither bun nor npm found in PATH. Cannot install update.";
-    log44.error(`❌ ${error}`);
+    log45.error(`❌ ${error}`);
     return { success: false, error };
   }
   saveUpdateState({
@@ -84773,7 +85080,7 @@ async function installVersion(version) {
   return new Promise((resolve8) => {
     const { cmd, isBun: isBun3 } = pm;
     const args = ["install", "-g", `${PACKAGE_NAME2}@${version}`];
-    log44.debug(`Using ${isBun3 ? "bun" : "npm"} for installation`);
+    log45.debug(`Using ${isBun3 ? "bun" : "npm"} for installation`);
     const child = spawn4(cmd, args, {
       stdio: ["ignore", "pipe", "pipe"],
       env: {
@@ -84791,7 +85098,7 @@ async function installVersion(version) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        log44.info(`✅ Successfully installed ${PACKAGE_NAME2}@${version}`);
+        log45.info(`✅ Successfully installed ${PACKAGE_NAME2}@${version}`);
         saveUpdateState({
           previousVersion: VERSION,
           targetVersion: version,
@@ -84801,20 +85108,20 @@ async function installVersion(version) {
         resolve8({ success: true });
       } else {
         const errorMsg = stderr || stdout || `Exit code: ${code}`;
-        log44.error(`❌ Installation failed: ${errorMsg}`);
+        log45.error(`❌ Installation failed: ${errorMsg}`);
         clearUpdateState();
         resolve8({ success: false, error: errorMsg });
       }
     });
     child.on("error", (err) => {
-      log44.error(`❌ Failed to spawn npm: ${err}`);
+      log45.error(`❌ Failed to spawn npm: ${err}`);
       clearUpdateState();
       resolve8({ success: false, error: err.message });
     });
     setTimeout(() => {
       if (child.exitCode === null) {
         child.kill();
-        log44.error("❌ Installation timed out");
+        log45.error("❌ Installation timed out");
         clearUpdateState();
         resolve8({ success: false, error: "Installation timed out" });
       }
@@ -84859,8 +85166,8 @@ class UpdateInstaller {
 init_logger();
 import { spawn as spawn5 } from "child_process";
 import { existsSync as existsSync17, statSync as statSync4 } from "fs";
-import { delimiter, join as join14 } from "path";
-var log45 = createLogger("respawn");
+import { delimiter, join as join15 } from "path";
+var log46 = createLogger("respawn");
 function decideRespawn(env5 = process.env, isTTY = !!process.stdout.isTTY) {
   if (env5.CLAUDE_THREADS_BIN) {
     return { kind: "exit-for-supervisor", supervisor: "claude-threads-daemon" };
@@ -84885,16 +85192,16 @@ function resolveClaudeThreadsBin(_env = process.env, _existsSync = existsSync17,
   const path10 = _env.PATH || _env.Path || "";
   const dirs = path10.split(delimiter).filter(Boolean);
   const home = _env.HOME || _env.USERPROFILE;
-  const bunRoot = _env.BUN_INSTALL || (home ? join14(home, ".bun") : null);
+  const bunRoot = _env.BUN_INSTALL || (home ? join15(home, ".bun") : null);
   if (bunRoot) {
-    const bunBin = join14(bunRoot, "bin");
+    const bunBin = join15(bunRoot, "bin");
     if (!dirs.includes(bunBin)) {
       dirs.push(bunBin);
     }
   }
   for (const dir of dirs) {
     for (const name of names) {
-      const candidate = join14(dir, name);
+      const candidate = join15(dir, name);
       if (_existsSync(candidate) && _isFileExecutable(candidate)) {
         return candidate;
       }
@@ -84916,7 +85223,7 @@ function isFileExecutable(path10) {
 }
 function spawnReplacement(argv = process.argv.slice(2), binPath = resolveClaudeThreadsBin()) {
   if (!binPath) {
-    log45.error("Could not resolve claude-threads on PATH; self-respawn aborted");
+    log46.error("Could not resolve claude-threads on PATH; self-respawn aborted");
     return false;
   }
   if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
@@ -84937,23 +85244,23 @@ function spawnReplacement(argv = process.argv.slice(2), binPath = resolveClaudeT
       shell: useShell
     });
   } catch (err) {
-    log45.error(`spawn() threw: ${err instanceof Error ? err.message : String(err)}`);
+    log46.error(`spawn() threw: ${err instanceof Error ? err.message : String(err)}`);
     return false;
   }
   child.once("error", (err) => {
-    log45.error(`Replacement process error: ${err.message}`);
+    log46.error(`Replacement process error: ${err.message}`);
   });
   if (child.pid === undefined) {
-    log45.error("Spawn returned no pid (binary likely not executable)");
+    log46.error("Spawn returned no pid (binary likely not executable)");
     return false;
   }
   child.unref();
-  log45.info(`Spawned replacement pid=${child.pid} from ${binPath}`);
+  log46.info(`Spawned replacement pid=${child.pid} from ${binPath}`);
   return true;
 }
 
 // src/auto-update/manager.ts
-var log46 = createLogger("updater");
+var log47 = createLogger("updater");
 
 class AutoUpdateManager extends EventEmitter9 {
   config;
@@ -84976,23 +85283,23 @@ class AutoUpdateManager extends EventEmitter9 {
   }
   start() {
     if (!this.config.enabled) {
-      log46.info("Auto-update is disabled");
+      log47.info("Auto-update is disabled");
       return;
     }
     const updateResult = this.installer.checkJustUpdated();
     if (updateResult) {
-      log46.info(`\uD83C\uDF89 Updated from v${updateResult.previousVersion} to v${updateResult.currentVersion}`);
+      log47.info(`\uD83C\uDF89 Updated from v${updateResult.previousVersion} to v${updateResult.currentVersion}`);
       this.callbacks.broadcastUpdate((fmt) => `\uD83C\uDF89 ${fmt.formatBold("Bot updated")} from v${updateResult.previousVersion} to v${updateResult.currentVersion}`).catch((err) => {
-        log46.warn(`Failed to broadcast update notification: ${err}`);
+        log47.warn(`Failed to broadcast update notification: ${err}`);
       });
     }
     this.checker.start();
-    log46.info(`\uD83D\uDD04 Auto-update manager started (mode: ${this.config.autoRestartMode})`);
+    log47.info(`\uD83D\uDD04 Auto-update manager started (mode: ${this.config.autoRestartMode})`);
   }
   stop() {
     this.checker.stop();
     this.scheduler.stop();
-    log46.debug("Auto-update manager stopped");
+    log47.debug("Auto-update manager stopped");
   }
   getState() {
     return { ...this.state };
@@ -85006,10 +85313,10 @@ class AutoUpdateManager extends EventEmitter9 {
   async forceUpdate() {
     const updateInfo = this.state.updateInfo || await this.checker.check();
     if (!updateInfo) {
-      log46.info("No update available");
+      log47.info("No update available");
       return;
     }
-    log46.info("Forcing immediate update");
+    log47.info("Forcing immediate update");
     await this.performUpdate(updateInfo);
   }
   deferUpdate(minutes = 60) {
@@ -85075,11 +85382,11 @@ class AutoUpdateManager extends EventEmitter9 {
         await this.callbacks.prepareForRestart();
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
-        log46.error(`prepareForRestart failed: ${reason}`);
+        log47.error(`prepareForRestart failed: ${reason}`);
         await this.callbacks.broadcastUpdate((fmt) => `⚠️ ${fmt.formatBold("Restart aborted")}: shutdown sequence failed (${reason}). Sessions may be in an inconsistent state; please run ${fmt.formatCode("claude-threads")} manually.`).catch(() => {});
         process.exit(1);
       }
-      log46.info(`\uD83D\uDD04 Restarting for update to v${updateInfo.latestVersion}`);
+      log47.info(`\uD83D\uDD04 Restarting for update to v${updateInfo.latestVersion}`);
       process.stdout.write("\x1B[2J\x1B[H");
       process.stdout.write("\x1B[?25h");
       if (decision.kind === "self-respawn") {
@@ -85088,14 +85395,14 @@ class AutoUpdateManager extends EventEmitter9 {
           if (ok) {
             process.exit(0);
           }
-          log46.error("Self-respawn launch failed after binary resolution succeeded");
+          log47.error("Self-respawn launch failed after binary resolution succeeded");
           await this.callbacks.broadcastUpdate((fmt) => `⚠️ ${fmt.formatBold("Auto-restart failed")} after install: please run ${fmt.formatCode("claude-threads")} to bring the bot back. Sessions are persisted and will resume.`).catch(() => {});
         } else {
-          log46.error("claude-threads not found on PATH; manual restart required");
+          log47.error("claude-threads not found on PATH; manual restart required");
         }
         process.exit(0);
       }
-      log46.debug(`Restart handled by supervisor: ${decision.supervisor}`);
+      log47.debug(`Restart handled by supervisor: ${decision.supervisor}`);
       process.exit(RESTART_EXIT_CODE);
     } else {
       const errorMsg = result.error ?? "Unknown error";
@@ -85489,6 +85796,7 @@ async function startWithoutDaemon() {
     });
     const client = createPlatformClient(platformConfig);
     platforms.set(platformConfig.id, client);
+    configureAuditLog(platformConfig.id, resolveAuditLogEnabled(platformConfig.auditLog, `platforms[${platformConfig.id}].auditLog`));
     session.addPlatform(platformConfig.id, client, {
       sessionHeader: resolveOverheadVisibility(platformConfig.sessionHeader, `platforms[${platformConfig.id}].sessionHeader`),
       stickyMessage: resolveOverheadVisibility(platformConfig.stickyMessage, `platforms[${platformConfig.id}].stickyMessage`)
@@ -85509,6 +85817,7 @@ async function startWithoutDaemon() {
         platformType: "mattermost",
         enabled: true
       });
+      configureAuditLog(dmConfig.id, resolveAuditLogEnabled(dmConfig.auditLog, `dm[${dmConfig.id}].auditLog`));
       session.addPlatform(dmConfig.id, dmClient, {
         sessionHeader: resolveOverheadVisibility(dmConfig.sessionHeader, `dm[${dmConfig.id}].sessionHeader`),
         stickyMessage: "hidden"
@@ -85553,10 +85862,10 @@ async function startWithoutDaemon() {
       enabled: false
     });
   }
-  const enabledPlatforms = Array.from(platforms.entries()).filter(([id]) => platformEnabledState.get(id) ?? true);
-  const disabledCount = platforms.size - enabledPlatforms.length;
-  ui.addLog({ level: "info", component: "init", message: `Connecting ${enabledPlatforms.length} platform(s)...${disabledCount > 0 ? ` (${disabledCount} disabled)` : ""}` });
-  const connectionResults = await Promise.allSettled(enabledPlatforms.map(async ([id, client]) => {
+  const enabledPlatforms2 = Array.from(platforms.entries()).filter(([id]) => platformEnabledState.get(id) ?? true);
+  const disabledCount = platforms.size - enabledPlatforms2.length;
+  ui.addLog({ level: "info", component: "init", message: `Connecting ${enabledPlatforms2.length} platform(s)...${disabledCount > 0 ? ` (${disabledCount} disabled)` : ""}` });
+  const connectionResults = await Promise.allSettled(enabledPlatforms2.map(async ([id, client]) => {
     ui.addLog({ level: "debug", component: "init", message: `Connecting to ${id}...` });
     try {
       await client.connect();