@hienlh/ppm 0.17.15 → 0.17.17

package/src/server/routes/group-chat.ts

@@ -6,15 +6,22 @@ import {
   listGroups,
   deleteGroup,
   addMember,
+  getMember,
+  updateMember,
+  removeMember,
   listMembers,
   readMessages,
+  setGroupMaxTurns,
 } from "../../services/group-chat/group-chat.store.ts";
 import { groupChatService } from "../../services/group-chat/group-chat.service.ts";
-import { readArchivedTranscript } from "../../services/group-chat/transcript-archive.ts";
-import type { AddMemberInput } from "../../types/group-chat.ts";
+import { resolveTranscriptPath } from "../../services/group-chat/transcript-archive.ts";
+import { parseJsonlTranscript, parseTranscriptConfig } from "../../services/jsonl-transcript-parser.ts";
+import type { AddMemberInput, UpdateMemberInput } from "../../types/group-chat.ts";
 
 /** Allowlist: group ids are UUIDs — alphanumeric + hyphens only. */
 const VALID_GROUP_ID = /^[a-zA-Z0-9-]+$/;
+/** Member ids are UUIDs too. */
+const VALID_MEMBER_ID = /^[a-zA-Z0-9-]+$/;
 /** Session refs are Claude session UUIDs. */
 const VALID_SESSION_REF = /^[a-zA-Z0-9-]+$/;
 
@@ -79,6 +86,101 @@ groupChatRoutes.get("/:id", (c) => {
   return c.json(ok({ ...group, members: listMembers(id) }));
 });
 
