clisbot 0.1.29 → 0.1.32

package/dist/main.js

@@ -4,25 +4,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
@@ -62543,6 +62561,421 @@ function prependAttachmentMentions(text, attachmentPaths) {
   return normalizedText ? `${mentions} ${normalizedText}` : mentions;
 }
 
+// src/agents/commands.ts
+function parseAgentCommand(text, options = {}) {
+  const normalized = text.trim();
+  const commandPrefixes = options.commandPrefixes ?? {
+    slash: ["::", "\\"],
+    bash: ["!"]
+  };
+  const bashPrefix = findMatchingPrefix(normalized, commandPrefixes.bash);
+  if (bashPrefix) {
+    const command2 = normalized.slice(bashPrefix.length).trim();
+    return {
+      type: "bash",
+      command: command2,
+      source: "shortcut"
+    };
+  }
+  const slashPrefix = findMatchingPrefix(normalized, ["/", ...commandPrefixes.slash]);
+  if (!slashPrefix) {
+    return null;
+  }
+  const withoutSlash = normalized.slice(slashPrefix.length).trim();
+  if (!withoutSlash) {
+    return {
+      type: "control",
+      name: "help"
+    };
+  }
+  const [command] = withoutSlash.split(/\s+/, 1);
+  const lowered = normalizeSlashCommandName(command, options.botUsername);
+  if (lowered === "start") {
+    return {
+      type: "control",
+      name: "start"
+    };
+  }
+  if (lowered === "status") {
+    return {
+      type: "control",
+      name: "status"
+    };
+  }
+  if (lowered === "help") {
+    return {
+      type: "control",
+      name: "help"
+    };
+  }
+  if (lowered === "whoami") {
+    return {
+      type: "control",
+      name: "whoami"
+    };
+  }
+  if (lowered === "transcript") {
+    return {
+      type: "control",
+      name: "transcript"
+    };
+  }
+  if (lowered === "attach") {
+    return {
+      type: "control",
+      name: "attach"
+    };
+  }
+  if (lowered === "detach") {
+    return {
+      type: "control",
+      name: "detach"
+    };
+  }
+  if (lowered === "watch") {
+    const parsed = parseWatchCommand(withoutSlash.slice(command.length).trim());
+    if (parsed) {
+      return {
+        type: "control",
+        name: "watch",
+        intervalMs: parsed.intervalMs,
+        durationMs: parsed.durationMs
+      };
+    }
+    return {
+      type: "control",
+      name: "help"
+    };
+  }
+  if (lowered === "stop") {
+    return {
+      type: "control",
+      name: "stop"
+    };
+  }
+  if (lowered === "nudge") {
+    return {
+      type: "control",
+      name: "nudge"
+    };
+  }
+  if (lowered === "followup") {
+    const action = withoutSlash.slice(command.length).trim().toLowerCase();
+    if (!action || action === "status") {
+      return {
+        type: "control",
+        name: "followup",
+        action: "status"
+      };
+    }
+    if (action === "auto") {
+      return {
+        type: "control",
+        name: "followup",
+        action: "auto",
+        mode: "auto"
+      };
+    }
+    if (action === "mention-only") {
+      return {
+        type: "control",
+        name: "followup",
+        action: "mention-only",
+        mode: "mention-only"
+      };
+    }
+    if (action === "pause") {
+      return {
+        type: "control",
+        name: "followup",
+        action: "pause",
+        mode: "paused"
+      };
+    }
+    if (action === "resume") {
+      return {
+        type: "control",
+        name: "followup",
+        action: "resume"
+      };
+    }
+    return {
+      type: "control",
+      name: "followup",
+      action: "status"
+    };
+  }
+  if (lowered === "responsemode") {
+    const action = withoutSlash.slice(command.length).trim().toLowerCase();
+    if (!action || action === "status") {
+      return {
+        type: "control",
+        name: "responsemode",
+        action: "status"
+      };
+    }
+    if (action === "capture-pane" || action === "message-tool") {
+      return {
+        type: "control",
+        name: "responsemode",
+        action,
+        responseMode: action
+      };
+    }
+    return {
+      type: "control",
+      name: "responsemode",
+      action: "status"
+    };
+  }
+  if (lowered === "streaming") {
+    const action = withoutSlash.slice(command.length).trim().toLowerCase();
+    if (!action || action === "status") {
+      return {
+        type: "control",
+        name: "streaming",
+        action: "status"
+      };
+    }
+    if (action === "on") {
+      return {
+        type: "control",
+        name: "streaming",
+        action: "on",
+        streaming: "all"
+      };
+    }
+    if (action === "off" || action === "latest" || action === "all") {
+      return {
+        type: "control",
+        name: "streaming",
+        action,
+        streaming: action
+      };
+    }
+    return {
+      type: "control",
+      name: "streaming",
+      action: "status"
+    };
+  }
+  if (lowered === "additionalmessagemode") {
+    const action = withoutSlash.slice(command.length).trim().toLowerCase();
+    if (!action || action === "status") {
+      return {
+        type: "control",
+        name: "additionalmessagemode",
+        action: "status"
+      };
+    }
+    if (action === "queue" || action === "steer") {
+      return {
+        type: "control",
+        name: "additionalmessagemode",
+        action,
+        additionalMessageMode: action
+      };
+    }
+    return {
+      type: "control",
+      name: "additionalmessagemode",
+      action: "status"
+    };
+  }
+  if (lowered === "bash") {
+    return {
+      type: "bash",
+      command: withoutSlash.slice(command.length).trim(),
+      source: "slash"
+    };
+  }
+  if (lowered === "loop") {
+    const loopText = withoutSlash.slice(command.length).trim();
+    const loweredLoopText = loopText.toLowerCase();
+    if (!loweredLoopText || loweredLoopText === "help") {
+      return {
+        type: "control",
+        name: "loop-help"
+      };
+    }
+    if (loweredLoopText === "status") {
+      return {
+        type: "loop-control",
+        action: "status"
+      };
+    }
+    if (loweredLoopText === "cancel" || loweredLoopText.startsWith("cancel ")) {
+      const cancelArgs = loopText.slice("cancel".length).trim();
+      if (hasLoopFlag(cancelArgs, LOOP_FORCE_FLAG)) {
+        return {
+          type: "loop-error",
+          message: `Use \`/loop cancel --all ${LOOP_APP_FLAG}\` for app-wide cancellation.`
+        };
+      }
+      const all = hasLoopFlag(cancelArgs, LOOP_ALL_FLAG);
+      const app = hasLoopFlag(cancelArgs, LOOP_APP_FLAG);
+      if (app && !all) {
+        return {
+          type: "loop-error",
+          message: `\`${LOOP_APP_FLAG}\` only works with \`/loop cancel ${LOOP_ALL_FLAG}\`.`
+        };
+      }
+      const loopId = cancelArgs.split(/\s+/).map((token) => token.trim()).find((token) => token && token !== LOOP_ALL_FLAG && token !== LOOP_APP_FLAG);
+      return {
+        type: "loop-control",
+        action: "cancel",
+        loopId: loopId || undefined,
+        all,
+        app
+      };
+    }
+    const parsed = parseLoopSlashCommand(loopText);
+    if ("error" in parsed) {
+      return {
+        type: "loop-error",
+        message: parsed.error
+      };
+    }
+    return {
+      type: "loop",
+      params: parsed
+    };
+  }
+  if (lowered === "queue" || lowered === "q") {
+    const queueText = withoutSlash.slice(command.length).trim();
+    const normalizedQueueText = queueText.toLowerCase();
+    if (lowered === "queue") {
+      if (normalizedQueueText === "help") {
+        return {
+          type: "control",
+          name: "queue-help"
+        };
+      }
+      if (normalizedQueueText === "list") {
+        return {
+          type: "control",
+          name: "queue-list"
+        };
+      }
+      if (normalizedQueueText === "clear") {
+        return {
+          type: "control",
+          name: "queue-clear"
+        };
+      }
+    }
+    return {
+      type: "queue",
+      text: queueText
+    };
+  }
+  if (lowered === "queue-list" || lowered === "queuelist") {
+    return {
+      type: "control",
+      name: "queue-list"
+    };
+  }
+  if (lowered === "queue-clear" || lowered === "queueclear") {
+    return {
+      type: "control",
+      name: "queue-clear"
+    };
+  }
+  if (lowered === "steer" || lowered === "s") {
+    return {
+      type: "steer",
+      text: withoutSlash.slice(command.length).trim()
+    };
+  }
+  return {
+    type: "native",
+    text: normalized
+  };
+}
+function findMatchingPrefix(text, prefixes) {
+  return [...prefixes].sort((left, right) => right.length - left.length).find((prefix) => prefix.length > 0 && text.startsWith(prefix));
+}
+function normalizeSlashCommandName(command, botUsername) {
+  const lowered = command?.toLowerCase() ?? "";
+  const normalizedBotUsername = (botUsername ?? "").trim().toLowerCase().replace(/^@/, "");
+  if (!normalizedBotUsername) {
+    return lowered;
+  }
+  const suffix = `@${normalizedBotUsername}`;
+  if (!lowered.endsWith(suffix)) {
+    return lowered;
+  }
+  return lowered.slice(0, lowered.length - suffix.length);
+}
+function renderAgentControlSlashHelp() {
+  return [
+    "Slash commands",
+    "",
+    "- `/start`: show onboarding help for the current surface",
+    "- `/status`: show the current route status and operator setup commands",
+    "- `/help`: show available control slash commands",
+    "- `/whoami`: show the current platform, route, and sender identity details",
+    "- `/transcript`: show the current conversation session transcript when the route verbose policy allows it",
+    "- `/attach`: attach this thread to the active run and resume live updates when it is still processing",
+    "- `/detach`: stop live updates for this thread, switch to sparse progress updates, and still allow final settlement here",
+    "- `/watch every 30s [for 10m]`: post the latest state on an interval until the run settles or the watch window ends",
+    "- `/stop`: send Escape to interrupt the current conversation session",
+    "- `/nudge`: send one extra Enter to the current tmux session without resending the prompt text",
+    "- `/followup status`: show the current conversation follow-up policy",
+    "- `/followup auto`: allow natural follow-up after the bot has replied in-thread",
+    "- `/followup mention-only`: require explicit mention for each later turn",
+    "- `/followup pause`: stop passive follow-up until the next explicit mention",
+    "- `/followup resume`: clear the runtime override and restore config defaults",
+    "- `/streaming status|on|off|latest|all`: show or change streaming mode for this surface",
+    "- `/responsemode status`: show the configured response mode for this surface",
+    "- `/responsemode capture-pane`: settle replies from captured pane output for this surface",
+    "- `/responsemode message-tool`: expect the agent to reply through `clisbot message send` for this surface",
+    "- `/additionalmessagemode status`: show how extra messages behave while a run is already active",
+    "- `/additionalmessagemode steer`: send later user messages straight into the active session",
+    "- `/additionalmessagemode queue`: queue later user messages behind the active run for this surface",
+    "- `/queue <message>` or `\\q <message>`: enqueue a later message behind the active run and let clisbot deliver it in order",
+    "- `/queue help`: show queue-specific help and examples",
+    "- `/steer <message>` or `\\s <message>`: inject a steering message into the active run immediately",
+    "- `/queue list`: show queued messages that have not started yet",
+    "- `/queue clear`: clear queued messages that have not started yet",
+    "- `/loop help`: show loop-specific help and syntax examples",
+    ...renderLoopHelpLines(),
+    "- `/bash` followed by a shell command: requires `shellExecute` on the resolved agent role",
+    "- shortcut prefixes such as `!` run bash only when the resolved agent role allows `shellExecute`",
+    "",
+    "Other slash commands are forwarded to the agent unchanged."
+  ].join(`
+`);
+}
+function renderQueueHelpLines() {
+  return [
+    "- `/queue <message>` or `\\q <message>`: enqueue one later message behind the active run",
+    "- `/queue list`: show queued messages that have not started yet",
+    "- `/queue clear`: clear queued messages that have not started yet",
+    "- `/queue help`: show this queue help again",
+    "- `/steer <message>` or `\\s <message>`: inject an immediate steering message instead of queueing"
+  ];
+}
+function parseWatchCommand(raw) {
+  const match = raw.match(/^every\s+(\S+)(?:\s+for\s+(\S+))?$/i);
+  if (!match) {
+    return null;
+  }
+  const intervalMs = parseCommandDurationMs(match[1] ?? "");
+  if (!intervalMs) {
+    return null;
+  }
+  const durationToken = match[2];
+  const parsedDurationMs = durationToken ? parseCommandDurationMs(durationToken) : null;
+  if (durationToken && !parsedDurationMs) {
+    return null;
+  }
+  return {
+    intervalMs,
+    durationMs: parsedDurationMs ?? undefined
+  };
+}
+
 // src/agents/agent-service.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 
@@ -62604,6 +63037,7 @@ class SessionStore {
       followUp: existing?.followUp,
       runtime: existing?.runtime,
       intervalLoops: existing?.intervalLoops,
+      recentConversation: existing?.recentConversation,
       updatedAt: Date.now()
     });
   }
@@ -62647,6 +63081,85 @@ class SessionStore {
   }
 }
 
