switchroom 0.14.7 → 0.14.9

package/telegram-plugin/tests/tool-activity-summary.test.ts

@@ -1,10 +1,5 @@
 import { describe, it, expect } from "vitest";
 import {
-  makeEmptyActivityState,
-  register,
-  formatSummary,
-  registerAndRender,
-  verbForTool,
   describeToolUse,
   appendActivityLine,
   appendActivityLabel,
@@ -77,228 +72,17 @@ describe("describeToolUse — friendly per-tool rendering (draft-mirror)", () =>
   });
 });
 
-describe("verbForTool — tool name → past-tense verb", () => {
-  it("maps standard CLI tools to readable verbs", () => {
-    expect(verbForTool("Read")).toBe("read");
-    expect(verbForTool("Write")).toBe("created");
-    expect(verbForTool("Edit")).toBe("edited");
-    expect(verbForTool("MultiEdit")).toBe("edited");
-    expect(verbForTool("NotebookEdit")).toBe("edited");
-    expect(verbForTool("Bash")).toBe("ran");
-    expect(verbForTool("BashOutput")).toBe("ran");
-    expect(verbForTool("WebSearch")).toBe("searched");
-    expect(verbForTool("Grep")).toBe("searched");
-    expect(verbForTool("Glob")).toBe("searched");
-    expect(verbForTool("WebFetch")).toBe("fetched");
-    expect(verbForTool("Task")).toBe("dispatched");
-    expect(verbForTool("Agent")).toBe("dispatched");
-    expect(verbForTool("TodoWrite")).toBe("noted");
-  });
-
-  it("skips user-facing switchroom-telegram tools (those ARE the surface)", () => {
-    expect(verbForTool("mcp__switchroom-telegram__reply")).toBeNull();
-    expect(verbForTool("mcp__switchroom-telegram__stream_reply")).toBeNull();
-    expect(verbForTool("mcp__switchroom-telegram__edit_message")).toBeNull();
-    expect(verbForTool("mcp__switchroom-telegram__react")).toBeNull();
-  });
-
-  it("maps recognised MCP tools (hindsight, google-workspace, notion) to specific verbs", () => {
-    // hindsight: recall/reflect → searched, retain/update_memory → saved
-    expect(verbForTool("mcp__hindsight__reflect")).toBe("searched");
-    expect(verbForTool("mcp__hindsight__recall")).toBe("searched");
-    expect(verbForTool("mcp__hindsight__retain")).toBe("saved");
-    expect(verbForTool("mcp__hindsight__update_memory")).toBe("saved");
-    // google-workspace / claude.ai variants: read-shaped → searched, write-shaped → edited
-    expect(verbForTool("mcp__google-workspace__list_files")).toBe("searched");
-    expect(verbForTool("mcp__claude_ai_Gmail__search_messages")).toBe("searched");
-    expect(verbForTool("mcp__google-workspace__create_file")).toBe("edited");
-    expect(verbForTool("mcp__claude_ai_Google_Drive__download_file_content")).toBe("searched");
-    // notion: query/get → searched, create/update → edited
-    expect(verbForTool("mcp__notion__query_database")).toBe("searched");
-    expect(verbForTool("mcp__claude_ai_Notion__notion-search")).toBe("searched");
-    expect(verbForTool("mcp__claude_ai_Notion__notion-update-page")).toBe("edited");
-  });
-
-  it("returns 'used' for genuinely unknown MCP / future tools (generic fallback)", () => {
-    expect(verbForTool("mcp__random-third-party__do_thing")).toBe("used");
-    expect(verbForTool("SomeFutureUnknownTool")).toBe("used");
-  });
-
-  it("returns null for empty toolName (defensive)", () => {
-    expect(verbForTool("")).toBeNull();
-  });
-});
-
-describe("register + formatSummary — Claude Code-style summary", () => {
-  it("formats a single Read as 'Read a file'", () => {
-    const s = makeEmptyActivityState();
-    register(s, "Read");
-    expect(formatSummary(s)).toBe("Read a file");
-  });
-
-  it("formats multiple Reads as 'Read N files'", () => {
-    const s = makeEmptyActivityState();
-    register(s, "Read");
-    register(s, "Read");
-    register(s, "Read");
-    expect(formatSummary(s)).toBe("Read 3 files");
-  });
-
-  it("formats single Bash as 'Ran a command'", () => {
-    const s = makeEmptyActivityState();
-    register(s, "Bash");
-    expect(formatSummary(s)).toBe("Ran a command");
-  });
-
-  it("formats multiple Bash as 'Ran N commands'", () => {
-    const s = makeEmptyActivityState();
-    for (let i = 0; i < 5; i++) register(s, "Bash");
-    expect(formatSummary(s)).toBe("Ran 5 commands");
-  });
-
-  it("joins multiple verb-classes with commas (first-occurrence order)", () => {
-    const s = makeEmptyActivityState();
-    // Tools fire in this order: Read → Bash → Edit
-    register(s, "Read");
-    register(s, "Bash");
-    register(s, "Edit");
-    // The summary renders chronologically: read, ran, edited.
-    expect(formatSummary(s)).toBe("Read a file, ran a command, edited a file");
-  });
-
-  it("matches the Claude Code screenshot examples", () => {
-    // "Ran 5 commands, read a file"
-    const s1 = makeEmptyActivityState();
-    for (let i = 0; i < 5; i++) register(s1, "Bash");
-    register(s1, "Read");
-    expect(formatSummary(s1)).toBe("Ran 5 commands, read a file");
-
-    // "Edited a file, read a file, ran a command"
-    const s2 = makeEmptyActivityState();
-    register(s2, "Edit");
-    register(s2, "Read");
-    register(s2, "Bash");
-    expect(formatSummary(s2)).toBe("Edited a file, read a file, ran a command");
-
-    // "Created a file, ran a command"
-    const s3 = makeEmptyActivityState();
-    register(s3, "Write");
-    register(s3, "Bash");
-    expect(formatSummary(s3)).toBe("Created a file, ran a command");
-  });
-
-  it("returns null when state is empty", () => {
-    expect(formatSummary(makeEmptyActivityState())).toBeNull();
-  });
-
-  it("ignores user-facing tools (reply/stream_reply etc.)", () => {
-    const s = makeEmptyActivityState();
-    register(s, "mcp__switchroom-telegram__reply");
-    register(s, "mcp__switchroom-telegram__stream_reply");
-    expect(formatSummary(s)).toBeNull(); // nothing tracked
-  });
-
-  it("includes generic 'used' for genuinely-unknown MCP tools (fallback)", () => {
-    const s = makeEmptyActivityState();
-    register(s, "mcp__random-third-party__do_thing");
-    expect(formatSummary(s)).toBe("Used a tool");
-    register(s, "mcp__another-unknown-server__something_else");
-    expect(formatSummary(s)).toBe("Used 2 tools");
-  });
-
-  it("maps recognised MCP tools to natural-language summaries (no generic 'Used N tools')", () => {
-    // hindsight search shows up as 'searched' (memory)
-    const s = makeEmptyActivityState();
-    register(s, "mcp__hindsight__reflect");
-    expect(formatSummary(s)).toBe("Ran a search");
-    register(s, "mcp__hindsight__reflect");
-    expect(formatSummary(s)).toBe("Ran 2 searches");
-    // hindsight retain shows up as 'saved a memory'
-    register(s, "mcp__hindsight__retain");
-    expect(formatSummary(s)).toBe("Ran 2 searches, saved a memory");
-  });
-
-  it("tracks firstToolName for forensic / telemetry use", () => {
-    const s = makeEmptyActivityState();
-    register(s, "Read");
-    register(s, "Bash");
-    expect(s.firstToolName).toBe("Read");
-  });
-});
-
-describe("parallel-tool-use coalescing — render only reflects accumulated state", () => {
-  it("synchronous burst of N tool_uses produces the right summary at each step", () => {
-    // Modern Claude emits parallel tool_uses in a tight sync loop. The
-    // gateway calls register() N times before any async drain runs.
-    // After N registers, the rendered string should reflect ALL of them
-    // — so when the drain fires once with the latest pendingRender, the
-    // sent text is correct and complete.
-    const s = makeEmptyActivityState();
-    register(s, "Read");
-    register(s, "Read");
-    register(s, "Read");
-    register(s, "Bash");
-    register(s, "Bash");
-    expect(formatSummary(s)).toBe("Read 3 files, ran 2 commands");
-  });
-
-  it("ordering is preserved across a chronological burst", () => {
-    const s = makeEmptyActivityState();
-    // Simulates: Bash, then Read, then Bash, then Read, then Edit
-    register(s, "Bash");
-    register(s, "Read");
-    register(s, "Bash");
-    register(s, "Read");
-    register(s, "Edit");
-    // Bash was first, then Read, then Edit. Counts: bash 2, read 2, edit 1.
-    expect(formatSummary(s)).toBe(
-      "Ran 2 commands, read 2 files, edited a file",
-    );
-  });
-
-  it("registerAndRender returns null on user-facing tools (no race contribution)", () => {
-    const s = makeEmptyActivityState();
-    register(s, "Read");
-    // A reply tool fires concurrently — should not enter the activity state.
-    expect(
-      registerAndRender(s, "mcp__switchroom-telegram__reply"),
-    ).toBeNull();
-    // State still reflects only the Read.
-    expect(formatSummary(s)).toBe("Read a file");
-  });
-});
-
-describe("registerAndRender — ergonomic full-pipeline call", () => {
-  it("returns the updated rendered text on a real tool (chronological)", () => {
-    const s = makeEmptyActivityState();
-    expect(registerAndRender(s, "Read")).toBe("Read a file");
-    // Bash fires AFTER Read — chronological order shows read first.
-    expect(registerAndRender(s, "Bash")).toBe(
-      "Read a file, ran a command",
-    );
-  });
-
-  it("returns null on a surface tool (no-op)", () => {
-    const s = makeEmptyActivityState();
-    expect(
-      registerAndRender(s, "mcp__switchroom-telegram__reply"),
-    ).toBeNull();
-    // State unchanged
-    expect(s.firstToolName).toBeNull();
-  });
-});
-
-describe("appendActivityLine + renderActivityFeed — accumulating draft feed", () => {
-  it("accumulates distinct actions chronologically (newest last)", () => {
+describe("appendActivityLine + renderActivityFeed — accumulating activity feed", () => {
+  it("accumulates distinct actions chronologically (newest = current → bold, earlier = done ✓ italic)", () => {
     const lines: string[] = [];
     expect(appendActivityLine(lines, "Read", { file_path: "a/gateway.ts" })).toBe(
-      "· Reading gateway.ts",
+      "<b>→ Reading gateway.ts</b>",
     );
     expect(appendActivityLine(lines, "mcp__hindsight__reflect", { query: "x" })).toBe(
-      "· Reading gateway.ts\n· Searching memory",
+      "<i>✓ Reading gateway.ts</i>\n<b>→ Searching memory</b>",
     );
     expect(appendActivityLine(lines, "Bash", { command: "ls", description: "List workspace" })).toBe(
-      "· Reading gateway.ts\n· Searching memory\n· List workspace",
+      "<i>✓ Reading gateway.ts</i>\n<i>✓ Searching memory</i>\n<b>→ List workspace</b>",
     );
   });
 
@@ -315,14 +99,26 @@ describe("appendActivityLine + renderActivityFeed — accumulating draft feed",
     expect(lines).toEqual([]);
   });
 
-  it("caps to the last MIRROR_MAX_LINES with a '+N earlier' header", () => {
+  it("caps to the last MIRROR_MAX_LINES with a '✓ +N earlier…' header", () => {
     const lines = Array.from({ length: 9 }, (_, i) => `Action ${i + 1}`);
     const out = renderActivityFeed(lines)!;
-    expect(out.startsWith("· +3 earlier…\n")).toBe(true);
-    // Only the last 6 actions are shown.
-    expect(out).toContain("· Action 4");
-    expect(out).toContain("· Action 9");
-    expect(out).not.toContain("· Action 3\n");
+    expect(out.startsWith("<i>✓ +3 earlier…</i>\n")).toBe(true);
+    // Only the last 6 actions are shown; the oldest 3 are collapsed.
+    expect(out).toContain("<i>✓ Action 4</i>");
+    expect(out).not.toContain("Action 3");
+    // The newest action is the in-progress step (bold →); the rest are done (✓).
+    expect(out).toContain("<b>→ Action 9</b>");
+    expect(out).toContain("<i>✓ Action 8</i>");
+    expect(out).not.toContain("<b>→ Action 8</b>");
+  });
+
+  it("HTML-escapes &, <, > in action text (no double-escaping by callers)", () => {
+    const out = renderActivityFeed(["Running <foo> & <bar>"])!;
+    expect(out).toBe("<b>→ Running &lt;foo&gt; &amp; &lt;bar&gt;</b>");
+  });
+
+  it("renders a single line as the current (bold →) step", () => {
+    expect(renderActivityFeed(["Reading a.ts"])).toBe("<b>→ Reading a.ts</b>");
   });
 
   it("renderActivityFeed returns null on empty", () => {
@@ -333,9 +129,9 @@ describe("appendActivityLine + renderActivityFeed — accumulating draft feed",
 describe("appendActivityLabel — precomputed label feed (tool_label path)", () => {
   it("accumulates precomputed labels, dedups consecutive, ignores empty", () => {
     const lines: string[] = [];
-    expect(appendActivityLabel(lines, "Searching memory")).toBe("· Searching memory");
+    expect(appendActivityLabel(lines, "Searching memory")).toBe("<b>→ Searching memory</b>");
     expect(appendActivityLabel(lines, "List workspace")).toBe(
-      "· Searching memory\n· List workspace",
+      "<i>✓ Searching memory</i>\n<b>→ List workspace</b>",
     );
     // consecutive dup collapses
     appendActivityLabel(lines, "List workspace");

package/telegram-plugin/tool-activity-summary.ts

@@ -1,205 +1,26 @@
 /**
- * Tool-activity summary — Claude Code-style natural-language progress
- * line that batches tool_use events for a turn into a single Telegram
- * message that updates in place.
+ * Tool-activity feed — a Claude-Code-style live list of what the agent
+ * is doing this turn, rendered into ONE Telegram message that edits in
+ * place and clears the moment the model's real reply lands.
  *
- * Replaces the per-tool intent surface (#1924). The screenshot from
- * Claude Code's own UI shows lines like:
+ * Each non-surface tool gets a human-friendly, present-tense line
+ * ("Reading CLAUDE.md", "Searching memory", "Running a command"); the
+ * feed renders them chronologically (oldest first, newest = the
+ * in-progress step), consecutive duplicates collapsed, capped to the
+ * most recent MIRROR_MAX_LINES with a "+N earlier" header.
  *
- *   "Ran 5 commands, read a file"
- *   "Edited a file, read a file, ran a command"
- *
- * Past tense, comma-joined, singular/plural-aware. One message per
- * "phase" (turn start → first reply), progressively edited as tools
- * accumulate. NOT raw tool calls — descriptions of what the agent has
- * been doing.
- *
- * Why this beats per-tool labels:
- *   - One Telegram message per phase (low signal-to-noise vs N
- *     messages on a heavy turn)
- *   - The user sees ACCUMULATED work in a glanceable form, not a flood
- *   - Plays nicely with the existing answer-lane stream that handles
- *     the actual reply text
- *
- * Tracking shape: per-turn counters keyed by `verb` (the action class
- * derived from tool name). One counter per verb so the summary line
- * collapses neatly regardless of which specific Read/Bash/WebSearch
- * the model chose. `register()` increments the counter; `formatSummary()`
- * renders the current state.
+ * Two append entrypoints feed the same `lines: string[]` accumulator:
+ *   - `appendActivityLabel` — for a pre-computed label from the
+ *     real-time PreToolUse sidecar (`tool_label` event). This is the
+ *     gateway's live driver: it fires at tool-call time regardless of
+ *     when claude flushes the transcript, so it stays deterministic on
+ *     fast/clustered-tool turns.
+ *   - `appendActivityLine` — derives the label from a tool_use's name +
+ *     input via `describeToolUse` (used where the raw tool_use is the
+ *     only signal available).
  */
 
-const READ_VERBS = new Set(["read"]);
-const WRITE_VERBS = new Set(["wrote", "created", "edited"]);
-
-export type ActivityVerb =
-  | "read"
-  | "edited"
-  | "created"
-  | "ran"
-  | "searched"
-  | "fetched"
-  | "dispatched"
-  | "noted"
-  | "saved" // memory-retain class (hindsight, etc.) — distinct from "noted" (TodoWrite)
-  | "used"; // generic fallback
-
-/** Object form so `register()` can mutate; pure functions inside the
- *  module work against this shape (easier to unit-test than a Map). */
-export interface ActivityState {
-  counts: Partial<Record<ActivityVerb, number>>;
-  /** Order verbs were first observed this turn. The summary renders in
-   *  this order so the line reads as a chronological natural-language
-   *  account: "edited a file, read a file, ran a command" matches the
-   *  agent's actual sequence of actions. Stable — once a verb is added
-   *  to this list, it never moves. */
-  order: ActivityVerb[];
-  /** First non-trivial tool name observed this turn (for telemetry / future
-   *  "what kicked this off" forensic). Not used in the rendered summary. */
-  firstToolName: string | null;
-}
-
-export function makeEmptyActivityState(): ActivityState {
-  return { counts: {}, order: [], firstToolName: null };
-}
-
-/** Map a tool name → verb. Mirrors the existing `tool-intent-surface.ts`
- *  verb table but in past tense. Tools that don't map (or surface tools
- *  like reply/stream_reply) return null — the caller skips them. */
-export function verbForTool(toolName: string): ActivityVerb | null {
-  if (!toolName) return null;
-  // Lazy match on the server segment so names containing underscores
-  // (e.g. `mcp__claude_ai_Gmail__search`) parse as
-  //   server="claude_ai_Gmail", tool="search"
-  // instead of the prior `[^_]+` which stopped at the first inner `_`.
-  const mcpMatch = /^mcp__(.+?)__(.+)$/.exec(toolName);
-  // Skip user-facing Telegram-plugin tools entirely — those ARE the
-  // surface, never to be summarised.
-  if (mcpMatch && mcpMatch[1] === "switchroom-telegram") return null;
-
-  // MCP allowlist — map common MCP tools to specific verbs so the summary
-  // reads as "Searched memory" or "Read 2 files" instead of the generic
-  // fallback "Used 2 tools". Tools NOT on this list fall through to the
-  // generic "used" verb, which is still better than nothing for one-offs
-  // but hurts on heavy MCP turns. Mirrors the label table in
-  // `telegram-plugin/hooks/tool-label-pretool.mjs` — keep them in sync.
-  if (mcpMatch) {
-    // Case-insensitive match — claude.ai prefixes use mixed-case
-    // server names ("claude_ai_Gmail", "claude_ai_Google_Drive") so we
-    // lowercase both sides before comparing.
-    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") {
-      // claude.ai Notion exposes tools as `notion-search`, `notion-update-page`,
-      // etc. Strip the redundant `notion-` prefix before matching the verb.
-      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";
-  }
-}
-
-/** Mutates `state` to record one tool_use of `toolName`. Returns true
- *  iff the activity state changed (so the caller knows to refresh the
- *  rendered summary). */
-export function register(state: ActivityState, toolName: string): boolean {
-  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;
-}
-
-interface VerbPhrase {
-  singular: string;
-  plural: string;
-}
-
-const VERB_PHRASE: Record<ActivityVerb, VerbPhrase> = {
-  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" },
-};
-
-/** Render the activity state as a single natural-language line.
- *  Verbs are rendered in `state.order` — first-occurrence order — so
- *  the line reads chronologically ("edited a file, read a file, ran
- *  a command" mirrors the agent's actual action sequence). Returns
- *  null when the state is empty (nothing to show yet). */
-export function formatSummary(state: ActivityState): string | null {
-  const phrases: string[] = [];
-  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;
-  // Capitalize first letter so the sentence reads as a statement.
-  const sentence = phrases.join(", ");
-  return sentence.charAt(0).toUpperCase() + sentence.slice(1);
-}
-
-/** Convenience: ergonomic full pipeline for callers that just want
- *  "given the new tool name and prior state, give me the updated rendered
- *  text or null if nothing changed". Returns null when the tool is a
- *  surface tool / no-op (so the caller can skip the Telegram edit). */
-export function registerAndRender(
-  state: ActivityState,
-  toolName: string,
-): string | null {
-  const changed = register(state, toolName);
-  if (!changed) return null;
-  return formatSummary(state);
-}
-
-// ─── Friendly per-tool rendering (draft-mirror, RFC draft-mirror-preview) ───
+// ─── Friendly per-tool rendering ────────────────────────────────────────────
 //
 // Claude Code's own UI reads human-friendly because the model AUTHORS the
 // descriptive text inside each tool_use.input — verified against a real
@@ -338,19 +159,18 @@ export function describeToolUse(
 
 // ─── Accumulating activity feed (draft-mirror Phase 2) ──────────────────────
 //
-// Phase 1 showed only the latest action; this accumulates the turn's actions
-// into a running feed — like Claude Code's own UI — streamed into the
-// ephemeral draft and cleared on reply. Chronological (oldest first, newest
-// last), consecutive exact-duplicates collapsed, capped to the most recent
-// MIRROR_MAX_LINES with a "+N earlier" header so a heavy turn stays readable
-// inside Telegram's compose-area draft.
+// Accumulates the turn's actions into a running feed — like Claude Code's
+// own UI — rendered into one Telegram message that edits in place and is
+// cleared on reply. Chronological (oldest first, newest last), consecutive
+// exact-duplicates collapsed, capped to the most recent MIRROR_MAX_LINES
+// with a "+N earlier" header so a heavy turn stays readable.
 
 export const MIRROR_MAX_LINES = 6;
 
 /**
  * Append a tool_use's friendly line to the running feed (mutates `lines`)
- * and return the rendered draft body — or null when the tool is a surface
- * tool / produced no line (caller skips the draft update).
+ * and return the rendered feed (ready Telegram HTML) — or null when the
+ * tool is a surface tool / produced no line (caller skips the update).
  *
  * Dedups only consecutive identical lines (e.g. a burst of parallel Reads of
  * the same file) so distinct actions are all preserved.
@@ -368,19 +188,32 @@ export function appendActivityLine(
   return renderActivityFeed(lines);
 }
 
+/** Minimal HTML escape for Telegram parse_mode=HTML (matches the gateway's). */
+function escapeFeedHtml(s: string): string {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
 /**
- * Render the accumulated feed as a plain-text block (one action per line).
- * The caller HTML-escapes + wraps it for Telegram. Returns null when empty.
- *
- * Newest-last chronological order; capped to the last MIRROR_MAX_LINES with a
- * dim "+N earlier" header when the turn ran longer.
+ * Render the accumulated feed as ready Telegram HTML — one action per line,
+ * newest last. The current (newest) step is bold with a `→`; finished steps
+ * are italic with a `✓`. Capped to the last MIRROR_MAX_LINES with a dim
+ * `✓ +N earlier…` header when the turn ran longer. Returns null when empty.
+ * Callers send the result verbatim — do NOT re-escape or re-wrap it.
  */
 export function renderActivityFeed(lines: string[]): string | null {
   if (lines.length === 0) return null;
   const shown = lines.slice(-MIRROR_MAX_LINES);
   const hidden = lines.length - shown.length;
-  const body = shown.map((l) => `· ${l}`).join("\n");
-  return hidden > 0 ? `· +${hidden} earlier…\n${body}` : body;
+  const out: string[] = [];
+  if (hidden > 0) out.push(`<i>✓ +${hidden} earlier…</i>`);
+  const lastIdx = shown.length - 1;
+  // Newest line = in-progress step (bold, →); earlier = done (italic, ✓).
+  // Returns ready Telegram HTML — callers must NOT re-escape or re-wrap it.
+  shown.forEach((l, i) => {
+    const esc = escapeFeedHtml(l);
+    out.push(i === lastIdx ? `<b>→ ${esc}</b>` : `<i>✓ ${esc}</i>`);
+  });
+  return out.join("\n");
 }
 
 /**