talon-agent 3.7.0 → 3.8.1

package/src/core/prompt/embedded-prompts.ts

@@ -26,13 +26,14 @@ import asset12 from "../../../prompts/system/cron.md" with { type: "file" };
 import asset13 from "../../../prompts/system/daily-memory.md" with { type: "file" };
 import asset14 from "../../../prompts/system/goals.md" with { type: "file" };
 import asset15 from "../../../prompts/system/heartbeat-agent.md" with { type: "file" };
-import asset16 from "../../../prompts/system/persistent-memory.md" with { type: "file" };
-import asset17 from "../../../prompts/system/skills.md" with { type: "file" };
-import asset18 from "../../../prompts/system/triggers.md" with { type: "file" };
-import asset19 from "../../../prompts/system/workspace.md" with { type: "file" };
-import asset20 from "../../../prompts/teams.md" with { type: "file" };
-import asset21 from "../../../prompts/telegram.md" with { type: "file" };
-import asset22 from "../../../prompts/terminal.md" with { type: "file" };
+import asset16 from "../../../prompts/system/memory-recall.md" with { type: "file" };
+import asset17 from "../../../prompts/system/persistent-memory.md" with { type: "file" };
+import asset18 from "../../../prompts/system/skills.md" with { type: "file" };
+import asset19 from "../../../prompts/system/triggers.md" with { type: "file" };
+import asset20 from "../../../prompts/system/workspace.md" with { type: "file" };
+import asset21 from "../../../prompts/teams.md" with { type: "file" };
+import asset22 from "../../../prompts/telegram.md" with { type: "file" };
+import asset23 from "../../../prompts/terminal.md" with { type: "file" };
 
 /** rel path (posix, under prompts/) → embedded file path (/$bunfs/… when compiled). */
 const ASSETS: Record<string, string> = {
@@ -52,13 +53,14 @@ const ASSETS: Record<string, string> = {
   "system/daily-memory.md": asset13,
   "system/goals.md": asset14,
   "system/heartbeat-agent.md": asset15,
-  "system/persistent-memory.md": asset16,
-  "system/skills.md": asset17,
-  "system/triggers.md": asset18,
-  "system/workspace.md": asset19,
-  "teams.md": asset20,
-  "telegram.md": asset21,
-  "terminal.md": asset22,
+  "system/memory-recall.md": asset16,
+  "system/persistent-memory.md": asset17,
+  "system/skills.md": asset18,
+  "system/triggers.md": asset19,
+  "system/workspace.md": asset20,
+  "teams.md": asset21,
+  "telegram.md": asset22,
+  "terminal.md": asset23,
 };
 
 /** Read an embedded prompt by its rel path (e.g. "system/cron.md"). */

package/src/core/types.ts

@@ -141,6 +141,16 @@ export type OneShotAgentParams = {
   workspace: string;
   /** Model id (interpretation is backend-specific). */
   model: string;
+  /**
+   * Reasoning effort for the run (config `heartbeatEffort` / `dreamEffort`).
+   * Undefined = let the backend/model pick its own default, which is what
+   * every background run did before the knob existed.
+   *
+   * Honoured by the backends that expose a reasoning knob (Claude SDK
+   * thinking/effort, Codex `modelReasoningEffort`); ignored by the ones
+   * that don't (Kilo, OpenCode).
+   */
+  reasoningEffort?: ReasoningEffortLevel;
   /**
    * Sentinel chat ID for outbound MCP tool calls (e.g. "heartbeat", "dream").
    * Frontend MCP servers use this to enforce explicit `chat_id` on outbound

package/src/core/weaver/index.ts

@@ -3,7 +3,6 @@ export { ThreadSession, type SessionSummary } from "./thread-session.js";
 export { Loom, type ContextRegistry } from "./loom.js";
 export { carryTurnEvents, type EventSink } from "./shuttle.js";
 export { startTypingLoop, TYPING_REFRESH_MS } from "./typing-loop.js";
-export { prefetchMemory } from "./memory-prefetch.js";
 export {
   resolveWarp,
   type WarpResolution,

package/src/core/weaver/weaver.ts

@@ -7,8 +7,6 @@
  *     null-model guard and per-run override fallback;
  *   - `startTypingLoop` (typing-loop.ts) — keeps the frontend's typing
  *     indicator alive for the duration of the turn;
- *   - `prefetchMemory` (memory-prefetch.ts) — optional fail-closed
- *     palace pre-retrieval for live user messages;
  *   - `carryTurnEvents` (shuttle.ts) — pumps the backend's AgentEvent
  *     stream into the frontend sink, settles delivery acks, captures
  *     the result and rethrows error terminators.
@@ -22,13 +20,11 @@ import { randomBytes } from "node:crypto";
 import type { Backend } from "../agent-runtime/capabilities.js";
 import type { AgentResult } from "../agent-runtime/events.js";
 import type { ModelRef } from "../agent-runtime/model-ref.js";
-import type { MemoryRetriever } from "../memory/retrieval.js";
 import type { ContextManager, ExecuteParams, ExecuteResult } from "../types.js";
 import { bus } from "../bus/index.js";
 import { taskTable, type TaskHandle } from "../tasks/index.js";
 import { log, logDebug, logWarn } from "../../util/log.js";
 import { Loom } from "./loom.js";
-import { prefetchMemory } from "./memory-prefetch.js";
 import { carryTurnEvents } from "./shuttle.js";
 import type { Thread, ThreadSnapshot } from "./thread.js";
 import { startTypingLoop } from "./typing-loop.js";
@@ -52,13 +48,6 @@ export type WeaverDeps = {
   ) => Promise<ModelRef | null>;
   context: ContextManager;
   sendTyping: (chatId: number, stringId?: string) => Promise<void>;
-  /**
-   * Optional memory pre-retrieval (Phase B). Called for `source: "message"`
-   * turns after model/backend resolution and context acquisition, before
-   * `runChatTurn(...)`. Fail-closed: errors are logged and the turn runs
-   * without injected memory. Absent dep ⇒ prompts byte-identical to before.
-   */
-  retrieveMemory?: MemoryRetriever;
 };
 
 export class Weaver {
@@ -163,7 +152,7 @@ export class Weaver {
     params: ExecuteParams,
     task: TaskHandle,
   ): Promise<ExecuteResult> {
-    const { context, retrieveMemory } = this.deps;
+    const { context } = this.deps;
     const backend = this.deps.getBackend(params.chatId);
     const reqId = randomBytes(4).toString("hex");
 
@@ -237,17 +226,6 @@ export class Weaver {
         );
       }
 
-      const retrievedMemory =
-        retrieveMemory && params.source === "message"
-          ? await prefetchMemory(retrieveMemory, {
-              chatId: params.chatId,
-              text: params.prompt,
-              senderName: params.senderName,
-              isGroup: params.isGroup,
-              reqId,
-            })
-          : undefined;
-
       const stream = backend.chat.runChatTurn({
         chatId: params.chatId,
         model: warp.ref,
@@ -255,7 +233,6 @@ export class Weaver {
         senderName: params.senderName,
         isGroup: params.isGroup,
         messageId: params.messageId,
-        retrievedMemory,
       });
       const agentResult = await carryTurnEvents(stream, params.onEvent);
 

package/src/frontend/telegram/callbacks/index.ts

@@ -7,6 +7,7 @@
  *   - `settings` — `settings:*` (effort/proactive + stale-picker handling)
  *   - `pulse`    — `pulse:*`
  *   - `effort`   — `effort:*`
+ *   - `metrics`  — `metrics:*` (today ↔ all-time panel grain)
  *   - `model`    — `model:*` (menu / backend / browse controller)
  *
  * `registerCallbacks` installs one `callback_query:data` listener that
@@ -22,6 +23,7 @@ import type { CallbackDeps } from "./shared.js";
 import { handleSettingsCallback } from "./settings.js";
 import { handlePulseCallback } from "./pulse.js";
 import { handleEffortCallback } from "./effort.js";
+import { handleMetricsCallback } from "./metrics.js";
 import { handleModelCallback } from "./model.js";
 
 export { answerCallbackQuerySafe } from "./shared.js";
@@ -56,6 +58,12 @@ export function registerCallbacks(
       return;
     }
 
+    // Handle /metrics grain switching (today ↔ all time).
+    if (data.startsWith("metrics:")) {
+      await handleMetricsCallback(ctx, data);
+      return;
+    }
+
     // Handle /model callbacks via the pure parser + menu controller.
     if (data.startsWith("model:")) {
       await handleModelCallback(ctx, data, cid, deps);

package/src/frontend/telegram/callbacks/metrics.ts

@@ -0,0 +1,36 @@
+/**
+ * `metrics:*` callbacks — swap the /metrics panel between the today and
+ * all-time grains by editing the message in place.
+ *
+ * Admin-gated like the command that posts the panel: in a group chat the
+ * buttons sit on a message anyone can tap.
+ */
+
+import type { Context } from "grammy";
+import { getMetrics, getTodayMetrics } from "../../../util/metrics.js";
+import {
+  renderMetricsKeyboard,
+  renderMetricsPanel,
+  type MetricsView,
+} from "../helpers/index.js";
+import { isAuthorizedAdmin } from "../commands/state.js";
+import { answerCallbackQuerySafe, editOrIgnoreSame } from "./shared.js";
+
+export async function handleMetricsCallback(
+  ctx: Context,
+  data: string,
+): Promise<void> {
+  if (!isAuthorizedAdmin(ctx)) {
+    await answerCallbackQuerySafe(ctx, { text: "Not authorized." });
+    return;
+  }
+
+  const view: MetricsView = data === "metrics:all" ? "all" : "today";
+  await answerCallbackQuerySafe(ctx);
+  const metrics = view === "all" ? getMetrics() : getTodayMetrics();
+  await editOrIgnoreSame(
+    ctx,
+    renderMetricsPanel(metrics, view),
+    renderMetricsKeyboard(view),
+  );
+}

package/src/frontend/telegram/commands/admin.ts

@@ -19,11 +19,12 @@ import { closestMatch } from "../../../native/strsim.js";
 import {
   formatDuration,
   renderDoctorMessage,
-  renderMetricsMessages,
+  renderMetricsKeyboard,
+  renderMetricsPanel,
 } from "../helpers/index.js";
 import { collectDoctorReport } from "../../../core/doctor.js";
 import { handleAdminCommand } from "../admin.js";
-import { getMetrics, getTodayMetrics } from "../../../util/metrics.js";
+import { getTodayMetrics } from "../../../util/metrics.js";
 import { isAuthorizedAdmin, type RegisterDeps } from "./state.js";
 import { telegramCommandMenu } from "./definitions.js";
 
@@ -44,17 +45,12 @@ export function registerAdminCommands(
       await ctx.reply("Not authorized.");
       return;
     }
-    const messages = [
-      ...renderMetricsMessages(getMetrics()),
-      ...renderMetricsMessages(
-        getTodayMetrics(),
-        undefined,
-        "📊 Metrics — today (UTC)",
-      ),
-    ];
-    for (const message of messages) {
-      await ctx.reply(message, { parse_mode: "HTML" });
-    }
+    // One message, two grains. Today opens first — it is the smaller,
+    // more actionable view; All time is a tap away on the same message.
+    await ctx.reply(renderMetricsPanel(getTodayMetrics(), "today"), {
+      parse_mode: "HTML",
+      reply_markup: { inline_keyboard: renderMetricsKeyboard("today") },
+    });
   });
 
   bot.command("doctor", async (ctx) => {

package/src/frontend/telegram/commands/info.ts

@@ -5,7 +5,7 @@
 import type { Bot } from "grammy";
 import { isUserClientReady } from "../userbot.js";
 import { escapeHtml } from "../formatting.js";
-import { formatDuration } from "../helpers/index.js";
+import { formatDuration, renderMeshReport } from "../helpers/index.js";
 import { getLoadedPlugins } from "../../../core/plugin/index.js";
 import { getMeshService } from "../../../core/mesh/index.js";
 import type { MeshPingResult } from "../../../core/mesh/service.js";
@@ -104,7 +104,7 @@ export function registerInfoCommands(bot: Bot): void {
   });
 
   bot.command("mesh", async (ctx) => {
-    const sent = await ctx.reply("🛰️ Pinging mesh devices…");
+    const sent = await ctx.reply("Pinging mesh devices…");
     let results: MeshPingResult[];
     try {
       results = await getMeshService().pingAll();
@@ -117,33 +117,11 @@ export function registerInfoCommands(bot: Bot): void {
       );
       return;
     }
-    if (results.length === 0) {
-      await editOrReply(
-        bot,
-        ctx.chat.id,
-        sent.message_id,
-        "<b>🛰️ Mesh</b>\n\nNo devices have registered yet.",
-      );
-      return;
-    }
-    // Online (reachable first, by latency) before offline; a stable, useful
-    // order for a glance at the fleet.
-    const sorted = [...results].sort((a, b) => {
-      if (a.device.online !== b.device.online) return a.device.online ? -1 : 1;
-      return (a.latencyMs ?? Infinity) - (b.latencyMs ?? Infinity);
-    });
-    const online = results.filter((r) => r.device.online).length;
-    const reachable = results.filter((r) => r.reachable).length;
-    const lines = sorted.map((r) => meshLine(r));
     await editOrReply(
       bot,
       ctx.chat.id,
       sent.message_id,
-      [
-        `<b>🛰️ Mesh</b> — ${results.length} device(s), ${online} online, ${reachable} responding`,
-        "",
-        ...lines,
-      ].join("\n"),
+      renderMeshReport(results),
     );
   });
 
@@ -171,25 +149,6 @@ export function registerInfoCommands(bot: Bot): void {
   });
 }
 
-/** One `/mesh` line: presence + reachability + latency + platform. */
-function meshLine(r: MeshPingResult): string {
-  const d = r.device;
-  const dot = r.reachable ? "🟢" : d.online ? "🟡" : "⚪";
-  const name = `<b>${escapeHtml(d.name)}</b>`;
-  const bits: string[] = [`${d.platform}`];
-  if (r.reachable && typeof r.latencyMs === "number") {
-    bits.push(`${r.latencyMs}ms`);
-  } else if (d.online && r.error) {
-    bits.push(escapeHtml(r.error));
-  } else if (!d.online) {
-    bits.push(`offline, last seen ${formatDuration(Date.now() - d.lastSeen)}`);
-  }
-  if (typeof d.battery === "number") {
-    bits.push(`${d.battery}%${d.charging ? "⚡" : ""}`);
-  }
-  return `${dot} ${name} — ${bits.join(" · ")}`;
-}
-
 /** Edit the placeholder in place, falling back to a fresh reply. */
 async function editOrReply(
   bot: Bot,

package/src/frontend/telegram/helpers/diagnostics.ts

@@ -1,13 +1,24 @@
 /**
- * Metrics + doctor report rendering for Telegram (HTML messages).
+ * Metrics, doctor, and mesh report rendering for Telegram (HTML messages).
  */
 
 import { escapeHtml } from "../formatting.js";
 import type { DoctorReport } from "../../../core/doctor.js";
+import type { MeshPingResult } from "../../../core/mesh/service.js";
+import type { SettingsButton } from "./menu.js";
 import { formatDuration, formatBytes } from "./format.js";
 
 const DEFAULT_METRICS_MESSAGE_MAX = 3800;
 
+/**
+ * Rows shown in the `tool_calls` leaderboard before the tail collapses
+ * into a "…and N more" line. A long-lived bot accumulates a lifetime
+ * tool-call entry per distinct tool name (easily 100+ once plugin and
+ * MCP tools are counted), which is what used to push /metrics past
+ * Telegram's message limit and split it across messages.
+ */
+const TOOL_CALLS_TOP_N = 12;
+
 type MetricsSnapshot = {
   counters: Record<string, number>;
   histograms: Record<
@@ -16,18 +27,26 @@ type MetricsSnapshot = {
   >;
 };
 
+/** Which grain the /metrics panel is currently showing. */
+export type MetricsView = "today" | "all";
+
+const VIEW_TITLES: Record<MetricsView, string> = {
+  today: "Metrics — today (UTC)",
+  all: "Metrics — all time",
+};
+
+/**
+ * One titled block of the panel. `hidden` counts rows dropped to make
+ * the panel fit one message; it renders as a trailing "…and N more".
+ */
+type Section = { title: string; rows: string[]; hidden: number };
+
 function truncateMetricLabel(label: string, max = 80): string {
   return label.length <= max ? label : `${label.slice(0, max - 3)}...`;
 }
 
-export function renderMetricsMessages(
-  metrics: MetricsSnapshot,
-  maxLen = DEFAULT_METRICS_MESSAGE_MAX,
-  title = "📊 Metrics",
-): string[] {
-  const firstHeader = `<b>${escapeHtml(title)}</b>`;
-  const continuationHeader = `<b>${escapeHtml(title)} (cont.)</b>`;
-  const sections: string[][] = [];
+function buildMetricsSections(metrics: MetricsSnapshot): Section[] {
+  const sections: Section[] = [];
 
   // Histograms come in two flavours: durations (keys ending in `_ms`,
   // rendered as human times) and plain counts like `tool_calls_per_turn`
@@ -44,16 +63,18 @@ export function renderMetricsMessages(
     );
   };
   if (durationKeys.length > 0) {
-    sections.push([
-      "<b>Latency</b>",
-      ...durationKeys.map((key) => histLine(key, formatDuration)),
-    ]);
+    sections.push({
+      title: "<b>Latency</b>",
+      rows: durationKeys.map((key) => histLine(key, formatDuration)),
+      hidden: 0,
+    });
   }
   if (countKeys.length > 0) {
-    sections.push([
-      "<b>Distributions</b>",
-      ...countKeys.map((key) => histLine(key, String)),
-    ]);
+    sections.push({
+      title: "<b>Distributions</b>",
+      rows: countKeys.map((key) => histLine(key, String)),
+      hidden: 0,
+    });
   }
 
   const counterKeys = Object.keys(metrics.counters).sort();
@@ -68,17 +89,20 @@ export function renderMetricsMessages(
     for (const prefix of [...groups.keys()].sort()) {
       // tool_calls reads best as a leaderboard — busiest tools first.
       // Other groups keep alphabetical order (stable lookup by name).
-      const keys =
-        prefix === "tool_calls"
-          ? [...groups.get(prefix)!].sort(
-              (a, b) =>
-                metrics.counters[b]! - metrics.counters[a]! ||
-                a.localeCompare(b),
-            )
-          : groups.get(prefix)!;
-      sections.push([
-        `<b>${escapeHtml(prefix)}</b>`,
-        ...keys.map((key) => {
+      const isToolCalls = prefix === "tool_calls";
+      const keys = isToolCalls
+        ? [...groups.get(prefix)!].sort(
+            (a, b) =>
+              metrics.counters[b]! - metrics.counters[a]! || a.localeCompare(b),
+          )
+        : groups.get(prefix)!;
+      // The leaderboard is pre-capped: past the top N the tail is a long
+      // list of one-call tools nobody reads, and on the all-time view it
+      // is what made the panel overflow.
+      const shown = isToolCalls ? keys.slice(0, TOOL_CALLS_TOP_N) : keys;
+      sections.push({
+        title: `<b>${escapeHtml(prefix)}</b>`,
+        rows: shown.map((key) => {
           const label = key.includes(".")
             ? key.split(".").slice(1).join(".")
             : key;
@@ -87,59 +111,88 @@ export function renderMetricsMessages(
             `${metrics.counters[key]!.toLocaleString()}`
           );
         }),
-      ]);
+        hidden: keys.length - shown.length,
+      });
     }
   }
 
-  if (sections.length === 0) {
-    return [`${firstHeader}\n\n<i>No metrics recorded yet.</i>`];
-  }
-
-  const chunks: string[] = [];
-  let header = firstHeader;
-  let current = header;
-
-  const flush = () => {
-    chunks.push(current);
-    header = continuationHeader;
-    current = header;
-  };
+  return sections;
+}
 
-  const appendLine = (line: string) => {
-    if (!line && current === header) return;
+function renderSection(section: Section): string {
+  const lines = [section.title, ...section.rows];
+  if (section.hidden > 0) {
+    lines.push(`  <i>…and ${section.hidden} more</i>`);
+  }
+  return lines.join("\n");
+}
 
-    const candidate = `${current}\n${line}`;
-    if (candidate.length <= maxLen) {
-      current = candidate;
-      return;
-    }
+/**
+ * Render the sections under `header`, shrinking to fit `maxLen`.
+ *
+ * Telegram hard-caps a message at 4096 characters. Rather than split the
+ * report across messages — which is what the panel replaced — rows are
+ * dropped from the longest section first (each drop bumping that
+ * section's "…and N more") until the whole thing fits. Sections always
+ * keep at least their first row, so every group stays visible.
+ */
+function fitPanel(header: string, sections: Section[], maxLen: number): string {
+  const render = () => [header, ...sections.map(renderSection)].join("\n\n");
 
-    if (current !== header) {
-      flush();
-      if (!line) return;
+  let out = render();
+  while (out.length > maxLen) {
+    let target: Section | undefined;
+    for (const section of sections) {
+      if (section.rows.length <= 1) continue;
+      if (!target || section.rows.length > target.rows.length) target = section;
     }
-
-    const available = maxLen - header.length - 1;
-    if (available < 0) return; // header alone already fills maxLen — skip line
-    const safeLine =
-      line.length <= available
-        ? line
-        : available >= 4
-          ? `${line.slice(0, available - 3)}...`
-          : line.slice(0, available); // not enough room for ellipsis — just truncate
-    current = `${current}\n${safeLine}`;
-  };
-
-  for (const section of sections) {
-    appendLine("");
-    for (const line of section) appendLine(line);
+    if (!target) break;
+    target.rows.pop();
+    target.hidden += 1;
+    out = render();
   }
 
-  if (current !== header || chunks.length === 0) {
-    chunks.push(current);
+  if (out.length <= maxLen) return out;
+  // Nothing left to shed (a pathologically small maxLen). Cut on a line
+  // boundary so we never slice through an HTML tag and fail the parse.
+  const cut = out.lastIndexOf("\n", maxLen - 1);
+  return cut > 0 ? out.slice(0, cut) : out.slice(0, maxLen);
+}
+
+/**
+ * Render the /metrics panel for one grain as a SINGLE Telegram message.
+ * Pair it with `renderMetricsKeyboard(view)` — the Today / All time
+ * buttons swap grains by editing this message in place.
+ */
+export function renderMetricsPanel(
+  metrics: MetricsSnapshot,
+  view: MetricsView,
+  maxLen = DEFAULT_METRICS_MESSAGE_MAX,
+): string {
+  const header = `<b>${escapeHtml(VIEW_TITLES[view])}</b>`;
+  const sections = buildMetricsSections(metrics);
+  if (sections.length === 0) {
+    return `${header}\n\n<i>No metrics recorded yet.</i>`;
   }
+  return fitPanel(header, sections, maxLen);
+}
 
-  return chunks;
+/** Grain-switch buttons for the /metrics panel. */
+export function renderMetricsKeyboard(
+  view: MetricsView,
+): Array<Array<SettingsButton>> {
+  return [
+    [
+      {
+        text: view === "today" ? "✓ Today" : "Today",
+        callback_data: "metrics:today",
+      },
+      {
+        text: view === "all" ? "✓ All time" : "All time",
+        callback_data: "metrics:all",
+      },
+    ],
+  ];
 }
 
 const DOCTOR_ICONS: Record<string, string> = {
@@ -187,3 +240,70 @@ export function renderDoctorMessage(report: DoctorReport): string {
 
   return lines.join("\n");
 }
+
+// ── /mesh ───────────────────────────────────────────────────────────────────
+
+function meshDeviceLine(r: MeshPingResult, now: number): string {
+  const d = r.device;
+  const bits: string[] = [escapeHtml(d.platform)];
+  if (r.reachable && typeof r.latencyMs === "number") {
+    bits.push(`${r.latencyMs} ms`);
+  } else if (d.online && r.error) {
+    bits.push(escapeHtml(r.error));
+  } else if (!d.online) {
+    bits.push(`last seen ${formatDuration(now - d.lastSeen)} ago`);
+  }
+  if (typeof d.battery === "number") {
+    bits.push(`${d.battery}%${d.charging ? " charging" : ""}`);
+  }
+  return `  <b>${escapeHtml(d.name)}</b> — ${bits.join(" · ")}`;
+}
+
+/**
+ * Render the `/mesh` fleet report as one HTML message.
+ *
+ * Devices group under a state heading — Responding, Unreachable, Offline
+ * — rather than carrying a coloured status glyph per row: the grouping
+ * already says what the glyph said, and the report stays readable when
+ * the fleet grows. Empty groups are omitted entirely.
+ */
+export function renderMeshReport(
+  results: MeshPingResult[],
+  now = Date.now(),
+): string {
+  if (results.length === 0) {
+    return "<b>Mesh</b>\n\n<i>No devices have registered yet.</i>";
+  }
+
+  const responding = results
+    .filter((r) => r.reachable)
+    .sort((a, b) => (a.latencyMs ?? Infinity) - (b.latencyMs ?? Infinity));
+  const unreachable = results
+    .filter((r) => !r.reachable && r.device.online)
+    .sort((a, b) => a.device.name.localeCompare(b.device.name));
+  const offline = results
+    .filter((r) => !r.reachable && !r.device.online)
+    .sort((a, b) => b.device.lastSeen - a.device.lastSeen);
+
+  const summary = [
+    `${results.length} device${results.length === 1 ? "" : "s"}`,
+    `${responding.length} responding`,
+    ...(unreachable.length > 0 ? [`${unreachable.length} unreachable`] : []),
+    ...(offline.length > 0 ? [`${offline.length} offline`] : []),
+  ].join(" · ");
+
+  const lines = ["<b>Mesh</b>", summary];
+  const section = (title: string, entries: MeshPingResult[]): void => {
+    if (entries.length === 0) return;
+    lines.push(
+      "",
+      `<b>${title}</b>`,
+      ...entries.map((r) => meshDeviceLine(r, now)),
+    );
+  };
+  section("Responding", responding);
+  section("Unreachable", unreachable);
+  section("Offline", offline);
+
+  return lines.join("\n");
+}