+// src/shared/recent-message-context.ts
+var RECENT_CONVERSATION_MESSAGE_LIMIT = 5;
+function normalizeMessage(message) {
+  return {
+    marker: message.marker.trim(),
+    text: message.text?.trim() || undefined,
+    senderId: message.senderId?.trim() || undefined,
+    senderName: message.senderName?.trim() || undefined
+  };
+}
+function normalizeReplayLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function renderSenderLabel(message) {
+  return message.senderName ?? message.senderId;
+}
+function appendRecentConversationMessage(state, message) {
+  const normalized = normalizeMessage(message);
+  if (!normalized.marker) {
+    return state ?? { messages: [] };
+  }
+  const currentMessages = state?.messages ?? [];
+  const nextMessages = [
+    ...currentMessages.filter((entry) => entry.marker !== normalized.marker),
+    normalized
+  ].slice(-RECENT_CONVERSATION_MESSAGE_LIMIT);
+  return {
+    lastProcessedMarker: state?.lastProcessedMarker,
+    messages: nextMessages
+  };
+}
+function markRecentConversationProcessed(state, marker) {
+  const normalizedMarker = marker.trim();
+  return {
+    lastProcessedMarker: normalizedMarker || state?.lastProcessedMarker,
+    messages: state?.messages ?? []
+  };
+}
+function collectRecentConversationReplayMessages(state, params = {}) {
+  const messages = state?.messages ?? [];
+  if (messages.length === 0) {
+    return [];
+  }
+  const excludeMarker = params.excludeMarker?.trim();
+  const pending = [];
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (state?.lastProcessedMarker && message.marker === state.lastProcessedMarker) {
+      break;
+    }
+    if (excludeMarker && message.marker === excludeMarker) {
+      continue;
+    }
+    pending.push(message);
+  }
+  return pending.reverse();
+}
+function prependRecentConversationContext(params) {
+  const replayLines = params.recentMessages.map((message) => {
+    const text = normalizeReplayLine(message.text ?? "");
+    if (!text) {
+      return "";
+    }
+    const sender = renderSenderLabel(message);
+    return sender ? `- ${sender}: ${text}` : `- ${text}`;
+  }).filter(Boolean);
+  if (replayLines.length === 0) {
+    return params.currentText;
+  }
+  return [
+    "Before answering, catch up on these newer messages from this conversation that were not processed yet:",
+    ...replayLines,
+    "",
+    "Current message:",
+    params.currentText
+  ].join(`
+`);
+}
+
 // src/agents/session-state.ts
 class AgentSessionState {
   sessionStore;
@@ -62665,7 +63178,8 @@ class AgentSessionState {
       followUp: existing?.followUp,
       runnerCommand: params.runnerCommand ?? existing?.runnerCommand ?? resolved.runner.command,
       runtime: params.runtime ?? existing?.runtime,
-      intervalLoops: existing?.intervalLoops
+      intervalLoops: existing?.intervalLoops,
+      recentConversation: existing?.recentConversation
     }));
   }
   async clearSessionIdEntry(resolved, params = {}) {
@@ -62676,7 +63190,8 @@ class AgentSessionState {
       runtime: {
         state: "idle"
       },
-      intervalLoops: existing?.intervalLoops
+      intervalLoops: existing?.intervalLoops,
+      recentConversation: existing?.recentConversation
     }));
   }
   async setSessionRuntime(resolved, runtime) {
@@ -62685,7 +63200,8 @@ class AgentSessionState {
       followUp: existing?.followUp,
       runnerCommand: existing?.runnerCommand ?? resolved.runner.command,
       runtime,
-      intervalLoops: existing?.intervalLoops
+      intervalLoops: existing?.intervalLoops,
+      recentConversation: existing?.recentConversation
     }));
   }
   async getConversationFollowUpState(target) {
@@ -62733,7 +63249,8 @@ class AgentSessionState {
       followUp: existing?.followUp,
       runnerCommand: existing?.runnerCommand ?? resolved.runner.command,
       runtime: existing?.runtime,
-      intervalLoops: [...(existing?.intervalLoops ?? []).filter((item) => item.id !== loop.id), loop]
+      intervalLoops: [...(existing?.intervalLoops ?? []).filter((item) => item.id !== loop.id), loop],
+      recentConversation: existing?.recentConversation
     }));
   }
   async replaceIntervalLoopIfPresent(resolved, loop) {
@@ -62753,6 +63270,7 @@ class AgentSessionState {
         followUp: existing?.followUp,
         runtime: existing?.runtime,
         intervalLoops: currentLoops.map((item) => item.id === loop.id ? loop : item),
+        recentConversation: existing?.recentConversation,
         updatedAt: Date.now()
       };
     });
@@ -62764,7 +63282,8 @@ class AgentSessionState {
       followUp: existing?.followUp,
       runnerCommand: existing?.runnerCommand ?? resolved.runner.command,
       runtime: existing?.runtime,
-      intervalLoops: (existing?.intervalLoops ?? []).filter((item) => item.id !== loopId)
+      intervalLoops: (existing?.intervalLoops ?? []).filter((item) => item.id !== loopId),
+      recentConversation: existing?.recentConversation
     }));
   }
   async clearIntervalLoops(resolved) {
@@ -62773,7 +63292,8 @@ class AgentSessionState {
       followUp: existing?.followUp,
       runnerCommand: existing?.runnerCommand ?? resolved.runner.command,
       runtime: existing?.runtime,
-      intervalLoops: []
+      intervalLoops: [],
+      recentConversation: existing?.recentConversation
     }));
   }
   async removeIntervalLoopById(loopId) {
@@ -62826,7 +63346,8 @@ class AgentSessionState {
         overrideMode: mode
       },
       runnerCommand: existing?.runnerCommand ?? resolved.runner.command,
-      intervalLoops: existing?.intervalLoops
+      intervalLoops: existing?.intervalLoops,
+      recentConversation: existing?.recentConversation
     }));
   }
   async resetConversationFollowUpMode(resolved) {
@@ -62837,7 +63358,8 @@ class AgentSessionState {
         overrideMode: undefined
       } : undefined,
       runnerCommand: existing?.runnerCommand ?? resolved.runner.command,
-      intervalLoops: existing?.intervalLoops
+      intervalLoops: existing?.intervalLoops,
+      recentConversation: existing?.recentConversation
     }));
   }
   async reactivateConversationFollowUp(resolved) {
@@ -62868,7 +63390,32 @@ class AgentSessionState {
           } : {}
         } : {}
       } : existing?.runtime,
-      intervalLoops: existing?.intervalLoops
+      intervalLoops: existing?.intervalLoops,
+      recentConversation: existing?.recentConversation
+    }));
+  }
+  async appendRecentConversationMessage(resolved, message) {
+    return this.upsertSessionEntry(resolved, (existing) => ({
+      sessionId: existing?.sessionId,
+      followUp: existing?.followUp,
+      runnerCommand: existing?.runnerCommand ?? resolved.runner.command,
+      runtime: existing?.runtime,
+      intervalLoops: existing?.intervalLoops,
+      recentConversation: appendRecentConversationMessage(existing?.recentConversation, message)
+    }));
+  }
+  async getRecentConversationReplayMessages(target, params = {}) {
+    const entry = await this.sessionStore.get(target.sessionKey);
+    return collectRecentConversationReplayMessages(entry?.recentConversation, params);
+  }
+  async markRecentConversationProcessed(resolved, marker) {
+    return this.upsertSessionEntry(resolved, (existing) => ({
+      sessionId: existing?.sessionId,
+      followUp: existing?.followUp,
+      runnerCommand: existing?.runnerCommand ?? resolved.runner.command,
+      runtime: existing?.runtime,
+      intervalLoops: existing?.intervalLoops,
+      recentConversation: markRecentConversationProcessed(existing?.recentConversation, marker)
     }));
   }
   async upsertSessionEntry(resolved, update) {
@@ -62883,6 +63430,7 @@ class AgentSessionState {
         followUp: next.followUp,
         runtime: next.runtime ?? existing?.runtime,
         intervalLoops: next.intervalLoops ?? existing?.intervalLoops,
+        recentConversation: next.recentConversation ?? existing?.recentConversation,
         updatedAt: Date.now()
       };
     });
@@ -62901,6 +63449,7 @@ You are operating inside clisbot.
 {{delivery_intro}}
 {{reply_command}}
 {{reply_rules}}
+{{reply_style_hint}}
 ${CONFIGURATION_GUIDANCE}{{protected_control_suffix}}
 </system>
 
@@ -62943,14 +63492,21 @@ var FINAL_RULE_REQUIRED = "send exactly 1 final user-facing response";
 var FINAL_RULE_OPTIONAL = "final response is optional";
 var EMPTY_REPLY_COMMAND = "";
 var EMPTY_REPLY_RULES = "";
+var EMPTY_REPLY_STYLE_HINT = "";
 var SLACK_REPLY_COMMAND_BASE = `{{command}} message send \\
   --channel slack \\
 {{account_clause}}  --target channel:{{channel_id}} \\
-{{thread_clause}}`;
+{{thread_clause}}  --input md \\
+  --render blocks \\
+`;
 var TELEGRAM_REPLY_COMMAND_BASE = `{{command}} message send \\
   --channel telegram \\
 {{account_clause}}  --target {{chat_id}} \\
-{{thread_clause}}`;
+{{thread_clause}}  --input md \\
+  --render native \\
+`;
+var SLACK_REPLY_STYLE_HINT = "Put readable hierarchical Markdown in the --message body.";
+var TELEGRAM_REPLY_STYLE_HINT = "Put readable hierarchical Markdown in the --message body.";
 var ACCOUNT_CLAUSE = "  --account {{account_id}} \\\n";
 var EMPTY_ACCOUNT_CLAUSE = "";
 var SLACK_THREAD_CLAUSE = "  --thread-id {{thread_ts}} \\\n";
@@ -62991,6 +63547,7 @@ function buildChannelPromptText(params) {
     delivery_intro: promptParts.deliveryIntro,
     reply_command: promptParts.replyCommand,
     reply_rules: promptParts.replyRules,
+    reply_style_hint: promptParts.replyStyleHint,
     protected_control_suffix: renderProtectedControlSuffix(params.protectedControlMutationRule),
     message_body: params.text
   });
@@ -63001,7 +63558,8 @@ function renderMessagePromptParts(params) {
     return {
       deliveryIntro: DELIVERY_INTRO_CAPTURE_PANE,
       replyCommand: EMPTY_REPLY_COMMAND,
-      replyRules: EMPTY_REPLY_RULES
+      replyRules: EMPTY_REPLY_RULES,
+      replyStyleHint: EMPTY_REPLY_STYLE_HINT
     };
   }
   const allowProgress = (params.streaming ?? "off") === "off";
@@ -63025,9 +63583,13 @@ function renderMessagePromptParts(params) {
         max_progress_messages: String(params.config.maxProgressMessages)
       }),
       final_rule_line: finalRuleLine
-    })
+    }),
+    replyStyleHint: buildReplyStyleHint(params.identity)
   };
 }
