switchroom 0.14.7 → 0.14.9

package/telegram-plugin/dist/gateway/gateway.js

@@ -30156,6 +30156,11 @@ async function handleRequestConfigApproval(client3, msg, deps) {
     reply("deny", `gateway serves '${deps.agentName}', not '${msg.agentName}'`, "dispatch_failure");
     return;
   }
+  if (deps.tryAutoResolve?.(msg) === "approve") {
+    deps.log?.(`config_approval_auto_resolved requestId=${msg.requestId} agent=${msg.agentName} (operator-tapped always-allow correlation)`);
+    reply("approve");
+    return;
+  }
   const target = deps.loadTargetChat();
   if (target === null) {
     reply("deny", "no target chat available \u2014 operator not paired?", "dispatch_failure");
@@ -31754,142 +31759,26 @@ function isTelegramSurfaceTool(toolName) {
   return suffix === "reply" || suffix === "stream_reply" || suffix === "edit_message" || suffix === "react";
 }
 
-// draft-transport.ts
-var DRAFT_STREAM_STATE_KEY = Symbol.for("switchroom.draftStreamState");
-function getDraftStreamState() {
-  const g = globalThis;
-  let state = g[DRAFT_STREAM_STATE_KEY];
-  if (!state) {
-    state = { nextDraftId: 0 };
-    g[DRAFT_STREAM_STATE_KEY] = state;
-  }
-  return state;
-}
-function allocateDraftId() {
-  const state = getDraftStreamState();
-  state.nextDraftId = state.nextDraftId >= 2147483647 ? 1 : state.nextDraftId + 1;
-  return state.nextDraftId;
-}
-
 // tool-activity-summary.ts
-var READ_VERBS = new Set(["read"]);
-var WRITE_VERBS = new Set(["wrote", "created", "edited"]);
-function makeEmptyActivityState() {
-  return { counts: {}, order: [], firstToolName: null };
-}
-function verbForTool(toolName) {
-  if (!toolName)
-    return null;
-  const mcpMatch = /^mcp__(.+?)__(.+)$/.exec(toolName);
-  if (mcpMatch && mcpMatch[1] === "switchroom-telegram")
-    return null;
-  if (mcpMatch) {
-    const server = mcpMatch[1].toLowerCase();
-    const mcpTool = mcpMatch[2].toLowerCase();
-    if (server === "hindsight") {
-      if (mcpTool === "recall" || mcpTool === "reflect")
-        return "searched";
-      if (mcpTool === "retain" || mcpTool === "update_memory" || mcpTool === "sync_retain")
-        return "saved";
-    }
-    if (server === "google-workspace" || server === "claude_ai_google_drive" || server === "claude_ai_gmail" || server === "claude_ai_google_calendar") {
-      if (/^(search|list|query|read|get|fetch|download)/i.test(mcpTool))
-        return "searched";
-      if (/^(create|update|write|send|move|copy|duplicate)/i.test(mcpTool))
-        return "edited";
-    }
-    if (server === "notion" || server === "claude_ai_notion") {
-      const action = mcpTool.replace(/^notion-/, "");
-      if (/^(search|fetch|query|get|read)/i.test(action))
-        return "searched";
-      if (/^(create|update|move|duplicate|comment)/i.test(action))
-        return "edited";
-    }
-  }
-  const suffix = (mcpMatch ? mcpMatch[2] : toolName).toLowerCase();
-  switch (suffix) {
-    case "read":
-      return "read";
-    case "write":
-      return "created";
-    case "edit":
-    case "multiedit":
-    case "notebookedit":
-      return "edited";
-    case "bash":
-    case "bashoutput":
-    case "killshell":
-      return "ran";
-    case "websearch":
-    case "grep":
-    case "glob":
-      return "searched";
-    case "webfetch":
-      return "fetched";
-    case "task":
-    case "agent":
-      return "dispatched";
-    case "todowrite":
-    case "todoread":
-      return "noted";
-    default:
-      return "used";
-  }
-}
-function register(state, toolName) {
-  const verb = verbForTool(toolName);
-  if (!verb)
-    return false;
-  if (state.firstToolName == null)
-    state.firstToolName = toolName;
-  const prior = state.counts[verb] ?? 0;
-  if (prior === 0)
-    state.order.push(verb);
-  state.counts[verb] = prior + 1;
-  return true;
-}
-var VERB_PHRASE = {
-  read: { singular: "read a file", plural: "read $N files" },
-  edited: { singular: "edited a file", plural: "edited $N files" },
-  created: { singular: "created a file", plural: "created $N files" },
-  ran: { singular: "ran a command", plural: "ran $N commands" },
-  searched: { singular: "ran a search", plural: "ran $N searches" },
-  fetched: { singular: "fetched a URL", plural: "fetched $N URLs" },
-  dispatched: { singular: "dispatched a sub-agent", plural: "dispatched $N sub-agents" },
-  noted: { singular: "updated the todo list", plural: "updated the todo list ($N edits)" },
-  saved: { singular: "saved a memory", plural: "saved $N memories" },
-  used: { singular: "used a tool", plural: "used $N tools" }
-};
-function formatSummary(state) {
-  const phrases = [];
-  for (const verb of state.order) {
-    const n = state.counts[verb] ?? 0;
-    if (n <= 0)
-      continue;
-    const p = VERB_PHRASE[verb];
-    phrases.push(n === 1 ? p.singular : p.plural.replace("$N", String(n)));
-  }
-  if (phrases.length === 0)
-    return null;
-  const sentence = phrases.join(", ");
-  return sentence.charAt(0).toUpperCase() + sentence.slice(1);
-}
-function registerAndRender(state, toolName) {
-  const changed = register(state, toolName);
-  if (!changed)
-    return null;
-  return formatSummary(state);
-}
 var MIRROR_MAX_LINES = 6;
+function escapeFeedHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
 function renderActivityFeed(lines) {
   if (lines.length === 0)
     return null;
   const shown = lines.slice(-MIRROR_MAX_LINES);
   const hidden = lines.length - shown.length;
-  const body = shown.map((l) => `\u00b7 ${l}`).join(`
+  const out = [];
+  if (hidden > 0)
+    out.push(`<i>\u2713 +${hidden} earlier\u2026</i>`);
+  const lastIdx = shown.length - 1;
+  shown.forEach((l, i) => {
+    const esc = escapeFeedHtml(l);
+    out.push(i === lastIdx ? `<b>\u2192 ${esc}</b>` : `<i>\u2713 ${esc}</i>`);
+  });
+  return out.join(`
 `);
-  return hidden > 0 ? `\u00b7 +${hidden} earlier\u2026
-${body}` : body;
 }
 function appendActivityLabel(lines, label) {
   const l = (label ?? "").trim();
@@ -32205,18 +32094,18 @@ function isDraft429(err) {
   const text = typeof err === "string" ? err : err instanceof Error ? err.message : typeof err === "object" && err != null && ("description" in err) ? typeof err.description === "string" ? err.description : "" : "";
   return /sendMessageDraft/i.test(text);
 }
-var DRAFT_STREAM_STATE_KEY2 = Symbol.for("switchroom.draftStreamState");
-function getDraftStreamState2() {
+var DRAFT_STREAM_STATE_KEY = Symbol.for("switchroom.draftStreamState");
+function getDraftStreamState() {
   const g = globalThis;
-  let state = g[DRAFT_STREAM_STATE_KEY2];
+  let state = g[DRAFT_STREAM_STATE_KEY];
   if (!state) {
     state = { nextDraftId: 0 };
-    g[DRAFT_STREAM_STATE_KEY2] = state;
+    g[DRAFT_STREAM_STATE_KEY] = state;
   }
   return state;
 }
-function allocateDraftId2() {
-  const state = getDraftStreamState2();
+function allocateDraftId() {
+  const state = getDraftStreamState();
   state.nextDraftId = state.nextDraftId >= 2147483647 ? 1 : state.nextDraftId + 1;
   return state.nextDraftId;
 }
@@ -32246,7 +32135,7 @@ function createDraftStream(send, edit, config = {}) {
     warn?.('draft-stream: previewTransport="auto" with sendMessageDraft but isPrivateChat undefined \u2014 defaulting to message transport');
   }
   let usesDraftTransport = prefersDraft && draftApi != null;
-  let draftId = usesDraftTransport ? allocateDraftId2() : undefined;
+  let draftId = usesDraftTransport ? allocateDraftId() : undefined;
   if (prefersDraft && !usesDraftTransport) {
     warn?.("draft-stream: sendMessageDraft unavailable; falling back to sendMessage/editMessageText");
   }
@@ -32354,7 +32243,7 @@ function createDraftStream(send, edit, config = {}) {
           const newMsgId = await send(chunk);
           messageId = newMsgId;
           persistedTextLen = textToSend.length;
-          draftId = allocateDraftId2();
+          draftId = allocateDraftId();
           currentChunkStartedAt = null;
           persistChainFires++;
           sendFires++;
@@ -38636,7 +38525,7 @@ var TRIVIAL_CONFIRMATIONS = new Set(["SENT", "DONE", "OK", "OKAY", "ACK"]);
 var MIN_INITIAL_CHARS = 50;
 var DEFAULT_THROTTLE_MS = 1000;
 var TELEGRAM_MAX_CHARS2 = 4096;
-var allocateDraftId3 = allocateDraftId2;
+var allocateDraftId2 = allocateDraftId;
 function createAnswerStream(config) {
   const {
     chatId,
@@ -38659,7 +38548,7 @@ function createAnswerStream(config) {
   const effectiveThrottle = Math.max(250, throttleMs);
   const preferDraft = isPrivateChat && draftApi != null;
   let usesDraftTransport = preferDraft;
-  let draftId = preferDraft ? allocateDraftId3() : undefined;
+  let draftId = preferDraft ? allocateDraftId2() : undefined;
   let streamMsgId;
   let pendingText = null;
   let lastSentText = "";
@@ -38908,7 +38797,7 @@ function createAnswerStream(config) {
         if (staleDraftId != null) {
           clearDraftBestEffort(staleDraftId);
         }
-        draftId = allocateDraftId3();
+        draftId = allocateDraftId2();
       }
       log?.(`answer-stream: forceNewMessage (gen=${generation})`);
     },
@@ -44601,14 +44490,14 @@ function hostdWillBeUsed(agentName3) {
     return false;
   return existsSync20(hostdSocketPath(agentName3));
 }
-async function tryHostdDispatch(agentName3, req) {
+async function tryHostdDispatch(agentName3, req, timeoutMs = 5000) {
   if (!isHostdEnabled())
     return "not-configured";
   const sockPath = hostdSocketPath(agentName3);
   if (!existsSync20(sockPath))
     return "not-configured";
   try {
-    return await hostdRequest({ socketPath: sockPath, timeoutMs: 5000 }, req);
+    return await hostdRequest({ socketPath: sockPath, timeoutMs }, req);
   } catch (err) {
     process.stderr.write(`telegram gateway: hostd dispatch failed ` + `(request_id=${req.request_id} op=${req.op}): ` + `${err.message}
 `);
@@ -49775,6 +49664,247 @@ function isRulePersisted(resolvedAllow, ruleRule) {
   return resolvedAllow.includes(ruleRule);
 }
 
+// permission-diff.ts
+var TARGET_HEADER_A = "--- a/switchroom.yaml";
+var TARGET_HEADER_B = "+++ b/switchroom.yaml";
+function indentOf(line) {
+  let n = 0;
+  while (n < line.length && line[n] === " ")
+    n++;
+  return n;
+}
+function isBlankOrComment(line) {
+  const t = line.trim();
+  return t.length === 0 || t.startsWith("#");
+}
+function locateAgentBlock(lines, agentName3) {
+  let agentsIdx = -1;
+  let agentsIndent = 0;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (isBlankOrComment(line))
+      continue;
+    if (line.trim() === "agents:") {
+      agentsIdx = i;
+      agentsIndent = indentOf(line);
+      break;
+    }
+  }
+  if (agentsIdx === -1)
+    return null;
+  let childIndent = -1;
+  for (let i = agentsIdx + 1;i < lines.length; i++) {
+    const line = lines[i];
+    if (isBlankOrComment(line))
+      continue;
+    const ind = indentOf(line);
+    if (ind <= agentsIndent)
+      break;
+    if (childIndent === -1)
+      childIndent = ind;
+    if (ind !== childIndent)
+      continue;
+    const key = line.slice(ind).split(":")[0].trim();
+    if (key === agentName3) {
+      let end = lines.length;
+      for (let j = i + 1;j < lines.length; j++) {
+        const l2 = lines[j];
+        if (isBlankOrComment(l2))
+          continue;
+        if (indentOf(l2) <= ind) {
+          end = j;
+          break;
+        }
+      }
+      return { agentIndent: ind, agentLineIdx: i, agentBlockEnd: end };
+    }
+  }
+  return null;
+}
+function locateToolsLine(lines, block) {
+  for (let i = block.agentLineIdx + 1;i < block.agentBlockEnd; i++) {
+    const line = lines[i];
+    if (isBlankOrComment(line))
+      continue;
+    const ind = indentOf(line);
+    if (ind <= block.agentIndent)
+      break;
+    const key = line.slice(ind).split(":")[0].trim();
+    if (key === "tools" && ind === block.agentIndent + 2) {
+      return { idx: i, indent: ind };
+    }
+  }
+  return null;
+}
+function locateAllowLine(lines, toolsIdx, toolsIndent, blockEnd) {
+  for (let i = toolsIdx + 1;i < blockEnd; i++) {
+    const line = lines[i];
+    if (isBlankOrComment(line))
+      continue;
+    const ind = indentOf(line);
+    if (ind <= toolsIndent)
+      break;
+    const key = line.slice(ind).split(":")[0].trim();
+    if (key === "allow" && ind === toolsIndent + 2) {
+      const after = line.slice(line.indexOf(":") + 1);
+      return { idx: i, indent: ind, inline: after };
+    }
+  }
+  return null;
+}
+function buildHunk(lines, changeStart, changeEnd, removed, added, contextN = 3) {
+  const preStart = Math.max(0, changeStart - contextN);
+  let postEnd = Math.min(lines.length, changeEnd + contextN);
+  if (postEnd === lines.length && lines.length > 0 && lines[lines.length - 1] === "") {
+    postEnd -= 1;
+  }
+  const pre = lines.slice(preStart, changeStart);
+  const post = lines.slice(changeEnd, Math.max(changeEnd, postEnd));
+  const oldCount = pre.length + removed.length + post.length;
+  const newCount = pre.length + added.length + post.length;
+  const oldStartLine = preStart + 1;
+  const newStartLine = preStart + 1;
+  const out = [];
+  out.push(`@@ -${oldStartLine},${oldCount} +${newStartLine},${newCount} @@`);
+  for (const l of pre)
+    out.push(` ${l}`);
+  for (const l of removed)
+    out.push(`-${l}`);
+  for (const l of added)
+    out.push(`+${l}`);
+  for (const l of post)
+    out.push(` ${l}`);
+  return out.join(`
+`);
+}
+function wrapDiff(hunk) {
+  return `${TARGET_HEADER_A}
+${TARGET_HEADER_B}
+${hunk}
+`;
+}
+function synthesizeAllowRuleDiff(args) {
+  const { agentName: agentName3, rule, configText } = args;
+  if (!agentName3 || !rule || !configText)
+    return null;
+  const lines = configText.split(`
+`);
+  const block = locateAgentBlock(lines, agentName3);
+  if (!block)
+    return null;
+  const tools = locateToolsLine(lines, block);
+  if (!tools) {
+    const baseIndent = block.agentIndent + 2;
+    const insertAt2 = block.agentLineIdx + 1;
+    const added2 = [
+      `${" ".repeat(baseIndent)}tools:`,
+      `${" ".repeat(baseIndent + 2)}allow:`,
+      `${" ".repeat(baseIndent + 4)}- ${rule}`
+    ];
+    const hunk2 = buildHunk(lines, insertAt2, insertAt2, [], added2);
+    return wrapDiff(hunk2);
+  }
+  const allow = locateAllowLine(lines, tools.idx, tools.indent, block.agentBlockEnd);
+  if (!allow) {
+    const baseIndent = tools.indent + 2;
+    const insertAt2 = tools.idx + 1;
+    const added2 = [
+      `${" ".repeat(baseIndent)}allow:`,
+      `${" ".repeat(baseIndent + 2)}- ${rule}`
+    ];
+    const hunk2 = buildHunk(lines, insertAt2, insertAt2, [], added2);
+    return wrapDiff(hunk2);
+  }
+  const inlineTrimmed = allow.inline.trim();
+  if (inlineTrimmed.startsWith("[")) {
+    const original = lines[allow.idx];
+    const close = original.lastIndexOf("]");
+    if (close === -1)
+      return null;
+    const inner = original.slice(original.indexOf("[") + 1, close).trim();
+    const replacement = inner.length === 0 ? `${original.slice(0, close)}${rule}${original.slice(close)}` : `${original.slice(0, close).replace(/\s*$/, "")}, ${rule}${original.slice(close)}`;
+    const hunk2 = buildHunk(lines, allow.idx, allow.idx + 1, [original], [replacement]);
+    return wrapDiff(hunk2);
+  }
+  const itemIndent = allow.indent + 2;
+  let lastItemIdx = -1;
+  for (let i = allow.idx + 1;i < block.agentBlockEnd; i++) {
+    const line = lines[i];
+    if (isBlankOrComment(line))
+      continue;
+    const ind = indentOf(line);
+    if (ind <= allow.indent)
+      break;
+    const t = line.slice(ind);
+    if (ind === itemIndent && t.startsWith("- ")) {
+      lastItemIdx = i;
+    }
+  }
+  if (lastItemIdx === -1) {
+    const insertAt2 = allow.idx + 1;
+    const added2 = [`${" ".repeat(itemIndent)}- ${rule}`];
+    const hunk2 = buildHunk(lines, insertAt2, insertAt2, [], added2);
+    return wrapDiff(hunk2);
+  }
+  const insertAt = lastItemIdx + 1;
+  const added = [`${" ".repeat(itemIndent)}- ${rule}`];
+  const hunk = buildHunk(lines, insertAt, insertAt, [], added);
+  return wrapDiff(hunk);
+}
+function extractAddedAllowRule(unifiedDiff) {
+  if (!unifiedDiff)
+    return null;
+  const lines = unifiedDiff.split(`
+`);
+  const plus = [];
+  const minus = [];
+  for (const l of lines) {
+    if (l.startsWith("+++") || l.startsWith("---"))
+      continue;
+    if (l.startsWith("@@"))
+      continue;
+    if (l.startsWith("+"))
+      plus.push(l.slice(1));
+    else if (l.startsWith("-"))
+      minus.push(l.slice(1));
+  }
+  if (minus.length === 0) {
+    const items = plus.map((p) => {
+      const ind = indentOf(p);
+      const t = p.slice(ind);
+      return t.startsWith("- ") ? t.slice(2).trim() : null;
+    }).filter((x) => x !== null);
+    if (items.length === 1)
+      return items[0];
+    return null;
+  }
+  if (minus.length === 1 && plus.length === 1) {
+    const before = extractFlowItems(minus[0]);
+    const after = extractFlowItems(plus[0]);
+    if (before === null || after === null)
+      return null;
+    if (after.length !== before.length + 1)
+      return null;
+    const added = after[after.length - 1];
+    for (let i = 0;i < before.length; i++) {
+      if (before[i] !== after[i])
+        return null;
+    }
+    return added;
+  }
+  return null;
+}
+function extractFlowItems(line) {
+  const open = line.indexOf("[");
+  const close = line.lastIndexOf("]");
+  if (open === -1 || close === -1 || close < open)
+    return null;
+  const inner = line.slice(open + 1, close).trim();
+  if (inner.length === 0)
+    return [];
+  return inner.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+
 // credits-watch.ts
 import { readFileSync as readFileSync29, writeFileSync as writeFileSync18, existsSync as existsSync30, mkdirSync as mkdirSync16 } from "fs";
 import { join as join27 } from "path";
@@ -50094,10 +50224,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.7";
-var COMMIT_SHA = "0f782e65";
-var COMMIT_DATE = "2026-05-28T22:15:06Z";
-var LATEST_PR = 1976;
+var VERSION = "0.14.9";
+var COMMIT_SHA = "fd8ed8ed";
+var COMMIT_DATE = "2026-05-29T03:11:29Z";
+var LATEST_PR = 1985;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -51485,6 +51615,15 @@ var STATUS_QUERY_RE = /^\s*status\??\s*$/i;
 var PERMISSION_REPLY_RE = /^\s*(y|yes|n|no)\s+([a-km-z]{5})\s*$/i;
 var pendingPermissions = new Map;
 var PERMISSION_TTL_MS = 600000;
+var pendingAlwaysAllowCorrelations = new Map;
+var ALWAYS_ALLOW_CORRELATION_TTL_MS = 30000;
+function sweepStaleAlwaysAllowCorrelations(now = Date.now()) {
+  for (const [key, entry] of pendingAlwaysAllowCorrelations) {
+    if (now - entry.createdAt > ALWAYS_ALLOW_CORRELATION_TTL_MS) {
+      pendingAlwaysAllowCorrelations.delete(key);
+    }
+  }
+}
 var pendingAskUser = new Map;
 var pendingReauthFlows = new Map;
 var REAUTH_INTERCEPT_TTL_MS = 600000;
@@ -51870,13 +52009,6 @@ var ANSWER_STREAM_VISIBLE_ENABLED = (() => {
     return false;
   return true;
 })();
-var DRAFT_MIRROR_ENABLED = (() => {
-  const raw = process.env.SWITCHROOM_DRAFT_MIRROR;
-  if (raw == null)
-    return false;
-  const v = raw.trim().toLowerCase();
-  return !(v === "0" || v === "false" || v === "off" || v === "no");
-})();
 var progressDriver = null;
 var unpinProgressCardForChat = null;
 var getPinnedProgressCardMessageId = null;
@@ -52589,7 +52721,20 @@ ${reminder}
         });
       },
       log: (m) => process.stderr.write(`telegram gateway: config-approval \u2014 ${m}
-`)
+`),
+      tryAutoResolve: (msg2) => {
+        sweepStaleAlwaysAllowCorrelations();
+        const added = extractAddedAllowRule(msg2.unifiedDiff);
+        if (!added)
+          return null;
+        const key = `${msg2.agentName}::${added}`;
+        const entry = pendingAlwaysAllowCorrelations.get(key);
+        if (entry && entry.unifiedDiff === msg2.unifiedDiff) {
+          pendingAlwaysAllowCorrelations.delete(key);
+          return "approve";
+        }
+        return null;
+      }
     });
   },
   async onRequestConfigFinalize(client3, msg) {
@@ -54084,22 +54229,17 @@ async function drainActivitySummary(turn) {
       const target = turn.activityPendingRender;
       if (target == null)
         break;
-      const html = `<i>${escapeHtmlForTg(target)}</i>`;
+      const html = target;
       const chat = turn.sessionChatId;
       const thread = turn.sessionThreadId;
-      const useDraft = turn.isDm && thread == null && sendMessageDraftFn != null;
+      const replyAnchor = turn.sourceMessageId != null ? { reply_parameters: { message_id: turn.sourceMessageId, allow_sending_without_reply: true } } : {};
       try {
-        if (useDraft) {
-          if (turn.activityDraftId == null) {
-            turn.activityDraftId = allocateDraftId();
-          }
-          const draftId = turn.activityDraftId;
-          await sendMessageDraftFn(chat, draftId, html, { parse_mode: "HTML" });
-        } else if (turn.activityMessageId == null) {
+        if (turn.activityMessageId == null) {
           const sent = await robustApiCall(() => bot.api.sendMessage(chat, html, {
             ...thread != null ? { message_thread_id: thread } : {},
             parse_mode: "HTML",
-            disable_notification: true
+            disable_notification: true,
+            ...replyAnchor
           }), { chat_id: chat, ...thread != null ? { threadId: thread } : {}, verb: "activity-summary.send" });
           turn.activityMessageId = sent.message_id;
         } else {
@@ -54125,16 +54265,7 @@ function clearActivitySummary(turn) {
   const thread = turn.sessionThreadId;
   const inFlight = turn.activityInFlight ?? Promise.resolve();
   inFlight.then(async () => {
-    if (turn.activityDraftId != null && sendMessageDraftFn != null) {
-      const draftId = turn.activityDraftId;
-      turn.activityDraftId = null;
-      try {
-        await sendMessageDraftFn(chat, draftId, "", undefined);
-      } catch (err) {
-        process.stderr.write(`telegram gateway: activity-summary draft-clear failed: ${err}
-`);
-      }
-    } else if (turn.activityMessageId != null) {
+    if (turn.activityMessageId != null) {
       const id = turn.activityMessageId;
       turn.activityMessageId = null;
       try {
@@ -54165,6 +54296,7 @@ function handleSessionEvent(ev) {
         const next = {
           sessionChatId: ev.chatId,
           sessionThreadId: ev.threadId != null ? Number(ev.threadId) : undefined,
+          sourceMessageId: ev.messageId != null && /^\d+$/.test(ev.messageId) ? Number(ev.messageId) : null,
           startedAt,
           gatewayReceiveAt: startedAt,
           replyCalled: false,
@@ -54178,9 +54310,7 @@ function handleSessionEvent(ev) {
           lastAssistantMsgId: null,
           lastAssistantDone: false,
           toolCallCount: 0,
-          toolActivity: makeEmptyActivityState(),
           activityMessageId: null,
-          activityDraftId: null,
           activityInFlight: null,
           activityPendingRender: null,
           activityLastSentRender: null,
@@ -54255,19 +54385,10 @@ function handleSessionEvent(ev) {
           clearTimeout(turn.orphanedReplyTimeoutId);
           turn.orphanedReplyTimeoutId = null;
         }
-        if (wasFirstReply && !DRAFT_MIRROR_ENABLED) {
+        if (wasFirstReply) {
           clearActivitySummary(turn);
         }
       }
-      if (!DRAFT_MIRROR_ENABLED && !turn.replyCalled && !isTelegramSurfaceTool(name)) {
-        const rendered = registerAndRender(turn.toolActivity, name);
-        if (rendered != null) {
-          turn.activityPendingRender = rendered;
-          if (turn.activityInFlight == null) {
-            turn.activityInFlight = drainActivitySummary(turn);
-          }
-        }
-      }
       if (!ctrl)
         return;
       if (isTelegramSurfaceTool(name))
@@ -54279,13 +54400,13 @@ function handleSessionEvent(ev) {
       return;
     }
     case "tool_label": {
-      if (!DRAFT_MIRROR_ENABLED)
-        return;
       const turn = currentTurn;
       if (turn == null)
         return;
       if (isTelegramSurfaceTool(ev.toolName))
         return;
+      if (turn.replyCalled)
+        return;
       const rendered = appendActivityLabel(turn.mirrorLines, ev.label);
       if (rendered != null) {
         turn.activityPendingRender = rendered;
@@ -54424,7 +54545,7 @@ function handleSessionEvent(ev) {
         clearTimeout(turn.orphanedReplyTimeoutId);
         turn.orphanedReplyTimeoutId = null;
       }
-      if (DRAFT_MIRROR_ENABLED && turn != null) {
+      if (turn != null) {
         clearActivitySummary(turn);
       }
       preambleSuppressor.flushNow();
@@ -59062,59 +59183,110 @@ ${prettyInput}`;
       await ctx.answerCallbackQuery({ text: "Always-allow needs SWITCHROOM_AGENT_NAME \u2014 gateway is misconfigured." }).catch(() => {});
       return;
     }
-    let grantOk = false;
-    let grantFailReason = "";
-    try {
-      switchroomExec(["agent", "grant", agentName3, rule.rule, "--no-restart"]);
+    pendingPermissions.delete(request_id);
+    dispatchPermissionVerdict({
+      type: "permission",
+      requestId: request_id,
+      behavior: "allow",
+      rule: rule.rule
+    });
+    let durable = false;
+    let legacy = false;
+    let failReason = "";
+    let editLockHint = false;
+    const configEditDisabled = (msg2) => msg2.includes("E_CONFIG_EDIT_DISABLED");
+    const unifiedDiff = (() => {
       try {
-        const cfg = loadConfig2();
-        const rawAgent = cfg.agents?.[agentName3];
-        if (rawAgent) {
-          const resolved = resolveAgentConfig2(cfg.defaults, cfg.profiles, rawAgent);
-          const allowList = resolved.tools?.allow ?? [];
-          if (isRulePersisted(allowList, rule.rule)) {
-            grantOk = true;
-            process.stderr.write(`telegram gateway: always-allow added rule="${rule.rule}" agent=${agentName3} (request_id=${request_id})
-`);
-          } else {
-            grantFailReason = `rule "${rule.rule}" not found in resolved tools.allow after write \u2014 config location may have drifted`;
-            process.stderr.write(`telegram gateway: always-allow VERIFY FAILED: ${grantFailReason} (request_id=${request_id})
+        const cfgPath = process.env.SWITCHROOM_CONFIG ?? SWITCHROOM_CONFIG ?? findConfigFile2();
+        const raw = readFileSync34(cfgPath, "utf8");
+        return synthesizeAllowRuleDiff({ agentName: agentName3, rule: rule.rule, configText: raw });
+      } catch (err) {
+        process.stderr.write(`telegram gateway: always-allow diff synth failed: ${err.message}
 `);
+        return null;
+      }
+    })();
+    const correlationKey = `${agentName3}::${rule.rule}`;
+    try {
+      if (unifiedDiff == null) {
+        legacy = true;
+      } else {
+        pendingAlwaysAllowCorrelations.set(correlationKey, { agentName: agentName3, rule: rule.rule, unifiedDiff, createdAt: Date.now() });
+        const req = {
+          v: 1,
+          op: "config_propose_edit",
+          request_id: hostdRequestId("gw-always-allow"),
+          args: {
+            unified_diff: unifiedDiff,
+            reason: `Operator 'always allow' for ${rule.label}`,
+            target_path: "/state/config/switchroom.yaml"
           }
+        };
+        const resp = await tryHostdDispatch(agentName3, req, 60000);
+        if (resp === "not-configured") {
+          warnLegacySpawnIfHostdDisabled("always-allow");
+          legacy = true;
+        } else if (resp.result === "completed") {
+          durable = true;
+          process.stderr.write(`telegram gateway: always-allow durable via hostd rule="${rule.rule}" agent=${agentName3} (request_id=${request_id})
+`);
         } else {
-          grantFailReason = `agent "${agentName3}" not found in config after write`;
-          process.stderr.write(`telegram gateway: always-allow VERIFY FAILED: ${grantFailReason} (request_id=${request_id})
+          failReason = resp.error ?? `hostd ${resp.result}`;
+          if (configEditDisabled(failReason))
+            editLockHint = true;
+          process.stderr.write(`telegram gateway: always-allow hostd FAILED: ${failReason} (request_id=${request_id})
 `);
         }
-      } catch (verifyErr) {
-        grantFailReason = `config re-read failed: ${verifyErr.message}`;
-        process.stderr.write(`telegram gateway: always-allow VERIFY FAILED: ${grantFailReason} (request_id=${request_id})
-`);
       }
-    } catch (err) {
-      grantFailReason = err.message;
-      process.stderr.write(`telegram gateway: always-allow grant failed: ${grantFailReason}
+      if (legacy) {
+        try {
+          switchroomExec(["agent", "grant", agentName3, rule.rule, "--no-restart"]);
+          try {
+            const cfg = loadConfig2();
+            const rawAgent = cfg.agents?.[agentName3];
+            if (rawAgent) {
+              const resolved = resolveAgentConfig2(cfg.defaults, cfg.profiles, rawAgent);
+              const allowList = resolved.tools?.allow ?? [];
+              if (isRulePersisted(allowList, rule.rule)) {
+                durable = true;
+                process.stderr.write(`telegram gateway: always-allow added rule="${rule.rule}" agent=${agentName3} via legacy grant (request_id=${request_id})
+`);
+              } else {
+                failReason = `rule "${rule.rule}" not found in resolved tools.allow after write \u2014 config location may have drifted`;
+                process.stderr.write(`telegram gateway: always-allow VERIFY FAILED: ${failReason} (request_id=${request_id})
+`);
+              }
+            } else {
+              failReason = `agent "${agentName3}" not found in config after write`;
+              process.stderr.write(`telegram gateway: always-allow VERIFY FAILED: ${failReason} (request_id=${request_id})
+`);
+            }
+          } catch (verifyErr) {
+            failReason = `config re-read failed: ${verifyErr.message}`;
+            process.stderr.write(`telegram gateway: always-allow VERIFY FAILED: ${failReason} (request_id=${request_id})
 `);
+          }
+        } catch (err) {
+          failReason = err.message;
+          process.stderr.write(`telegram gateway: always-allow grant failed: ${failReason}
+`);
+        }
+      }
+    } finally {
+      pendingAlwaysAllowCorrelations.delete(correlationKey);
     }
-    pendingPermissions.delete(request_id);
-    const ackText = grantOk ? `\uD83D\uDD01 Always allow ${rule.label} for ${agentName3}` : `\u26A0\uFE0F Allowed for now, but "always" did NOT save \u2014 it will ask again after restart. Check gateway log.`;
+    const ok = durable;
+    const legacyNote = legacy && durable;
+    const ackText = ok ? legacyNote ? `\uD83D\uDD01 Always allow ${rule.label} for ${agentName3} (legacy path)` : `\uD83D\uDD01 Always allow ${rule.label} for ${agentName3}` : editLockHint ? `\u26A0\uFE0F Allowed for now \u2014 config edits are locked. Enable hostd.config_edit_enabled.` : `\u26A0\uFE0F Allowed for now, but "always" did NOT save \u2014 it will ask again after restart. Check gateway log.`;
     const sourceMsg = ctx.callbackQuery?.message;
     const baseText2 = sourceMsg && "text" in sourceMsg && sourceMsg.text ? escapeHtmlForTg(sourceMsg.text) : "";
-    const editLabel = grantOk ? `\uD83D\uDD01 <b>Always allow ${escapeHtmlForTg(rule.label)}</b> for ${escapeHtmlForTg(agentName3)} \u2014 restart agent for full effect` : `\u26A0\uFE0F <b>Allowed for now \u2014 "always" did NOT save.</b> It will ask again after restart. Check gateway log.`;
+    const editLabel = ok ? legacyNote ? `\uD83D\uDD01 <b>Always allow ${escapeHtmlForTg(rule.label)}</b> for ${escapeHtmlForTg(agentName3)} \u2014 saved (legacy path); restart agent for full effect` : `\uD83D\uDD01 <b>Always allow ${escapeHtmlForTg(rule.label)}</b> for ${escapeHtmlForTg(agentName3)} \u2014 saved; restart agent for full effect` : editLockHint ? `\u26A0\uFE0F <b>Allowed for now \u2014 "always" did NOT save.</b> Config edits are locked; enable <code>hostd.config_edit_enabled</code>.` : `\u26A0\uFE0F <b>Allowed for now \u2014 "always" did NOT save.</b> It will ask again after restart. Check gateway log.`;
     await finalizeCallback(ctx, {
       ackText: ackText.slice(0, 200),
       newText: baseText2 ? `${baseText2}
 
 ${editLabel}` : editLabel,
-      parseMode: "HTML",
-      synthInbound: () => {
-        dispatchPermissionVerdict({
-          type: "permission",
-          requestId: request_id,
-          behavior: "allow",
-          ...grantOk ? { rule: rule.rule } : {}
-        });
-      }
+      parseMode: "HTML"
     });
     return;
   }