@indianic/dialout 1.11.0 → 1.12.1

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const session_announce_1 = require("./session-announce");
+(0, vitest_1.describe)('shouldAnnounceSession', () => {
+    (0, vitest_1.it)('announces a session with no prior row at all', () => {
+        (0, vitest_1.expect)((0, session_announce_1.shouldAnnounceSession)(null, '2026-10-29T09:00:00Z')).toBe(true);
+        (0, vitest_1.expect)((0, session_announce_1.shouldAnnounceSession)(null, null)).toBe(true);
+    });
+    // The reported bug. The agent reconnects, the row was marked ended, and the
+    // same tmux session is re-reported — it is not news.
+    (0, vitest_1.it)('stays quiet when the prior row is the same session by creation time', () => {
+        (0, vitest_1.expect)((0, session_announce_1.shouldAnnounceSession)({ endedAt: '2026-10-29T08:00:00Z', createdLocal: '2026-10-29T07:00:00Z', notifiedAt: null }, '2026-10-29T07:00:00Z')).toBe(false);
+    });
+    (0, vitest_1.it)('announces a genuinely new session that reuses a name', () => {
+        (0, vitest_1.expect)((0, session_announce_1.shouldAnnounceSession)({ endedAt: '2026-10-29T08:00:00Z', createdLocal: '2026-10-29T07:00:00Z', notifiedAt: '2026-10-29T07:00:01Z' }, '2026-10-29T09:30:00Z')).toBe(true);
+    });
+    // Durable suppression: lastNewNotifiedAt is in memory, so a ws-server
+    // restart must not replay an announcement the database already recorded.
+    (0, vitest_1.it)('stays quiet when the prior row was already announced and is still live', () => {
+        (0, vitest_1.expect)((0, session_announce_1.shouldAnnounceSession)({ endedAt: null, createdLocal: '2026-10-29T07:00:00Z', notifiedAt: '2026-10-29T07:00:01Z' }, '2026-10-29T07:00:00Z')).toBe(false);
+    });
+    // The documented reversal of the original push spec. Without a creation time
+    // there is no way to tell a revival from a new session, and the complaint is
+    // bursts, so silence is the right direction here.
+    (0, vitest_1.it)('treats a missing creation time on either side as the same session', () => {
+        (0, vitest_1.expect)((0, session_announce_1.shouldAnnounceSession)({ endedAt: '2026-10-29T08:00:00Z', createdLocal: null, notifiedAt: null }, '2026-10-29T09:00:00Z')).toBe(false);
+        (0, vitest_1.expect)((0, session_announce_1.shouldAnnounceSession)({ endedAt: '2026-10-29T08:00:00Z', createdLocal: '2026-10-29T07:00:00Z', notifiedAt: null }, null)).toBe(false);
+    });
+});

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

@@ -1,6 +1,6 @@
 {
   "name": "@indianic/dialout-shared",
-  "version": "1.5.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 -p tsconfig.build.json",
+    "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;
@@ -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

@@ -12,11 +12,21 @@ export { REPLAY_LIMIT } from './session';
 
 export type { CommandSource, AiCommand, McpServerInfo, AiCapabilities } from './capabilities';
 
-export { NOTIFY_COOLDOWN_MS, shouldNotifyAi, shouldNotifyPrompt } from './notify';
+export {
+  NOTIFY_COOLDOWN_MS,
+  shouldNotifyAi,
+  shouldNotifyPrompt,
+  shouldNotifyNewTerminal,
+  shouldNotifyNewAiSession,
+  type PushPrefs,
+} 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 +51,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/node_modules/@indianic/dialout-shared/src/notify.ts

@@ -46,3 +46,54 @@ export function shouldNotifyPrompt(
   if (lastNotifiedAt && nowMs - lastNotifiedAt < NOTIFY_COOLDOWN_MS) return false;
   return true;
 }
+
+/** Which events a user wants pushed. One flag per event, no nesting. */
+export interface PushPrefs {
+  aiQuestions: boolean;
+  newTerminal: boolean;
+  newAiSession: boolean;
+  announcements: boolean;
+}
+
+/**
+ * Per-subscription, not per-session: whether a session is worth announcing
+ * depends on which device is being told.
+ *
+ * `createdByInstallId` is null for a native tmux shell the agent merely found,
+ * which is the case most worth announcing — so a null creator always notifies,
+ * whatever the subscriber knows about itself. An unknown subscriber (one
+ * registered before install ids existed) also notifies: a missed notification
+ * is a worse failure than one extra.
+ */
+function notifyNewSession(
+  enabled: boolean,
+  subscriberInstallId: string | null,
+  createdByInstallId: string | null,
+  lastNotifiedAt: number | undefined,
+  nowMs: number,
+): boolean {
+  if (!enabled) return false;
+  if (createdByInstallId !== null && subscriberInstallId === createdByInstallId) return false;
+  if (lastNotifiedAt && nowMs - lastNotifiedAt < NOTIFY_COOLDOWN_MS) return false;
+  return true;
+}
+
+export function shouldNotifyNewTerminal(
+  prefs: PushPrefs,
+  subscriberInstallId: string | null,
+  createdByInstallId: string | null,
+  lastNotifiedAt: number | undefined,
+  nowMs: number,
+): boolean {
+  return notifyNewSession(prefs.newTerminal, subscriberInstallId, createdByInstallId, lastNotifiedAt, nowMs);
+}
+
+export function shouldNotifyNewAiSession(
+  prefs: PushPrefs,
+  subscriberInstallId: string | null,
+  createdByInstallId: string | null,
+  lastNotifiedAt: number | undefined,
+  nowMs: number,
+): boolean {
+  return notifyNewSession(prefs.newAiSession, subscriberInstallId, createdByInstallId, lastNotifiedAt, nowMs);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@indianic/dialout",
-  "version": "1.11.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.",
+  "version": "1.12.1",
+  "description": "Dialout agent \u2014 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"
   },