+function buildReplyStyleHint(identity) {
+  return identity.platform === "slack" ? SLACK_REPLY_STYLE_HINT : TELEGRAM_REPLY_STYLE_HINT;
+}
 function renderProtectedControlSuffix(rule) {
   if (!rule) {
     return "";
@@ -64027,6 +64589,17 @@ function extractScrolledAppend(previous, current) {
   }
   return "";
 }
+function deriveRunningInteractionText(previousSnapshot, currentSnapshot) {
+  const previous = cleanRunningInteractionSnapshot(previousSnapshot);
+  const current = cleanRunningInteractionSnapshot(currentSnapshot);
+  if (!current || current === previous) {
+    return "";
+  }
+  if (!previous) {
+    return current;
+  }
+  return extractScrolledAppend(previous, current);
+}
 function deriveRunningInteractionSnapshot(currentSnapshot) {
   return cleanRunningInteractionSnapshot(currentSnapshot);
 }
@@ -64382,6 +64955,8 @@ var PASTE_SETTLE_POLL_INTERVAL_MS = 40;
 var PASTE_SETTLE_QUIET_WINDOW_MS = 60;
 var PASTE_SETTLE_MULTILINE_MAX_WAIT_MS = 800;
 var PASTE_SETTLE_SINGLE_LINE_MAX_WAIT_MS = 80;
+var PASTE_CAPTURE_REVALIDATE_POLL_INTERVAL_MS = 40;
+var PASTE_CAPTURE_REVALIDATE_MAX_WAIT_MS = 160;
 var SUBMIT_CONFIRM_POLL_INTERVAL_MS = 40;
 var SUBMIT_CONFIRM_MAX_WAIT_MS = 160;
 var TMUX_MISSING_TARGET_PATTERN = /(?:no current target|can't find pane|can't find window)/i;
@@ -64398,14 +64973,35 @@ class TmuxBootstrapSessionLostError extends Error {
 }
 async function submitTmuxSessionInput(params) {
   const prePasteState = await params.tmux.getPaneState(params.sessionName);
+  const captureLines = estimatePasteCaptureLines(params.text);
+  const prePasteSnapshot = normalizePaneText(await params.tmux.capturePane(params.sessionName, captureLines));
   await params.tmux.sendLiteral(params.sessionName, params.text);
-  const preSubmitState = await waitForPanePasteSettlement({
+  const pasteSettlement = await waitForPanePasteSettlement({
     tmux: params.tmux,
     sessionName: params.sessionName,
     baseline: prePasteState,
     text: params.text,
     minDelayMs: params.promptSubmitDelayMs
   });
+  let preSubmitState = pasteSettlement.state;
+  if (!pasteSettlement.visible) {
+    logLatencyDebug("tmux-paste-retry", params.timingContext, {
+      sessionName: params.sessionName
+    });
+    const snapshotConfirmed = await waitForPanePasteSnapshotConfirmation({
+      tmux: params.tmux,
+      sessionName: params.sessionName,
+      baselineSnapshot: prePasteSnapshot,
+      captureLines
+    });
+    if (!snapshotConfirmed) {
+      logLatencyDebug("tmux-paste-unconfirmed", params.timingContext, {
+        sessionName: params.sessionName
+      });
+      throw new Error("tmux paste was not confirmed before Enter. The pane state did not change, so clisbot did not treat the prompt as visibly delivered.");
+    }
+    preSubmitState = await params.tmux.getPaneState(params.sessionName);
+  }
   await params.tmux.sendKey(params.sessionName, "Enter");
   if (await waitForPaneSubmitConfirmation({
     tmux: params.tmux,
@@ -64609,11 +65205,17 @@ async function waitForPanePasteSettlement(params) {
   const deadline = Date.now() + (shouldWaitForVisiblePaste(params.text) ? PASTE_SETTLE_MULTILINE_MAX_WAIT_MS : PASTE_SETTLE_SINGLE_LINE_MAX_WAIT_MS);
   while (true) {
     if (sawChange && Date.now() - lastChangeAt >= PASTE_SETTLE_QUIET_WINDOW_MS) {
-      return currentState;
+      return {
+        visible: true,
+        state: currentState
+      };
     }
     const remainingMs = deadline - Date.now();
     if (remainingMs <= 0) {
-      return currentState;
+      return {
+        visible: sawChange,
+        state: currentState
+      };
     }
     await sleep(Math.min(PASTE_SETTLE_POLL_INTERVAL_MS, remainingMs));
     const nextState = await params.tmux.getPaneState(params.sessionName);
@@ -64626,6 +65228,24 @@ async function waitForPanePasteSettlement(params) {
     }
   }
 }
+async function waitForPanePasteSnapshotConfirmation(params) {
+  const deadline = Date.now() + PASTE_CAPTURE_REVALIDATE_MAX_WAIT_MS;
+  while (true) {
+    const snapshot = normalizePaneText(await params.tmux.capturePane(params.sessionName, params.captureLines));
+    if (snapshot !== params.baselineSnapshot) {
+      return true;
+    }
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      return false;
+    }
+    await sleep(Math.min(PASTE_CAPTURE_REVALIDATE_POLL_INTERVAL_MS, remainingMs));
+  }
+}
+function estimatePasteCaptureLines(text) {
+  return Math.max(40, Math.min(160, text.split(`
+`).length + 24));
+}
 function hasPaneStateChanged(left, right) {
   return left.cursorX !== right.cursorX || left.cursorY !== right.cursorY || left.historySize !== right.historySize;
 }
@@ -64914,6 +65534,12 @@ class RunnerService {
       nextAllowFreshRetry: false
     });
   }
+  async retryAfterStartupTimeout(target, resolved, allowFreshRetry) {
+    return this.retryFreshStartWithClearedSessionId(target, resolved, {
+      allowRetry: allowFreshRetry,
+      nextAllowFreshRetry: false
+    });
+  }
   async abortUnreadySession(resolved, reason, snapshot) {
     await this.tmux.killSession(resolved.sessionName);
     throw new Error(`${reason}${summarizeSnapshot(snapshot)}`);
@@ -65058,6 +65684,10 @@ class RunnerService {
         await this.abortUnreadySession(resolved, bootstrapResult.message, bootstrapResult.snapshot);
       }
       if (bootstrapResult.status === "timeout" && resolved.runner.startupReadyPattern) {
+        const retried = await this.retryAfterStartupTimeout(target, resolved, options.allowFreshRetry);
+        if (retried) {
+          return retried;
+        }
         await this.abortUnreadySession(resolved, `Runner session "${resolved.sessionName}" did not reach the configured ready state within ${resolved.runner.startupDelayMs}ms.`, bootstrapResult.snapshot);
       }
       await this.finalizeSessionStartup(resolved, {
@@ -65322,7 +65952,7 @@ async function monitorTmuxRun(params) {
     await sleep(sawActivity ? params.updateIntervalMs : Math.min(params.updateIntervalMs, FIRST_OUTPUT_POLL_INTERVAL_MS));
     const snapshot = normalizePaneText(await params.tmux.capturePane(params.sessionName, params.captureLines));
     const now = Date.now();
-    const runningSnapshot = deriveRunningInteractionSnapshot(snapshot);
+    const runningSnapshot = params.initialSnapshot ? deriveRunningInteractionText(params.initialSnapshot, snapshot) : deriveRunningInteractionSnapshot(snapshot);
     previousSnapshot = snapshot;
     if (runningSnapshot && runningSnapshot !== previousRunningSnapshot) {
       previousRunningSnapshot = runningSnapshot;
@@ -66057,6 +66687,15 @@ class AgentService {
   async recordConversationReply(target, kind = "reply", source = "channel") {
     return this.sessionState.recordConversationReply(this.resolveTarget(target), kind, source);
   }
+  async appendRecentConversationMessage(target, message) {
+    return this.sessionState.appendRecentConversationMessage(this.resolveTarget(target), message);
+  }
+  async getRecentConversationReplayMessages(target, params = {}) {
+    return this.sessionState.getRecentConversationReplayMessages(target, params);
+  }
+  async markRecentConversationProcessed(target, marker) {
+    return this.sessionState.markRecentConversationProcessed(this.resolveTarget(target), marker);
+  }
   async runShellCommand(target, command) {
     return this.queue.enqueue(`${target.sessionKey}:bash`, async () => this.runnerSessions.runShellCommand(target, command)).result;
   }
@@ -66566,421 +67205,6 @@ class AgentService {
   }
 }
 
-// src/agents/commands.ts
-function parseAgentCommand(text, options = {}) {
-  const normalized = text.trim();
-  const commandPrefixes = options.commandPrefixes ?? {
-    slash: ["::", "\\"],
-    bash: ["!"]
-  };
-  const bashPrefix = findMatchingPrefix(normalized, commandPrefixes.bash);
-  if (bashPrefix) {
-    const command2 = normalized.slice(bashPrefix.length).trim();
-    return {
-      type: "bash",
-      command: command2,
-      source: "shortcut"
-    };
-  }
-  const slashPrefix = findMatchingPrefix(normalized, ["/", ...commandPrefixes.slash]);
-  if (!slashPrefix) {
-    return null;
-  }
-  const withoutSlash = normalized.slice(slashPrefix.length).trim();
-  if (!withoutSlash) {
-    return {
-      type: "control",
-      name: "help"
-    };
-  }
-  const [command] = withoutSlash.split(/\s+/, 1);
-  const lowered = normalizeSlashCommandName(command, options.botUsername);
-  if (lowered === "start") {
-    return {
-      type: "control",
-      name: "start"
-    };
-  }
-  if (lowered === "status") {
-    return {
-      type: "control",
-      name: "status"
-    };
-  }
-  if (lowered === "help") {
-    return {
-      type: "control",
-      name: "help"
-    };
-  }
-  if (lowered === "whoami") {
-    return {
-      type: "control",
-      name: "whoami"
-    };
-  }
-  if (lowered === "transcript") {
-    return {
-      type: "control",
-      name: "transcript"
-    };
-  }
-  if (lowered === "attach") {
-    return {
-      type: "control",
-      name: "attach"
-    };
-  }
-  if (lowered === "detach") {
-    return {
-      type: "control",
-      name: "detach"
-    };
-  }
-  if (lowered === "watch") {
-    const parsed = parseWatchCommand(withoutSlash.slice(command.length).trim());
-    if (parsed) {
-      return {
-        type: "control",
-        name: "watch",
-        intervalMs: parsed.intervalMs,
-        durationMs: parsed.durationMs
-      };
-    }
-    return {
-      type: "control",
-      name: "help"
-    };
-  }
-  if (lowered === "stop") {
-    return {
-      type: "control",
-      name: "stop"
-    };
-  }
-  if (lowered === "nudge") {
-    return {
-      type: "control",
-      name: "nudge"
-    };
-  }
-  if (lowered === "followup") {
-    const action = withoutSlash.slice(command.length).trim().toLowerCase();
-    if (!action || action === "status") {
-      return {
-        type: "control",
-        name: "followup",
-        action: "status"
-      };
-    }
-    if (action === "auto") {
-      return {
-        type: "control",
-        name: "followup",
-        action: "auto",
-        mode: "auto"
-      };
-    }
-    if (action === "mention-only") {
-      return {
-        type: "control",
-        name: "followup",
-        action: "mention-only",
-        mode: "mention-only"
-      };
-    }
-    if (action === "pause") {
-      return {
-        type: "control",
-        name: "followup",
-        action: "pause",
-        mode: "paused"
-      };
-    }
-    if (action === "resume") {
-      return {
-        type: "control",
-        name: "followup",
-        action: "resume"
-      };
-    }
-    return {
-      type: "control",
-      name: "followup",
-      action: "status"
-    };
-  }
-  if (lowered === "responsemode") {
-    const action = withoutSlash.slice(command.length).trim().toLowerCase();
-    if (!action || action === "status") {
-      return {
-        type: "control",
-        name: "responsemode",
-        action: "status"
-      };
-    }
-    if (action === "capture-pane" || action === "message-tool") {
-      return {
-        type: "control",
-        name: "responsemode",
-        action,
-        responseMode: action
-      };
-    }
-    return {
-      type: "control",
-      name: "responsemode",
-      action: "status"
-    };
-  }
-  if (lowered === "streaming") {
-    const action = withoutSlash.slice(command.length).trim().toLowerCase();
-    if (!action || action === "status") {
-      return {
-        type: "control",
-        name: "streaming",
-        action: "status"
-      };
-    }
-    if (action === "on") {
-      return {
-        type: "control",
-        name: "streaming",
-        action: "on",
-        streaming: "all"
-      };
-    }
-    if (action === "off" || action === "latest" || action === "all") {
-      return {
-        type: "control",
-        name: "streaming",
-        action,
-        streaming: action
-      };
-    }
-    return {
-      type: "control",
-      name: "streaming",
-      action: "status"
-    };
-  }
-  if (lowered === "additionalmessagemode") {
-    const action = withoutSlash.slice(command.length).trim().toLowerCase();
-    if (!action || action === "status") {
-      return {
-        type: "control",
-        name: "additionalmessagemode",
-        action: "status"
-      };
-    }
-    if (action === "queue" || action === "steer") {
-      return {
-        type: "control",
-        name: "additionalmessagemode",
-        action,
-        additionalMessageMode: action
-      };
-    }
-    return {
-      type: "control",
-      name: "additionalmessagemode",
-      action: "status"
-    };
-  }
-  if (lowered === "bash") {
-    return {
-      type: "bash",
-      command: withoutSlash.slice(command.length).trim(),
-      source: "slash"
-    };
-  }
-  if (lowered === "loop") {
-    const loopText = withoutSlash.slice(command.length).trim();
-    const loweredLoopText = loopText.toLowerCase();
-    if (!loweredLoopText || loweredLoopText === "help") {
-      return {
-        type: "control",
-        name: "loop-help"
-      };
-    }
-    if (loweredLoopText === "status") {
-      return {
-        type: "loop-control",
-        action: "status"
-      };
-    }
-    if (loweredLoopText === "cancel" || loweredLoopText.startsWith("cancel ")) {
-      const cancelArgs = loopText.slice("cancel".length).trim();
-      if (hasLoopFlag(cancelArgs, LOOP_FORCE_FLAG)) {
-        return {
-          type: "loop-error",
-          message: `Use \`/loop cancel --all ${LOOP_APP_FLAG}\` for app-wide cancellation.`
-        };
-      }
-      const all = hasLoopFlag(cancelArgs, LOOP_ALL_FLAG);
-      const app = hasLoopFlag(cancelArgs, LOOP_APP_FLAG);
-      if (app && !all) {
-        return {
-          type: "loop-error",
-          message: `\`${LOOP_APP_FLAG}\` only works with \`/loop cancel ${LOOP_ALL_FLAG}\`.`
-        };
-      }
-      const loopId = cancelArgs.split(/\s+/).map((token) => token.trim()).find((token) => token && token !== LOOP_ALL_FLAG && token !== LOOP_APP_FLAG);
-      return {
-        type: "loop-control",
-        action: "cancel",
-        loopId: loopId || undefined,
-        all,
-        app
-      };
-    }
-    const parsed = parseLoopSlashCommand(loopText);
-    if ("error" in parsed) {
-      return {
-        type: "loop-error",
-        message: parsed.error
-      };
-    }
-    return {
-      type: "loop",
-      params: parsed
-    };
-  }
-  if (lowered === "queue" || lowered === "q") {
-    const queueText = withoutSlash.slice(command.length).trim();
-    const normalizedQueueText = queueText.toLowerCase();
-    if (lowered === "queue") {
-      if (normalizedQueueText === "help") {
-        return {
-          type: "control",
-          name: "queue-help"
-        };
-      }
-      if (normalizedQueueText === "list") {
-        return {
-          type: "control",
-          name: "queue-list"
-        };
-      }
-      if (normalizedQueueText === "clear") {
-        return {
-          type: "control",
-          name: "queue-clear"
-        };
-      }
-    }
-    return {
-      type: "queue",
-      text: queueText
-    };
-  }
-  if (lowered === "queue-list" || lowered === "queuelist") {
-    return {
-      type: "control",
-      name: "queue-list"
-    };
-  }
-  if (lowered === "queue-clear" || lowered === "queueclear") {
-    return {
-      type: "control",
-      name: "queue-clear"
-    };
-  }
-  if (lowered === "steer" || lowered === "s") {
-    return {
-      type: "steer",
-      text: withoutSlash.slice(command.length).trim()
-    };
-  }
-  return {
-    type: "native",
-    text: normalized
-  };
-}
-function findMatchingPrefix(text, prefixes) {
-  return [...prefixes].sort((left, right) => right.length - left.length).find((prefix) => prefix.length > 0 && text.startsWith(prefix));
-}
-function normalizeSlashCommandName(command, botUsername) {
-  const lowered = command?.toLowerCase() ?? "";
-  const normalizedBotUsername = (botUsername ?? "").trim().toLowerCase().replace(/^@/, "");
-  if (!normalizedBotUsername) {
-    return lowered;
-  }
-  const suffix = `@${normalizedBotUsername}`;
-  if (!lowered.endsWith(suffix)) {
-    return lowered;
-  }
-  return lowered.slice(0, lowered.length - suffix.length);
-}
-function renderAgentControlSlashHelp() {
-  return [
-    "Slash commands",
-    "",
-    "- `/start`: show onboarding help for the current surface",
-    "- `/status`: show the current route status and operator setup commands",
-    "- `/help`: show available control slash commands",
-    "- `/whoami`: show the current platform, route, and sender identity details",
-    "- `/transcript`: show the current conversation session transcript when the route verbose policy allows it",
-    "- `/attach`: attach this thread to the active run and resume live updates when it is still processing",
-    "- `/detach`: stop live updates for this thread, switch to sparse progress updates, and still allow final settlement here",
-    "- `/watch every 30s [for 10m]`: post the latest state on an interval until the run settles or the watch window ends",
-    "- `/stop`: send Escape to interrupt the current conversation session",
-    "- `/nudge`: send one extra Enter to the current tmux session without resending the prompt text",
-    "- `/followup status`: show the current conversation follow-up policy",
-    "- `/followup auto`: allow natural follow-up after the bot has replied in-thread",
-    "- `/followup mention-only`: require explicit mention for each later turn",
-    "- `/followup pause`: stop passive follow-up until the next explicit mention",
-    "- `/followup resume`: clear the runtime override and restore config defaults",
-    "- `/streaming status|on|off|latest|all`: show or change streaming mode for this surface",
-    "- `/responsemode status`: show the configured response mode for this surface",
-    "- `/responsemode capture-pane`: settle replies from captured pane output for this surface",
-    "- `/responsemode message-tool`: expect the agent to reply through `clisbot message send` for this surface",
-    "- `/additionalmessagemode status`: show how extra messages behave while a run is already active",
-    "- `/additionalmessagemode steer`: send later user messages straight into the active session",
-    "- `/additionalmessagemode queue`: queue later user messages behind the active run for this surface",
-    "- `/queue <message>` or `\\q <message>`: enqueue a later message behind the active run and let clisbot deliver it in order",
-    "- `/queue help`: show queue-specific help and examples",
-    "- `/steer <message>` or `\\s <message>`: inject a steering message into the active run immediately",
-    "- `/queue list`: show queued messages that have not started yet",
-    "- `/queue clear`: clear queued messages that have not started yet",
-    "- `/loop help`: show loop-specific help and syntax examples",
-    ...renderLoopHelpLines(),
-    "- `/bash` followed by a shell command: requires `shellExecute` on the resolved agent role",
-    "- shortcut prefixes such as `!` run bash only when the resolved agent role allows `shellExecute`",
-    "",
-    "Other slash commands are forwarded to the agent unchanged."
-  ].join(`
-`);
-}
-function renderQueueHelpLines() {
-  return [
-    "- `/queue <message>` or `\\q <message>`: enqueue one later message behind the active run",
-    "- `/queue list`: show queued messages that have not started yet",
-    "- `/queue clear`: clear queued messages that have not started yet",
-    "- `/queue help`: show this queue help again",
-    "- `/steer <message>` or `\\s <message>`: inject an immediate steering message instead of queueing"
-  ];
-}
-function parseWatchCommand(raw) {
-  const match = raw.match(/^every\s+(\S+)(?:\s+for\s+(\S+))?$/i);
-  if (!match) {
-    return null;
-  }
-  const intervalMs = parseCommandDurationMs(match[1] ?? "");
-  if (!intervalMs) {
-    return null;
-  }
-  const durationToken = match[2];
-  const parsedDurationMs = durationToken ? parseCommandDurationMs(durationToken) : null;
-  if (durationToken && !parsedDurationMs) {
-    return null;
-  }
-  return {
-    intervalMs,
-    durationMs: parsedDurationMs ?? undefined
-  };
-}
-
 // src/channels/rendering.ts
 function buildRenderedMessageState(params) {
   const body = params.snapshot.trim() || (params.status === "completed" || params.status === "timeout" || params.status === "detached" ? params.previousState?.body ?? "" : "");
@@ -67706,6 +67930,9 @@ async function executePromptDelivery(params) {
       }
     });
     queueStartPending = positionAhead > 0 && (params.queueStartMode ?? "none") !== "none";
+    if (params.onPromptAccepted) {
+      await params.onPromptAccepted();
+    }
     if (previewEnabled) {
       const placeholderText = buildInitialPlaceholderText(positionAhead);
       const postedNew2 = await renderResponseText(placeholderText);
@@ -68375,9 +68602,12 @@ ${escapeCodeFence(shellResult.output)}
       return interactionResult;
     }
     await params.agentService.submitSessionInput(params.sessionTarget, buildSteeringPromptText({
-      text: explicitSteerMessage,
+      text: params.transformSessionInputText?.(explicitSteerMessage) ?? explicitSteerMessage,
       protectedControlMutationRule: params.protectedControlMutationRule
     }));
+    if (params.onPromptAccepted) {
+      await params.onPromptAccepted();
+    }
     await params.postText("Steered.");
     await params.agentService.recordConversationReply(params.sessionTarget);
     return {
@@ -68387,9 +68617,12 @@ ${escapeCodeFence(shellResult.output)}
   if (!forceQueuedDelivery && params.route.additionalMessageMode === "steer") {
     if (sessionBusy && canSteerActiveRun) {
       await params.agentService.submitSessionInput(params.sessionTarget, buildSteeringPromptText({
-        text: params.text,
+        text: params.transformSessionInputText?.(params.text) ?? params.text,
         protectedControlMutationRule: params.protectedControlMutationRule
       }));
+      if (params.onPromptAccepted) {
+        await params.onPromptAccepted();
+      }
       return {
         processingIndicatorLifecycle: "active-run"
       };
@@ -68408,7 +68641,8 @@ ${escapeCodeFence(shellResult.output)}
     reconcileText: params.reconcileText,
     observerId,
     timingContext: params.timingContext,
-    forceQueuedDelivery
+    forceQueuedDelivery,
+    onPromptAccepted: params.onPromptAccepted
   });
   return interactionResult;
 }
@@ -68463,6 +68697,16 @@ function isTelegramSenderAllowed(params) {
   return false;
 }
 
+// src/channels/mention-follow-up.ts
+function buildMentionOnlyFollowUpPrompt(params) {
+  const scope = params.threaded ? "this thread" : params.conversationKind === "dm" ? "this conversation" : "the recent conversation here";
+  return [
+    "The user explicitly mentioned you without any additional text.",
+    `Review the recent context in ${scope} and respond to the latest unresolved request.`,
+    "If the next step is still unclear, ask one short clarifying question."
+  ].join(" ");
+}
+
 // src/auth/resolve.ts
 function mergeRoleDefinitions(inherited, override) {
   return {
@@ -69219,13 +69463,21 @@ function canUseImplicitSlackFollowUp(params) {
   return params.conversationKind !== "dm" && typeof params.event.thread_ts === "string" && params.event.thread_ts.length > 0;
 }
 function hasBotMention(text, botUserId) {
-  if (!text) {
+  const mentions = extractSlackMentionedUserIds(text);
+  if (botUserId) {
+    return mentions.includes(botUserId);
+  }
+  return mentions.length > 0;
+}
+function hasForeignSlackUserMention(text, botUserId) {
+  const mentions = extractSlackMentionedUserIds(text);
+  if (mentions.length === 0) {
     return false;
   }
-  if (botUserId) {
-    return text.includes(`<@${botUserId}>`);
+  if (!botUserId) {
+    return true;
   }
-  return /<@[^>]+>/.test(text);
+  return !mentions.includes(botUserId);
 }
 function stripBotMention(text, botUserId) {
   if (!botUserId) {
@@ -69241,6 +69493,12 @@ function resolveSlackDirectReplyThreadTs(params) {
   const messageTs = (params.messageTs ?? "").trim();
   return messageTs || undefined;
 }
+function extractSlackMentionedUserIds(text) {
+  if (!text) {
+    return [];
+  }
+  return [...text.matchAll(/<@([A-Z0-9_]+)(?:\|[^>]+)?>/gi)].map((match) => match[1]?.trim()).filter((value) => Boolean(value));
+}
 
 // src/channels/slack/reactions.ts
 function normalizeSlackReactionName(value) {
@@ -69343,7 +69601,7 @@ function isSlackCommandLikeMessage(params) {
   }) !== null;
 }
 function renderSlackRouteChoiceMessage(params) {
-  const botHandle = params.botLabel?.trim() ? `@${params.botLabel.trim()}` : "@<botname>";
+  const botReference = params.botLabel?.trim() ? `mention this bot (${params.botLabel.trim()})` : "mention this bot";
   return [
     "clisbot: this Slack channel is not configured yet.",
     "",
@@ -69351,19 +69609,34 @@ function renderSlackRouteChoiceMessage(params) {
     `- \`clisbot channels add slack-channel ${params.channelId}\``,
     `- \`clisbot channels add slack-channel ${params.channelId} --agent <id>\``,
     "",
-    `After that, mention \`${botHandle} \\start\` or \`${botHandle} \\status\` here.`
+    `After that, ${botReference} and send \`\\start\` or \`\\status\` here.`
   ].join(`
 `);
 }
 function renderSlackMentionRequiredMessage(botLabel) {
-  const botHandle = botLabel?.trim() ? `@${botLabel.trim()}` : "@<botname>";
+  const botReference = botLabel?.trim() ? `mention this bot (${botLabel.trim()})` : "mention this bot";
   return [
     "clisbot: this Slack channel requires a bot mention for new commands.",
-    `Try \`${botHandle} \\start\` or \`${botHandle} \\status\` here.`,
+    `Try ${botReference} and send \`\\start\` or \`\\status\` here.`,
     "After the bot replies in a thread, normal follow-up messages there can continue according to the follow-up policy."
   ].join(`
 `);
 }
+function shouldSendSlackMentionRequiredGuidance(params) {
+  return params.conversationKind === "dm" && params.isCommandLike;
+}
+function shouldGuideUnroutedSlackEvent(params) {
+  if (params.isBotOriginated) {
+    return false;
+  }
+  if (!params.isCommandLike) {
+    return false;
+  }
+  if (params.conversationKind === "dm") {
+    return true;
+  }
+  return params.wasMentioned;
+}
 async function sendSlackGuidanceOnce(params) {
   if (!params.eventId) {
     await params.send();
@@ -70100,6 +70373,14 @@ class SlackSocketService {
       conversationKind: params.conversationKind,
       replyToMode: params.route.replyToMode
     });
+    if (hasForeignSlackUserMention(event.text ?? "", this.botUserId)) {
+      debugSlackEvent("drop-foreign-mention", {
+        eventId,
+        channelId
+      });
+      await this.processedEventsStore.markCompleted(eventId);
+      return;
+    }
     const explicitMention = params.wasMentioned || hasBotMention(event.text ?? "", this.botUserId);
     const followUpState = await this.agentService.getConversationFollowUpState(sessionTarget);
     const effectiveFollowUpMode = resolveFollowUpMode({
@@ -70115,12 +70396,27 @@ class SlackSocketService {
       lastBotReplyAt: followUpState.lastBotReplyAt,
       directReplyToBot: isImplicitBotThreadReply(event, this.botUserId)
     });
+    const rawText = explicitMention ? stripBotMention(event.text ?? "", this.botUserId) : `${event.text ?? ""}`.trim();
+    const recentMessageMarker = messageTs?.trim();
+    if (recentMessageMarker && (rawText || explicitMention)) {
+      await this.agentService.appendRecentConversationMessage(sessionTarget, {
+        marker: recentMessageMarker,
+        text: parseAgentCommand(rawText, {
+          commandPrefixes: params.route.commandPrefixes
+        }) ? "" : rawText,
+        senderId: typeof event.user === "string" ? event.user.trim().toUpperCase() : undefined
+      });
+    }
     if (requiresMention && !wasMentioned) {
-      if (isSlackCommandLikeMessage({
+      const isCommandLike = isSlackCommandLikeMessage({
         text: event.text ?? "",
         botUserId: this.botUserId,
         botUsername: this.botLabel,
         commandPrefixes: params.route.commandPrefixes
+      });
+      if (shouldSendSlackMentionRequiredGuidance({
+        conversationKind: params.conversationKind,
+        isCommandLike
       })) {
         try {
           await postSlackText(this.app.client, {
@@ -70137,6 +70433,7 @@ class SlackSocketService {
         channelId,
         requiresMention,
         explicitMention,
+        isCommandLike,
         effectiveFollowUpMode
       });
       await this.processedEventsStore.markCompleted(eventId);
@@ -70145,7 +70442,10 @@ class SlackSocketService {
     if (explicitMention && followUpState.overrideMode === "paused") {
       await this.agentService.reactivateConversationFollowUp(sessionTarget);
     }
-    const rawText = explicitMention ? stripBotMention(event.text ?? "", this.botUserId) : `${event.text ?? ""}`.trim();
+    const effectivePromptText = rawText || (explicitMention ? buildMentionOnlyFollowUpPrompt({
+      conversationKind: params.conversationKind,
+      threaded: Boolean(threadTs)
+    }) : "");
     const attachmentPaths = await resolveSlackAttachmentPaths({
       client: this.app.client,
       event,
@@ -70157,12 +70457,19 @@ class SlackSocketService {
       sessionKey: sessionTarget.sessionKey,
       messageId: messageTs ?? threadTs ?? `${Date.now()}`
     });
-    const text = prependAttachmentMentions(rawText, attachmentPaths);
+    const text = prependAttachmentMentions(effectivePromptText, attachmentPaths);
     if (!text) {
       debugSlackEvent("drop-empty-text", { eventId, channelId });
       await this.processedEventsStore.markCompleted(eventId);
       return;
     }
+    const recentConversationReplay = recentMessageMarker ? await this.agentService.getRecentConversationReplayMessages(sessionTarget, {
+      excludeMarker: recentMessageMarker
+    }) : [];
+    const enrichPromptText = (nextText) => prependRecentConversationContext({
+      currentText: nextText,
+      recentMessages: recentConversationReplay
+    });
     debugSlackEvent("process-message", {
       eventId,
       channelId,
@@ -70197,7 +70504,7 @@ class SlackSocketService {
     });
     const protectedControlMutationRule = auth.mayManageProtectedResources ? undefined : DEFAULT_PROTECTED_CONTROL_RULE;
     const agentPromptText = buildAgentPromptText({
-      text,
+      text: enrichPromptText(text),
       identity,
       config: this.loadedConfig.raw.channels.slack.agentPrompt,
       cliTool,
@@ -70250,7 +70557,7 @@ class SlackSocketService {
         text,
         agentPromptText,
         agentPromptBuilder: (nextText) => buildAgentPromptText({
-          text: nextText,
+          text: enrichPromptText(nextText),
           identity,
           config: this.loadedConfig.raw.channels.slack.agentPrompt,
           cliTool,
@@ -70259,6 +70566,10 @@ class SlackSocketService {
           protectedControlMutationRule
         }),
         protectedControlMutationRule,
+        transformSessionInputText: enrichPromptText,
+        onPromptAccepted: recentMessageMarker ? async () => {
+          await this.agentService.markRecentConversationProcessed(sessionTarget, recentMessageMarker);
+        } : undefined,
         route: params.route,
         maxChars: this.getSlackMaxChars(params.route.agentId),
         timingContext,
@@ -70323,6 +70634,13 @@ class SlackSocketService {
       const resolvedRoute = resolveSlackConversationRoute(this.loadedConfig, normalizedEvent, { accountId: this.accountId });
       const route = resolvedRoute.route;
       if (!route) {
+        if (isBotOriginatedSlackEvent(normalizedEvent) && !this.loadedConfig.raw.channels.slack.allowBots) {
+          debugSlackEvent("drop-unrouted-bot-mention", {
+            eventId: body.event_id,
+            allowBots: this.loadedConfig.raw.channels.slack.allowBots
+          });
+          return;
+        }
         try {
           await this.maybeGuideUnroutedSlackEvent({
             eventId: body.event_id,
@@ -70358,11 +70676,16 @@ class SlackSocketService {
       const resolvedRoute = resolveSlackConversationRoute(this.loadedConfig, normalizedEvent, { accountId: this.accountId });
       const route = resolvedRoute.route;
       if (!route) {
-        const shouldGuide = isSlackCommandLikeMessage({
-          text: normalizedEvent.text ?? "",
-          botUserId: this.botUserId,
-          botUsername: this.botLabel,
-          commandPrefixes: this.loadedConfig.raw.channels.slack.commandPrefixes
+        const shouldGuide = shouldGuideUnroutedSlackEvent({
+          conversationKind: resolvedRoute.conversationKind,
+          isCommandLike: isSlackCommandLikeMessage({
+            text: normalizedEvent.text ?? "",
+            botUserId: this.botUserId,
+            botUsername: this.botLabel,
+            commandPrefixes: this.loadedConfig.raw.channels.slack.commandPrefixes
+          }),
+          wasMentioned: hasBotMention(normalizedEvent.text ?? "", this.botUserId),
+          isBotOriginated: isBotOriginatedSlackEvent(normalizedEvent) && !this.loadedConfig.raw.channels.slack.allowBots
         });
         if (shouldGuide) {
           try {
@@ -70433,6 +70756,399 @@ class SlackSocketService {
 var import_bolt = __toESM(require_dist7(), 1);
 import { basename } from "node:path";
 import { readFile as readFile2 } from "node:fs/promises";
+
+// src/channels/slack/content.ts
+var SLACK_MAX_BLOCKS = 50;
+function normalizeMarkdownLinks(text) {
+  return text.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_match, label, href) => {
+    const trimmedHref = href.trim();
+    if (!trimmedHref) {
+      return label;
+    }
+    return `<${trimmedHref}|${label}>`;
+  });
+}
+function renderInlineMarkdownToSlackMrkdwn(text) {
+  return normalizeMarkdownLinks(text).replace(/~~([^~]+)~~/g, "~$1~").replace(/\*\*([^*\n][\s\S]*?[^*\n])\*\*/g, "*$1*");
+}
+function stripMarkdownInline(text) {
+  return text.replace(/`([^`\n]+)`/g, "$1").replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, "$1").replace(/\*\*([^*\n][\s\S]*?[^*\n])\*\*/g, "$1").replace(/\*([^*\n][\s\S]*?[^*\n])\*/g, "$1").replace(/~~([^~]+)~~/g, "$1").trim();
+}
+function normalizeSlackHeaderText(text) {
+  const normalized = stripMarkdownInline(text);
+  if (!normalized) {
+    return "Untitled";
+  }
+  return normalized.slice(0, 150);
+}
+function buildSlackBlocksFallbackText(blocks) {
+  for (const block of blocks) {
+    if (typeof block !== "object" || !block) {
+      continue;
+    }
+    const text = block.text?.text;
+    if (typeof text === "string" && text.trim()) {
+      return stripMarkdownInline(text).replace(/\s+/g, " ").trim();
+    }
+    const elements = block.elements;
+    if (!Array.isArray(elements)) {
+      continue;
+    }
+    for (const element of elements) {
+      if (typeof element?.text === "string" && element.text.trim()) {
+        return stripMarkdownInline(element.text).replace(/\s+/g, " ").trim();
+      }
+    }
+    const rows = block.rows;
+    if (!Array.isArray(rows) || rows.length === 0) {
+      continue;
+    }
+    const firstRow = rows[0];
+    if (!Array.isArray(firstRow)) {
+      continue;
+    }
+    const rowText = firstRow.map((cell) => {
+      if (!cell || typeof cell !== "object") {
+        return "";
+      }
+      const rawText = cell.text;
+      return typeof rawText === "string" ? stripMarkdownInline(rawText) : "";
+    }).filter(Boolean).join(" | ").trim();
+    if (rowText) {
+      return rowText;
+    }
+  }
+  return "Shared a Block Kit message";
+}
+function validateSlackBlocksArray(raw) {
+  if (!Array.isArray(raw)) {
+    throw new Error("Slack blocks input must be a JSON array");
+  }
+  if (raw.length === 0) {
+    throw new Error("Slack blocks input cannot be empty");
+  }
+  if (raw.length > SLACK_MAX_BLOCKS) {
+    throw new Error(`Slack blocks cannot exceed ${SLACK_MAX_BLOCKS} items`);
+  }
+  for (const block of raw) {
+    if (!block || typeof block !== "object" || Array.isArray(block)) {
+      throw new Error("Each Slack block must be an object");
+    }
+    const type = block.type;
+    if (typeof type !== "string" || !type.trim()) {
+      throw new Error("Each Slack block must include a non-empty string type");
+    }
+  }
+  return raw;
+}
+function parseSlackBlocksInput(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new Error("Slack blocks input must be valid JSON");
+  }
+  return validateSlackBlocksArray(parsed);
+}
+function renderMarkdownToSlackMrkdwn(markdown) {
+  const normalized = markdown.replaceAll(`\r
+`, `
+`).replaceAll("\r", `
+`).trim();
+  if (!normalized) {
+    return "";
+  }
+  return normalized.split(`
+`).map((line) => {
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      const level = headingMatch[1]?.length ?? 1;
+      const content = renderInlineMarkdownToSlackMrkdwn(headingMatch[2] ?? "");
+      if (level <= 3) {
+        return `*${content}*`;
+      }
+      return content;
+    }
+    const bulletMatch = line.match(/^\s*[-*+]\s+(.+)$/);
+    if (bulletMatch) {
+      return `• ${renderInlineMarkdownToSlackMrkdwn(bulletMatch[1] ?? "")}`;
+    }
+    const orderedMatch = line.match(/^\s*(\d+)\.\s+(.+)$/);
+    if (orderedMatch) {
+      return `${orderedMatch[1]}. ${renderInlineMarkdownToSlackMrkdwn(orderedMatch[2] ?? "")}`;
+    }
+    return renderInlineMarkdownToSlackMrkdwn(line);
+  }).join(`
+`);
+}
+function splitMarkdownTableCells(line) {
+  return line.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim());
+}
+function isMarkdownTableSeparator(line) {
+  const cells = splitMarkdownTableCells(line);
+  return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+}
+function isMarkdownTableLine(line) {
+  const trimmed = line.trim();
+  return trimmed.includes("|") && splitMarkdownTableCells(trimmed).length >= 2;
+}
+function renderSlackTableRow(headers, row) {
+  if (headers.length === 2 && row.length >= 2) {
+    return `*${renderInlineMarkdownToSlackMrkdwn(row[0] ?? "")}*: ${renderInlineMarkdownToSlackMrkdwn(row[1] ?? "")}`;
+  }
+  return headers.map((header, index) => {
+    const value = row[index] ?? "";
+    return `*${renderInlineMarkdownToSlackMrkdwn(header)}:* ${renderInlineMarkdownToSlackMrkdwn(value)}`;
+  }).join(" • ");
+}
+function normalizeSlackTableCellText(text) {
+  return stripMarkdownInline(text).slice(0, 3000);
+}
+function buildSlackTableCell(text) {
+  return {
+    type: "raw_text",
+    text: normalizeSlackTableCellText(text)
+  };
+}
+function renderMarkdownTableToNativeSlackBlock(headers, rows) {
+  if (headers.length === 0 || rows.length === 0) {
+    return null;
+  }
+  return {
+    type: "table",
+    column_settings: headers.map((_header, index) => ({
+      is_wrapped: index === 0
+    })),
+    rows: [headers, ...rows].map((row) => row.map((cell) => buildSlackTableCell(cell)))
+  };
+}
+function renderMarkdownTableToFallbackSlackBlock(headers, rows) {
+  if (headers.length === 0 || rows.length === 0) {
+    return null;
+  }
+  const text = rows.map((row) => renderSlackTableRow(headers, row)).filter(Boolean).join(`
+`);
+  if (!text.trim()) {
+    return null;
+  }
+  return {
+    type: "section",
+    text: {
+      type: "mrkdwn",
+      text
+    }
+  };
+}
+function renderMarkdownToSlackBlocks(markdown) {
+  const normalized = markdown.replaceAll(`\r
+`, `
+`).replaceAll("\r", `
+`).trim();
+  if (!normalized) {
+    return [];
+  }
+  const blocks = [];
+  const lines = normalized.split(`
+`);
+  const firstHeadingLineIndex = lines.findIndex((line) => /^(#{1,6})\s+.+$/.test(line));
+  const paragraph = [];
+  const codeLines = [];
+  let inCodeFence = false;
+  let hasVisibleContent = false;
+  let hasSeenHeading = false;
+  let majorHeadingCount = 0;
+  let hasNativeTableBlock = false;
+  const pushBlock = (block) => {
+    blocks.push(block);
+    hasVisibleContent = true;
+  };
+  const pushDividerIfNeeded = () => {
+    if (!hasVisibleContent) {
+      return;
+    }
+    const lastBlock = blocks[blocks.length - 1];
+    if (lastBlock?.type === "divider") {
+      return;
+    }
+    blocks.push({ type: "divider" });
+  };
+  const flushParagraph = () => {
+    if (paragraph.length === 0) {
+      return;
+    }
+    const text = paragraph.join(`
+`).trim();
+    if (text) {
+      const shouldRenderAsPreamble = !hasSeenHeading && firstHeadingLineIndex > 0 && blocks.length === 0;
+      pushBlock({
+        ...shouldRenderAsPreamble ? {
+          type: "context",
+          elements: [
+            {
+              type: "mrkdwn",
+              text
+            }
+          ]
+        } : {
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text
+          }
+        }
+      });
+    }
+    paragraph.length = 0;
+  };
+  const flushCodeFence = () => {
+    if (codeLines.length === 0) {
+      return;
+    }
+    pushBlock({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `\`\`\`
+${codeLines.join(`
+`)}
+\`\`\``
+      }
+    });
+    codeLines.length = 0;
+  };
+  for (let lineIndex = 0;lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex] ?? "";
+    const fenceMatch = line.match(/^```([^\n`]*)$/);
+    if (fenceMatch) {
+      if (inCodeFence) {
+        flushCodeFence();
+        inCodeFence = false;
+      } else {
+        flushParagraph();
+        inCodeFence = true;
+      }
+      continue;
+    }
+    if (inCodeFence) {
+      codeLines.push(line);
+      continue;
+    }
+    if (line.trim().length === 0) {
+      flushParagraph();
+      continue;
+    }
+    const nextLine = lines[lineIndex + 1] ?? "";
+    if (isMarkdownTableLine(line) && isMarkdownTableSeparator(nextLine)) {
+      flushParagraph();
+      const headers = splitMarkdownTableCells(line);
+      const rows = [];
+      lineIndex += 2;
+      while (lineIndex < lines.length) {
+        const tableLine = lines[lineIndex] ?? "";
+        if (!tableLine.trim() || !isMarkdownTableLine(tableLine)) {
+          lineIndex -= 1;
+          break;
+        }
+        rows.push(splitMarkdownTableCells(tableLine));
+        lineIndex += 1;
+      }
+      const tableBlock = !hasNativeTableBlock ? renderMarkdownTableToNativeSlackBlock(headers, rows) : renderMarkdownTableToFallbackSlackBlock(headers, rows);
+      if (tableBlock) {
+        pushBlock(tableBlock);
+        if (tableBlock.type === "table") {
+          hasNativeTableBlock = true;
+        }
+      }
+      continue;
+    }
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      flushParagraph();
+      hasSeenHeading = true;
+      const level = headingMatch[1]?.length ?? 1;
+      const content = headingMatch[2] ?? "";
+      if (level <= 2) {
+        if (majorHeadingCount > 0) {
+          pushDividerIfNeeded();
+        }
+        pushBlock({
+          type: "header",
+          text: {
+            type: "plain_text",
+            text: normalizeSlackHeaderText(content)
+          }
+        });
+        majorHeadingCount += 1;
+      } else if (level === 3) {
+        pushBlock({
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text: `*${renderInlineMarkdownToSlackMrkdwn(content)}*`
+          }
+        });
+      } else {
+        paragraph.push(`*${renderInlineMarkdownToSlackMrkdwn(content)}*`);
+      }
+      continue;
+    }
+    const bulletMatch = line.match(/^\s*[-*+]\s+(.+)$/);
+    if (bulletMatch) {
+      paragraph.push(`• ${renderInlineMarkdownToSlackMrkdwn(bulletMatch[1] ?? "")}`);
+      continue;
+    }
+    const orderedMatch = line.match(/^\s*(\d+)\.\s+(.+)$/);
+    if (orderedMatch) {
+      paragraph.push(`${orderedMatch[1]}. ${renderInlineMarkdownToSlackMrkdwn(orderedMatch[2] ?? "")}`);
+      continue;
+    }
+    paragraph.push(renderInlineMarkdownToSlackMrkdwn(line));
+  }
+  if (inCodeFence) {
+    flushCodeFence();
+  }
+  flushParagraph();
+  return blocks;
+}
+function resolveSlackMessageContent(params) {
+  const { text, inputFormat, renderMode } = params;
+  if (inputFormat === "blocks") {
+    if (renderMode !== "none" && renderMode !== "blocks") {
+      throw new Error("Slack blocks input supports only --render none or --render blocks");
+    }
+    const blocks = parseSlackBlocksInput(text);
+    return {
+      text: buildSlackBlocksFallbackText(blocks),
+      blocks,
+      apiText: "​"
+    };
+  }
+  if (inputFormat === "html") {
+    throw new Error("Slack does not support HTML input; use --input md, mrkdwn, plain, or blocks");
+  }
+  if (renderMode === "blocks") {
+    const blocks = renderMarkdownToSlackBlocks(text);
+    return {
+      text: buildSlackBlocksFallbackText(blocks),
+      blocks,
+      apiText: "​"
+    };
+  }
+  if (renderMode === "html") {
+    throw new Error("Slack does not support --render html");
+  }
+  if (inputFormat === "mrkdwn" || renderMode === "mrkdwn") {
+    return { text };
+  }
+  if (inputFormat === "md" || renderMode === "native") {
+    return {
+      text: renderMarkdownToSlackMrkdwn(text)
+    };
+  }
+  return { text };
+}
+
+// src/channels/slack/message-actions.ts
 var { WebClient } = import_bolt.webApi;
 function createSlackClient(botToken) {
   return new WebClient(botToken);
@@ -70500,13 +71216,18 @@ async function loadSlackMedia(media) {
 async function sendSlackMessage(params) {
   const client = createSlackClient(params.botToken);
   const target = await resolveSlackTarget(client, params.target, params.threadId, params.replyTo);
+  const resolvedMessage = resolveSlackMessageContent({
+    text: params.message ?? "",
+    inputFormat: params.inputFormat ?? "md",
+    renderMode: params.renderMode ?? "native"
+  });
   if (params.media) {
     const media = await loadSlackMedia(params.media);
     const filesClient = client.files;
     await filesClient.uploadV2({
       channel_id: target.channelId,
       thread_ts: target.threadTs,
-      initial_comment: params.message,
+      initial_comment: resolvedMessage.text,
       filename: media.filename,
       file: media.data
     });
@@ -70518,10 +71239,20 @@ async function sendSlackMessage(params) {
       filename: media.filename
     };
   }
-  const posted = await postSlackText(client, {
+  const posted = resolvedMessage.blocks ? [
+    {
+      text: resolvedMessage.text,
+      ts: (await client.chat.postMessage({
+        channel: target.channelId,
+        thread_ts: target.threadTs,
+        text: resolvedMessage.apiText ?? resolvedMessage.text,
+        blocks: resolvedMessage.blocks
+      })).ts ?? ""
+    }
+  ].filter((entry) => entry.ts) : await postSlackText(client, {
     channel: target.channelId,
     threadTs: target.threadTs,
-    text: params.message ?? ""
+    text: resolvedMessage.text
   });
   return {
     ok: true,
@@ -70583,10 +71314,16 @@ async function editSlackMessage(params) {
   }
   const client = createSlackClient(params.botToken);
   const target = await resolveSlackTarget(client, params.target);
+  const resolvedMessage = resolveSlackMessageContent({
+    text: params.message,
+    inputFormat: params.inputFormat ?? "md",
+    renderMode: params.renderMode ?? "native"
+  });
   await client.chat.update({
     channel: target.channelId,
     ts: params.messageId,
-    text: params.message
+    text: resolvedMessage.apiText ?? resolvedMessage.text,
+    ...resolvedMessage.blocks ? { blocks: resolvedMessage.blocks } : {}
   });
   return { ok: true };
 }
@@ -70780,7 +71517,9 @@ var slackChannelPlugin = {
       limit: command.limit,
       query: command.query,
       pollQuestion: command.pollQuestion,
-      pollOptions: command.pollOptions
+      pollOptions: command.pollOptions,
+      inputFormat: command.inputFormat,
+      renderMode: command.renderMode
     };
     switch (command.action) {
       case "send":
@@ -70924,8 +71663,18 @@ function hasTelegramBotMention(text, botUsername) {
   if (!text || !normalizedBotUsername) {
     return false;
   }
-  const pattern = new RegExp(`(^|\\s)@${escapeRegExp2(normalizedBotUsername)}\\b`, "i");
-  return pattern.test(text);
+  return extractTelegramMentionTargets(text).includes(normalizedBotUsername.toLowerCase());
+}
+function hasForeignTelegramMention(text, botUsername) {
+  const mentions = extractTelegramMentionTargets(text);
+  if (mentions.length === 0) {
+    return false;
+  }
+  const normalizedBotUsername = (botUsername ?? "").trim().replace(/^@/, "").toLowerCase();
+  if (!normalizedBotUsername) {
+    return true;
+  }
+  return !mentions.includes(normalizedBotUsername);
 }
 function stripTelegramBotMention(text, botUsername) {
   const normalizedBotUsername = (botUsername ?? "").trim().replace(/^@/, "");
@@ -70944,6 +71693,27 @@ function isReplyToTelegramBot(message, botUserId) {
 function escapeRegExp2(raw) {
   return raw.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function extractTelegramMentionTargets(text) {
+  if (!text) {
+    return [];
+  }
+  const matches = new Set;
+  const mentionPattern = /(^|\s)@([A-Za-z0-9_]{2,32})\b/g;
+  const slashCommandTargetPattern = /(^|\s)\/[A-Za-z0-9_]+@([A-Za-z0-9_]{2,32})\b/g;
+  for (const match of text.matchAll(mentionPattern)) {
+    const username = match[2]?.trim().toLowerCase();
+    if (username) {
+      matches.add(username);
+    }
+  }
+  for (const match of text.matchAll(slashCommandTargetPattern)) {
+    const username = match[2]?.trim().toLowerCase();
+    if (username) {
+      matches.add(username);
+    }
+  }
+  return [...matches];
+}
 
 // src/channels/telegram/session-routing.ts
 function resolveTelegramConversationTarget(params) {
@@ -71075,6 +71845,20 @@ async function paceTelegramEdit(params) {
 function recordTelegramEdit(params) {
   lastTelegramEditAtByMessage.set(getTelegramEditKey(params), Date.now());
 }
+function buildTelegramTextPayload(params) {
+  if (params.wireFormat !== "html") {
+    return {
+      text: params.text
+    };
+  }
+  return {
+    text: params.text,
+    parseMode: "HTML"
+  };
+}
+function isTelegramHtmlParseError(error) {
+  return error instanceof TelegramApiError && error.errorCode === 400 && /can't parse entities|unsupported start tag|unexpected end tag|entity beginning/i.test(error.description);
+}
 function splitTelegramText(text, maxChars = 3900) {
   if (!text) {
     return [];
@@ -71109,83 +71893,136 @@ function splitTelegramText(text, maxChars = 3900) {
 }
 async function postTelegramText(params) {
   const posted = [];
-  const chunks = splitTelegramText(params.text);
-  for (const chunk of chunks) {
-    const response = await callTelegramApi(params.token, "sendMessage", {
-      chat_id: params.chatId,
-      text: chunk,
-      ...params.topicId != null && !params.omitThreadId ? { message_thread_id: params.topicId } : {}
-    });
-    posted.push({
-      text: chunk,
-      messageId: response.message_id
-    });
+  const rawChunks = splitTelegramText(params.text);
+  try {
+    for (const chunk of rawChunks) {
+      const payload = buildTelegramTextPayload({
+        text: chunk,
+        wireFormat: params.wireFormat
+      });
+      const response = await callTelegramApi(params.token, "sendMessage", {
+        chat_id: params.chatId,
+        text: payload.text,
+        ...payload.parseMode ? { parse_mode: payload.parseMode } : {},
+        ...params.topicId != null && !params.omitThreadId ? { message_thread_id: params.topicId } : {}
+      });
+      posted.push({
+        text: payload.text,
+        messageId: response.message_id
+      });
+    }
+  } catch (error) {
+    if (params.wireFormat !== "html" || !isTelegramHtmlParseError(error)) {
+      throw error;
+    }
+    for (const chunk of posted) {
+      await callTelegramApi(params.token, "deleteMessage", {
+        chat_id: params.chatId,
+        message_id: chunk.messageId
+      });
+      lastTelegramEditAtByMessage.delete(getTelegramEditKey({
+        token: params.token,
+        chatId: params.chatId,
+        messageId: chunk.messageId
+      }));
+    }
+    posted.length = 0;
+    for (const chunk of rawChunks) {
+      const response = await callTelegramApi(params.token, "sendMessage", {
+        chat_id: params.chatId,
+        text: chunk,
+        ...params.topicId != null && !params.omitThreadId ? { message_thread_id: params.topicId } : {}
+      });
+      posted.push({
+        text: chunk,
+        messageId: response.message_id
+      });
+    }
   }
   return posted;
 }
 async function reconcileTelegramText(params) {
-  const nextTexts = splitTelegramText(params.text);
-  const reconciled = [];
-  const sharedCount = Math.min(params.chunks.length, nextTexts.length);
-  for (let index = 0;index < sharedCount; index += 1) {
-    const existingChunk = params.chunks[index];
-    const nextText = nextTexts[index];
-    if (!existingChunk || !nextText) {
-      continue;
-    }
-    if (existingChunk.text !== nextText) {
-      await paceTelegramEdit({
-        token: params.token,
-        chatId: params.chatId,
+  const rawNextTexts = splitTelegramText(params.text);
+  const reconcileWithTexts = async (nextTexts, parseMode) => {
+    const reconciled = [];
+    const sharedCount = Math.min(params.chunks.length, nextTexts.length);
+    for (let index = 0;index < sharedCount; index += 1) {
+      const existingChunk = params.chunks[index];
+      const nextText = nextTexts[index];
+      if (!existingChunk || !nextText) {
+        continue;
+      }
+      if (existingChunk.text !== nextText) {
+        await paceTelegramEdit({
+          token: params.token,
+          chatId: params.chatId,
+          messageId: existingChunk.messageId
+        });
+        await callTelegramApi(params.token, "editMessageText", {
+          chat_id: params.chatId,
+          message_id: existingChunk.messageId,
+          text: nextText,
+          ...parseMode ? { parse_mode: parseMode } : {}
+        });
+        recordTelegramEdit({
+          token: params.token,
+          chatId: params.chatId,
+          messageId: existingChunk.messageId
+        });
+      }
+      reconciled.push({
+        text: nextText,
         messageId: existingChunk.messageId
       });
-      await callTelegramApi(params.token, "editMessageText", {
+    }
+    for (let index = sharedCount;index < nextTexts.length; index += 1) {
+      const nextText = nextTexts[index];
+      if (!nextText) {
+        continue;
+      }
+      const response = await callTelegramApi(params.token, "sendMessage", {
         chat_id: params.chatId,
-        message_id: existingChunk.messageId,
-        text: nextText
+        text: nextText,
+        ...parseMode ? { parse_mode: parseMode } : {},
+        ...params.topicId != null && !params.omitThreadId ? { message_thread_id: params.topicId } : {}
       });
-      recordTelegramEdit({
-        token: params.token,
-        chatId: params.chatId,
-        messageId: existingChunk.messageId
+      reconciled.push({
+        text: nextText,
+        messageId: response.message_id
       });
     }
-    reconciled.push({
-      text: nextText,
-      messageId: existingChunk.messageId
-    });
-  }
-  for (let index = sharedCount;index < nextTexts.length; index += 1) {
-    const nextText = nextTexts[index];
-    if (!nextText) {
-      continue;
+    for (let index = nextTexts.length;index < params.chunks.length; index += 1) {
+      const staleChunk = params.chunks[index];
+      if (!staleChunk) {
+        continue;
+      }
+      await callTelegramApi(params.token, "deleteMessage", {
+        chat_id: params.chatId,
+        message_id: staleChunk.messageId
+      });
+      lastTelegramEditAtByMessage.delete(getTelegramEditKey({
+        token: params.token,
+        chatId: params.chatId,
+        messageId: staleChunk.messageId
+      }));
     }
-    const response = await callTelegramApi(params.token, "sendMessage", {
-      chat_id: params.chatId,
-      text: nextText,
-      ...params.topicId != null && !params.omitThreadId ? { message_thread_id: params.topicId } : {}
-    });
-    reconciled.push({
-      text: nextText,
-      messageId: response.message_id
-    });
+    return reconciled;
+  };
+  if (params.wireFormat !== "html") {
+    return await reconcileWithTexts(rawNextTexts);
   }
-  for (let index = nextTexts.length;index < params.chunks.length; index += 1) {
-    const staleChunk = params.chunks[index];
-    if (!staleChunk) {
-      continue;
+  try {
+    const renderedTexts = rawNextTexts.map((text) => buildTelegramTextPayload({
+      text,
+      wireFormat: params.wireFormat
+    }).text);
+    return await reconcileWithTexts(renderedTexts, "HTML");
+  } catch (error) {
+    if (!isTelegramHtmlParseError(error)) {
+      throw error;
     }
-    await callTelegramApi(params.token, "deleteMessage", {
-      chat_id: params.chatId,
-      message_id: staleChunk.messageId
-    });
-    lastTelegramEditAtByMessage.delete(getTelegramEditKey({
-      token: params.token,
-      chatId: params.chatId,
-      messageId: staleChunk.messageId
-    }));
+    return await reconcileWithTexts(rawNextTexts);
   }
-  return reconciled;
 }
 function shouldOmitTelegramThreadId(topicId) {
   return topicId === 1;
@@ -71194,6 +72031,235 @@ function getTelegramMaxChars(maxMessageChars) {
   return Math.min(maxMessageChars, 3900);
 }
 
+// src/channels/telegram/html-safe.ts
+var TOKEN_PREFIX = "\x00TGH";
+function escapeHtml(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function sanitizeTelegramHref(rawHref) {
+  const href = rawHref.trim();
+  if (!href) {
+    return null;
+  }
+  const lowered = href.toLowerCase();
+  if (lowered.startsWith("http://") || lowered.startsWith("https://") || lowered.startsWith("tg://") || lowered.startsWith("mailto:")) {
+    return escapeHtml(href);
+  }
+  return null;
+}
+function storeToken(tokens, value) {
+  const token = `${TOKEN_PREFIX}${tokens.length};\x00`;
+  tokens.push(value);
+  return token;
+}
+function restoreTokens(text, tokens) {
+  let restored = text;
+  for (let index = 0;index < tokens.length; index += 1) {
+    restored = restored.replaceAll(`${TOKEN_PREFIX}${index};\x00`, tokens[index] ?? "");
+  }
+  return restored;
+}
+function applyInlineFormatting(text) {
+  return text.replaceAll(/~~([^~]+)~~/g, "<s>$1</s>").replaceAll(/\*\*([^*\n][\s\S]*?[^*\n])\*\*/g, "<b>$1</b>").replaceAll(/\*([^*\n][\s\S]*?[^*\n])\*/g, "<i>$1</i>");
+}
+function renderInlineMarkdownToTelegramHtml(text) {
+  const tokens = [];
+  let working = text;
+  working = working.replaceAll(/`([^`\n]+)`/g, (_match, code) => storeToken(tokens, `<code>${escapeHtml(code)}</code>`));
+  working = working.replaceAll(/\[([^\]]+)\]\(([^)\s]+)\)/g, (match, label, href) => {
+    const safeHref = sanitizeTelegramHref(href);
+    if (!safeHref) {
+      return match;
+    }
+    return storeToken(tokens, `<a href="${safeHref}">${escapeHtml(label)}</a>`);
+  });
+  working = escapeHtml(working);
+  working = applyInlineFormatting(working);
+  return restoreTokens(working, tokens);
+}
+function renderHeadingLine(level, content) {
+  const renderedContent = renderInlineMarkdownToTelegramHtml(content);
+  if (level <= 2) {
+    return {
+      kind: "section-heading",
+      text: `<b>${renderedContent}</b>`
+    };
+  }
+  if (level === 3) {
+    return {
+      kind: "subsection-heading",
+      text: `<b>${renderedContent}</b>`
+    };
+  }
+  return {
+    kind: "text",
+    text: renderedContent
+  };
+}
+function renderMarkdownLine(line) {
+  if (line.trim().length === 0) {
+    return { kind: "blank", text: "" };
+  }
+  const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+  if (headingMatch) {
+    return renderHeadingLine(headingMatch[1]?.length ?? 1, headingMatch[2] ?? "");
+  }
+  const bulletMatch = line.match(/^\s*[-*+]\s+(.+)$/);
+  if (bulletMatch) {
+    return {
+      kind: "text",
+      text: `• ${renderInlineMarkdownToTelegramHtml(bulletMatch[1] ?? "")}`
+    };
+  }
+  const orderedMatch = line.match(/^\s*(\d+)\.\s+(.+)$/);
+  if (orderedMatch) {
+    return {
+      kind: "text",
+      text: `${orderedMatch[1]}. ${renderInlineMarkdownToTelegramHtml(orderedMatch[2] ?? "")}`
+    };
+  }
+  const quoteMatch = line.match(/^\s*>\s?(.*)$/);
+  if (quoteMatch) {
+    return {
+      kind: "text",
+      text: `&gt; ${renderInlineMarkdownToTelegramHtml(quoteMatch[1] ?? "")}`
+    };
+  }
+  return {
+    kind: "text",
+    text: renderInlineMarkdownToTelegramHtml(line)
+  };
+}
+function renderMarkdownTextBlock(text) {
+  const lines = text.split(`
+`).map(renderMarkdownLine);
+  const rendered = [];
+  const ensureBlankSeparator = () => {
+    if (rendered.length === 0 || rendered[rendered.length - 1] === "") {
+      return;
+    }
+    rendered.push("");
+  };
+  const hasLaterVisibleLine = (startIndex) => lines.slice(startIndex + 1).some((line) => line.kind !== "blank");
+  for (let index = 0;index < lines.length; index += 1) {
+    const line = lines[index];
+    if (!line) {
+      continue;
+    }
+    if (line.kind === "blank") {
+      ensureBlankSeparator();
+      continue;
+    }
+    if (line.kind === "section-heading") {
+      ensureBlankSeparator();
+      rendered.push(line.text);
+      if (hasLaterVisibleLine(index)) {
+        rendered.push("");
+      }
+      continue;
+    }
+    if (line.kind === "subsection-heading") {
+      rendered.push(line.text);
+      continue;
+    }
+    rendered.push(line.text);
+  }
+  while (rendered[rendered.length - 1] === "") {
+    rendered.pop();
+  }
+  return rendered.join(`
+`);
+}
+function renderCodeFence(language, code) {
+  const trimmedLanguage = language.trim();
+  const safeLanguage = /^[a-z0-9_+-]+$/i.test(trimmedLanguage) ? trimmedLanguage : "";
+  const escapedCode = escapeHtml(code.replace(/\n$/, ""));
+  if (safeLanguage) {
+    return `<pre><code class="language-${safeLanguage}">${escapedCode}</code></pre>`;
+  }
+  return `<pre><code>${escapedCode}</code></pre>`;
+}
+function renderTelegramHtmlSafeFromMarkdown(markdown) {
+  const normalized = markdown.replaceAll(`\r
+`, `
+`).replaceAll("\r", `
+`).trim();
+  if (!normalized) {
+    return "";
+  }
+  const segments = [];
+  const codeFencePattern = /```([^\n`]*)\n([\s\S]*?)```/g;
+  let cursor = 0;
+  for (const match of normalized.matchAll(codeFencePattern)) {
+    const matchText = match[0];
+    const matchIndex = match.index ?? -1;
+    if (matchIndex < 0) {
+      continue;
+    }
+    const textBefore = normalized.slice(cursor, matchIndex);
+    if (textBefore) {
+      segments.push(renderMarkdownTextBlock(textBefore));
+    }
+    segments.push(renderCodeFence(match[1] ?? "", match[2] ?? ""));
+    cursor = matchIndex + matchText.length;
+  }
+  const tail = normalized.slice(cursor);
+  if (tail) {
+    const unmatchedFenceMatch = tail.match(/([\s\S]*?)```([^\n`]*)\n([\s\S]*)$/);
+    if (unmatchedFenceMatch) {
+      const textBeforeFence = unmatchedFenceMatch[1] ?? "";
+      const language = unmatchedFenceMatch[2] ?? "";
+      const codeTail = unmatchedFenceMatch[3] ?? "";
+      if (textBeforeFence) {
+        segments.push(renderMarkdownTextBlock(textBeforeFence));
+      }
+      segments.push(renderCodeFence(language, codeTail));
+    } else {
+      segments.push(renderMarkdownTextBlock(tail));
+    }
+  }
+  return segments.filter((segment) => segment.length > 0).join(`
+`).replaceAll(/\n{3,}/g, `
+
+`).trim();
+}
+
+// src/channels/telegram/content.ts
+function resolveTelegramMessageContent(params) {
+  const { text, inputFormat, renderMode } = params;
+  if (inputFormat === "blocks" || renderMode === "blocks") {
+    throw new Error("Telegram does not support block payloads");
+  }
+  if (inputFormat === "mrkdwn" || renderMode === "mrkdwn") {
+    throw new Error("Telegram does not support Slack mrkdwn payloads");
+  }
+  if (inputFormat === "html") {
+    if (renderMode !== "none" && renderMode !== "html" && renderMode !== "native") {
+      throw new Error("Telegram HTML input supports only --render none, html, or native");
+    }
+    return {
+      text,
+      wireFormat: "html"
+    };
+  }
+  if (renderMode === "html") {
+    return {
+      text: renderTelegramHtmlSafeFromMarkdown(text),
+      wireFormat: "html"
+    };
+  }
+  if (renderMode === "none" || inputFormat === "plain") {
+    return {
+      text,
+      wireFormat: "text"
+    };
+  }
+  return {
+    text: renderTelegramHtmlSafeFromMarkdown(text),
+    wireFormat: "html"
+  };
+}
+
 // src/channels/telegram/attachments.ts
 import { basename as basename2 } from "node:path";
 function pickTelegramPhoto(photo) {
@@ -71463,12 +72529,18 @@ class TelegramPollingService {
           return;
         }
         const topicId = binding.topicId ? Number(binding.topicId) : undefined;
+        const renderedNotification = resolveTelegramMessageContent({
+          text,
+          inputFormat: "md",
+          renderMode: "native"
+        });
         await postTelegramText({
           token: this.accountConfig.botToken,
           chatId,
-          text,
+          text: renderedNotification.text,
           topicId: Number.isFinite(topicId) ? topicId : undefined,
-          omitThreadId: shouldOmitTelegramThreadId(Number.isFinite(topicId) ? topicId : undefined)
+          omitThreadId: shouldOmitTelegramThreadId(Number.isFinite(topicId) ? topicId : undefined),
+          wireFormat: renderedNotification.wireFormat
         });
       }
     });
@@ -71699,6 +72771,10 @@ class TelegramPollingService {
         }
       }
     }
+    if (hasForeignTelegramMention(rawText, this.botUsername)) {
+      await this.processedEventsStore.markCompleted(eventId);
+      return;
+    }
     const explicitMention = hasTelegramBotMention(rawText, this.botUsername) || Boolean(slashCommand && rawText.startsWith("/"));
     const followUpState = await this.agentService.getConversationFollowUpState(routeInfo.sessionTarget);
     const effectiveFollowUpMode = resolveFollowUpMode({
@@ -71712,6 +72788,16 @@ class TelegramPollingService {
       lastBotReplyAt: followUpState.lastBotReplyAt,
       directReplyToBot: isReplyToTelegramBot(message, this.botUserId)
     });
+    const textBody = explicitMention ? stripTelegramBotMention(rawText, this.botUsername) : rawText;
+    const recentMessageMarker = String(message.message_id);
+    if (rawText || explicitMention || slashCommand) {
+      await this.agentService.appendRecentConversationMessage(routeInfo.sessionTarget, {
+        marker: recentMessageMarker,
+        text: slashCommand ? "" : textBody,
+        senderId: message.from?.id != null ? String(message.from.id).trim() : undefined,
+        senderName: [message.from?.first_name, message.from?.last_name].filter((value) => typeof value === "string" && value.trim().length > 0).join(" ").trim() || message.from?.username?.trim() || undefined
+      });
+    }
     if (routeInfo.route.requireMention && !wasMentioned) {
       await this.processedEventsStore.markCompleted(eventId);
       return;
@@ -71719,7 +72805,10 @@ class TelegramPollingService {
     if (explicitMention && followUpState.overrideMode === "paused") {
       await this.agentService.reactivateConversationFollowUp(routeInfo.sessionTarget);
     }
-    const textBody = explicitMention ? stripTelegramBotMention(rawText, this.botUsername) : rawText;
+    const effectivePromptText = textBody || (explicitMention ? buildMentionOnlyFollowUpPrompt({
+      conversationKind: routeInfo.conversationKind === "topic" ? "group" : routeInfo.conversationKind,
+      threaded: routeInfo.topicId != null || message.message_thread_id != null && Number.isFinite(message.message_thread_id)
+    }) : "");
     const attachmentPaths = await resolveTelegramAttachmentPaths({
       message,
       botToken: this.accountConfig.botToken,
@@ -71727,11 +72816,18 @@ class TelegramPollingService {
       sessionKey: routeInfo.sessionTarget.sessionKey,
       messageId: String(message.message_id)
     });
-    const text = prependAttachmentMentions(textBody, attachmentPaths);
+    const text = prependAttachmentMentions(effectivePromptText, attachmentPaths);
     if (!text) {
       await this.processedEventsStore.markCompleted(eventId);
       return;
     }
+    const recentConversationReplay = await this.agentService.getRecentConversationReplayMessages(routeInfo.sessionTarget, {
+      excludeMarker: recentMessageMarker
+    });
+    const enrichPromptText = (nextText) => prependRecentConversationContext({
+      currentText: nextText,
+      recentMessages: recentConversationReplay
+    });
     await this.processedEventsStore.markProcessing(eventId);
     await this.activityStore.record({
       agentId: routeInfo.route.agentId,
@@ -71759,7 +72855,7 @@ class TelegramPollingService {
       });
       const protectedControlMutationRule = auth.mayManageProtectedResources ? undefined : DEFAULT_PROTECTED_CONTROL_RULE;
       const agentPromptText = buildAgentPromptText({
-        text,
+        text: enrichPromptText(text),
         identity,
         config: this.loadedConfig.raw.channels.telegram.agentPrompt,
         cliTool,
@@ -71802,7 +72898,7 @@ class TelegramPollingService {
           text,
           agentPromptText,
           agentPromptBuilder: (nextText) => buildAgentPromptText({
-            text: nextText,
+            text: enrichPromptText(nextText),
             identity,
             config: this.loadedConfig.raw.channels.telegram.agentPrompt,
             cliTool,
@@ -71811,27 +72907,43 @@ class TelegramPollingService {
             protectedControlMutationRule
           }),
           protectedControlMutationRule,
+          transformSessionInputText: enrichPromptText,
+          onPromptAccepted: async () => {
+            await this.agentService.markRecentConversationProcessed(routeInfo.sessionTarget, recentMessageMarker);
+          },
           route: routeInfo.route,
           maxChars: this.getTelegramMaxChars(routeInfo.route.agentId),
           timingContext,
           postText: async (nextText) => {
+            const renderedReply = resolveTelegramMessageContent({
+              text: nextText,
+              inputFormat: "md",
+              renderMode: "native"
+            });
             responseChunks = await postTelegramText({
               token: this.accountConfig.botToken,
               chatId: message.chat.id,
-              text: nextText,
+              text: renderedReply.text,
               topicId: routeInfo.topicId,
-              omitThreadId: shouldOmitTelegramThreadId(routeInfo.topicId)
+              omitThreadId: shouldOmitTelegramThreadId(routeInfo.topicId),
+              wireFormat: renderedReply.wireFormat
             });
             return responseChunks;
           },
           reconcileText: async (chunks, nextText) => {
+            const renderedReply = resolveTelegramMessageContent({
+              text: nextText,
+              inputFormat: "md",
+              renderMode: "native"
+            });
             responseChunks = await reconcileTelegramText({
               token: this.accountConfig.botToken,
               chatId: message.chat.id,
               chunks,
-              text: nextText,
+              text: renderedReply.text,
               topicId: routeInfo.topicId,
-              omitThreadId: shouldOmitTelegramThreadId(routeInfo.topicId)
+              omitThreadId: shouldOmitTelegramThreadId(routeInfo.topicId),
+              wireFormat: renderedReply.wireFormat
             });
             return responseChunks;
           }
@@ -71932,6 +73044,23 @@ function resolveRouteAndTarget(params) {
 // src/channels/telegram/message-actions.ts
 import { basename as basename3, extname as extname2 } from "node:path";
 import { readFile as readFile3 } from "node:fs/promises";
+function isTelegramHtmlParseError2(error) {
+  return error instanceof TelegramApiError && error.errorCode === 400 && /can't parse entities|unsupported start tag|unexpected end tag|entity beginning/i.test(error.description);
+}
+function buildTelegramMessagePayload(params) {
+  if (!params.text) {
+    return null;
+  }
+  const resolved = resolveTelegramMessageContent({
+    text: params.text,
+    inputFormat: params.inputFormat ?? "md",
+    renderMode: params.renderMode ?? "native"
+  });
+  return {
+    text: resolved.text,
+    parse_mode: resolved.wireFormat === "html" ? "HTML" : undefined
+  };
+}
 function parseTelegramChatId(raw) {
   const value = raw.trim();
   if (value.startsWith("@")) {
@@ -71944,7 +73073,11 @@ function parseTelegramChatId(raw) {
   throw new Error(`Invalid Telegram target: ${raw}`);
 }
 function parseTelegramThreadId(threadId) {
-  const parsed = Number(threadId ?? "");
+  const raw = threadId?.trim();
+  if (!raw) {
+    return;
+  }
+  const parsed = Number(raw);
   return Number.isFinite(parsed) ? parsed : undefined;
 }
 async function loadTelegramMedia(media) {
@@ -71999,6 +73132,11 @@ async function sendTelegramMessage(params) {
   const chatId = parseTelegramChatId(params.target);
   const threadId = parseTelegramThreadId(params.threadId);
   const replyTo = params.replyTo ? Number(params.replyTo) : undefined;
+  const formattedMessage = buildTelegramMessagePayload({
+    text: params.message,
+    inputFormat: params.inputFormat,
+    renderMode: params.renderMode
+  });
   if (params.media) {
     const media = await loadTelegramMedia(params.media);
     const kind = inferTelegramMediaKind(media.filename, params.forceDocument);
@@ -72018,35 +73156,75 @@ async function sendTelegramMessage(params) {
     };
     const method = methodByKind[kind];
     const fileField = fieldByKind[kind];
-    const payload = {
+    const payload2 = {
       chat_id: chatId,
-      ...params.message ? { caption: params.message } : {},
+      ...formattedMessage ? { caption: formattedMessage.text } : {},
+      ...formattedMessage?.parse_mode ? { parse_mode: formattedMessage.parse_mode } : {},
       ...threadId != null && threadId !== 1 ? { message_thread_id: threadId } : {},
       ...replyTo != null ? { reply_to_message_id: replyTo } : {},
       ...params.silent ? { disable_notification: true } : {}
     };
-    if (media.remoteUrl) {
-      return await callTelegramApi(params.botToken, method, {
-        ...payload,
-        [fileField]: media.remoteUrl
+    try {
+      if (media.remoteUrl) {
+        return await callTelegramApi(params.botToken, method, {
+          ...payload2,
+          [fileField]: media.remoteUrl
+        });
+      }
+      return await callTelegramMultipartApi({
+        token: params.botToken,
+        method,
+        payload: payload2,
+        fileField,
+        file: media.file,
+        filename: media.filename
+      });
+    } catch (error) {
+      if (!formattedMessage || !isTelegramHtmlParseError2(error)) {
+        throw error;
+      }
+      const plainPayload = {
+        ...payload2,
+        caption: params.message ?? ""
+      };
+      delete plainPayload.parse_mode;
+      if (media.remoteUrl) {
+        return await callTelegramApi(params.botToken, method, {
+          ...plainPayload,
+          [fileField]: media.remoteUrl
+        });
+      }
+      return await callTelegramMultipartApi({
+        token: params.botToken,
+        method,
+        payload: plainPayload,
+        fileField,
+        file: media.file,
+        filename: media.filename
       });
     }
-    return await callTelegramMultipartApi({
-      token: params.botToken,
-      method,
-      payload,
-      fileField,
-      file: media.file,
-      filename: media.filename
-    });
   }
-  return await callTelegramApi(params.botToken, "sendMessage", {
+  const payload = {
     chat_id: chatId,
-    text: params.message ?? "",
+    text: formattedMessage?.text ?? params.message ?? "",
+    ...formattedMessage?.parse_mode ? { parse_mode: formattedMessage.parse_mode } : {},
     ...threadId != null && threadId !== 1 ? { message_thread_id: threadId } : {},
     ...replyTo != null ? { reply_to_message_id: replyTo } : {},
     ...params.silent ? { disable_notification: true } : {}
-  });
+  };
+  try {
+    return await callTelegramApi(params.botToken, "sendMessage", payload);
+  } catch (error) {
+    if (!formattedMessage || !isTelegramHtmlParseError2(error)) {
+      throw error;
+    }
+    const plainPayload = {
+      ...payload,
+      text: params.message ?? ""
+    };
+    delete plainPayload.parse_mode;
+    return await callTelegramApi(params.botToken, "sendMessage", plainPayload);
+  }
 }
 async function sendTelegramPoll(params) {
   if (!params.pollQuestion || !params.pollOptions?.length) {
@@ -72064,11 +73242,30 @@ async function editTelegramMessage(params) {
   if (!params.messageId || !params.message) {
     throw new Error("--message-id and --message are required");
   }
-  return await callTelegramApi(params.botToken, "editMessageText", {
+  const formattedMessage = buildTelegramMessagePayload({
+    text: params.message,
+    inputFormat: params.inputFormat,
+    renderMode: params.renderMode
+  });
+  const payload = {
     chat_id: parseTelegramChatId(params.target),
     message_id: Number(params.messageId),
-    text: params.message
-  });
+    text: formattedMessage?.text ?? params.message,
+    ...formattedMessage?.parse_mode ? { parse_mode: formattedMessage.parse_mode } : {}
+  };
+  try {
+    return await callTelegramApi(params.botToken, "editMessageText", payload);
+  } catch (error) {
+    if (!formattedMessage || !isTelegramHtmlParseError2(error)) {
+      throw error;
+    }
+    const plainPayload = {
+      ...payload,
+      text: params.message
+    };
+    delete plainPayload.parse_mode;
+    return await callTelegramApi(params.botToken, "editMessageText", plainPayload);
+  }
 }
 async function deleteTelegramMessageAction(params) {
   if (!params.messageId) {
@@ -72186,7 +73383,9 @@ var telegramChannelPlugin = {
       pollQuestion: command.pollQuestion,
       pollOptions: command.pollOptions,
       forceDocument: command.forceDocument,
-      silent: command.silent
+      silent: command.silent,
+      inputFormat: command.inputFormat,
+      renderMode: command.renderMode
     };
     switch (command.action) {
       case "send":
@@ -72387,6 +73586,7 @@ function buildOwnerAlertCommand(params) {
     account: params.accountId,
     target: params.platform === "slack" ? `user:${params.userId}` : params.userId,
     message: params.message,
+    messageFile: undefined,
     media: undefined,
     messageId: undefined,
     emoji: undefined,
@@ -72401,7 +73601,9 @@ function buildOwnerAlertCommand(params) {
     silent: false,
     progress: false,
     final: false,
-    json: false
+    json: false,
+    inputFormat: "md",
+    renderMode: "native"
   };
 }
 async function sendOwnerAlert(params) {
@@ -74573,6 +75775,47 @@ async function runLoopsCli(args) {
   throw new Error(renderLoopsHelp());
 }
 
+// src/control/message-cli.ts
+import { readFile as readFile4 } from "node:fs/promises";
+
+// src/channels/message-format.ts
+var DEFAULT_MESSAGE_INPUT_FORMAT = "md";
+var DEFAULT_MESSAGE_RENDER_MODE = "native";
+var MESSAGE_INPUT_FORMATS = [
+  "plain",
+  "md",
+  "html",
+  "mrkdwn",
+  "blocks"
+];
+var MESSAGE_RENDER_MODES = [
+  "native",
+  "none",
+  "html",
+  "mrkdwn",
+  "blocks"
+];
+function parseMessageInputFormat(raw) {
+  const normalized = raw?.trim().toLowerCase();
+  if (!normalized) {
+    return DEFAULT_MESSAGE_INPUT_FORMAT;
+  }
+  if (MESSAGE_INPUT_FORMATS.includes(normalized)) {
+    return normalized;
+  }
+  throw new Error(`--input must be one of: ${MESSAGE_INPUT_FORMATS.join(", ")}`);
+}
+function parseMessageRenderMode(raw) {
+  const normalized = raw?.trim().toLowerCase();
+  if (!normalized) {
+    return DEFAULT_MESSAGE_RENDER_MODE;
+  }
+  if (MESSAGE_RENDER_MODES.includes(normalized)) {
+    return normalized;
+  }
+  throw new Error(`--render must be one of: ${MESSAGE_RENDER_MODES.join(", ")}`);
+}
+
 // src/control/message-cli.ts
 function getConfigPath() {
   return process.env.CLISBOT_CONFIG_PATH;
@@ -74604,6 +75847,14 @@ function parseOptionValue3(args, name) {
   const values = parseRepeatedOption3(args, name);
   return values.length > 0 ? values.at(-1) : undefined;
 }
+function parseMessageBodyFileOption(args) {
+  const bodyFileValues = parseRepeatedOption3(args, "--body-file");
+  const messageFileValues = parseRepeatedOption3(args, "--message-file");
+  if (bodyFileValues.length > 0 && messageFileValues.length > 0) {
+    throw new Error("--body-file and --message-file are aliases; use only one");
+  }
+  return bodyFileValues.at(-1) ?? messageFileValues.at(-1);
+}
 function parseIntegerOption(args, name) {
   const raw = parseOptionValue3(args, name);
   if (!raw) {
@@ -74644,6 +75895,7 @@ function parseMessageCommand(args) {
     account: parseOptionValue3(rest, "--account"),
     target: parseOptionValue3(rest, "--target"),
     message: parseOptionValue3(rest, "--message") ?? parseOptionValue3(rest, "-m"),
+    messageFile: parseMessageBodyFileOption(rest),
     media: parseOptionValue3(rest, "--media"),
     messageId: parseOptionValue3(rest, "--message-id"),
     emoji: parseOptionValue3(rest, "--emoji"),
@@ -74658,7 +75910,9 @@ function parseMessageCommand(args) {
     silent: hasFlag4(rest, "--silent"),
     progress: hasFlag4(rest, "--progress"),
     final: hasFlag4(rest, "--final"),
-    json: hasFlag4(rest, "--json")
+    json: hasFlag4(rest, "--json"),
+    inputFormat: parseMessageInputFormat(parseOptionValue3(rest, "--input")),
+    renderMode: parseMessageRenderMode(parseOptionValue3(rest, "--render"))
   };
 }
 function renderMessageHelp() {
@@ -74666,20 +75920,59 @@ function renderMessageHelp() {
     "clisbot message",
     "",
     "Usage:",
-    "  clisbot message send --channel <slack|telegram> --target <dest> --message <text> [--account <id>] [--media <path-or-url>] [--reply-to <id>] [--thread-id <id>] [--force-document] [--silent] [--progress|--final]",
+    "  clisbot message send --channel <slack|telegram> --target <dest> [--message <text> | --body-file <path>] [--input <plain|md|html|mrkdwn|blocks>] [--render <native|none|html|mrkdwn|blocks>] [--account <id>] [--media <path-or-url>] [--reply-to <id>] [--thread-id <id>] [--force-document] [--silent] [--progress|--final]",
     "  clisbot message poll --channel <slack|telegram> --target <dest> --poll-question <text> --poll-option <value> [--poll-option <value>] [--account <id>] [--thread-id <id>] [--silent]",
     "  clisbot message react --channel <slack|telegram> --target <dest> --message-id <id> --emoji <emoji> [--account <id>] [--remove]",
     "  clisbot message reactions --channel <slack|telegram> --target <dest> --message-id <id> [--account <id>]",
     "  clisbot message read --channel <slack|telegram> --target <dest> [--account <id>] [--limit <n>]",
-    "  clisbot message edit --channel <slack|telegram> --target <dest> --message-id <id> --message <text> [--account <id>]",
+    "  clisbot message edit --channel <slack|telegram> --target <dest> --message-id <id> [--message <text> | --body-file <path>] [--input <plain|md|html|mrkdwn|blocks>] [--render <native|none|html|mrkdwn|blocks>] [--account <id>]",
     "  clisbot message delete --channel <slack|telegram> --target <dest> --message-id <id> [--account <id>]",
     "  clisbot message pin --channel <slack|telegram> --target <dest> --message-id <id> [--account <id>]",
     "  clisbot message unpin --channel <slack|telegram> --target <dest> [--message-id <id>] [--account <id>]",
     "  clisbot message pins --channel <slack|telegram> --target <dest> [--account <id>]",
-    "  clisbot message search --channel <slack|telegram> --target <dest> --query <text> [--account <id>] [--limit <n>]"
+    "  clisbot message search --channel <slack|telegram> --target <dest> --query <text> [--account <id>] [--limit <n>]",
+    "",
+    "Send/Edit Content Options:",
+    "  --message <text>              Inline message body",
+    "  --body-file <path>            Read the message body from a file",
+    "                                Alias: --message-file (compat only)",
+    "  --input <plain|md|html|mrkdwn|blocks>",
+    "                               Input content format. Default: md",
+    "  --render <native|none|html|mrkdwn|blocks>",
+    "                               Output rendering mode. Default: native",
+    "",
+    "Render Rules:",
+    "  native                        Channel-owned default rendering",
+    "                                - Telegram: Markdown/plain -> safe HTML",
+    "                                - Slack: Markdown/plain -> mrkdwn",
+    "  none                          Content is already destination-native",
+    "                                - Telegram: use with --input html",
+    "                                - Slack: use with --input mrkdwn or blocks",
+    "  blocks                        Slack only. Render Markdown into Block Kit",
+    "  html                          Telegram only",
+    "  mrkdwn                        Slack only",
+    "",
+    "Examples:",
+    '  clisbot message send --channel telegram --target -1001234567890 --thread-id 42 --message "## Status"',
+    '  clisbot message send --channel telegram --target -1001234567890 --thread-id 42 --input html --render none --message "<b>Status</b>"',
+    '  clisbot message send --channel slack --target channel:C1234567890 --thread-id 1712345678.123456 --message "## Status"',
+    '  clisbot message send --channel slack --target channel:C1234567890 --thread-id 1712345678.123456 --input mrkdwn --render none --message "*Status*"',
+    "  clisbot message send --channel slack --target channel:C1234567890 --thread-id 1712345678.123456 --input blocks --render none --body-file ./reply-blocks.json"
   ].join(`
 `);
 }
+async function resolveCommandMessage(command) {
+  if (!command.messageFile) {
+    return command;
+  }
+  if (command.message) {
+    throw new Error("--message cannot be used together with --body-file or --message-file");
+  }
+  return {
+    ...command,
+    message: await readFile4(command.messageFile, "utf8")
+  };
+}
 function assertTarget(command) {
   if (!command.target) {
     throw new Error("--target is required");
@@ -74691,21 +75984,22 @@ async function runMessageCli(args, dependencies = defaultMessageCliDependencies)
     dependencies.print(renderMessageHelp());
     return;
   }
-  if (command.progress && command.final) {
+  const resolvedCommand = await resolveCommandMessage(command);
+  if (resolvedCommand.progress && resolvedCommand.final) {
     throw new Error("--progress and --final cannot be used together");
   }
-  assertTarget(command);
+  assertTarget(resolvedCommand);
   const loadedConfig = await dependencies.loadConfig(getConfigPath(), {
-    materializeChannels: [command.channel]
+    materializeChannels: [resolvedCommand.channel]
   });
-  const plugin = dependencies.plugins.find((entry) => entry.id === command.channel);
+  const plugin = dependencies.plugins.find((entry) => entry.id === resolvedCommand.channel);
   if (!plugin) {
-    throw new Error(`Unsupported message channel: ${command.channel}`);
+    throw new Error(`Unsupported message channel: ${resolvedCommand.channel}`);
   }
-  const execution = await plugin.runMessageCommand(loadedConfig, command);
-  const replyTarget = command.action === "send" || command.action === "poll" ? plugin.resolveMessageReplyTarget({
+  const execution = await plugin.runMessageCommand(loadedConfig, resolvedCommand);
+  const replyTarget = resolvedCommand.action === "send" || resolvedCommand.action === "poll" ? plugin.resolveMessageReplyTarget({
     loadedConfig,
-    command,
+    command: resolvedCommand,
     accountId: execution.accountId
   }) : null;
   if (replyTarget) {
@@ -75768,7 +77062,7 @@ import { statSync as statSync5, watch } from "node:fs";
 import { basename as basename4, dirname as dirname15 } from "node:path";
 
 // src/channels/processed-events-store.ts
-import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile5, writeFile as writeFile2 } from "node:fs/promises";
 var DEFAULT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 var PROCESSING_STALE_MS = 30 * 60 * 1000;
 
@@ -75786,7 +77080,7 @@ class ProcessedEventsStore {
       return;
     }
     try {
-      const text = await readFile4(this.filePath, "utf8");
+      const text = await readFile5(this.filePath, "utf8");
       this.document = JSON.parse(text);
     } catch {
       this.document = { events: {} };