claude-threads 1.24.3 → 1.25.1

package/dist/mcp/mcp-server.js

@@ -15725,7 +15725,7 @@ var require_websocket = __commonJS((exports, module) => {
   var http = __require("http");
   var net = __require("net");
   var tls = __require("tls");
-  var { randomBytes, createHash } = __require("crypto");
+  var { randomBytes, createHash: createHash2 } = __require("crypto");
   var { Duplex, Readable } = __require("stream");
   var { URL: URL2 } = __require("url");
   var PerMessageDeflate = require_permessage_deflate();
@@ -16268,7 +16268,7 @@ var require_websocket = __commonJS((exports, module) => {
         abortHandshake(websocket, socket, "Invalid Upgrade header");
         return;
       }
-      const digest = createHash("sha1").update(key + GUID).digest("base64");
+      const digest = createHash2("sha1").update(key + GUID).digest("base64");
       if (res.headers["sec-websocket-accept"] !== digest) {
         abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
         return;
@@ -16643,7 +16643,7 @@ var require_websocket_server = __commonJS((exports, module) => {
   var EventEmitter3 = __require("events");
   var http = __require("http");
   var { Duplex } = __require("stream");
-  var { createHash } = __require("crypto");
+  var { createHash: createHash2 } = __require("crypto");
   var extension = require_extension();
   var PerMessageDeflate = require_permessage_deflate();
   var subprotocol = require_subprotocol();
@@ -16858,7 +16858,7 @@ var require_websocket_server = __commonJS((exports, module) => {
       }
       if (this._state > RUNNING)
         return abortHandshake(socket, 503);
-      const digest = createHash("sha1").update(key + GUID).digest("base64");
+      const digest = createHash2("sha1").update(key + GUID).digest("base64");
       const headers = [
         "HTTP/1.1 101 Switching Protocols",
         "Upgrade: websocket",
@@ -55395,7 +55395,48 @@ function formatReleaseNotes(notes, formatter) {
 // src/utils/keep-alive.ts
 import { spawn } from "child_process";
 var log5 = createLogger("keepalive");
-
+function keepAliveSpawnSpec(platform, parentPid) {
+  switch (platform) {
+    case "darwin":
+      return {
+        command: "caffeinate",
+        args: ["-s", "-i", "-w", String(parentPid)],
+        stdio: "ignore"
+      };
+    case "linux":
+      return {
+        command: "systemd-inhibit",
+        args: [
+          "--what=sleep:idle:handle-lid-switch",
+          "--why=Claude Code session active",
+          "--mode=block",
+          "cat"
+        ],
+        stdio: ["pipe", "ignore", "ignore"]
+      };
+    default:
+      return null;
+  }
+}
+function linuxFallbackScript(parentPid) {
+  return `while kill -0 ${parentPid} 2>/dev/null; do xdg-screensaver reset 2>/dev/null || true; sleep 60; done`;
+}
+function windowsScript(parentPid) {
+  return `
+        Add-Type -TypeDefinition @"
+          using System;
+          using System.Runtime.InteropServices;
+          public class PowerState {
+            [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+            public static extern uint SetThreadExecutionState(uint esFlags);
+          }
+"@
+        # ES_CONTINUOUS | ES_SYSTEM_REQUIRED
+        [PowerState]::SetThreadExecutionState(0x80000001) | Out-Null
+        # Keep running until killed or the parent process exits
+        while (Get-Process -Id ${parentPid} -ErrorAction SilentlyContinue) { Start-Sleep -Seconds 60 }
+      `;
+}
 class KeepAliveManager {
   activeSessionCount = 0;
   keepAliveProcess = null;
@@ -55472,8 +55513,11 @@ class KeepAliveManager {
   }
   startMacOSKeepAlive() {
     try {
-      this.keepAliveProcess = spawn("caffeinate", ["-s", "-i"], {
-        stdio: "ignore",
+      const spec = keepAliveSpawnSpec("darwin", process.pid);
+      if (!spec)
+        return;
+      this.keepAliveProcess = spawn(spec.command, spec.args, {
+        stdio: spec.stdio,
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
@@ -55493,14 +55537,11 @@ class KeepAliveManager {
   }
   startLinuxKeepAlive() {
     try {
-      this.keepAliveProcess = spawn("systemd-inhibit", [
-        "--what=sleep:idle:handle-lid-switch",
-        "--why=Claude Code session active",
-        "--mode=block",
-        "sleep",
-        "infinity"
-      ], {
-        stdio: "ignore",
+      const spec = keepAliveSpawnSpec("linux", process.pid);
+      if (!spec)
+        return;
+      this.keepAliveProcess = spawn(spec.command, spec.args, {
+        stdio: spec.stdio,
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
@@ -55522,10 +55563,7 @@ class KeepAliveManager {
   }
   startLinuxKeepAliveFallback() {
     try {
-      this.keepAliveProcess = spawn("bash", [
-        "-c",
-        `while true; do xdg-screensaver reset 2>/dev/null || true; sleep 60; done`
-      ], {
+      this.keepAliveProcess = spawn("bash", ["-c", linuxFallbackScript(process.pid)], {
         stdio: "ignore",
         detached: false
       });
@@ -55543,20 +55581,7 @@ class KeepAliveManager {
   }
   startWindowsKeepAlive() {
     try {
-      const script = `
-        Add-Type -TypeDefinition @"
-          using System;
-          using System.Runtime.InteropServices;
-          public class PowerState {
-            [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
-            public static extern uint SetThreadExecutionState(uint esFlags);
-          }
-"@
-        # ES_CONTINUOUS | ES_SYSTEM_REQUIRED
-        [PowerState]::SetThreadExecutionState(0x80000001) | Out-Null
-        # Keep running until killed
-        while ($true) { Start-Sleep -Seconds 60 }
-      `;
+      const script = windowsScript(process.pid);
       this.keepAliveProcess = spawn("powershell", ["-NoProfile", "-Command", script], {
         stdio: "ignore",
         detached: false,
@@ -56131,6 +56156,9 @@ function buildClaudeChildEnv(parentEnv, account, opts) {
   if (env.ENABLE_PROMPT_CACHING_1H === undefined) {
     env.ENABLE_PROMPT_CACHING_1H = "true";
   }
+  if (opts?.disableAutoMemory) {
+    env.CLAUDE_CODE_DISABLE_AUTO_MEMORY = "1";
+  }
   if (opts?.decisionBridge && env.MCP_TOOL_TIMEOUT === undefined) {
     env.MCP_TOOL_TIMEOUT = "3600000";
   }
@@ -56145,6 +56173,21 @@ function buildClaudeChildEnv(parentEnv, account, opts) {
   }
   return env;
 }
+function buildInlineSettings(statusLineCommand, memory) {
+  const settings = {};
+  if (statusLineCommand) {
+    settings.statusLine = {
+      type: "command",
+      command: statusLineCommand,
+      padding: 0
+    };
+  }
+  if (memory) {
+    settings.autoMemoryEnabled = true;
+    settings.autoMemoryDirectory = memory.autoMemoryDir;
+  }
+  return Object.keys(settings).length > 0 ? settings : null;
+}
 function runtimeForScriptPath(scriptPath) {
   return scriptPath.endsWith(".ts") ? process.execPath : "node";
 }
@@ -56342,18 +56385,16 @@ class ClaudeCli extends EventEmitter2 {
     if (this.options.appendSystemPrompt) {
       args.push("--append-system-prompt", this.options.appendSystemPrompt);
     }
+    let statusLineCommand;
     if (this.options.sessionId) {
       this.statusFilePath = join4(tmpdir2(), `claude-threads-status-${this.options.sessionId}.json`);
       const statusLineWriterPath = this.getStatusLineWriterPath();
       const runtime = runtimeForScriptPath(statusLineWriterPath);
-      const statusLineSettings = {
-        statusLine: {
-          type: "command",
-          command: `${runtime} ${statusLineWriterPath} ${this.options.sessionId}`,
-          padding: 0
-        }
-      };
-      args.push("--settings", JSON.stringify(statusLineSettings));
+      statusLineCommand = `${runtime} ${statusLineWriterPath} ${this.options.sessionId}`;
+    }
+    const settings = buildInlineSettings(statusLineCommand, this.options.memory);
+    if (settings) {
+      args.push("--settings", JSON.stringify(settings));
     }
     this.log.debug(`Starting: ${claudePath} ${args.slice(0, 5).join(" ")}...`);
     const childEnv = this.buildChildEnv();
@@ -56575,7 +56616,8 @@ class ClaudeCli extends EventEmitter2 {
   }
   buildChildEnv() {
     return buildClaudeChildEnv(process.env, this.options.account, {
-      decisionBridge: this.options.decisionBridgePath !== undefined
+      decisionBridge: this.options.decisionBridgePath !== undefined,
+      disableAutoMemory: this.options.memory === null
     });
   }
   getMcpServerPath() {
@@ -56723,6 +56765,25 @@ var COMMAND_REGISTRY = [
     audience: "user",
     claudeNotes: "User decisions, not yours"
   },
+  {
+    command: "remember",
+    description: "Save a note to this channel's shared memory (visible to all future sessions here)",
+    args: "<text>",
+    category: "settings",
+    audience: "user",
+    claudeNotes: "User decisions, not yours"
+  },
+  {
+    command: "memory",
+    description: "Show channel memory; forget removes entries",
+    args: "[forget <n|text> | forget all]",
+    category: "settings",
+    audience: "user",
+    claudeNotes: "User decisions, not yours",
+    subcommands: [
+      { name: "forget", description: "Remove one entry (by number or matching text), or all", args: "<n|text> | all" }
+    ]
+  },
   {
     command: "update",
     description: "Show auto-update status",
@@ -56963,6 +57024,40 @@ var handleGitHubEmail = async (ctx, args) => {
   await ctx.sessionManager.setGitHubEmail(ctx.threadId, ctx.username, args);
   return { handled: true };
 };
+var handleRemember = async (ctx, args) => {
+  if (ctx.commandContext === "first-message") {
+    return { handled: false };
+  }
+  if (!ctx.isAllowed) {
+    return { handled: true };
+  }
+  if (!args?.trim()) {
+    await ctx.client.createPost(`⚠️ Usage: ${ctx.formatter.formatCode("!remember <text>")}`, ctx.threadId);
+    return { handled: true };
+  }
+  await ctx.sessionManager.rememberEntry(ctx.threadId, args, ctx.username);
+  return { handled: true };
+};
+var handleMemory = async (ctx, args) => {
+  if (ctx.commandContext === "first-message") {
+    return { handled: false };
+  }
+  if (!ctx.isAllowed) {
+    return { handled: true };
+  }
+  const trimmed = args?.trim();
+  if (!trimmed) {
+    await ctx.sessionManager.showMemory(ctx.threadId, ctx.username);
+    return { handled: true };
+  }
+  const forgetMatch = trimmed.match(/^forget\s+([\s\S]+)$/i);
+  if (forgetMatch) {
+    await ctx.sessionManager.forgetMemory(ctx.threadId, forgetMatch[1].trim(), ctx.username);
+    return { handled: true };
+  }
+  await ctx.client.createPost(`⚠️ Usage: ${ctx.formatter.formatCode("!memory")} or ${ctx.formatter.formatCode("!memory forget <n|text>")} or ${ctx.formatter.formatCode("!memory forget all")}`, ctx.threadId);
+  return { handled: true };
+};
 var handleCd = async (ctx, args) => {
   if (!args) {
     return { handled: false };
@@ -57152,6 +57247,8 @@ handlers.set("approve", handleApprove);
 handlers.set("invite", handleInvite);
 handlers.set("kick", handleKick);
 handlers.set("github-email", handleGitHubEmail);
+handlers.set("remember", handleRemember);
+handlers.set("memory", handleMemory);
 handlers.set("cd", handleCd);
 handlers.set("permissions", handlePermissions);
 handlers.set("mentions", handleMentions);
@@ -57290,9 +57387,257 @@ var log16 = createLogger("context");
 var sessionLog2 = createSessionLog(log16);
 var contextPromptTimeouts = new Map;
 var contextPromptFiles = new Map;
+// src/memory/store.ts
+import { createHash } from "crypto";
+import {
+  chmodSync,
+  existsSync as existsSync5,
+  mkdirSync,
+  readFileSync as readFileSync4,
+  renameSync,
+  realpathSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { homedir as homedir4 } from "os";
+import { basename as basename3, dirname as dirname7, join as join6, sep as sep2 } from "path";
+var log17 = createLogger("memory");
+var DEFAULT_ROOT = join6(homedir4(), ".config", "claude-threads", "memory");
+var CHANNEL_BLOCK_MAX_LINES = 200;
+var CHANNEL_BLOCK_MAX_BYTES = 25 * 1024;
+var CHANNEL_FILE_MAX_ENTRIES = 400;
+var MAX_ENTRY_LENGTH = 500;
+var FILE_HEADER = "# Channel memory — managed by claude-threads.";
+var ENTRY_RE = /^- \[(\d{4}-\d{2}-\d{2})\] \((@[^\s)]+|distilled)\) (.+)$/;
+function safeIdSegment(id) {
+  return id.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function shortHash(value, length) {
+  return createHash("sha256").update(value).digest("hex").slice(0, length);
+}
+function platformSegment(platformId) {
+  return `${safeIdSegment(platformId) || "platform"}-${shortHash(platformId, 6)}`;
+}
+function normalizeForDedupe(text) {
+  return text.toLowerCase().replace(/\s+/g, " ").replace(/[.!?\s]+$/g, "").trim();
+}
+function collapseEntryText(text) {
+  return text.replace(/\s*[\r\n]+\s*/g, "; ").replace(/\s+/g, " ").trim();
+}
+function sanitizeEntryText(text) {
+  return collapseEntryText(text).slice(0, MAX_ENTRY_LENGTH);
+}
+function formatEntryLine(entry) {
+  const source = entry.source === "user" ? `@${entry.addedBy ?? "unknown"}` : "distilled";
+  return `- [${entry.addedAt}] (${source}) ${entry.text}`;
+}
+function todayStamp() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+class MemoryStore {
+  root;
+  locks = new Map;
+  constructor(rootDir) {
+    this.root = rootDir ?? process.env.CLAUDE_THREADS_MEMORY_DIR ?? DEFAULT_ROOT;
+  }
+  get rootDir() {
+    return this.root;
+  }
+  channelMemoryPath(platformId) {
+    return join6(this.root, platformSegment(platformId), "channel", "MEMORY.md");
+  }
+  repoMemoryDir(platformId, repoKey) {
+    const dir = join6(this.root, platformSegment(platformId), "repos", repoKey);
+    this.ensureDir(dir);
+    return dir;
+  }
+  listChannelEntries(platformId) {
+    return this.loadLines(platformId).map((l) => l.entry).filter((e) => e !== undefined);
+  }
+  addChannelEntries(platformId, entries) {
+    return this.runExclusive(platformId, () => {
+      const lines = this.loadLines(platformId);
+      const result = { added: [], duplicates: [], superseded: [] };
+      for (const candidate of entries) {
+        const text = sanitizeEntryText(candidate.text);
+        if (!text)
+          continue;
+        const normalized = normalizeForDedupe(text);
+        const existing = lines.map((l) => l.entry).filter((e) => e !== undefined);
+        const isDuplicate = existing.some((e) => {
+          const en = normalizeForDedupe(e.text);
+          if (en === normalized)
+            return true;
+          return candidate.source === "distilled" && en.includes(normalized);
+        });
+        if (isDuplicate) {
+          result.duplicates.push(text);
+          continue;
+        }
+        const canSupersede = (e) => e.source === "distilled" || candidate.source === "user" && e.source === "user" && e.addedBy === candidate.addedBy;
+        for (let i = lines.length - 1;i >= 0; i--) {
+          const e = lines[i].entry;
+          if (e && canSupersede(e) && normalized.includes(normalizeForDedupe(e.text))) {
+            result.superseded.push(e);
+            lines.splice(i, 1);
+          }
+        }
+        const entry = {
+          text,
+          addedAt: todayStamp(),
+          source: candidate.source,
+          addedBy: candidate.source === "user" ? candidate.addedBy : undefined
+        };
+        lines.push({ raw: formatEntryLine(entry), entry });
+        result.added.push(entry);
+      }
+      if (result.added.length > 0) {
+        this.enforceFileCap(lines);
+        this.writeLines(platformId, lines);
+        log17.debug(`Channel memory for ${platformId}: +${result.added.length} entries` + (result.duplicates.length ? ` (${result.duplicates.length} duplicates skipped)` : ""));
+      }
+      return result;
+    });
+  }
+  forgetChannelEntry(platformId, selector) {
+    return this.runExclusive(platformId, () => {
+      const lines = this.loadLines(platformId);
+      const entryLines = [];
+      lines.forEach((l, i) => {
+        if (l.entry)
+          entryLines.push({ lineIndex: i, entry: l.entry });
+      });
+      if (entryLines.length === 0) {
+        return { ok: false, reason: "empty", matches: [] };
+      }
+      let target;
+      if (typeof selector === "number") {
+        if (!Number.isInteger(selector) || selector < 1 || selector > entryLines.length) {
+          return { ok: false, reason: "not-found", matches: [] };
+        }
+        target = entryLines[selector - 1];
+      } else {
+        const needle = selector.toLowerCase().trim();
+        const matches = entryLines.filter((el) => el.entry.text.toLowerCase().includes(needle));
+        if (matches.length === 0) {
+          return { ok: false, reason: "not-found", matches: [] };
+        }
+        if (matches.length > 1) {
+          return {
+            ok: false,
+            reason: "ambiguous",
+            matches: matches.map((el) => el.entry)
+          };
+        }
+        target = matches[0];
+      }
+      lines.splice(target.lineIndex, 1);
+      this.writeLines(platformId, lines);
+      log17.debug(`Channel memory for ${platformId}: removed one entry`);
+      return { ok: true, removed: target.entry };
+    });
+  }
+  clearChannel(platformId) {
+    return this.runExclusive(platformId, () => {
+      this.writeLines(platformId, []);
+      log17.debug(`Channel memory for ${platformId}: cleared`);
+    });
+  }
+  buildChannelMemoryBlock(platformId) {
+    let lines;
+    try {
+      lines = this.loadLines(platformId);
+    } catch (err) {
+      log17.warn(`Failed to read channel memory for ${platformId}: ${err.message}`);
+      return null;
+    }
+    if (lines.length === 0)
+      return null;
+    let truncated = false;
+    const overCap = (ls) => {
+      if (ls.length > CHANNEL_BLOCK_MAX_LINES)
+        return true;
+      const bytes = Buffer.byteLength(ls.map((l) => l.raw).join(`
+`), "utf-8");
+      return bytes > CHANNEL_BLOCK_MAX_BYTES;
+    };
+    while (lines.length > 1 && overCap(lines)) {
+      truncated = true;
+      const distilledIdx = lines.findIndex((l) => l.entry?.source === "distilled");
+      lines.splice(distilledIdx >= 0 ? distilledIdx : 0, 1);
+    }
+    const rendered = lines.map((l) => l.raw).join(`
+`);
+    return truncated ? `${rendered}
+_(older entries omitted — \`!memory\` shows all)_` : rendered;
+  }
+  runExclusive(platformId, fn) {
+    const tail = this.locks.get(platformId) ?? Promise.resolve();
+    const next = tail.then(fn, fn);
+    this.locks.set(platformId, next.catch(() => {
+      return;
+    }));
+    return next;
+  }
+  loadLines(platformId) {
+    const file2 = this.channelMemoryPath(platformId);
+    if (!existsSync5(file2))
+      return [];
+    const raw = readFileSync4(file2, "utf-8");
+    const lines = [];
+    for (const line of raw.split(`
+`)) {
+      const trimmed = line.trimEnd();
+      if (!trimmed || trimmed === FILE_HEADER)
+        continue;
+      const m = trimmed.match(ENTRY_RE);
+      if (m) {
+        const source = m[2] === "distilled" ? "distilled" : "user";
+        lines.push({
+          raw: trimmed,
+          entry: {
+            addedAt: m[1],
+            source,
+            addedBy: source === "user" ? m[2].slice(1) : undefined,
+            text: m[3]
+          }
+        });
+      } else {
+        lines.push({ raw: trimmed });
+      }
+    }
+    return lines;
+  }
+  enforceFileCap(lines) {
+    while (lines.length > CHANNEL_FILE_MAX_ENTRIES) {
+      const distilledIdx = lines.findIndex((l) => l.entry?.source === "distilled");
+      lines.splice(distilledIdx >= 0 ? distilledIdx : 0, 1);
+    }
+  }
+  writeLines(platformId, lines) {
+    const file2 = this.channelMemoryPath(platformId);
+    this.ensureDir(dirname7(file2));
+    const content = [FILE_HEADER, ...lines.map((l) => l.raw)].join(`
+`) + `
+`;
+    const tempFile = `${file2}.tmp`;
+    writeFileSync2(tempFile, content, { encoding: "utf-8", mode: 384 });
+    renameSync(tempFile, file2);
+    chmodSync(file2, 384);
+  }
+  ensureDir(dir) {
+    if (!existsSync5(dir)) {
+      mkdirSync(dir, { recursive: true, mode: 448 });
+    }
+  }
+}
+
+// src/memory/distiller.ts
+var log18 = createLogger("memory");
+
 // src/session/lifecycle.ts
-var log17 = createLogger("lifecycle");
-var sessionLog3 = createSessionLog(log17);
+var log19 = createLogger("lifecycle");
+var sessionLog3 = createSessionLog(log19);
 var CHAT_PLATFORM_PROMPT = generateChatPlatformPrompt();
 // src/update-notifier.ts
 var import_semver2 = __toESM(require_semver2(), 1);
@@ -57301,29 +57646,29 @@ var import_semver2 = __toESM(require_semver2(), 1);
 init_emoji();
 
 // src/persistence/github-emails-store.ts
-import { homedir as homedir4 } from "os";
-import { join as join6 } from "path";
-var log18 = createLogger("gh-emails");
-var DEFAULT_CONFIG_DIR = join6(homedir4(), ".config", "claude-threads");
-var DEFAULT_FILE = join6(DEFAULT_CONFIG_DIR, "github-emails.yaml");
+import { homedir as homedir5 } from "os";
+import { join as join7 } from "path";
+var log20 = createLogger("gh-emails");
+var DEFAULT_CONFIG_DIR = join7(homedir5(), ".config", "claude-threads");
+var DEFAULT_FILE = join7(DEFAULT_CONFIG_DIR, "github-emails.yaml");
 
 // src/operations/commands/handler.ts
-var log19 = createLogger("commands");
-var sessionLog4 = createSessionLog(log19);
+var log21 = createLogger("commands");
+var sessionLog4 = createSessionLog(log21);
 // src/operations/suggestions/branch.ts
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync2 = promisify2(exec2);
-var log20 = createLogger("branch");
+var log22 = createLogger("branch");
 
 // src/operations/worktree/handler.ts
-var log21 = createLogger("worktree");
-var sessionLog5 = createSessionLog(log21);
+var log23 = createLogger("worktree");
+var sessionLog5 = createSessionLog(log23);
 // src/operations/events/handler.ts
-var log22 = createLogger("events");
-var sessionLog6 = createSessionLog(log22);
+var log24 = createLogger("events");
+var sessionLog6 = createSessionLog(log24);
 // src/operations/monitor/handler.ts
-var log23 = createLogger("monitor");
+var log25 = createLogger("monitor");
 var DEFAULT_INTERVAL_MS = 60 * 1000;
 // src/utils/websocket.ts
 var WS;
@@ -57405,7 +57750,7 @@ ${code}
 
 // src/platform/mattermost/upload.ts
 import { readFile } from "fs/promises";
-var log24 = createLogger("mm-upload");
+var log26 = createLogger("mm-upload");
 async function uploadFileMattermost(args) {
   const { url: url2, token, channelId, threadId, filePath, filename, caption } = args;
   const buffer = await readFile(filePath);
@@ -57413,7 +57758,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);
-  log24.debug(`POST /files (${buffer.length} bytes, ${filename})`);
+  log26.debug(`POST /files (${buffer.length} bytes, ${filename})`);
   const uploadResponse = await fetch(uploadUrl, {
     method: "POST",
     headers: {
@@ -57437,7 +57782,7 @@ async function uploadFileMattermost(args) {
     root_id: threadId,
     file_ids: [fileInfo.id]
   };
-  log24.debug(`POST /posts (file_ids=[${fileInfo.id}])`);
+  log26.debug(`POST /posts (file_ids=[${fileInfo.id}])`);
   const postResponse = await fetch(postUrl, {
     method: "POST",
     headers: {
@@ -57638,7 +57983,7 @@ class MattermostMcpPlatformApi {
     await updatePostRaw(this.apiConfig, postId, message);
   }
   async waitForReaction(postId, botUserId, timeoutMs) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const wsUrl = this.config.url.replace(/^http/, "ws") + "/api/v4/websocket";
       mcpLogger.debug(`Connecting to WebSocket: ${wsUrl}`);
       const ws = new WS(wsUrl);
@@ -57653,7 +57998,7 @@ class MattermostMcpPlatformApi {
           mcpLogger.debug(`Reaction wait timed out after ${timeoutMs}ms`);
           resolved = true;
           cleanup();
-          resolve5(null);
+          resolve6(null);
         }
       }, timeoutMs);
       ws.onopen = () => {
@@ -57681,7 +58026,7 @@ class MattermostMcpPlatformApi {
             resolved = true;
             clearTimeout(timeout);
             cleanup();
-            resolve5({
+            resolve6({
               postId: reaction.post_id,
               userId: reaction.user_id,
               emojiName: reaction.emoji_name
@@ -57696,7 +58041,7 @@ class MattermostMcpPlatformApi {
         if (!resolved) {
           resolved = true;
           clearTimeout(timeout);
-          resolve5(null);
+          resolve6(null);
         }
       };
       ws.onclose = () => {
@@ -57704,7 +58049,7 @@ class MattermostMcpPlatformApi {
         if (!resolved) {
           resolved = true;
           clearTimeout(timeout);
-          resolve5(null);
+          resolve6(null);
         }
       };
     });
@@ -57931,7 +58276,7 @@ ${code}
 
 // src/platform/slack/upload.ts
 import { readFile as readFile2 } from "fs/promises";
-var log25 = createLogger("slack-upload");
+var log27 = createLogger("slack-upload");
 var DEFAULT_API_URL = "https://slack.com/api";
 async function uploadFileSlack(args) {
   const { botToken, channelId, threadTs, filePath, filename, caption } = args;
@@ -57939,7 +58284,7 @@ async function uploadFileSlack(args) {
   const buffer = await readFile2(filePath);
   const params = new URLSearchParams({ filename, length: String(buffer.length) });
   const step1Url = `${apiUrl}/files.getUploadURLExternal?${params.toString()}`;
-  log25.debug(`GET files.getUploadURLExternal (${buffer.length} bytes, ${filename})`);
+  log27.debug(`GET files.getUploadURLExternal (${buffer.length} bytes, ${filename})`);
   const step1Response = await fetch(step1Url, {
     method: "GET",
     headers: {
@@ -57957,7 +58302,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);
-  log25.debug(`POST <upload_url>`);
+  log27.debug(`POST <upload_url>`);
   const step2Response = await fetch(uploadUrl, {
     method: "POST",
     headers: {
@@ -57977,7 +58322,7 @@ async function uploadFileSlack(args) {
   if (caption !== undefined) {
     step3Body.initial_comment = caption;
   }
-  log25.debug(`POST files.completeUploadExternal (file_id=${fileId}, thread_ts=${threadTs})`);
+  log27.debug(`POST files.completeUploadExternal (file_id=${fileId}, thread_ts=${threadTs})`);
   const step3Response = await fetch(`${apiUrl}/files.completeUploadExternal`, {
     method: "POST",
     headers: {
@@ -57995,7 +58340,7 @@ async function uploadFileSlack(args) {
     throw new Error(`Slack completeUploadExternal error: ${step3Data.error || "unknown"}`);
   }
   if (!step3Data.ts) {
-    log25.warn(`Slack completeUploadExternal returned no ts; using fileId ${fileId} as postId. ` + `Do not use this id for updatePost/addReaction.`);
+    log27.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 };
 }
@@ -58101,7 +58446,7 @@ class SlackMcpPlatformApi {
     });
   }
   async waitForReaction(postId, botUserId, timeoutMs) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       let resolved = false;
       let ws = null;
       const cleanup = () => {
@@ -58114,7 +58459,7 @@ class SlackMcpPlatformApi {
           mcpLogger.debug(`Reaction wait timed out after ${timeoutMs}ms`);
           resolved = true;
           cleanup();
-          resolve5(null);
+          resolve6(null);
         }
       }, timeoutMs);
       this.getSocketModeUrl().then((wsUrl) => {
@@ -58152,7 +58497,7 @@ class SlackMcpPlatformApi {
                 resolved = true;
                 clearTimeout(timeout);
                 cleanup();
-                resolve5({
+                resolve6({
                   postId: item.ts,
                   userId,
                   emojiName
@@ -58168,7 +58513,7 @@ class SlackMcpPlatformApi {
                 resolved = true;
                 clearTimeout(timeout);
                 cleanup();
-                resolve5(null);
+                resolve6(null);
               }
             }
           } catch (err) {
@@ -58181,7 +58526,7 @@ class SlackMcpPlatformApi {
             resolved = true;
             clearTimeout(timeout);
             cleanup();
-            resolve5(null);
+            resolve6(null);
           }
         };
         ws.onclose = () => {
@@ -58189,7 +58534,7 @@ class SlackMcpPlatformApi {
           if (!resolved) {
             resolved = true;
             clearTimeout(timeout);
-            resolve5(null);
+            resolve6(null);
           }
         };
       }).catch((err) => {
@@ -58197,7 +58542,7 @@ class SlackMcpPlatformApi {
         if (!resolved) {
           resolved = true;
           clearTimeout(timeout);
-          resolve5(null);
+          resolve6(null);
         }
       });
     });
@@ -58388,11 +58733,11 @@ function createMcpPlatformApi(platformType, config3) {
 
 // src/mcp/path-validator.ts
 import { lstat, realpath, stat } from "fs/promises";
-import { sep as sep2, isAbsolute } from "path";
+import { sep as sep3, isAbsolute as isAbsolute2 } from "path";
 function isUnderRoot(needle, root) {
   if (needle === root)
     return true;
-  const withSep = root.endsWith(sep2) ? root : root + sep2;
+  const withSep = root.endsWith(sep3) ? root : root + sep3;
   return needle.startsWith(withSep);
 }
 var DANGEROUSLY_WIDE_ROOTS = new Set([
@@ -58417,7 +58762,7 @@ async function validateOutboundPath(inputPath, opts) {
   if (typeof inputPath !== "string" || inputPath.length === 0) {
     return { ok: false, reason: "path is required" };
   }
-  if (!isAbsolute(inputPath)) {
+  if (!isAbsolute2(inputPath)) {
     return { ok: false, reason: "path must be absolute" };
   }
   if (!Number.isFinite(opts.maxBytes) || opts.maxBytes <= 0) {