+// Group settings (reply-burst cap) -----------------------------------------
+groupChatRoutes.patch("/:id", async (c) => {
+  const id = c.req.param("id");
+  if (!VALID_GROUP_ID.test(id)) return c.json(err("Invalid group id"), 400);
+  if (!getGroup(id)) return c.json(err("Group not found"), 404);
+  let body: { maxTurns?: number };
+  try { body = await c.req.json(); } catch { return c.json(err("Invalid JSON body"), 400); }
+  if (body.maxTurns !== undefined) {
+    const n = Math.floor(Number(body.maxTurns));
+    if (!Number.isFinite(n) || n < 1 || n > 50) return c.json(err("maxTurns must be 1–50"), 400);
+    setGroupMaxTurns(id, n);
+  }
+  return c.json(ok({ ...getGroup(id)!, members: listMembers(id) }));
+});
+
+// Member management (add / update / remove) -------------------------------
+// Invariant: a group always has exactly one leader and at least one member.
+
+groupChatRoutes.post("/:id/members", async (c) => {
+  const id = c.req.param("id");
+  if (!VALID_GROUP_ID.test(id)) return c.json(err("Invalid group id"), 400);
+  if (!getGroup(id)) return c.json(err("Group not found"), 404);
+
+  let body: { role?: string; name?: string; persona?: string; model?: string; color?: string };
+  try { body = await c.req.json(); } catch { return c.json(err("Invalid JSON body"), 400); }
+  const name = body.name?.trim();
+  if (!name) return c.json(err("member name is required"), 400);
+  const role = body.role === "leader" ? "leader" : "member";
+
+  // Promoting a new leader demotes the current one (keep exactly one leader).
+  if (role === "leader") {
+    for (const m of listMembers(id)) {
+      if (m.role === "leader") updateMember(m.id, { role: "member" });
+    }
+  }
+  const input: AddMemberInput = {
+    groupId: id, role, name,
+    persona: body.persona ?? null, model: body.model ?? null, color: body.color ?? null,
+  };
+  return c.json(ok(addMember(input)));
+});
+
+groupChatRoutes.patch("/:id/members/:memberId", async (c) => {
+  const id = c.req.param("id");
+  const memberId = c.req.param("memberId");
+  if (!VALID_GROUP_ID.test(id) || !VALID_MEMBER_ID.test(memberId)) return c.json(err("Invalid id"), 400);
+  if (!getGroup(id)) return c.json(err("Group not found"), 404);
+  const member = getMember(memberId);
+  if (!member || member.groupId !== id) return c.json(err("Member not found"), 404);
+
+  let body: { role?: string; name?: string; persona?: string; model?: string; color?: string };
+  try { body = await c.req.json(); } catch { return c.json(err("Invalid JSON body"), 400); }
+
+  const patch: UpdateMemberInput = {};
+  if (body.name !== undefined) {
+    const n = body.name.trim();
+    if (!n) return c.json(err("member name cannot be empty"), 400);
+    patch.name = n;
+  }
+  if (body.persona !== undefined) patch.persona = body.persona || null;
+  if (body.model !== undefined) patch.model = body.model || null;
+  if (body.color !== undefined) patch.color = body.color || null;
+
+  if (body.role !== undefined) {
+    if (body.role !== "leader" && body.role !== "member") return c.json(err("invalid role"), 400);
+    if (body.role === "leader") {
+      // Demote the current leader(s) before promoting this member.
+      for (const m of listMembers(id)) {
+        if (m.role === "leader" && m.id !== memberId) updateMember(m.id, { role: "member" });
+      }
+      patch.role = "leader";
+    } else if (member.role === "leader") {
+      return c.json(err("promote another member to leader before demoting this one"), 400);
+    }
+  }
+  return c.json(ok(updateMember(memberId, patch)));
+});
+
+groupChatRoutes.delete("/:id/members/:memberId", async (c) => {
+  const id = c.req.param("id");
+  const memberId = c.req.param("memberId");
+  if (!VALID_GROUP_ID.test(id) || !VALID_MEMBER_ID.test(memberId)) return c.json(err("Invalid id"), 400);
+  const group = getGroup(id);
+  if (!group) return c.json(err("Group not found"), 404);
+  const member = getMember(memberId);
+  if (!member || member.groupId !== id) return c.json(err("Member not found"), 404);
+
+  const members = listMembers(id);
+  if (members.length <= 1) return c.json(err("a group needs at least one member"), 400);
+  if (member.role === "leader") return c.json(err("reassign the leader before removing this member"), 400);
+  await groupChatService.archiveMemberSession(group.name, member.sessionId);
+  removeMember(memberId);
+  return c.json(ok({ deleted: memberId }));
+});
+
 // Feed (windowed/paginated) ------------------------------------------------
 groupChatRoutes.get("/:id/feed", (c) => {
   const id = c.req.param("id");
@@ -93,8 +195,9 @@ groupChatRoutes.get("/:id/feed", (c) => {
   return c.json(ok({ messages }));
 });
 
-// Archived transcript for a member session (powers "view full") -----------
-groupChatRoutes.get("/:id/transcript", (c) => {
+// Archived transcript for a member session (powers "view full") — parsed into
+// chat-style messages (text/thinking/tool_use/tool_result) + input config.
+groupChatRoutes.get("/:id/transcript", async (c) => {
   const id = c.req.param("id");
   if (!VALID_GROUP_ID.test(id)) return c.json(err("Invalid group id"), 400);
   const group = getGroup(id);
@@ -104,9 +207,13 @@ groupChatRoutes.get("/:id/transcript", (c) => {
   if (!sessionRef || !VALID_SESSION_REF.test(sessionRef)) {
     return c.json(err("Invalid sessionRef"), 400);
   }
-  const content = readArchivedTranscript(sessionRef, group.name);
-  if (content === null) return c.json(err("Transcript not found"), 404);
-  return c.json(ok({ content }));
+  const path = await resolveTranscriptPath(sessionRef, group.name);
+  if (path === null) return c.json(err("Transcript not found"), 404);
+  const [messages, config] = await Promise.all([
+    parseJsonlTranscript(path),
+    parseTranscriptConfig(path),
+  ]);
+  return c.json(ok({ messages, config }));
 });
 
 // Send a message → starts / feeds the engine ------------------------------
@@ -150,11 +257,13 @@ groupChatRoutes.post("/:id/resume", async (c) => {
 });
 
 // Delete -------------------------------------------------------------------
-groupChatRoutes.delete("/:id", (c) => {
+groupChatRoutes.delete("/:id", async (c) => {
   const id = c.req.param("id");
   if (!VALID_GROUP_ID.test(id)) return c.json(err("Invalid group id"), 400);
   if (!getGroup(id)) return c.json(err("Group not found"), 404);
-  groupChatService.stop(id);
+  // Archive member sessions (keep-alive means they live until now) BEFORE the store
+  // cascade removes the member rows.
+  await groupChatService.archiveAndForget(id);
   deleteGroup(id);
   return c.json(ok({ deleted: id }));
 });

package/src/server/ws/chat.ts

@@ -3,27 +3,44 @@ import { providerRegistry } from "../../providers/registry.ts";
 import { resolveProjectPath } from "../helpers/resolve-project.ts";
 import { logSessionEvent } from "../../services/session-log.service.ts";
 import { listSessions as sdkListSessions } from "@anthropic-ai/claude-agent-sdk";
-import { getSessionTitle, incrementSessionUnread, clearSessionUnread, getSessionModel, setSessionModel, getSessionProvider } from "../../services/db.service.ts";
+import { getSessionTitle, incrementSessionUnread, clearSessionUnread, getSessionModel, setSessionModel, getSessionProvider, getSessionEffort, setSessionEffort, getSessionThinking, setSessionThinking } from "../../services/db.service.ts";
+import { VALID_EFFORT_VALUES } from "../../providers/claude-agent-sdk-query-options.ts";
 import type { ChatWsClientMessage, SessionPhase } from "../../types/api.ts";
+
+/** Budget passed to the SDK as maxThinkingTokens when the per-session Thinking toggle is ON. */
+const DEFAULT_THINKING_BUDGET = 12000;
 import { startWatching, stopWatching, onFileChange } from "../../services/file-watcher.service.ts";
 import { bashOutputSpy } from "../../services/bash-output-spy.ts";
 import { backgroundShellRegistry } from "../../services/background-shell-registry.ts";
 import { basename } from "node:path";
 import { configService } from "../../services/config.service.ts";
 
-/** Resolve the model shown in session_state: per-session override, else provider default. */
-function resolveSessionModel(sessionId: string): string | undefined {
-  const override = getSessionModel(sessionId);
-  if (override) return override;
+/** Resolve the SESSION's provider config — not the global default provider's.
+ * Otherwise a non-default provider's chat (e.g. codex) would inherit claude's values. */
+function sessionProviderConfig(sessionId: string) {
   const ai = configService.get("ai");
-  // Fall back to the SESSION's provider default model — not the global default
-  // provider's. Otherwise a non-default provider's chat (e.g. codex) would show
-  // the claude default model in the picker.
   const pid = activeSessions.get(sessionId)?.providerId
     ?? chatService.getSession(sessionId)?.providerId
     ?? getSessionProvider(sessionId)
     ?? ai.default_provider ?? "claude";
-  return ai.providers[pid]?.model;
+  return ai.providers[pid];
+}
+
+/** Resolve the model shown in session_state: per-session override, else provider default. */
+function resolveSessionModel(sessionId: string): string | undefined {
+  return getSessionModel(sessionId) ?? sessionProviderConfig(sessionId)?.model;
+}
+
+/** Resolve the effort shown in session_state: per-session override, else provider default. */
+function resolveSessionEffort(sessionId: string): string | undefined {
+  return getSessionEffort(sessionId) ?? sessionProviderConfig(sessionId)?.effort;
+}
+
+/** Whether thinking is effectively ON: per-session override (>0) wins, else provider config budget. */
+function resolveSessionThinkingEnabled(sessionId: string): boolean {
+  const v = getSessionThinking(sessionId);
+  if (v != null) return v > 0;
+  return (sessionProviderConfig(sessionId)?.thinking_budget_tokens ?? 0) > 0;
 }
 
 // Broadcast file changes to all WS clients for real-time editor reload
@@ -294,7 +311,11 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
       broadcast(sessionId, { type: "phase_changed", phase: "connecting", elapsed });
     }, 5_000);
 
-    for await (const event of chatService.sendMessage(providerId, sessionId, content, { permissionMode, images, ...(model && { model }) })) {
+    // Per-session effort/thinking overrides (sticky, read fresh each turn). Null = inherit
+    // provider config: omit so the provider falls back. thinking 0 = explicit OFF (overrides config).
+    const effortOverride = getSessionEffort(sessionId) ?? undefined;
+    const thinkingBudget = getSessionThinking(sessionId);
+    for await (const event of chatService.sendMessage(providerId, sessionId, content, { permissionMode, images, ...(model && { model }), ...(effortOverride && { effort: effortOverride }), ...(thinkingBudget != null && { maxThinkingTokens: thinkingBudget }) })) {
       eventCount++;
       const ev = event as any;
       const evType = ev.type ?? "unknown";
@@ -635,6 +656,8 @@ export const chatWebSocket = {
         sessionTitle: session?.title || null,
         compactStatus: existing.compactStatus ?? null,
         model: resolveSessionModel(sessionId),
+        effort: resolveSessionEffort(sessionId),
+        thinking: resolveSessionThinkingEnabled(sessionId),
       }));
 
       // If actively streaming, send buffered turn events for reconnect sync
@@ -759,6 +782,8 @@ export const chatWebSocket = {
         sessionTitle: chatService.getSession(sessionId)?.title || null,
         compactStatus: entry.compactStatus ?? null,
         model: resolveSessionModel(sessionId),
+        effort: resolveSessionEffort(sessionId),
+        thinking: resolveSessionThinkingEnabled(sessionId),
       }));
       if (entry.phase !== "idle") {
         sendTurnEvents(sessionId, ws);
@@ -804,6 +829,14 @@ export const chatWebSocket = {
         entry.model = parsed.model;
         setSessionModel(sessionId, parsed.model);
       }
+      // Effort/thinking picked on a draft chat (before the WS existed) ride along on the
+      // first message so they persist like the model does. Reject invalid effort ("extra").
+      if (parsed.effort && VALID_EFFORT_VALUES.includes(parsed.effort as typeof VALID_EFFORT_VALUES[number])) {
+        setSessionEffort(sessionId, parsed.effort);
+      }
+      if (typeof parsed.thinking === "boolean") {
+        setSessionThinking(sessionId, parsed.thinking ? DEFAULT_THINKING_BUDGET : 0);
+      }
 
       // Intercept PPM-handled built-in commands (e.g. /skills, /version)
       const content = parsed.content.trim();
@@ -913,6 +946,54 @@ export const chatWebSocket = {
         sessionTitle: chatService.getSession(sessionId)?.title || null,
         compactStatus: entry.compactStatus ?? null,
         model: resolveSessionModel(sessionId),
+        effort: resolveSessionEffort(sessionId),
+        thinking: resolveSessionThinkingEnabled(sessionId),
+      }));
+    } else if (parsed.type === "set_effort") {
+      // Per-session effort override. Reject anything outside the SDK enum — notably
+      // "extra" (UI label maps to "xhigh"), which would crash the CLI subprocess.
+      if (!parsed.effort || !VALID_EFFORT_VALUES.includes(parsed.effort as typeof VALID_EFFORT_VALUES[number])) {
+        ws.send(JSON.stringify({ type: "error", message: `effort must be one of: ${VALID_EFFORT_VALUES.join(", ")}` }));
+        return;
+      }
+      setSessionEffort(sessionId, parsed.effort);
+      const provider = providerRegistry.get(providerId);
+      // Abort only when idle-but-alive so the next turn recreates the query with the new
+      // effort (mirror set_model); never interrupt an active turn.
+      if ((provider?.hasStreamingSession?.(sessionId) ?? false) && entry.phase === "idle") {
+        provider?.abortQuery?.(sessionId, "set_effort");
+      }
+      logSessionEvent(sessionId, "INFO", `Effort switched to ${parsed.effort}`);
+      ws.send(JSON.stringify({
+        type: "session_state",
+        sessionId,
+        phase: entry.phase,
+        pendingApproval: entry.pendingApprovalEvent ?? null,
+        sessionTitle: chatService.getSession(sessionId)?.title || null,
+        compactStatus: entry.compactStatus ?? null,
+        model: resolveSessionModel(sessionId),
+        effort: resolveSessionEffort(sessionId),
+        thinking: resolveSessionThinkingEnabled(sessionId),
+      }));
+    } else if (parsed.type === "set_thinking") {
+      // Per-session thinking toggle → maxThinkingTokens. ON = DEFAULT_THINKING_BUDGET,
+      // OFF = 0 (explicit, overrides provider config). Abort idle like set_model.
+      setSessionThinking(sessionId, parsed.enabled ? DEFAULT_THINKING_BUDGET : 0);
+      const provider = providerRegistry.get(providerId);
+      if ((provider?.hasStreamingSession?.(sessionId) ?? false) && entry.phase === "idle") {
+        provider?.abortQuery?.(sessionId, "set_thinking");
+      }
+      logSessionEvent(sessionId, "INFO", `Thinking ${parsed.enabled ? "on" : "off"}`);
+      ws.send(JSON.stringify({
+        type: "session_state",
+        sessionId,
+        phase: entry.phase,
+        pendingApproval: entry.pendingApprovalEvent ?? null,
+        sessionTitle: chatService.getSession(sessionId)?.title || null,
+        compactStatus: entry.compactStatus ?? null,
+        model: resolveSessionModel(sessionId),
+        effort: resolveSessionEffort(sessionId),
+        thinking: resolveSessionThinkingEnabled(sessionId),
       }));
     } else if (parsed.type === "cancel") {
       // Fully teardown streaming session — user must resume to continue

package/src/services/account.service.ts

@@ -575,16 +575,19 @@ class AccountService {
     if (!res.ok) {
       const errorBody = await res.text().catch(() => "");
       console.error(`[accounts] Refresh failed for ${accountId}: ${res.status} ${errorBody}`);
-      // invalid_grant or invalid_request = refresh token permanently dead → clear it so account becomes temporary
       if (errorBody.includes("invalid_grant") || errorBody.includes("invalid_request")) {
-        // Double-check: another session might have already refreshed between our read and the OAuth call
+        // Another session/process may have refreshed (and rotated) the token between
+        // our read and this OAuth call — if the DB token is now fresh, this failure is stale.
         const recheckAccount = this.getWithTokens(accountId);
         if (recheckAccount?.expiresAt && recheckAccount.expiresAt - Math.floor(Date.now() / 1000) > 60) {
           console.log(`[accounts] Refresh failed with invalid_grant but DB token is now fresh — another session refreshed it`);
           return;
         }
-        console.log(`[accounts] Clearing invalid refresh token for ${account.email ?? accountId} — account is now temporary`);
-        updateAccount(accountId, { refresh_token: encrypt("") });
+        // Do NOT wipe the refresh token. On multi-device/multi-process setups the token is
+        // usually rotated elsewhere, not truly dead; clearing it bricks the local copy
+        // permanently with no recovery path (esp. for parked/disabled accounts). Preserve
+        // it so re-enable / re-import / re-sync can restore access.
+        console.warn(`[accounts] Refresh token rejected for ${account.email ?? accountId} — preserving token for recovery (not clearing)`);
       }
       if (disableOnFail) {
         this.setDisabled(accountId);
@@ -743,9 +746,12 @@ class AccountService {
       const accounts = this.list();
       const nowS = Math.floor(Date.now() / 1000);
       for (const acc of accounts) {
-        // Disabled accounts are still refreshed to keep the refresh token alive.
-        // Disable only removes an account from the chat rotation; skipping refresh
-        // lets the token rotation lapse and eventually expires the account for good.
+        // Freeze disabled accounts: skip background refresh entirely.
+        // Refreshing rotates the OAuth refresh token; when the same account is
+        // shared across machines/processes the rotation races and one side gets
+        // invalid_grant, killing an account the user only meant to park. Leaving
+        // a disabled account untouched keeps its token intact until re-enabled.
+        if (acc.status === "disabled") continue;
         if (!acc.expiresAt) continue;
         if (acc.expiresAt - nowS > REFRESH_BUFFER_S) continue;
         // Skip temporary accounts (no refresh token) — they can't be refreshed

package/src/services/db.service.ts

@@ -3,7 +3,7 @@ import { resolve } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
 import { encrypt, decrypt } from "../lib/account-crypto.ts";
 import { getPpmDir } from "./ppm-dir.ts";
-export const CURRENT_SCHEMA_VERSION = 35;
+export const CURRENT_SCHEMA_VERSION = 36;
 
 let db: Database | null = null;
 let dbProfile: string | null = null;
@@ -831,6 +831,12 @@ function runMigrations(database: Database): void {
       PRAGMA user_version = 35;
     `);
   }
+
+  if (current < 36) {
+    try { database.exec("ALTER TABLE session_metadata ADD COLUMN effort TEXT"); } catch {}
+    try { database.exec("ALTER TABLE session_metadata ADD COLUMN thinking_budget INTEGER"); } catch {}
+    database.exec("PRAGMA user_version = 36;");
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -1023,6 +1029,30 @@ export function setSessionModel(sessionId: string, model: string): void {
   ).run(sessionId, model);
 }
 
+/** Per-session effort override; null when session uses provider default */
+export function getSessionEffort(sessionId: string): string | null {
+  const row = getDb().query("SELECT effort FROM session_metadata WHERE session_id = ?").get(sessionId) as { effort: string | null } | null;
+  return row?.effort ?? null;
+}
+
+export function setSessionEffort(sessionId: string, effort: string): void {
+  getDb().query(
+    "INSERT INTO session_metadata (session_id, effort) VALUES (?, ?) ON CONFLICT(session_id) DO UPDATE SET effort = excluded.effort",
+  ).run(sessionId, effort);
+}
+
+/** Per-session thinking budget (maxThinkingTokens); null = thinking OFF / use provider default */
+export function getSessionThinking(sessionId: string): number | null {
+  const row = getDb().query("SELECT thinking_budget FROM session_metadata WHERE session_id = ?").get(sessionId) as { thinking_budget: number | null } | null;
+  return row?.thinking_budget ?? null;
+}
+
+export function setSessionThinking(sessionId: string, budget: number | null): void {
+  getDb().query(
+    "INSERT INTO session_metadata (session_id, thinking_budget) VALUES (?, ?) ON CONFLICT(session_id) DO UPDATE SET thinking_budget = excluded.thinking_budget",
+  ).run(sessionId, budget);
+}
+
 // ---------------------------------------------------------------------------
 // Unread tracking
 // ---------------------------------------------------------------------------

package/src/services/group-chat/agent-runner.ts

@@ -10,8 +10,8 @@ export interface ChatBackend {
     providerId: string,
     sessionId: string,
     prompt: string,
-    opts?: { permissionMode?: string; signal?: AbortSignal },
-  ): AsyncIterable<{ type: string; content?: string; costUsd?: number; usage?: { costUsd?: number } }>;
+    opts?: { permissionMode?: string; signal?: AbortSignal; model?: string; oneMContext?: boolean },
+  ): AsyncIterable<{ type: string; content?: string; message?: string; costUsd?: number; usage?: { costUsd?: number } }>;
 }
 
 export interface AgentRunResult {
@@ -38,12 +38,25 @@ export async function runAgentTurn(
 
   const events = backend.sendMessage(providerId, member.sessionId, prompt, {
     permissionMode: "bypassPermissions",
+    // Honor the member's configured model (e.g. haiku); falls back to the provider
+    // default when unset. Without this the turn always used the provider default.
+    model: member.model ?? undefined,
+    // Group turns are short/windowed — never request the 1M-context beta. If the user's
+    // config has context_1m on, the [1m] model suffix triggers "long context beta not
+    // available for this subscription" (HTTP 400). Opt out here (like the router).
+    oneMContext: false,
     signal: opts.signal,
   });
 
   for await (const ev of events) {
     if (opts.signal?.aborted) break;
     if (ev.type === "text") full += ev.content ?? "";
+    else if (ev.type === "error") {
+      // Provider errors (auth, rate limit, crash) are terminal for this turn.
+      // Throw so the turn loop aborts and surfaces the error to the UI instead
+      // of appending an empty message and looping to the turn cap.
+      throw new Error(ev.message || `agent turn failed for ${member.name}`);
+    }
     else if (ev.type === "done") {
       costUsd = ev.costUsd ?? ev.usage?.costUsd;
       break;

package/src/services/group-chat/context-window.ts

@@ -41,3 +41,18 @@ export function renderWindow(window: GroupMessage[]): string {
   if (window.length === 0) return "(channel empty)";
   return window.map(line).join("\n");
 }
+
+/** Full turn text stored on the bus (`data.full`), falling back to the short feed
+ *  summary for legacy rows that predate full-text storage. */
+export function fullText(m: GroupMessage): string {
+  const full = (m.data as { full?: string } | null)?.full;
+  return typeof full === "string" && full.length > 0 ? full : (m.summary ?? "");
+}
+
+/** Render messages using FULL text (not the 600-char feed clip) for prompt injection. */
+export function renderFull(messages: GroupMessage[]): string {
+  if (messages.length === 0) return "(channel empty)";
+  return messages
+    .map((m) => `${m.fromMember} -> ${m.toMember ?? "all"}: ${fullText(m)}`.trim())
+    .join("\n");
+}