clawmini 0.0.8 → 0.0.9

package/src/shared/adapters/turn-log-buffer.ts

@@ -0,0 +1,266 @@
+import type { ChatMessage } from '../chats.js';
+import {
+  buildTurnStartEntry,
+  condenseTurnLog,
+  formatTurnLogEntry,
+  type TurnLogEntry,
+} from './turn-log.js';
+
+export interface TurnLogBufferOptions {
+  maxToolPreview: number;
+  maxLogMessageChars: number;
+  editDebounceMs: number;
+}
+
+export interface TurnLogBufferDeps<TAnchor> {
+  /**
+   * Posts a new threaded message under `anchor` and returns the new message's
+   * id (whatever the transport uses to address it later for editing). Throws
+   * on failure; the buffer treats the *initial* post failure as an
+   * unrecoverable per-turn abort.
+   */
+  postThreaded: (anchor: TAnchor, text: string) => Promise<string | undefined>;
+  /** Edits a previously-posted threaded message by id. Throws on failure. */
+  editThreaded: (anchor: TAnchor, messageId: string, text: string) => Promise<void>;
+  /**
+   * Predicate that decides whether an error from `editThreaded` indicates the
+   * underlying message no longer exists (e.g. user deleted it). When true,
+   * the buffer recovers by posting a fresh log message rather than retrying.
+   */
+  isMissingMessageError: (err: unknown) => boolean;
+  options: TurnLogBufferOptions;
+  /** When false, no thread-log activity is ever posted. */
+  threadsEnabled: boolean;
+}
+
+export interface StartParams<TAnchor> {
+  turnId: string;
+  /** Per-chat opt-out. When true, thread-log is suppressed for this turn. */
+  threadsDisabled: boolean;
+  /** Anchor to post into, if known at turn start. */
+  anchorThread: TAnchor | undefined;
+}
+
+export interface TurnLogBuffer<TAnchor> {
+  start(params: StartParams<TAnchor>): void;
+  append(turnId: string, message: ChatMessage): void;
+  assignAnchor(turnId: string, anchor: TAnchor): void;
+  end(turnId: string): Promise<void>;
+  has(turnId: string): boolean;
+  isAnchored(turnId: string): boolean;
+  threadsDisabledFor(turnId: string): boolean;
+  shutdown(): void;
+}
+
+interface Ctx<TAnchor> {
+  turnId: string;
+  threadsDisabled: boolean;
+  startedAt: string;
+  anchor: TAnchor | undefined;
+  activityLogMessageId: string | undefined;
+  entries: TurnLogEntry[];
+  editTimer: NodeJS.Timeout | null;
+  flushChain: Promise<void>;
+  /**
+   * Once the thread-log post fails, the whole turn's activity log is
+   * abandoned: subsequent appends drop silently rather than trying to post
+   * anything else. Matches the user-level expectation that if the thread
+   * never opened, we simply stop logging for that turn.
+   */
+  aborted: boolean;
+}
+
+export function createTurnLogBuffer<TAnchor>(
+  deps: TurnLogBufferDeps<TAnchor>
+): TurnLogBuffer<TAnchor> {
+  const { options, threadsEnabled, postThreaded, editThreaded, isMissingMessageError } = deps;
+  const ctxs = new Map<string, Ctx<TAnchor>>();
+
+  const engaged = (ctx: Ctx<TAnchor>) => threadsEnabled && !ctx.threadsDisabled && !ctx.aborted;
+
+  const runFlush = async (ctx: Ctx<TAnchor>): Promise<void> => {
+    if (!engaged(ctx)) {
+      ctx.entries = [];
+      return;
+    }
+    if (ctx.anchor === undefined) return;
+    if (ctx.entries.length === 0) return;
+
+    let result = condenseTurnLog(ctx.entries, { maxChars: options.maxLogMessageChars });
+
+    const send = async (): Promise<void> => {
+      const text = result.kind === 'fits' ? result.text : result.finalText;
+      if (!ctx.activityLogMessageId) {
+        try {
+          const id = await postThreaded(ctx.anchor!, text);
+          if (id) ctx.activityLogMessageId = id;
+        } catch (err) {
+          console.error(
+            `Failed to open thread-log for turn ${ctx.turnId}; dropping further thread-log events for this turn.`,
+            err
+          );
+          ctx.aborted = true;
+          ctx.entries = [];
+        }
+        return;
+      }
+      try {
+        await editThreaded(ctx.anchor!, ctx.activityLogMessageId, text);
+      } catch (err) {
+        if (isMissingMessageError(err)) {
+          // The activity-log message is gone (user deleted it, transport
+          // returned a "not found" code). Open a fresh log message on the
+          // next event rather than retrying the edit.
+          console.warn('Log message missing on edit — opening a fresh log message.');
+          ctx.activityLogMessageId = undefined;
+          try {
+            const id = await postThreaded(ctx.anchor!, text);
+            if (id) ctx.activityLogMessageId = id;
+          } catch (innerErr) {
+            console.error('Failed to re-open log message after missing edit:', innerErr);
+            ctx.activityLogMessageId = undefined;
+          }
+        } else {
+          await new Promise((resolve) => setTimeout(resolve, 500));
+          try {
+            await editThreaded(ctx.anchor!, ctx.activityLogMessageId, text);
+          } catch (retryErr) {
+            console.warn('Edit failed twice — finalizing log message.', retryErr);
+            ctx.activityLogMessageId = undefined;
+          }
+        }
+      }
+    };
+
+    await send();
+
+    // On rollover, the finalized message is sealed; carry-over entries seed a
+    // brand-new activity-log message. A single flush can rollover multiple
+    // times (tight budget with several entries), so loop until the carry fits
+    // or is empty.
+    while (!ctx.aborted && result.kind === 'rollover') {
+      const prevLen = ctx.entries.length;
+      ctx.entries = result.carryEntries.slice();
+      ctx.activityLogMessageId = undefined;
+      if (ctx.entries.length === 0) break;
+      // Degenerate case: a single entry's rendered line is itself larger
+      // than the per-message budget. Drop the stuck head so we can make
+      // progress rather than spinning the flush loop forever.
+      if (ctx.entries.length >= prevLen) {
+        console.warn(
+          `Turn-log entry larger than maxLogMessageChars — dropping head for turn ${ctx.turnId}`
+        );
+        ctx.entries = ctx.entries.slice(1);
+        if (ctx.entries.length === 0) break;
+      }
+      result = condenseTurnLog(ctx.entries, { maxChars: options.maxLogMessageChars });
+      await send();
+    }
+  };
+
+  const enqueueFlush = (ctx: Ctx<TAnchor>): void => {
+    ctx.flushChain = ctx.flushChain
+      .then(() => runFlush(ctx))
+      .catch((err) => console.error('Flush error:', err));
+  };
+
+  const scheduleFlush = (ctx: Ctx<TAnchor>) => {
+    if (!engaged(ctx)) return;
+    if (ctx.editTimer) return;
+    ctx.editTimer = setTimeout(() => {
+      ctx.editTimer = null;
+      enqueueFlush(ctx);
+    }, options.editDebounceMs);
+  };
+
+  return {
+    start(params) {
+      const ctx: Ctx<TAnchor> = {
+        turnId: params.turnId,
+        threadsDisabled: params.threadsDisabled,
+        startedAt: new Date().toISOString(),
+        anchor: params.anchorThread,
+        activityLogMessageId: undefined,
+        // Seed the turn's activity log with an opening entry so the thread
+        // appears as soon as the turn starts, rather than only after the first
+        // tool call / subagent event. Skipped when threads are disabled.
+        entries: threadsEnabled && !params.threadsDisabled ? [buildTurnStartEntry()] : [],
+        editTimer: null,
+        flushChain: Promise.resolve(),
+        aborted: false,
+      };
+      ctxs.set(params.turnId, ctx);
+      // If the anchor is known at start (inbound-user turn, or proactive turn
+      // whose top-level post already landed), flush immediately so the
+      // "Started processing…" line appears without waiting for the debounce.
+      if (ctx.anchor !== undefined && engaged(ctx)) {
+        enqueueFlush(ctx);
+      }
+    },
+
+    append(turnId, message) {
+      const ctx = ctxs.get(turnId);
+      if (!ctx) return;
+      if (!engaged(ctx)) return;
+      const entry = formatTurnLogEntry(message, {
+        maxToolPreview: options.maxToolPreview,
+        turnStartedAt: ctx.startedAt,
+      });
+      if (!entry) return;
+      ctx.entries.push(entry);
+      // Without an anchor yet, entries accumulate; assignAnchor will flush
+      // them once the anchor arrives.
+      if (ctx.anchor !== undefined) {
+        scheduleFlush(ctx);
+      }
+    },
+
+    assignAnchor(turnId, anchor) {
+      const ctx = ctxs.get(turnId);
+      if (!ctx) return;
+      if (ctx.anchor !== undefined) return;
+      ctx.anchor = anchor;
+      if (engaged(ctx) && ctx.entries.length > 0) {
+        enqueueFlush(ctx);
+      }
+    },
+
+    async end(turnId) {
+      const ctx = ctxs.get(turnId);
+      if (!ctx) return;
+      if (ctx.editTimer) {
+        clearTimeout(ctx.editTimer);
+        ctx.editTimer = null;
+      }
+      // Tack a final flush onto the chain so any pending entries are sent.
+      enqueueFlush(ctx);
+      try {
+        await ctx.flushChain;
+      } catch (err) {
+        console.error('Final flush error:', err);
+      }
+      ctxs.delete(turnId);
+    },
+
+    has(turnId) {
+      return ctxs.has(turnId);
+    },
+
+    isAnchored(turnId) {
+      const ctx = ctxs.get(turnId);
+      return ctx?.anchor !== undefined;
+    },
+
+    threadsDisabledFor(turnId) {
+      const ctx = ctxs.get(turnId);
+      return ctx?.threadsDisabled ?? false;
+    },
+
+    shutdown() {
+      for (const ctx of ctxs.values()) {
+        if (ctx.editTimer) clearTimeout(ctx.editTimer);
+      }
+      ctxs.clear();
+    },
+  };
+}

