claude-threads 1.25.1 → 1.27.0

package/dist/mcp/mcp-server.js

@@ -47754,7 +47754,11 @@ function truncateWithEllipsis(str, maxLength) {
   return str.substring(0, maxLength) + "...";
 }
 function escapeCodeBlockContent(content) {
-  return content.replace(/```/g, "` ``");
+  let result = content;
+  while (result.includes("```")) {
+    result = result.replace(/```/g, "` ``");
+  }
+  return result;
 }
 // src/operations/tool-formatters/registry.ts
 class ToolFormatterRegistry {
@@ -48553,6 +48557,15 @@ var fileToolsFormatter = {
   }
 };
 // src/operations/tool-formatters/bash-tools.ts
+var PERMISSION_COMMAND_MAX = 1500;
+function truncateAtCodePoint(text, max) {
+  if (text.length <= max)
+    return { text, truncated: false };
+  const points = Array.from(text);
+  if (points.length <= max)
+    return { text, truncated: false };
+  return { text: points.slice(0, max).join(""), truncated: true };
+}
 var bashToolFormatter = {
   toolNames: ["Bash"],
   format(toolName, input, options) {
@@ -48565,9 +48578,13 @@ var bashToolFormatter = {
     }
     const truncated = cmd.length > maxCommandLength;
     const displayCmd = cmd.substring(0, maxCommandLength);
+    const permission = truncateAtCodePoint(cmd, PERMISSION_COMMAND_MAX);
+    const permissionCmd = escapeCodeBlockContent(permission.text) + (permission.truncated ? `
+[... truncated]` : "");
     return {
       display: `\uD83D\uDCBB ${formatter.formatBold("Bash")} ${formatter.formatCode(displayCmd + (truncated ? "..." : ""))}`,
-      permissionText: `\uD83D\uDCBB ${formatter.formatBold("Bash")} ${formatter.formatCode(cmd.substring(0, 100) + (cmd.length >= 100 ? "..." : ""))}`,
+      permissionText: `\uD83D\uDCBB ${formatter.formatBold("Bash")}
+${formatter.formatCodeBlock(permissionCmd, "bash")}`,
       isDestructive: true
     };
   }
@@ -49632,6 +49649,13 @@ function convertMarkdownTablesToSlack(content) {
 `);
   });
 }
+var DCM_THREAD_PREFIX = "dcm:";
+function isDcmThreadId(threadId) {
+  return !!threadId && threadId.startsWith(DCM_THREAD_PREFIX);
+}
+function resolvePostThreadId(threadId) {
+  return isDcmThreadId(threadId) ? undefined : threadId;
+}
 
 // src/version.ts
 import { readFileSync, existsSync } from "fs";
@@ -51087,7 +51111,8 @@ class PromptExecutor extends BaseExecutor {
     return {
       pendingContextPrompt: null,
       pendingExistingWorktreePrompt: null,
-      pendingUpdatePrompt: null
+      pendingUpdatePrompt: null,
+      pendingRoutinePrompt: null
     };
   }
   getInitialState() {
@@ -51097,14 +51122,16 @@ class PromptExecutor extends BaseExecutor {
     return {
       pendingContextPrompt: this.state.pendingContextPrompt ? { ...this.state.pendingContextPrompt } : null,
       pendingExistingWorktreePrompt: this.state.pendingExistingWorktreePrompt ? { ...this.state.pendingExistingWorktreePrompt } : null,
-      pendingUpdatePrompt: this.state.pendingUpdatePrompt ? { ...this.state.pendingUpdatePrompt } : null
+      pendingUpdatePrompt: this.state.pendingUpdatePrompt ? { ...this.state.pendingUpdatePrompt } : null,
+      pendingRoutinePrompt: this.state.pendingRoutinePrompt ? { ...this.state.pendingRoutinePrompt } : null
     };
   }
   hydrateState(persisted) {
     this.state = {
       pendingContextPrompt: persisted.pendingContextPrompt ?? null,
       pendingExistingWorktreePrompt: persisted.pendingExistingWorktreePrompt ?? null,
-      pendingUpdatePrompt: persisted.pendingUpdatePrompt ?? null
+      pendingUpdatePrompt: persisted.pendingUpdatePrompt ?? null,
+      pendingRoutinePrompt: null
     };
   }
   setPendingContextPrompt(prompt) {
@@ -51234,6 +51261,30 @@ class PromptExecutor extends BaseExecutor {
     }
     return true;
   }
+  setPendingRoutinePrompt(prompt) {
+    this.state.pendingRoutinePrompt = prompt;
+  }
+  hasPendingRoutinePrompt() {
+    return this.state.pendingRoutinePrompt !== null;
+  }
+  async handleRoutinePromptResponse(postId, approved, username, ctx) {
+    if (!this.state.pendingRoutinePrompt)
+      return false;
+    if (this.state.pendingRoutinePrompt.postId !== postId)
+      return false;
+    const { parsed, requestedBy } = this.state.pendingRoutinePrompt;
+    const statusMessage = approved ? `✅ ${ctx.formatter.formatBold(`Routine "${parsed.name}" confirmed`)} by ${ctx.formatter.formatUserMention(username)} — saving...` : `❌ ${ctx.formatter.formatBold(`Routine "${parsed.name}" discarded`)} by ${ctx.formatter.formatUserMention(username)}`;
+    try {
+      await ctx.platform.updatePost(postId, statusMessage);
+    } catch (err) {
+      ctx.logger.debug(`Failed to update routine prompt post: ${err}`);
+    }
+    this.state.pendingRoutinePrompt = null;
+    if (this.events) {
+      this.events.emit("routine-prompt:complete", { approved, parsed, requestedBy, postId });
+    }
+    return true;
+  }
   async handleReaction(postId, emoji4, user, action, ctx) {
     ctx.logger.debug(`PromptExecutor.handleReaction: postId=${postId.substring(0, 8)}, emoji=${emoji4}, user=${user}, action=${action}`);
     if (action !== "added") {
@@ -51294,6 +51345,18 @@ class PromptExecutor extends BaseExecutor {
       ctx.logger.debug(`PromptExecutor: emoji ${emoji4} not valid for update prompt, ignoring`);
       return false;
     }
+    if (this.state.pendingRoutinePrompt?.postId === postId) {
+      if (isApprovalEmoji(emoji4)) {
+        ctx.logger.debug(`Routine prompt reaction from @${user}: approve`);
+        return this.handleRoutinePromptResponse(postId, true, user, ctx);
+      }
+      if (isDenialEmoji(emoji4)) {
+        ctx.logger.debug(`Routine prompt reaction from @${user}: discard`);
+        return this.handleRoutinePromptResponse(postId, false, user, ctx);
+      }
+      ctx.logger.debug(`PromptExecutor: emoji ${emoji4} not valid for routine prompt, ignoring`);
+      return false;
+    }
     ctx.logger.debug(`PromptExecutor: no pending prompt state matches postId=${postId.substring(0, 8)}`);
     return false;
   }
@@ -51910,6 +51973,9 @@ class MessageManager {
   clearPendingUpdatePrompt() {
     this.promptExecutor.clearPendingUpdatePrompt();
   }
+  setPendingRoutinePrompt(prompt) {
+    this.promptExecutor.setPendingRoutinePrompt(prompt);
+  }
   setPendingBugReport(report) {
     this.bugReportExecutor.setPendingBugReport(report);
   }
@@ -52184,6 +52250,9 @@ import { resolve as resolve2, dirname as dirname2 } from "path";
 import { homedir } from "os";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
 var jsYaml = {};
 var loader = {};
 var common = {};
@@ -55287,6 +55356,7 @@ function requireJsYaml() {
   return jsYaml;
 }
 var jsYamlExports = requireJsYaml();
+var yaml = /* @__PURE__ */ getDefaultExportFromCjs(jsYamlExports);
 
 // src/config/index.ts
 var CONFIG_PATH = resolve2(homedir(), ".config", "claude-threads", "config.yaml");
@@ -56784,6 +56854,28 @@ var COMMAND_REGISTRY = [
       { name: "forget", description: "Remove one entry (by number or matching text), or all", args: "<n|text> | all" }
     ]
   },
+  {
+    command: "routine",
+    description: "Create a scheduled routine from a natural-language request (confirmed with \uD83D\uDC4D before saving)",
+    args: "<schedule, task>",
+    category: "settings",
+    audience: "user",
+    claudeNotes: "User decisions, not yours"
+  },
+  {
+    command: "routines",
+    description: "List scheduled routines; pause/resume/delete/run manage them",
+    args: "[pause|resume|delete|run <n>]",
+    category: "settings",
+    audience: "user",
+    claudeNotes: "User decisions, not yours",
+    subcommands: [
+      { name: "pause", description: "Pause a routine", args: "<n>" },
+      { name: "resume", description: "Resume a paused routine", args: "<n>" },
+      { name: "delete", description: "Delete a routine", args: "<n>" },
+      { name: "run", description: "Run a routine now, outside its schedule", args: "<n>" }
+    ]
+  },
   {
     command: "update",
     description: "Show auto-update status",
@@ -57058,6 +57150,30 @@ var handleMemory = async (ctx, args) => {
   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 handleRoutine = 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("!routine every weekday at 9:00, <task>")}`, ctx.threadId);
+    return { handled: true };
+  }
+  await ctx.sessionManager.createRoutine(ctx.threadId, args, ctx.username);
+  return { handled: true };
+};
+var handleRoutines = async (ctx, args) => {
+  if (ctx.commandContext === "first-message") {
+    return { handled: false };
+  }
+  if (!ctx.isAllowed) {
+    return { handled: true };
+  }
+  await ctx.sessionManager.manageRoutines(ctx.threadId, args, ctx.username);
+  return { handled: true };
+};
 var handleCd = async (ctx, args) => {
   if (!args) {
     return { handled: false };
@@ -57249,6 +57365,8 @@ handlers.set("kick", handleKick);
 handlers.set("github-email", handleGitHubEmail);
 handlers.set("remember", handleRemember);
 handlers.set("memory", handleMemory);
+handlers.set("routine", handleRoutine);
+handlers.set("routines", handleRoutines);
 handlers.set("cd", handleCd);
 handlers.set("permissions", handlePermissions);
 handlers.set("mentions", handleMentions);
@@ -57638,6 +57756,7 @@ var log18 = createLogger("memory");
 // src/session/lifecycle.ts
 var log19 = createLogger("lifecycle");
 var sessionLog3 = createSessionLog(log19);
+var _inFlightSessionStarts = new Map;
 var CHAT_PLATFORM_PROMPT = generateChatPlatformPrompt();
 // src/update-notifier.ts
 var import_semver2 = __toESM(require_semver2(), 1);
@@ -57652,23 +57771,200 @@ 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/persistence/routines-store.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join8 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/persistence/atomic-file.ts
+import { chmodSync as chmodSync2, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
+
+class SerialQueue {
+  tail = Promise.resolve();
+  run(fn) {
+    const next = this.tail.then(fn, fn);
+    this.tail = next.catch(() => {
+      return;
+    });
+    return next;
+  }
+}
+function writeFileAtomic(file2, content) {
+  const tempFile = `${file2}.tmp`;
+  writeFileSync3(tempFile, content, { encoding: "utf-8", mode: 384 });
+  renameSync2(tempFile, file2);
+  chmodSync2(file2, 384);
+}
+
+// src/persistence/routines-store.ts
+var log21 = createLogger("routines");
+var DEFAULT_CONFIG_DIR2 = join8(homedir6(), ".config", "claude-threads");
+var DEFAULT_FILE2 = join8(DEFAULT_CONFIG_DIR2, "routines.yaml");
+var STORE_VERSION = 1;
+var DEFAULT_MAX_ROUTINES = 10;
+var SCHEDULE_PRESETS = ["hourly", "daily", "weekdays", "weekly"];
+var TIME_RE = /^([01]\d|2[0-3]):[0-5]\d$/;
+function isValidTimezone(tz) {
+  if (typeof tz !== "string" || !tz)
+    return false;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateSchedule(schedule) {
+  if (!SCHEDULE_PRESETS.includes(schedule.preset)) {
+    return `unknown preset "${String(schedule.preset)}" (expected ${SCHEDULE_PRESETS.join("/")})`;
+  }
+  if (!isValidTimezone(schedule.timezone)) {
+    return `invalid timezone "${String(schedule.timezone)}"`;
+  }
+  if (schedule.preset === "hourly") {
+    return null;
+  }
+  if (!schedule.time || !TIME_RE.test(schedule.time)) {
+    return `invalid time "${String(schedule.time)}" (expected HH:MM, 24h)`;
+  }
+  if (schedule.preset === "weekly") {
+    const weekday = schedule.weekday;
+    if (typeof weekday !== "number" || !Number.isInteger(weekday) || weekday < 1 || weekday > 7) {
+      return `invalid weekday "${String(weekday)}" (expected 1=Mon … 7=Sun)`;
+    }
+  }
+  return null;
+}
+class RoutinesStore {
+  file;
+  configDir;
+  queue = new SerialQueue;
+  constructor(filePath) {
+    const effective = filePath ?? process.env.CLAUDE_THREADS_ROUTINES_PATH;
+    if (effective) {
+      this.file = effective;
+      this.configDir = join8(effective, "..");
+    } else {
+      this.file = DEFAULT_FILE2;
+      this.configDir = DEFAULT_CONFIG_DIR2;
+    }
+    if (!existsSync6(this.configDir)) {
+      mkdirSync2(this.configDir, { recursive: true, mode: 448 });
+    }
+  }
+  list(platformId) {
+    return this.loadRaw().routines[platformId] ?? [];
+  }
+  get(platformId, id) {
+    return this.list(platformId).find((r) => r.id === id);
+  }
+  add(platformId, routine, maxRoutines = DEFAULT_MAX_ROUTINES) {
+    return this.runExclusive(() => {
+      const scheduleError = validateSchedule(routine.schedule);
+      if (scheduleError)
+        return { ok: false, error: scheduleError };
+      const name = routine.name.trim().slice(0, 80);
+      const prompt = routine.prompt.trim().slice(0, 2000);
+      if (!name || !prompt)
+        return { ok: false, error: "name and prompt are required" };
+      const data = this.loadRaw();
+      const existing = data.routines[platformId] ?? [];
+      if (existing.length >= maxRoutines) {
+        return { ok: false, error: `routine limit reached (${maxRoutines}); delete one first` };
+      }
+      const full = {
+        ...routine,
+        name,
+        prompt,
+        id: randomUUID2().slice(0, 8),
+        createdAt: new Date().toISOString(),
+        enabled: true,
+        consecutiveFailures: 0
+      };
+      data.routines[platformId] = [...existing, full];
+      this.writeAtomic(data);
+      log21.info(`Routine "${full.name}" created on ${platformId} by @${full.createdBy}`);
+      return { ok: true, routine: full };
+    });
+  }
+  update(platformId, id, patch) {
+    return this.runExclusive(() => {
+      const data = this.loadRaw();
+      const routines = data.routines[platformId] ?? [];
+      const idx = routines.findIndex((r) => r.id === id);
+      if (idx < 0)
+        return;
+      routines[idx] = { ...routines[idx], ...patch };
+      this.writeAtomic(data);
+      return routines[idx];
+    });
+  }
+  remove(platformId, id) {
+    return this.runExclusive(() => {
+      const data = this.loadRaw();
+      const routines = data.routines[platformId] ?? [];
+      const idx = routines.findIndex((r) => r.id === id);
+      if (idx < 0)
+        return;
+      const [removed] = routines.splice(idx, 1);
+      if (routines.length === 0)
+        delete data.routines[platformId];
+      this.writeAtomic(data);
+      log21.info(`Routine "${removed.name}" removed from ${platformId}`);
+      return removed;
+    });
+  }
+  runExclusive(fn) {
+    return this.queue.run(fn);
+  }
+  loadRaw() {
+    if (!existsSync6(this.file)) {
+      return { version: STORE_VERSION, routines: {} };
+    }
+    try {
+      const parsed = yaml.load(readFileSync5(this.file, "utf-8"));
+      if (!parsed || typeof parsed !== "object") {
+        return { version: STORE_VERSION, routines: {} };
+      }
+      const routines = parsed.routines && typeof parsed.routines === "object" ? parsed.routines : {};
+      for (const list of Object.values(routines)) {
+        for (const r of list) {
+          r.enabled = r.enabled ?? true;
+          r.consecutiveFailures = r.consecutiveFailures ?? 0;
+        }
+      }
+      return { version: parsed.version ?? STORE_VERSION, routines };
+    } catch (err) {
+      log21.warn(`Failed to read ${this.file}: ${err.message} — starting empty`);
+      return { version: STORE_VERSION, routines: {} };
+    }
+  }
+  writeAtomic(data) {
+    writeFileAtomic(this.file, yaml.dump(data, { sortKeys: true, lineWidth: -1 }));
+  }
+}
+
+// src/routines/parser.ts
+var log22 = createLogger("routines");
+
 // src/operations/commands/handler.ts
-var log21 = createLogger("commands");
-var sessionLog4 = createSessionLog(log21);
+var log23 = createLogger("commands");
+var sessionLog4 = createSessionLog(log23);
 // src/operations/suggestions/branch.ts
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync2 = promisify2(exec2);
-var log22 = createLogger("branch");
+var log24 = createLogger("branch");
 
 // src/operations/worktree/handler.ts
-var log23 = createLogger("worktree");
-var sessionLog5 = createSessionLog(log23);
+var log25 = createLogger("worktree");
+var sessionLog5 = createSessionLog(log25);
 // src/operations/events/handler.ts
-var log24 = createLogger("events");
-var sessionLog6 = createSessionLog(log24);
+var log26 = createLogger("events");
+var sessionLog6 = createSessionLog(log26);
 // src/operations/monitor/handler.ts
-var log25 = createLogger("monitor");
+var log27 = createLogger("monitor");
 var DEFAULT_INTERVAL_MS = 60 * 1000;
 // src/utils/websocket.ts
 var WS;
@@ -57750,7 +58046,7 @@ ${code}
 
 // src/platform/mattermost/upload.ts
 import { readFile } from "fs/promises";
-var log26 = createLogger("mm-upload");
+var log28 = createLogger("mm-upload");
 async function uploadFileMattermost(args) {
   const { url: url2, token, channelId, threadId, filePath, filename, caption } = args;
   const buffer = await readFile(filePath);
@@ -57758,7 +58054,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);
-  log26.debug(`POST /files (${buffer.length} bytes, ${filename})`);
+  log28.debug(`POST /files (${buffer.length} bytes, ${filename})`);
   const uploadResponse = await fetch(uploadUrl, {
     method: "POST",
     headers: {
@@ -57779,10 +58075,10 @@ async function uploadFileMattermost(args) {
   const postBody = {
     channel_id: channelId,
     message: caption ?? "",
-    root_id: threadId,
+    root_id: resolvePostThreadId(threadId),
     file_ids: [fileInfo.id]
   };
-  log26.debug(`POST /posts (file_ids=[${fileInfo.id}])`);
+  log28.debug(`POST /posts (file_ids=[${fileInfo.id}])`);
   const postResponse = await fetch(postUrl, {
     method: "POST",
     headers: {
@@ -57835,7 +58131,7 @@ async function createPost(config3, channelId, message, rootId) {
   return mattermostApi(config3, "POST", "/posts", {
     channel_id: channelId,
     message,
-    root_id: rootId
+    root_id: resolvePostThreadId(rootId)
   });
 }
 async function updatePostRaw(config3, postId, message) {
@@ -58276,7 +58572,7 @@ ${code}
 
 // src/platform/slack/upload.ts
 import { readFile as readFile2 } from "fs/promises";
-var log27 = createLogger("slack-upload");
+var log29 = createLogger("slack-upload");
 var DEFAULT_API_URL = "https://slack.com/api";
 async function uploadFileSlack(args) {
   const { botToken, channelId, threadTs, filePath, filename, caption } = args;
@@ -58284,7 +58580,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()}`;
-  log27.debug(`GET files.getUploadURLExternal (${buffer.length} bytes, ${filename})`);
+  log29.debug(`GET files.getUploadURLExternal (${buffer.length} bytes, ${filename})`);
   const step1Response = await fetch(step1Url, {
     method: "GET",
     headers: {
@@ -58302,7 +58598,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);
-  log27.debug(`POST <upload_url>`);
+  log29.debug(`POST <upload_url>`);
   const step2Response = await fetch(uploadUrl, {
     method: "POST",
     headers: {
@@ -58317,12 +58613,12 @@ async function uploadFileSlack(args) {
   const step3Body = {
     files: [{ id: fileId, title: caption ?? filename }],
     channel_id: channelId,
-    thread_ts: threadTs
+    thread_ts: resolvePostThreadId(threadTs)
   };
   if (caption !== undefined) {
     step3Body.initial_comment = caption;
   }
-  log27.debug(`POST files.completeUploadExternal (file_id=${fileId}, thread_ts=${threadTs})`);
+  log29.debug(`POST files.completeUploadExternal (file_id=${fileId}, thread_ts=${threadTs})`);
   const step3Response = await fetch(`${apiUrl}/files.completeUploadExternal`, {
     method: "POST",
     headers: {
@@ -58340,7 +58636,7 @@ async function uploadFileSlack(args) {
     throw new Error(`Slack completeUploadExternal error: ${step3Data.error || "unknown"}`);
   }
   if (!step3Data.ts) {
-    log27.warn(`Slack completeUploadExternal returned no ts; using fileId ${fileId} as postId. ` + `Do not use this id for updatePost/addReaction.`);
+    log29.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 };
 }
@@ -58416,7 +58712,7 @@ class SlackMcpPlatformApi {
     const response = await slackApi("chat.postMessage", this.config.botToken, {
       channel: this.config.channelId,
       text: message,
-      thread_ts: threadTs || this.config.threadTs,
+      thread_ts: resolvePostThreadId(threadTs || this.config.threadTs),
       mrkdwn: true
     });
     const messageTs = response.ts;
@@ -59360,6 +59656,12 @@ async function resolveLatestThreadPost(cfg) {
   if (!cfg.sessionThreadId) {
     return { ok: false, reason: "no session thread to react in — pass a permalink URL instead" };
   }
+  if (isDcmThreadId(cfg.sessionThreadId)) {
+    return {
+      ok: false,
+      reason: "this session runs in direct channel mode (no thread of its own) — pass a permalink URL to the target message instead"
+    };
+  }
   let thread;
   try {
     thread = await cfg.api.readThread(cfg.sessionThreadId);
@@ -59461,6 +59763,12 @@ async function handleListThreadWith(args, cfg) {
         reason: "no session thread to read — pass a permalink URL instead"
       };
     }
+    if (isDcmThreadId(cfg.sessionThreadId)) {
+      return {
+        ok: false,
+        reason: "this session runs in direct channel mode (no thread of its own) — use read_channel_history, or pass a permalink URL"
+      };
+    }
     rootId = cfg.sessionThreadId;
   }
   const limit = clampThreadLimit(args.max_messages);