@indianic/dialout 1.11.0 → 1.12.0

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;
@@ -14,6 +15,7 @@ export type ChatBlock =
   | { kind: 'assistant'; key: string; text: string }
   | { kind: 'tools';     key: string; items: ToolItem[] }
   | { 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;
     }
 

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/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,6 +44,9 @@ 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, freeTextRow, isFreeTextOption, isSafeKeyList, promptKeys, promptMoveKeys } from './pane-prompt';

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');
+  });
+});

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

@@ -0,0 +1,159 @@
+import { thinkingDuration } from './thinking';
+
+// Not every "user" message in a transcript came from a person.
+//
+// The CLIs inject their own machinery into the user role: a background task
+// finishing, a subagent handing its report back, a slash command, the output
+// of a local command, a reminder the harness wants the model to re-read. Each
+// arrives as an XML-ish frame, and rendering those frames verbatim is what
+// filled the chat with `<task-notification>` and `<tool-use-id>` instead of
+// the one line the terminal prints for the same event.
+//
+// So a user message is read before it is rendered. It comes back as the
+// person's words, as a one-line notice with the detail folded away, or as
+// nothing at all — the terminal shows no trace of a system reminder and
+// neither should we. The body kept on a notice is markdown, dedented, ready
+// for the same renderer that draws an agent's reply.
+
+export type NoticeKind = 'task' | 'handback' | 'session' | 'command' | 'output' | 'compact';
+
+export interface MessageNotice {
+  kind: NoticeKind;
+  /** The single line, the way the terminal would print it. */
+  label: string;
+  /** What the line earns a suffix for: a duration, a tool count, an id. */
+  detail?: string;
+  /** Markdown worth keeping behind a toggle; absent means nothing to open. */
+  body?: string;
+}
+
+export type ReadMessage =
+  | { kind: 'text'; text: string }
+  | { kind: 'notice'; notice: MessageNotice }
+  | { kind: 'hidden' };
+
+/** Reminders are a frame around other content as often as they are content. */
+const REMINDER = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
+const CAVEAT = /<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g;
+const HANDBACK_FRAME = 'The report follows:';
+
+function tag(src: string, name: string): string {
+  const m = new RegExp(`<${name}>([\\s\\S]*?)</${name}>`).exec(src);
+  return m ? m[1].trim() : '';
+}
+
+/**
+ * Strip the indent a frame added, so the markdown inside survives.
+ *
+ * The hand-back frame indents every line of a subagent's report by two
+ * spaces — deliberately, so a forged frame line at column zero is visible.
+ * Left in place that indent turns the report's `- ` bullets into continuation
+ * lines and its fenced blocks into something the parser never reaches.
+ */
+export function dedent(src: string): string {
+  const lines = String(src || '').replace(/\r\n?/g, '\n').split('\n')
+    .map((l) => l.replace(/\t/g, '  '));
+  let min = Infinity;
+  for (const l of lines) {
+    if (!l.trim()) continue;
+    min = Math.min(min, (/^ */.exec(l) as RegExpExecArray)[0].length);
+  }
+  if (!isFinite(min) || min === 0) return lines.join('\n').trim();
+  return lines.map((l) => (l.trim() ? l.slice(min) : '')).join('\n').trim();
+}
+
+function taskNotice(src: string): MessageNotice {
+  const n = src.slice(src.indexOf('<task-notification>'));
+  const summary = tag(n, 'summary');
+  const status = tag(n, 'status');
+  const ms = Number(tag(n, 'duration_ms') || 0);
+  const tools = Number(tag(n, 'tool_uses') || 0);
+  const bits: string[] = [];
+  if (ms > 0) bits.push(thinkingDuration(ms));
+  if (tools > 0) bits.push(`${tools} tool${tools === 1 ? '' : 's'}`);
+  // The result is usually a pointer to the report rather than the report, and
+  // the note explains the lifecycle. Both are worth keeping, neither is worth
+  // a line of its own.
+  const body = [tag(n, 'result'), tag(n, 'note')].filter(Boolean).join('\n\n');
+  return {
+    kind: 'task',
+    label: summary || (status ? `Background task ${status}` : 'Background task'),
+    detail: bits.join(' · ') || undefined,
+    body: body || undefined,
+  };
+}
+
+function handbackNotice(src: string, from: string): MessageNotice {
+  const open = /<agent-message from="([^"]*)">/.exec(src);
+  let body = open ? src.slice((open.index ?? 0) + open[0].length) : src;
+  body = body.replace(/<\/agent-message>\s*$/, '');
+  const handback = body.includes('[Subagent hand-back]');
+  // Everything before "The report follows:" is the harness explaining that
+  // the report carries no user authority. True, and already enforced by the
+  // fact that we render it as a notice rather than as a request.
+  const at = body.indexOf(HANDBACK_FRAME);
+  if (at >= 0) body = body.slice(at + HANDBACK_FRAME.length);
+  const who = (from || '').trim();
+  return {
+    kind: handback ? 'handback' : 'session',
+    label: handback ? 'Report from a delegated agent' : 'Message from another session',
+    detail: who || undefined,
+    body: dedent(body) || undefined,
+  };
+}
+
+/**
+ * What to draw for one user-role message.
+ *
+ * Order matters: a task notification usually arrives wrapped in a reminder,
+ * and a slash command carries its own stdout, so the frames are peeled before
+ * anything is matched and the more specific shape is tested first.
+ */
+export function readUserMessage(raw: string): ReadMessage {
+  const full = String(raw || '').replace(/\r\n?/g, '\n');
+  const src = full.replace(REMINDER, '\n').replace(CAVEAT, '\n').trim();
+  if (!src) return { kind: 'hidden' };
+
+  if (src.includes('<task-notification>')) {
+    return { kind: 'notice', notice: taskNotice(src) };
+  }
+
+  const from = /<agent-message from="([^"]*)">/.exec(src);
+  if (from || src.startsWith('Another Claude session sent a message')) {
+    return { kind: 'notice', notice: handbackNotice(src, from ? from[1] : '') };
+  }
+
+  if (src.includes('<command-name>')) {
+    const name = tag(src, 'command-name');
+    const args = tag(src, 'command-args');
+    const out = tag(src, 'local-command-stdout');
+    return {
+      kind: 'notice',
+      notice: {
+        kind: 'command',
+        label: [name || 'Command', args].filter(Boolean).join(' '),
+        body: out || undefined,
+      },
+    };
+  }
+
+  if (src.includes('<local-command-stdout>')) {
+    const out = tag(src, 'local-command-stdout');
+    return { kind: 'notice', notice: { kind: 'output', label: 'Command output', body: out || undefined } };
+  }
+
+  if (src.includes('<tools-used-before-summary>')
+    || src.startsWith('This session is being continued from a previous conversation')) {
+    return {
+      kind: 'notice',
+      notice: { kind: 'compact', label: 'Earlier conversation summarised', body: src },
+    };
+  }
+
+  // A frame we do not know, with nothing but tags inside it, is machinery too.
+  if (/^<[a-z][\w-]*>/.test(src) && !/[^\s<>/\w-]/.test(src.replace(/<[^>]*>/g, ''))) {
+    return { kind: 'hidden' };
+  }
+
+  return { kind: 'text', text: src };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indianic/dialout",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "Dialout agent — reach your office, home or build machine from any browser or phone. Remote tmux terminals, live port checks, filesystem browsing, process control and HTTP tunnels. The agent dials out: no inbound ports, no VPN, no port forwarding.",
   "bin": {
     "dialout": "./bin/devdash-agent.js"