package/src/shared/adapters/turn-log.test.ts

@@ -0,0 +1,389 @@
+import { describe, it, expect } from 'vitest';
+import {
+  formatTurnLogEntry,
+  condenseTurnLog,
+  buildTurnStartEntry,
+  TURN_START_EMOJI,
+  type TurnLogEntry,
+} from './turn-log.js';
+import type {
+  AgentReplyMessage,
+  CommandLogMessage,
+  PolicyRequestMessage,
+  SubagentStatusMessage,
+  SystemMessage,
+  ToolMessage,
+  UserMessage,
+} from '../chats.js';
+
+const FIXED_TS = '2026-04-20T12:04:02.000Z';
+
+function makeTool(overrides: Partial<ToolMessage> = {}): ToolMessage {
+  return {
+    id: 'id',
+    role: 'tool',
+    content: '',
+    timestamp: FIXED_TS,
+    sessionId: 's',
+    messageId: 'mid',
+    name: 'Read',
+    payload: { file_path: 'src/app.ts' },
+    ...overrides,
+  };
+}
+
+describe('formatTurnLogEntry', () => {
+  it('returns null for top-level UserMessage / AgentReplyMessage', () => {
+    const user: UserMessage = {
+      id: '1',
+      role: 'user',
+      content: 'hi',
+      timestamp: FIXED_TS,
+      sessionId: 's',
+    };
+    const reply: AgentReplyMessage = {
+      id: '2',
+      role: 'agent',
+      content: 'hi back',
+      timestamp: FIXED_TS,
+      sessionId: 's',
+    };
+    expect(formatTurnLogEntry(user)).toBeNull();
+    expect(formatTurnLogEntry(reply)).toBeNull();
+  });
+
+  it('renders a subagent prompt (user role with subagentId) as a subagent entry', () => {
+    const msg: UserMessage = {
+      id: '1',
+      role: 'user',
+      content: 'research auth flow',
+      timestamp: FIXED_TS,
+      sessionId: 's',
+      subagentId: 'sub-1',
+    };
+    const entry = formatTurnLogEntry(msg);
+    expect(entry).not.toBeNull();
+    expect(entry!.kind).toBe('subagent');
+    expect(entry!.summary).toContain('sub-1');
+    expect(entry!.summary).toContain('research auth flow');
+    expect(entry!.summary).toContain('👉');
+  });
+
+  it('renders a subagent reply (agent role with subagentId) as a subagent entry', () => {
+    const msg: AgentReplyMessage = {
+      id: '2',
+      role: 'agent',
+      content: 'found 3 callers',
+      timestamp: FIXED_TS,
+      sessionId: 's',
+      subagentId: 'sub-1',
+    };
+    const entry = formatTurnLogEntry(msg);
+    expect(entry).not.toBeNull();
+    expect(entry!.kind).toBe('subagent');
+    expect(entry!.summary).toContain('sub-1');
+    expect(entry!.summary).toContain('found 3 callers');
+    expect(entry!.summary).toContain('👈');
+  });
+
+  it('formats a ToolMessage with a known extractor (emoji replaces verb)', () => {
+    const msg = makeTool({ name: 'Read', payload: { file_path: 'src/app.ts' } });
+    const entry = formatTurnLogEntry(msg);
+    expect(entry).not.toBeNull();
+    expect(entry!.kind).toBe('tool');
+    expect(entry!.summary).toBe('📖 src/app.ts');
+  });
+
+  it('falls back to <name>: <json> for unknown tools (no emoji)', () => {
+    const msg = makeTool({ name: 'mystery_tool', payload: { foo: 1, bar: 'two' } });
+    const entry = formatTurnLogEntry(msg)!;
+    expect(entry.summary).toContain('mystery_tool');
+    expect(entry.summary).toContain('"foo"');
+    expect(entry.summary).toContain('"bar"');
+  });
+
+  it('uses a verb-specific emoji for common tools', () => {
+    expect(
+      formatTurnLogEntry(makeTool({ name: 'run_shell_command', payload: { command: 'ls -la' } }))!
+        .summary
+    ).toBe('🧑‍💻 ls -la');
+    expect(
+      formatTurnLogEntry(
+        makeTool({ name: 'activate_skill', payload: { name: 'clawmini-subagents' } })
+      )!.summary
+    ).toBe('📚 clawmini-subagents');
+    expect(
+      formatTurnLogEntry(makeTool({ name: 'Bash', payload: { command: 'echo hi' } }))!.summary
+    ).toBe('🧑‍💻 echo hi');
+    expect(
+      formatTurnLogEntry(makeTool({ name: 'Grep', payload: { pattern: 'TODO' } }))!.summary
+    ).toBe('🔎 TODO');
+  });
+
+  it('formats a SubagentStatusMessage with a sigil', () => {
+    const msg: SubagentStatusMessage = {
+      id: '1',
+      role: 'subagent_status',
+      content: 'done',
+      timestamp: FIXED_TS,
+      sessionId: 's',
+      subagentId: 'sub-1',
+      status: 'completed',
+    };
+    expect(formatTurnLogEntry(msg)!.summary).toBe('✅ sub-1');
+
+    const failed = { ...msg, status: 'failed' as const };
+    expect(formatTurnLogEntry(failed)!.summary).toBe('❌ sub-1');
+  });
+
+  it('shortens UUID subagent ids but leaves human ids alone', () => {
+    const uuid = '5ea7b9ba-5103-40ee-95b6-c90808bbc431';
+    const status: SubagentStatusMessage = {
+      id: '1',
+      role: 'subagent_status',
+      content: '',
+      timestamp: FIXED_TS,
+      sessionId: 's',
+      subagentId: uuid,
+      status: 'completed',
+    };
+    expect(formatTurnLogEntry(status)!.summary).toBe('✅ 5ea7b9ba');
+
+    const human = { ...status, subagentId: 'hello-sub' };
+    expect(formatTurnLogEntry(human)!.summary).toBe('✅ hello-sub');
+  });
+
+  it('formats a PolicyRequestMessage with a status verb', () => {
+    const msg: PolicyRequestMessage = {
+      id: '1',
+      role: 'policy',
+      content: '',
+      timestamp: FIXED_TS,
+      sessionId: 's',
+      messageId: 'mid',
+      requestId: 'req',
+      commandName: 'rm',
+      args: ['-rf', '/tmp/cache'],
+      status: 'approved',
+    };
+    const entry = formatTurnLogEntry(msg)!;
+    expect(entry.kind).toBe('policy');
+    expect(entry.summary).toBe('policy approved: rm -rf /tmp/cache');
+  });
+
+  it('prefixes subagent-produced tool calls with the subagent marker and id', () => {
+    // A tool call emitted *inside* a subagent turn. The formatter flags it via
+    // `subagentId`; the renderer then prefixes the entry with 🤖 <short-id> so
+    // the reader knows which delegated turn produced the activity.
+    const parent = formatTurnLogEntry(makeTool({ name: 'Bash', payload: { command: 'ls' } }))!;
+    const child = formatTurnLogEntry(
+      makeTool({
+        name: 'Bash',
+        payload: { command: 'sleep 20' },
+        subagentId: 'sub-1',
+      })
+    )!;
+    // Run both through condenseTurnLog to observe the rendered form.
+    const rendered = condenseTurnLog([parent, child], { maxChars: 500 });
+    expect(rendered.kind).toBe('fits');
+    if (rendered.kind !== 'fits') return;
+    const [parentLine, childLine] = rendered.text.split('\n');
+    expect(parentLine).not.toContain('🤖');
+    expect(parentLine).toContain('🧑‍💻 ls');
+    expect(childLine).toContain('🤖 sub-1 🧑‍💻 sleep 20');
+  });
+
+  it('shortens UUID subagent ids in the marker prefix', () => {
+    const uuid = '5ea7b9ba-5103-40ee-95b6-c90808bbc431';
+    const entry = formatTurnLogEntry(
+      makeTool({
+        name: 'Bash',
+        payload: { command: 'ls' },
+        subagentId: uuid,
+      })
+    )!;
+    const rendered = condenseTurnLog([entry], { maxChars: 500 });
+    if (rendered.kind !== 'fits') throw new Error('expected fits');
+    expect(rendered.text).toContain('🤖 5ea7b9ba 🧑‍💻 ls');
+    expect(rendered.text).not.toContain(uuid);
+  });
+
+  it('does not mark subagent boundary events (prompt/reply/status)', () => {
+    // These kinds already name the subagent via 👉/👈/✅; a second marker is noise.
+    const prompt: UserMessage = {
+      id: 'p',
+      role: 'user',
+      content: 'do it',
+      timestamp: FIXED_TS,
+      sessionId: 's',
+      subagentId: 'sub-1',
+    };
+    const reply: AgentReplyMessage = {
+      id: 'r',
+      role: 'agent',
+      content: 'done',
+      timestamp: FIXED_TS,
+      sessionId: 's',
+      subagentId: 'sub-1',
+    };
+    const status: SubagentStatusMessage = {
+      id: 'st',
+      role: 'subagent_status',
+      content: '',
+      timestamp: FIXED_TS,
+      sessionId: 's',
+      subagentId: 'sub-1',
+      status: 'completed',
+    };
+    const entries = [prompt, reply, status].map((m) => formatTurnLogEntry(m)!);
+    const rendered = condenseTurnLog(entries, { maxChars: 500 });
+    if (rendered.kind !== 'fits') throw new Error('expected fits');
+    expect(rendered.text).not.toContain('🤖');
+  });
+
+  it('drops CommandLogMessage from the turn log', () => {
+    const msg: CommandLogMessage = {
+      id: '1',
+      role: 'command',
+      content: '',
+      timestamp: FIXED_TS,
+      sessionId: 's',
+      messageId: 'mid',
+      command: 'echo hi',
+      cwd: '/tmp',
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    };
+    expect(formatTurnLogEntry(msg)).toBeNull();
+  });
+
+  it('formats a SystemMessage', () => {
+    const msg: SystemMessage = {
+      id: '1',
+      role: 'system',
+      content: 'stuff',
+      timestamp: FIXED_TS,
+      sessionId: 's',
+      event: 'cron',
+    };
+    const entry = formatTurnLogEntry(msg);
+    expect(entry!.kind).toBe('system');
+    expect(entry!.summary).toBe('cron: stuff');
+  });
+
+  it('drops subagent_update system messages (orchestration plumbing)', () => {
+    const msg: SystemMessage = {
+      id: '1',
+      role: 'system',
+      content: '<notification>Subagent x completed.</notification>',
+      timestamp: FIXED_TS,
+      sessionId: 's',
+      event: 'subagent_update',
+    };
+    expect(formatTurnLogEntry(msg)).toBeNull();
+  });
+
+  it('truncates tool principal-arg longer than maxToolPreview', () => {
+    const msg = makeTool({ name: 'Bash', payload: { command: 'x'.repeat(500) } });
+    const entry = formatTurnLogEntry(msg, { maxToolPreview: 100 })!;
+    expect(entry.summary).toContain('[truncated]');
+    expect(entry.summary.length).toBeLessThanOrEqual(200);
+    expect(entry.rawLength).toBe(500);
+  });
+
+  it('replaces newlines in tool principal-arg with spaces', () => {
+    const msg = makeTool({ name: 'Bash', payload: { command: 'line1\nline2\nline3' } });
+    const entry = formatTurnLogEntry(msg)!;
+    expect(entry.summary).not.toContain('\n');
+    expect(entry.summary).toContain('line1');
+    expect(entry.summary).toContain('line3');
+  });
+
+  it('renders relative timestamps when turnStartedAt is supplied', () => {
+    const start = '2026-04-20T12:04:02.000Z';
+    const make = (offsetMs: number): SubagentStatusMessage => ({
+      id: '1',
+      role: 'subagent_status',
+      content: '',
+      timestamp: new Date(new Date(start).getTime() + offsetMs).toISOString(),
+      sessionId: 's',
+      subagentId: 'sub-1',
+      status: 'completed',
+    });
+    expect(formatTurnLogEntry(make(0), { turnStartedAt: start })!.timestamp).toBe('0s');
+    expect(formatTurnLogEntry(make(5_000), { turnStartedAt: start })!.timestamp).toBe('5s');
+    expect(formatTurnLogEntry(make(60_000), { turnStartedAt: start })!.timestamp).toBe('1m');
+    expect(formatTurnLogEntry(make(125_000), { turnStartedAt: start })!.timestamp).toBe('2m5s');
+  });
+
+  it('falls back to wall-clock timestamps when turnStartedAt is omitted', () => {
+    const msg = makeTool({ payload: { file_path: 'x.md' } });
+    const entry = formatTurnLogEntry(msg)!;
+    expect(entry.timestamp).toMatch(/^\d{2}:\d{2}:\d{2}$/);
+  });
+});
+
+describe('buildTurnStartEntry', () => {
+  it('renders the opening line with a 0s timestamp and start emoji', () => {
+    const entry = buildTurnStartEntry();
+    expect(entry.timestamp).toBe('0s');
+    expect(entry.kind).toBe('system');
+    expect(entry.summary).toContain(TURN_START_EMOJI);
+    expect(entry.summary).toContain('Started processing');
+    expect(entry.subagentId).toBeUndefined();
+  });
+
+  it('renders cleanly through condenseTurnLog (no subagent marker)', () => {
+    const entry = buildTurnStartEntry();
+    const rendered = condenseTurnLog([entry], { maxChars: 500 });
+    expect(rendered.kind).toBe('fits');
+    if (rendered.kind !== 'fits') return;
+    expect(rendered.text).not.toContain('🤖');
+    expect(rendered.text).toContain('0s');
+    expect(rendered.text).toContain('Started processing');
+  });
+});
+
+function mkEntry(summary: string, overrides: Partial<TurnLogEntry> = {}): TurnLogEntry {
+  return {
+    timestamp: '12:04:02',
+    kind: 'tool',
+    summary,
+    rawLength: summary.length,
+    messageRole: 'tool',
+    ...overrides,
+  };
+}
+
+describe('condenseTurnLog', () => {
+  it('fits when under budget', () => {
+    const entries = [mkEntry('Read(small)'), mkEntry('Grep(small)')];
+    const result = condenseTurnLog(entries, { maxChars: 500 });
+    expect(result.kind).toBe('fits');
+    if (result.kind === 'fits') {
+      expect(result.text).toContain('Read');
+      expect(result.text).toContain('Grep');
+    }
+  });
+
+  it('rolls over when exceeded', () => {
+    const entries = Array.from({ length: 20 }, (_, i) => mkEntry('X'.repeat(40) + ` #${i}`));
+    const result = condenseTurnLog(entries, { maxChars: 200 });
+    expect(result.kind).toBe('rollover');
+    if (result.kind === 'rollover') {
+      expect(result.finalText).toContain('…log continues');
+      expect(result.carryEntries.length).toBeGreaterThan(0);
+      expect(result.carryEntries.length).toBeLessThan(entries.length);
+    }
+  });
+
+  it('is pure — does not mutate input', () => {
+    const entries = [mkEntry('one'), mkEntry('two')];
+    const copy = entries.map((e) => ({ ...e }));
+    const r1 = condenseTurnLog(entries, { maxChars: 500 });
+    const r2 = condenseTurnLog(entries, { maxChars: 500 });
+    expect(r1).toEqual(r2);
+    expect(entries).toEqual(copy);
+  });
+});