@tritard/waterbrother 0.15.10 → 0.15.11

package/README.md

@@ -244,6 +244,8 @@ waterbrother channels list
 waterbrother channels status
 waterbrother channels show telegram
 waterbrother gateway status
+waterbrother gateway pairings
+waterbrother gateway pair telegram <user-id>
 waterbrother gateway run telegram
 waterbrother onboarding telegram
 waterbrother onboarding discord
@@ -260,6 +262,7 @@ Current Telegram limitation:
 - remote prompts run with `approval=never`
 - status, runtime inspection, and read-oriented prompts work best
 - mutating and approval-heavy work stay local until remote approvals land
+- pairing is now explicit: first DM creates a pending request, then approve locally with `waterbrother gateway pair telegram <user-id>`
 
 ## Release flow
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tritard/waterbrother",
-  "version": "0.15.10",
+  "version": "0.15.11",
   "description": "Waterbrother: bring-your-own-model coding CLI with local tools, sessions, operator modes, and approval controls",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -5,6 +5,8 @@ import { createToolRuntime } from "./tools.js";
 const BASE_SYSTEM_PROMPT = `You are Waterbrother, a coding assistant running in a local terminal.
 You can inspect and modify files with tools.
 When you use tools:
+- Describe Waterbrother as a bring-your-own-model local coding CLI when you need to describe it.
+- Do not call Waterbrother "Grok-powered", "xAI-powered", or otherwise provider-branded unless the user is explicitly asking about provider configuration or the active model.
 - Be precise and minimal.
 - Prefer read/search before write.
 - For large rewrites, design overhauls, or multi-section HTML/CSS edits, prefer reading the file once and then using write_file to replace the full file instead of chaining many replace_in_file calls.

package/src/channels.js

@@ -178,16 +178,19 @@ export function buildChannelOnboardingPayload(serviceId) {
       prerequisites: [
         "Create a Telegram bot with BotFather",
         "Capture the bot token",
-        "Choose manual pairing or an allowlist"
+        "Start with manual pairing so first-contact DMs create a pending approval request"
       ],
       commands: [
         "waterbrother config set-json channels '{\"telegram\":{\"enabled\":true,\"botToken\":\"YOUR_BOT_TOKEN\",\"pairingMode\":\"manual\",\"allowedUserIds\":[]}}'",
+        "waterbrother gateway pairings",
+        "waterbrother gateway pair telegram <user-id>",
         "waterbrother channels status",
         "waterbrother gateway status"
       ],
       notes: [
         "Start with direct messages only.",
-        "Keep pairing manual until remote-control approvals are stable."
+        "Unknown DMs create a pending pairing request you approve locally.",
+        "Remote commands include /help, /status, /runtime, /sessions, /resume <id>, /new, and /clear."
       ]
     };
   }

package/src/cli.js

@@ -10,6 +10,7 @@ import { getConfigPath, loadConfigLayers, resolveRuntimeConfig, saveConfig } fro
 import { createChatCompletion, createJsonCompletion, listModels } from "./model-client.js";
 import { buildChannelOnboardingPayload, getChannelStatuses, getGatewayStatus } from "./channels.js";
 import { runGatewayService } from "./gateway.js";
+import { loadGatewayState, saveGatewayState } from "./gateway-state.js";
 import {
   getDefaultDesignModelForProvider,
   getDefaultModelForProvider,
@@ -125,6 +126,9 @@ const INTERACTIVE_COMMANDS = [
   { name: "/runtime-profile save <name>", description: "Save current runtime as a named profile" },
   { name: "/runtime-profile load <name>", description: "Load a named runtime profile" },
   { name: "/gateway", description: "Show messaging gateway readiness" },
+  { name: "/gateway pairings", description: "List pending Telegram pairing requests" },
+  { name: "/gateway pair <user-id>", description: "Approve a pending Telegram user id" },
+  { name: "/gateway unpair <user-id>", description: "Remove a paired Telegram user id" },
   { name: "/channels", description: "Show messaging channel readiness" },
   { name: "/agent", description: "Show active agent profile" },
   { name: "/agent <profile>", description: "Switch profile: coder|designer|reviewer|planner" },
@@ -236,6 +240,9 @@ Usage:
   waterbrother channels show <service>
   waterbrother gateway status
   waterbrother gateway run telegram
+  waterbrother gateway pairings [telegram]
+  waterbrother gateway pair [telegram] <user-id>
+  waterbrother gateway unpair [telegram] <user-id>
   waterbrother mcp list
   waterbrother commit [--push]
   waterbrother pr [--branch=<name>]
@@ -3217,6 +3224,83 @@ async function runGatewayCommand(positional, runtime, { cwd = process.cwd(), asJ
     return;
   }
 
+  if (sub === "pairings") {
+    const service = String(positional[2] || "telegram").trim().toLowerCase();
+    if (service !== "telegram") {
+      throw new Error("Usage: waterbrother gateway pairings [telegram]");
+    }
+    const state = await loadGatewayState(service);
+    const pending = Object.values(state.pendingPairings || {});
+    const paired = Array.isArray(runtime.channels?.telegram?.allowedUserIds)
+      ? runtime.channels.telegram.allowedUserIds.map((value) => String(value || "").trim()).filter(Boolean)
+      : [];
+    if (asJson) {
+      printData({ service, pending, paired }, true);
+      return;
+    }
+    console.log(`telegram paired users: ${paired.length ? paired.join(", ") : "none"}`);
+    if (!pending.length) {
+      console.log("telegram pending pairings: none");
+      return;
+    }
+    console.log("telegram pending pairings:");
+    for (const item of pending) {
+      const username = String(item?.username || "").trim();
+      const detail = username ? ` (${username})` : "";
+      console.log(`  ${item.userId}${detail}`);
+    }
+    return;
+  }
+
+  if (sub === "pair" || sub === "unpair") {
+    let service = String(positional[2] || "").trim().toLowerCase();
+    let userId = String(positional[3] || "").trim();
+    if (!userId) {
+      userId = service;
+      service = "telegram";
+    }
+    if (service !== "telegram" || !userId) {
+      throw new Error(`Usage: waterbrother gateway ${sub} [telegram] <user-id>`);
+    }
+    const { userConfig, projectConfig } = await loadConfigLayers(cwd);
+    const targetScope = projectConfig?.channels?.telegram ? "project" : "user";
+    const targetConfig = targetScope === "project" ? { ...projectConfig } : { ...userConfig };
+    const channels = targetConfig.channels && typeof targetConfig.channels === "object" ? { ...targetConfig.channels } : {};
+    const telegram = channels.telegram && typeof channels.telegram === "object" ? { ...channels.telegram } : {};
+    const allowed = new Set(Array.isArray(telegram.allowedUserIds) ? telegram.allowedUserIds.map((value) => String(value || "").trim()).filter(Boolean) : []);
+    if (sub === "pair") {
+      allowed.add(userId);
+      telegram.enabled = telegram.enabled !== false;
+      if (!telegram.pairingMode) telegram.pairingMode = "manual";
+    } else {
+      allowed.delete(userId);
+    }
+    telegram.allowedUserIds = [...allowed];
+    channels.telegram = telegram;
+    targetConfig.channels = channels;
+    await saveConfig(targetConfig, { scope: targetScope, cwd });
+
+    const state = await loadGatewayState(service);
+    if (state.pendingPairings?.[userId]) {
+      delete state.pendingPairings[userId];
+    }
+    if (sub === "unpair" && state.peers?.[userId]) {
+      delete state.peers[userId];
+    }
+    await saveGatewayState(service, state);
+
+    const message =
+      sub === "pair"
+        ? `Paired Telegram user ${userId} via ${getConfigPath({ scope: targetScope, cwd })}`
+        : `Unpaired Telegram user ${userId} via ${getConfigPath({ scope: targetScope, cwd })}`;
+    if (asJson) {
+      printData({ ok: true, service, userId, scope: targetScope, action: sub, allowedUserIds: telegram.allowedUserIds }, true);
+    } else {
+      console.log(message);
+    }
+    return;
+  }
+
   if (sub === "run") {
     const service = String(positional[2] || "").trim().toLowerCase();
     if (!service) {
@@ -3234,7 +3318,7 @@ async function runGatewayCommand(positional, runtime, { cwd = process.cwd(), asJ
     return;
   }
 
-  throw new Error("Usage: waterbrother gateway status|run <telegram>");
+  throw new Error("Usage: waterbrother gateway status|run <telegram>|pairings [telegram]|pair [telegram] <user-id>|unpair [telegram] <user-id>");
 }
 
 async function runMcpCommand(positional, runtime, { cwd, asJson = false } = {}) {
@@ -6746,6 +6830,57 @@ Be concrete about surfaces — name actual pages/flows. Choose the best stack fo
       continue;
     }
 
+    if (line === "/gateway pairings") {
+      const state = await loadGatewayState("telegram");
+      const pending = Object.values(state.pendingPairings || {});
+      const paired = Array.isArray(context.runtime.channels?.telegram?.allowedUserIds)
+        ? context.runtime.channels.telegram.allowedUserIds.map((value) => String(value || "").trim()).filter(Boolean)
+        : [];
+      console.log(`telegram paired users: ${paired.length ? paired.join(", ") : "none"}`);
+      if (!pending.length) {
+        console.log("telegram pending pairings: none");
+      } else {
+        console.log("telegram pending pairings:");
+        for (const item of pending) {
+          const username = String(item?.username || "").trim();
+          console.log(`  ${item.userId}${username ? ` (${username})` : ""}`);
+        }
+      }
+      continue;
+    }
+
+    if (line.startsWith("/gateway pair ")) {
+      const userId = line.replace("/gateway pair", "").trim();
+      if (!userId) {
+        console.log("Usage: /gateway pair <user-id>");
+        continue;
+      }
+      try {
+        await runGatewayCommand(["gateway", "pair", "telegram", userId], context.runtime, { cwd: context.cwd, asJson: false });
+        const { config } = await loadConfigLayers(context.cwd);
+        context.runtime.channels = config.channels || context.runtime.channels;
+      } catch (error) {
+        console.log(`gateway pair failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      continue;
+    }
+
+    if (line.startsWith("/gateway unpair ")) {
+      const userId = line.replace("/gateway unpair", "").trim();
+      if (!userId) {
+        console.log("Usage: /gateway unpair <user-id>");
+        continue;
+      }
+      try {
+        await runGatewayCommand(["gateway", "unpair", "telegram", userId], context.runtime, { cwd: context.cwd, asJson: false });
+        const { config } = await loadConfigLayers(context.cwd);
+        context.runtime.channels = config.channels || context.runtime.channels;
+      } catch (error) {
+        console.log(`gateway unpair failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      continue;
+    }
+
     if (line === "/channels") {
       for (const status of getChannelStatuses(context.runtime)) {
         console.log(formatChannelStatusLine(status));

package/src/gateway-state.js

@@ -20,11 +20,12 @@ export async function loadGatewayState(serviceId) {
     const parsed = JSON.parse(raw);
     return {
       offset: Number.isFinite(Number(parsed?.offset)) ? Math.max(0, Math.floor(Number(parsed.offset))) : 0,
-      peers: parsed?.peers && typeof parsed.peers === "object" ? parsed.peers : {}
+      peers: parsed?.peers && typeof parsed.peers === "object" ? parsed.peers : {},
+      pendingPairings: parsed?.pendingPairings && typeof parsed.pendingPairings === "object" ? parsed.pendingPairings : {}
     };
   } catch (error) {
     if (error?.code === "ENOENT") {
-      return { offset: 0, peers: {} };
+      return { offset: 0, peers: {}, pendingPairings: {} };
     }
     throw error;
   }
@@ -35,7 +36,8 @@ export async function saveGatewayState(serviceId, state) {
   const filePath = gatewayStatePath(serviceId);
   const next = {
     offset: Number.isFinite(Number(state?.offset)) ? Math.max(0, Math.floor(Number(state.offset))) : 0,
-    peers: state?.peers && typeof state.peers === "object" ? state.peers : {}
+    peers: state?.peers && typeof state.peers === "object" ? state.peers : {},
+    pendingPairings: state?.pendingPairings && typeof state.pendingPairings === "object" ? state.pendingPairings : {}
   };
   const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   await fs.writeFile(tmpPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");

package/src/gateway.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
-import { createSession, saveSession } from "./session-store.js";
+import { createSession, listSessions, loadSession, saveSession } from "./session-store.js";
 import { loadGatewayState, saveGatewayState } from "./gateway-state.js";
 import { getGatewayStatus, getChannelSpec } from "./channels.js";
 
@@ -37,38 +37,94 @@ function stringifyError(error) {
   return error.stderr || error.stdout || error.message || String(error);
 }
 
+function escapeTelegramHtml(text) {
+  return String(text || "")
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
+function renderTelegramMarkup(text) {
+  let value = escapeTelegramHtml(String(text || "").trim());
+  value = value.replace(/\*\*([^*\n][^*]*?)\*\*/g, "<b>$1</b>");
+  value = value.replace(/`([^`\n]+)`/g, "<code>$1</code>");
+  value = value.replace(/^\s*-\s+/gm, "• ");
+  return value;
+}
+
 function buildRemoteHelp() {
   return [
-    "Waterbrother Telegram control",
+    "<b>Waterbrother Telegram control</b>",
     "",
-    "Commands:",
-    "/help - show this help",
-    "/status - show current remote session",
-    "/runtime - show active provider/model/runtime state",
-    "/new - start a fresh remote session",
+    "<b>Commands</b>",
+    "<code>/help</code> show this help",
+    "<code>/status</code> show the current linked remote session",
+    "<code>/runtime</code> show active provider/model/runtime state",
+    "<code>/sessions</code> list recent linked remote sessions",
+    "<code>/resume &lt;session-id&gt;</code> switch the linked remote session",
+    "<code>/new</code> start a fresh remote session",
+    "<code>/clear</code> clear the current remote conversation history",
     "",
     "Any other message is sent to the linked Waterbrother session.",
     "",
-    "Current limitation:",
-    "- remote prompts run with approval=never",
-    "- read/status flows work best today",
-    "- mutating actions stay local until remote approvals land"
+    "<b>Current limitation</b>",
+    "• remote prompts run with <code>approval=never</code>",
+    "• read/status flows work best today",
+    "• mutating actions stay local until remote approvals land"
   ].join("\n");
 }
 
 function formatGatewaySessionStatus({ sessionId, userId, username, cwd, runtimeProfile, provider, model }) {
   const bits = [
-    "Telegram remote session",
-    `user=${userId}${username ? ` (${username})` : ""}`,
-    `session=${sessionId}`,
-    `provider=${provider}`,
-    `model=${model}`,
-    `runtimeProfile=${runtimeProfile || "none"}`,
-    `cwd=${cwd}`
+    "<b>Telegram remote session</b>",
+    `user: <code>${escapeTelegramHtml(userId)}</code>${username ? ` (${escapeTelegramHtml(username)})` : ""}`,
+    `session: <code>${escapeTelegramHtml(sessionId)}</code>`,
+    `provider: <code>${escapeTelegramHtml(provider)}</code>`,
+    `model: <code>${escapeTelegramHtml(model)}</code>`,
+    `runtime profile: <code>${escapeTelegramHtml(runtimeProfile || "none")}</code>`,
+    `cwd: <code>${escapeTelegramHtml(cwd)}</code>`
   ];
   return bits.join("\n");
 }
 
+function upsertSessionHistory(existing, sessionId) {
+  const next = Array.isArray(existing) ? existing.map((value) => String(value || "").trim()).filter(Boolean) : [];
+  const normalized = String(sessionId || "").trim();
+  if (!normalized) return next;
+  return [normalized, ...next.filter((value) => value !== normalized)].slice(0, 12);
+}
+
+function formatRuntimeStatus(status = {}) {
+  return [
+    "<b>Runtime status</b>",
+    `provider: <code>${escapeTelegramHtml(status.provider || "unknown")}</code>`,
+    `model: <code>${escapeTelegramHtml(status.model || "unknown")}</code>`,
+    `design model: <code>${escapeTelegramHtml(status.designModel || "unknown")}</code>`,
+    `base URL: <code>${escapeTelegramHtml(status.baseUrl || "")}</code>`,
+    `API key configured: <code>${status.apiKeyConfigured ? "yes" : "no"}</code>`
+  ].join("\n");
+}
+
+function formatSessionListMarkup(currentSessionId, sessions = []) {
+  if (!sessions.length) {
+    return "<b>Remote sessions</b>\nNo linked remote sessions yet.";
+  }
+
+  const lines = ["<b>Remote sessions</b>"];
+  for (const session of sessions) {
+    const id = String(session?.id || "").trim();
+    if (!id) continue;
+    const label = id === currentSessionId ? "current" : "recent";
+    const preview = String(session?.lastUserPreview || "").trim();
+    const updatedAt = String(session?.updatedAt || "").trim();
+    let line = `• <code>${escapeTelegramHtml(id)}</code> <i>(${label})</i>`;
+    if (updatedAt) line += `\n  updated: <code>${escapeTelegramHtml(updatedAt)}</code>`;
+    if (preview) line += `\n  last user: ${escapeTelegramHtml(preview).slice(0, 140)}`;
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+
 class TelegramGateway {
   constructor({ runtime, cwd, io = console }) {
     this.runtime = runtime;
@@ -100,13 +156,15 @@ class TelegramGateway {
     return json.result;
   }
 
-  async sendMessage(chatId, text, replyToMessageId = null) {
+  async sendMessage(chatId, text, replyToMessageId = null, { parseMode = "HTML" } = {}) {
     const chunks = chunkText(text);
     for (const chunk of chunks) {
       await this.callApi("sendMessage", {
         chat_id: chatId,
         text: chunk,
-        reply_to_message_id: replyToMessageId || undefined
+        reply_to_message_id: replyToMessageId || undefined,
+        parse_mode: parseMode || undefined,
+        disable_web_page_preview: true
       });
     }
   }
@@ -129,17 +187,37 @@ class TelegramGateway {
     return allowed.includes(userId);
   }
 
+  async addPendingPairing(message) {
+    const userId = String(message?.from?.id || "").trim();
+    const username = [message?.from?.username, message?.from?.first_name, message?.from?.last_name].filter(Boolean).join(" ").trim();
+    this.state.pendingPairings[userId] = {
+      userId,
+      username,
+      chatId: String(message.chat.id),
+      firstSeenAt: this.state.pendingPairings[userId]?.firstSeenAt || new Date().toISOString(),
+      lastSeenAt: new Date().toISOString(),
+      lastMessageId: message.message_id
+    };
+    await saveGatewayState("telegram", this.state);
+  }
+
   async rejectUnpairedMessage(message) {
     const userId = String(message?.from?.id || "").trim();
+    await this.addPendingPairing(message);
     await this.sendMessage(
       message.chat.id,
       [
-        "This Telegram account is not paired with Waterbrother yet.",
-        `Your Telegram user id is: ${userId}`,
+        "<b>Pairing required</b>",
+        `This Telegram account is not paired with Waterbrother yet.`,
+        `Your Telegram user id is: <code>${escapeTelegramHtml(userId)}</code>`,
+        "",
+        "Approve it locally with:",
+        `<code>waterbrother gateway pair telegram ${escapeTelegramHtml(userId)}</code>`,
         "",
-        "Add it to channels.telegram.allowedUserIds in ~/.waterbrother/config.json, then restart the gateway."
+        "Then keep the gateway running and send your message again."
       ].join("\n"),
-      message.message_id
+      message.message_id,
+      { parseMode: "HTML" }
     );
   }
 
@@ -156,6 +234,7 @@ class TelegramGateway {
         ...existing,
         chatId: String(message.chat.id),
         username,
+        sessions: upsertSessionHistory(existing.sessions, existing.sessionId),
         lastSeenAt: new Date().toISOString(),
         lastMessageId: message.message_id
       };
@@ -178,10 +257,12 @@ class TelegramGateway {
       sessionId: session.id,
       chatId: String(message.chat.id),
       username,
+      sessions: upsertSessionHistory([], session.id),
       linkedAt: new Date().toISOString(),
       lastSeenAt: new Date().toISOString(),
       lastMessageId: message.message_id
     };
+    delete this.state.pendingPairings[userId];
     await saveGatewayState("telegram", this.state);
     return session.id;
   }
@@ -205,14 +286,57 @@ class TelegramGateway {
       sessionId: session.id,
       chatId: String(message.chat.id),
       username: [message?.from?.username, message?.from?.first_name, message?.from?.last_name].filter(Boolean).join(" ").trim(),
+      sessions: upsertSessionHistory(previous.sessions, session.id),
       linkedAt: new Date().toISOString(),
       lastSeenAt: new Date().toISOString(),
       lastMessageId: message.message_id
     };
+    delete this.state.pendingPairings[userId];
     await saveGatewayState("telegram", this.state);
     return session.id;
   }
 
+  async listPeerSessions(userId) {
+    const peer = this.getPeerState(userId);
+    const ids = Array.isArray(peer?.sessions) ? peer.sessions.map((value) => String(value || "").trim()).filter(Boolean) : [];
+    if (!ids.length && peer?.sessionId) ids.push(String(peer.sessionId));
+    if (!ids.length) return [];
+    const all = await listSessions(Math.max(20, ids.length + 4));
+    const byId = new Map(all.map((session) => [session.id, session]));
+    return ids.map((id) => byId.get(id) || { id }).filter(Boolean);
+  }
+
+  async resumePeerSession(message, sessionId) {
+    const userId = String(message?.from?.id || "").trim();
+    const normalizedId = String(sessionId || "").trim();
+    if (!normalizedId) throw new Error("Usage: /resume <session-id>");
+    const session = await loadSession(normalizedId);
+    const previous = this.getPeerState(userId) || {};
+    this.state.peers[userId] = {
+      ...previous,
+      sessionId: session.id,
+      chatId: String(message.chat.id),
+      username: [message?.from?.username, message?.from?.first_name, message?.from?.last_name].filter(Boolean).join(" ").trim(),
+      sessions: upsertSessionHistory(previous.sessions, session.id),
+      linkedAt: previous.linkedAt || new Date().toISOString(),
+      lastSeenAt: new Date().toISOString(),
+      lastMessageId: message.message_id
+    };
+    await saveGatewayState("telegram", this.state);
+    return session.id;
+  }
+
+  async clearRemoteConversation(sessionId) {
+    const session = await loadSession(sessionId);
+    session.messages = [];
+    session.runState = {
+      state: "done",
+      detail: "",
+      updatedAt: new Date().toISOString()
+    };
+    await saveSession(session);
+  }
+
   async runWaterbrother(args = []) {
     const childEnv = {
       ...process.env
@@ -280,9 +404,9 @@ class TelegramGateway {
     }
 
     const sessionId = await this.ensurePeerSession(message);
+    const peer = this.getPeerState(userId);
 
     if (text === "/status") {
-      const peer = this.getPeerState(userId);
       await this.sendMessage(
         message.chat.id,
         formatGatewaySessionStatus({
@@ -301,16 +425,40 @@ class TelegramGateway {
 
     if (text === "/runtime") {
       const status = await this.runRuntimeStatus();
+      await this.sendMessage(message.chat.id, formatRuntimeStatus(status), message.message_id);
+      return;
+    }
+
+    if (text === "/sessions") {
+      const sessions = await this.listPeerSessions(userId);
+      await this.sendMessage(message.chat.id, formatSessionListMarkup(sessionId, sessions), message.message_id);
+      return;
+    }
+
+    if (text.startsWith("/resume")) {
+      const nextSessionId = text.replace("/resume", "").trim();
+      if (!nextSessionId) {
+        await this.sendMessage(
+          message.chat.id,
+          "Usage: <code>/resume &lt;session-id&gt;</code>\nUse <code>/sessions</code> to list recent remote session ids.",
+          message.message_id
+        );
+        return;
+      }
+      const resumedId = await this.resumePeerSession(message, nextSessionId);
       await this.sendMessage(
         message.chat.id,
-        [
-          "Runtime status",
-          `provider=${status.provider}`,
-          `model=${status.model}`,
-          `designModel=${status.designModel}`,
-          `baseUrl=${status.baseUrl}`,
-          `apiKeyConfigured=${status.apiKeyConfigured ? "yes" : "no"}`
-        ].join("\n"),
+        `Linked remote session: <code>${escapeTelegramHtml(resumedId)}</code>`,
+        message.message_id
+      );
+      return;
+    }
+
+    if (text === "/clear") {
+      await this.clearRemoteConversation(sessionId);
+      await this.sendMessage(
+        message.chat.id,
+        `Cleared conversation history for <code>${escapeTelegramHtml(sessionId)}</code>.`,
         message.message_id
       );
       return;
@@ -327,12 +475,13 @@ class TelegramGateway {
 
     try {
       const content = await this.runPrompt(sessionId, text);
-      await this.sendMessage(message.chat.id, content, message.message_id);
+      await this.sendMessage(message.chat.id, renderTelegramMarkup(content), message.message_id);
     } catch (error) {
       await this.sendMessage(
         message.chat.id,
-        `Remote run failed:\n${stringifyError(error).slice(0, 3000)}`,
-        message.message_id
+        `<b>Remote run failed</b>\n${escapeTelegramHtml(stringifyError(error).slice(0, 3000))}`,
+        message.message_id,
+        { parseMode: "HTML" }
       );
     }
   }