@indianic/dialout 1.1.1 → 1.2.0

package/node_modules/@dialout/shared/src/ai-chat-prefs.ts

@@ -0,0 +1,39 @@
+// Per-device AI chat preferences. Every read and write is guarded, because
+// blocked storage must degrade to the default rather than break the composer.
+//
+// Storage is injected so this stays free of both `window` assumptions in the
+// function signatures and of any React Native / Next import. The web default
+// uses localStorage; a native client passes SecureStore.
+
+export const FUNCTION_KEYS_PREF = 'devdash-ai-function-keys';
+
+export interface PrefStore {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+}
+
+function browserStore(): PrefStore | null {
+  const w = (globalThis as { window?: { localStorage?: PrefStore } }).window;
+  if (!w?.localStorage) return null;
+  try {
+    return w.localStorage;
+  } catch {
+    return null;
+  }
+}
+
+export function getFunctionKeysVisible(store: PrefStore | null = browserStore()): boolean {
+  if (!store) return false;
+  try {
+    return store.getItem(FUNCTION_KEYS_PREF) === '1';
+  } catch {
+    return false;
+  }
+}
+
+export function setFunctionKeysVisible(on: boolean, store: PrefStore | null = browserStore()): void {
+  if (!store) return;
+  try {
+    store.setItem(FUNCTION_KEYS_PREF, on ? '1' : '0');
+  } catch { /* blocked storage: keep the in-memory default */ }
+}

package/node_modules/@dialout/shared/src/capabilities.ts

@@ -0,0 +1,30 @@
+import type { AiKind } from './kinds';
+
+export type CommandSource = 'user' | 'project' | 'plugin' | 'builtin';
+
+export interface AiCommand {
+  name: string;          // without the leading slash
+  alias?: string;        // Grok publishes these
+  description: string;   // may be empty, never undefined
+  source: CommandSource;
+}
+
+export interface McpServerInfo {
+  name: string;
+  scope: 'global' | 'project';
+  transport: 'stdio' | 'http';
+  enabled: boolean;
+  origin: string;        // the file it came from
+  command?: string;      // stdio only
+  args?: string[];       // redacted before it leaves the machine
+}
+
+export interface AiCapabilities {
+  kind: AiKind | string;
+  commands: AiCommand[];
+  mcpServers: McpServerInfo[];
+  scannedAt: string;
+  // Set by the server when the agent could not scan. That is not the same as
+  // "this session has no commands" — three facts, three sentences.
+  unavailable?: boolean;
+}

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

@@ -0,0 +1,65 @@
+import { describe, it, expect } from 'vitest';
+import { groupEvents } from './chat-blocks';
+import type { AiEvent } from './events';
+
+const call = (id: string, name: string): AiEvent =>
+  ({ kind: 'tool_call', id, name, summary: `${name} thing` });
+const result = (forId: string, ok = true): AiEvent =>
+  ({ kind: 'tool_result', forId, ok, preview: 'line1\nline2' });
+const msg = (role: 'user' | 'assistant', text: string, id = text): AiEvent =>
+  ({ kind: 'message', role, text, id });
+
+describe('groupEvents', () => {
+  it('merges consecutive tool calls into one block', () => {
+    const blocks = groupEvents([call('a', 'Read'), call('b', 'Bash')]);
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].kind).toBe('tools');
+    if (blocks[0].kind === 'tools') expect(blocks[0].items).toHaveLength(2);
+  });
+
+  it('splits tool blocks when a message comes between them', () => {
+    const blocks = groupEvents([
+      call('a', 'Read'), msg('assistant', 'hello'), call('b', 'Bash'),
+    ]);
+    expect(blocks.map((b) => b.kind)).toEqual(['tools', 'assistant', 'tools']);
+  });
+
+  it('attaches a result to its call by forId', () => {
+    const blocks = groupEvents([call('a', 'Read'), call('b', 'Bash'), result('a', false)]);
+    if (blocks[0].kind !== 'tools') throw new Error('expected tools');
+    expect(blocks[0].items[0].ok).toBe(false);
+    expect(blocks[0].items[0].resultLines).toBe(2);
+    expect(blocks[0].items[1].ok).toBe(null); // no result yet
+  });
+
+  // A result whose call was never seen must not crash or invent a row.
+  it('ignores an orphan result', () => {
+    expect(groupEvents([result('nope')])).toHaveLength(0);
+  });
+
+  it('keeps a lone tool call', () => {
+    const blocks = groupEvents([call('a', 'Read')]);
+    expect(blocks).toHaveLength(1);
+  });
+
+  it('collapses repeated identical statuses to one divider', () => {
+    const blocks = groupEvents([
+      { kind: 'state', status: 'working' },
+      { kind: 'state', status: 'working' },
+      { kind: 'state', status: 'waiting_approval' },
+    ]);
+    expect(blocks.map((b) => b.kind)).toEqual(['status', 'status']);
+    if (blocks[1].kind === 'status') expect(blocks[1].status).toBe('waiting_approval');
+  });
+
+  it('separates user and assistant messages into their own blocks', () => {
+    const blocks = groupEvents([msg('user', 'hi'), msg('assistant', 'hello')]);
+    expect(blocks.map((b) => b.kind)).toEqual(['user', 'assistant']);
+  });
+
+  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);
+    expect(new Set(keys).size).toBe(keys.length);
+  });
+});

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

@@ -0,0 +1,79 @@
+import type { AiEvent } from './events';
+
+export interface ToolItem {
+  id: string;
+  name: string;
+  summary: string;
+  ok: boolean | null;           // null = the call has not returned yet
+  resultPreview: string | null;
+  resultLines: number | null;
+}
+
+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: 'status';    key: string; status: string };
+
+// Grouping only ever merges ADJACENT events, so the worst case for an adapter
+// that interleaves is two blocks instead of one — never a reordering.
+export function groupEvents(events: AiEvent[]): ChatBlock[] {
+  const blocks: ChatBlock[] = [];
+  let lastStatus: string | null = null;
+
+  events.forEach((e, i) => {
+    const key = `${('id' in e && e.id) || ('forId' in e && e.forId) || e.kind}-${i}`;
+    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 || '' });
+      return;
+    }
+
+    if (e.kind === 'tool_call') {
+      const item: ToolItem = {
+        id: e.id || key,
+        name: e.name || 'tool',
+        summary: e.summary || '',
+        ok: null, resultPreview: null, resultLines: null,
+      };
+      if (tail && tail.kind === 'tools') tail.items.push(item);
+      else blocks.push({ kind: 'tools', key, items: [item] });
+      return;
+    }
+
+    if (e.kind === 'tool_result') {
+      // Search backwards: the call is usually in the current block, but a
+      // slow tool can return after a message has split the trace.
+      for (let b = blocks.length - 1; b >= 0; b--) {
+        const blk = blocks[b];
+        if (blk.kind !== 'tools') continue;
+        const item = blk.items.find((t) => t.id === e.forId);
+        if (!item) continue;
+        item.ok = e.ok !== false;
+        item.resultPreview = e.preview || '';
+        item.resultLines = e.preview ? e.preview.split('\n').length : 0;
+        return;
+      }
+      return; // orphan result: drop it rather than invent a row
+    }
+
+    if (e.kind === 'thinking') {
+      blocks.push({ kind: 'thinking', key, text: e.text || '' });
+      return;
+    }
+
+    if (e.kind === 'state') {
+      const status = e.status || '';
+      if (status && status !== lastStatus) {
+        lastStatus = status;
+        blocks.push({ kind: 'status', key, status });
+      }
+    }
+  });
+
+  return blocks;
+}

package/node_modules/@dialout/shared/src/command-filter.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect } from 'vitest';
+import { commandQuery, rankCommands } from './command-filter';
+import type { AiCommand } from './capabilities';
+
+const cmd = (name: string, source: AiCommand['source'], description = ''): AiCommand =>
+  ({ name, source, description });
+
+describe('commandQuery', () => {
+  it('opens on a lone slash', () => {
+    expect(commandQuery('/')).toBe('');
+  });
+
+  it('returns the text after the slash', () => {
+    expect(commandQuery('/comp')).toBe('comp');
+  });
+
+  // A slash mid-sentence is a path or a date, not a command.
+  it('does not open for a slash that is not first', () => {
+    expect(commandQuery('what about /tmp')).toBe(null);
+    expect(commandQuery(' /leading-space')).toBe(null);
+  });
+
+  it('closes once the command is complete', () => {
+    expect(commandQuery('/compact now')).toBe(null);
+  });
+
+  it('is closed for ordinary text and for empty input', () => {
+    expect(commandQuery('')).toBe(null);
+    expect(commandQuery('hello')).toBe(null);
+  });
+});
+
+describe('rankCommands', () => {
+  const all = [
+    cmd('code-review:code-review', 'plugin', 'Review a PR'),
+    cmd('compact', 'builtin', 'Compact conversation history'),
+    cmd('commit-commands:clean_gone', 'plugin', 'Delete merged branches'),
+    cmd('seo', 'user', 'SEO Machine'),
+    cmd('deploy', 'project', 'Ship it'),
+  ];
+
+  it('puts a name prefix match above a name substring above a description match', () => {
+    const names = rankCommands(all, 'co').map((c) => c.name);
+    expect(names[0]).toBe('compact');            // prefix on the bare name
+    expect(names).toContain('code-review:code-review');
+    expect(names).not.toContain('seo');
+  });
+
+  // 52 of 81 commands are plugin-namespaced, so the prefix has to be searchable
+  // or half the list is unreachable by typing.
+  it('matches the plugin namespace as well as the command name', () => {
+    const names = rankCommands(all, 'commit').map((c) => c.name);
+    expect(names).toContain('commit-commands:clean_gone');
+  });
+
+  it('matches a word in the description', () => {
+    const names = rankCommands(all, 'branches').map((c) => c.name);
+    expect(names).toEqual(['commit-commands:clean_gone']);
+  });
+
+  // Plugins outnumber the user's own commands 52:29, so a purely alphabetical
+  // sort buries the ones they wrote.
+  it('breaks ties by source, user first and plugin last', () => {
+    const tie = [cmd('zzz', 'plugin'), cmd('zzz2', 'user'), cmd('zzz3', 'project')];
+    expect(rankCommands(tie, 'zzz').map((c) => c.source)).toEqual(['user', 'project', 'plugin']);
+  });
+
+  it('an empty query returns everything, still ranked by source', () => {
+    expect(rankCommands(all, '')).toHaveLength(5);
+    expect(rankCommands(all, '')[0].source).toBe('user');
+  });
+
+  it('is case insensitive', () => {
+    expect(rankCommands(all, 'SEO').map((c) => c.name)).toEqual(['seo']);
+  });
+});

package/node_modules/@dialout/shared/src/command-filter.ts

@@ -0,0 +1,45 @@
+import type { AiCommand, CommandSource } from './capabilities';
+
+// The menu opens only when the slash starts the message. A slash anywhere else
+// is a path, a date, or a fraction — not a command.
+export function commandQuery(text: string): string | null {
+  if (!text.startsWith('/')) return null;
+  const rest = text.slice(1);
+  // A space means the command has been chosen and arguments are being typed.
+  if (/\s/.test(rest)) return null;
+  return rest;
+}
+
+// User commands are the ones they wrote; plugins outnumber them 52 to 29 on a
+// real install, so source is the tie-breaker or the list buries them.
+const SOURCE_RANK: Record<CommandSource, number> = {
+  user: 0, project: 1, builtin: 2, plugin: 3,
+};
+
+// Lower is better.
+function score(c: AiCommand, q: string): number {
+  const name = c.name.toLowerCase();
+  const bare = name.includes(':') ? name.slice(name.indexOf(':') + 1) : name;
+  const desc = c.description.toLowerCase();
+
+  if (!q) return 40;
+  if (bare.startsWith(q)) return 0;
+  if (name.startsWith(q)) return 10;   // the plugin prefix
+  if (bare.includes(q)) return 20;
+  if (name.includes(q)) return 25;
+  if (desc.includes(q)) return 30;
+  return Infinity;                     // no match at all
+}
+
+export function rankCommands(commands: AiCommand[], query: string): AiCommand[] {
+  const q = query.trim().toLowerCase();
+
+  return commands
+    .map((c) => ({ c, s: score(c, q) }))
+    .filter((x) => x.s !== Infinity)
+    .sort((a, b) =>
+      a.s - b.s
+      || SOURCE_RANK[a.c.source] - SOURCE_RANK[b.c.source]
+      || a.c.name.localeCompare(b.c.name))
+    .map((x) => x.c);
+}

package/node_modules/@dialout/shared/src/composer-behaviour.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+import { shouldSubmitOnEnter, COARSE_POINTER_QUERY } from './composer-behaviour';
+
+const k = (key: string, shiftKey = false) => ({ key, shiftKey });
+
+describe('shouldSubmitOnEnter', () => {
+  it('sends on Enter where there is a real keyboard', () => {
+    expect(shouldSubmitOnEnter(k('Enter'), false)).toBe(true);
+  });
+
+  // On a touch device the on-screen Enter is conventionally a newline, and a
+  // stray one would fire a half-typed message.
+  it('never sends on Enter on a coarse pointer', () => {
+    expect(shouldSubmitOnEnter(k('Enter'), true)).toBe(false);
+  });
+
+  it('Shift+Enter is always a newline', () => {
+    expect(shouldSubmitOnEnter(k('Enter', true), false)).toBe(false);
+    expect(shouldSubmitOnEnter(k('Enter', true), true)).toBe(false);
+  });
+
+  it('ignores every other key', () => {
+    for (const key of ['a', 'Escape', 'Tab', 'NumpadEnter']) {
+      expect(shouldSubmitOnEnter(k(key), false)).toBe(false);
+    }
+  });
+
+  it('exposes the media query it is paired with', () => {
+    expect(COARSE_POINTER_QUERY).toBe('(pointer: coarse)');
+  });
+});

package/node_modules/@dialout/shared/src/composer-behaviour.ts

@@ -0,0 +1,22 @@
+// The compact key bar exists for a device with a finger and no real keyboard.
+// That is a pointer question, not a width one: a half-width desktop window is
+// not a phone, and an iPad in landscape is not a desktop.
+export const COARSE_POINTER_QUERY = '(pointer: coarse)';
+
+// Enter sends where there is a real keyboard. On an on-screen keyboard the
+// Enter key is conventionally a newline, and a stray one would fire a
+// half-typed message — so there the send button is the only way to send.
+//
+// The second argument is deliberately "on-screen keyboard only", not "coarse
+// pointer". They are not the same thing: an iPad with a keyboard cover is a
+// coarse pointer WITH a real Enter key, and treating it as a phone made Enter
+// useless there. The caller combines the pointer test with the hardware
+// inference in useHardwareKeyboard.
+export function shouldSubmitOnEnter(
+  e: { key: string; shiftKey: boolean },
+  onScreenKeyboardOnly: boolean
+): boolean {
+  if (e.key !== 'Enter') return false;
+  if (e.shiftKey) return false;      // Shift+Enter is a newline everywhere
+  return !onScreenKeyboardOnly;
+}

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

@@ -0,0 +1,27 @@
+// The one shape the whole feature speaks. The browser never learns which
+// vendor produced a session, which is the entire point of the adapter layer.
+
+export type AiStatus = 'working' | 'waiting_input' | 'waiting_approval' | 'idle';
+
+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 }
+  | { kind: 'state';       status: AiStatus; at?: string };
+
+export interface AiAdapter {
+  // Never throws. An unrecognised record yields [].
+  toEvents(record: unknown): AiEvent[];
+  // A display title if this record carries one, else null.
+  title(record: unknown): string | null;
+}
+
+// Tool output is routinely megabytes (a full test run, a large file read).
+// Only a preview crosses the socket; the full text is never needed to follow
+// a conversation, and shipping it would stall a phone on mobile data.
+export const PREVIEW_LIMIT = 2000;
+
+export function preview(text: string): string {
+  return text.length <= PREVIEW_LIMIT ? text : `${text.slice(0, PREVIEW_LIMIT)}\n…truncated`;
+}

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

@@ -0,0 +1,32 @@
+export type { AiKind } from './kinds';
+
+export type { AiStatus, AiEvent, AiAdapter } from './events';
+export { PREVIEW_LIMIT, preview } from './events';
+
+export type { PermissionMode } from './permission';
+export { PERMISSION_MODES, isPermissionMode } from './permission';
+
+export type { AiSessionSummary } from './session';
+export { REPLAY_LIMIT } from './session';
+
+export type { CommandSource, AiCommand, McpServerInfo, AiCapabilities } from './capabilities';
+
+export { NOTIFY_COOLDOWN_MS, shouldNotifyAi } from './notify';
+
+export type { ToolItem, ChatBlock } from './chat-blocks';
+export { groupEvents } from './chat-blocks';
+
+export { PIN_THRESHOLD_PX, shouldFollow } from './scroll-pin';
+
+export type { ToolClass, ToolAppearance } from './tool-appearance';
+export { toolClass, toolAppearance } from './tool-appearance';
+
+export { commandQuery, rankCommands } from './command-filter';
+
+export { COARSE_POINTER_QUERY, shouldSubmitOnEnter } from './composer-behaviour';
+
+export type { PrefStore } from './ai-chat-prefs';
+export { FUNCTION_KEYS_PREF, getFunctionKeysVisible, setFunctionKeysVisible } from './ai-chat-prefs';
+
+export type { TerminalNameVars } from './terminal-name';
+export { DEFAULT_TERMINAL_TEMPLATE, TERMINAL_NAME_TOKENS, factsFromSession, renderTerminalName } from './terminal-name';

package/node_modules/@dialout/shared/src/kinds.ts

@@ -0,0 +1,5 @@
+// Vendors we know today. A client that switches exhaustively on this will
+// break the week a fourth is added — treat an unknown kind as generic at
+// runtime (string on the wire, this union at compile time for the ones we
+// have adapters for).
+export type AiKind = 'claude' | 'codex' | 'grok';

package/node_modules/@dialout/shared/src/notify.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest';
+import { shouldNotifyAi } from './notify';
+
+// This is the logic most capable of annoying someone into turning
+// notifications off, so every rule gets a case.
+describe('shouldNotifyAi', () => {
+  const NOW = 1_000_000;
+
+  it('fires when a working session starts waiting for input', () => {
+    expect(shouldNotifyAi('working', 'waiting_input', undefined, NOW)).toBe(true);
+  });
+
+  it('fires when a working session starts waiting for approval', () => {
+    expect(shouldNotifyAi('working', 'waiting_approval', undefined, NOW)).toBe(true);
+  });
+
+  it('stays silent while the status is unchanged', () => {
+    // Without this the agent's five-second poll would re-notify forever.
+    expect(shouldNotifyAi('waiting_input', 'waiting_input', undefined, NOW)).toBe(false);
+  });
+
+  it('stays silent for a session seen for the first time', () => {
+    // It was probably already sitting there before anyone subscribed;
+    // announcing it would mean a burst on every reconnect.
+    expect(shouldNotifyAi(undefined, 'waiting_input', undefined, NOW)).toBe(false);
+  });
+
+  it('stays silent when a session goes back to working', () => {
+    expect(shouldNotifyAi('waiting_input', 'working', undefined, NOW)).toBe(false);
+  });
+
+  it('stays silent when a session merely goes idle', () => {
+    // Idle is not "your turn" — nobody needs waking for it.
+    expect(shouldNotifyAi('working', 'idle', undefined, NOW)).toBe(false);
+  });
+
+  it('does not fire on idle -> waiting_input', () => {
+    // Only work that was actually running is worth being pulled back to.
+    expect(shouldNotifyAi('idle', 'waiting_input', undefined, NOW)).toBe(false);
+  });
+
+  it('respects the cooldown so a run of short tool calls cannot spam', () => {
+    expect(shouldNotifyAi('working', 'waiting_input', NOW - 30_000, NOW)).toBe(false);
+  });
+
+  it('fires again once the cooldown has passed', () => {
+    expect(shouldNotifyAi('working', 'waiting_input', NOW - 200_000, NOW)).toBe(true);
+  });
+});

package/node_modules/@dialout/shared/src/notify.ts

@@ -0,0 +1,30 @@
+// When an AI session change is worth interrupting someone for.
+//
+// Pure so it can be tested without starting a server. This is the logic most
+// capable of annoying a user into switching notifications off, so it is
+// deliberately conservative.
+
+export const NOTIFY_COOLDOWN_MS = 120_000;
+
+const WAITING = new Set(['waiting_input', 'waiting_approval']);
+
+export function shouldNotifyAi(
+  previous: string | undefined,
+  next: string,
+  lastNotifiedAt: number | undefined,
+  nowMs: number
+): boolean {
+  // Nothing to say about a session we are seeing for the first time: it was
+  // probably already sitting there before anyone subscribed, and announcing
+  // it would mean a burst on every agent reconnect.
+  if (previous === undefined) return false;
+  if (previous === next) return false;
+  // Only a transition INTO waiting counts. Notifying on the state itself
+  // would re-fire every five seconds for as long as the session sat there.
+  if (!WAITING.has(next)) return false;
+  // Only work that was actually running is worth being pulled back to; idle
+  // sessions drifting into 'waiting' are not news.
+  if (previous !== 'working') return false;
+  if (lastNotifiedAt && nowMs - lastNotifiedAt < NOTIFY_COOLDOWN_MS) return false;
+  return true;
+}

package/node_modules/@dialout/shared/src/permission.ts

@@ -0,0 +1,10 @@
+// Trust levels offered when launching a session. Order is safest-first.
+// `bypassPermissions` is deliberately absent — nothing arriving from a phone
+// should be able to disable every permission check.
+export type PermissionMode = 'plan' | 'default' | 'acceptEdits' | 'dontAsk';
+
+export const PERMISSION_MODES: PermissionMode[] = ['plan', 'default', 'acceptEdits', 'dontAsk'];
+
+export function isPermissionMode(value: string): value is PermissionMode {
+  return (PERMISSION_MODES as string[]).includes(value);
+}

package/node_modules/@dialout/shared/src/scroll-pin.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { shouldFollow, PIN_THRESHOLD_PX } from './scroll-pin';
+
+describe('shouldFollow', () => {
+  it('follows when parked at the bottom', () => {
+    expect(shouldFollow(900, 1400, 500)).toBe(true);
+  });
+
+  it('follows at exactly the threshold, and stops one pixel past it', () => {
+    expect(shouldFollow(900 - PIN_THRESHOLD_PX, 1400, 500)).toBe(true);
+    expect(shouldFollow(900 - PIN_THRESHOLD_PX - 1, 1400, 500)).toBe(false);
+  });
+
+  it('does not follow when the reader has scrolled up', () => {
+    expect(shouldFollow(0, 1400, 500)).toBe(false);
+  });
+
+  // Content shorter than the viewport is always "at the bottom": there is
+  // nowhere to scroll, so a new event must still land in view.
+  it('follows when content is shorter than the viewport', () => {
+    expect(shouldFollow(0, 300, 500)).toBe(true);
+  });
+});

package/node_modules/@dialout/shared/src/scroll-pin.ts

@@ -0,0 +1,13 @@
+// A terminal follows the tail unless you have scrolled away from it. Pulled
+// out of the component so the threshold is a tested constant rather than a
+// number buried in an effect.
+export const PIN_THRESHOLD_PX = 80;
+
+export function shouldFollow(
+  scrollTop: number,
+  scrollHeight: number,
+  clientHeight: number,
+  threshold: number = PIN_THRESHOLD_PX
+): boolean {
+  return scrollHeight - scrollTop - clientHeight <= threshold;
+}

package/node_modules/@dialout/shared/src/session.ts

@@ -0,0 +1,25 @@
+import type { AiKind } from './kinds';
+import type { AiStatus } from './events';
+import type { PermissionMode } from './permission';
+
+export interface AiSessionSummary {
+  tmuxName: string;
+  kind: AiKind;
+  title: string;
+  folder: string;
+  folderPath: string;
+  gitBranch: string;
+  profile: string;
+  status: AiStatus;
+  // 'tmux' = you started it in your own terminal; 'launched' = DevDash did.
+  origin: 'tmux' | 'launched';
+  permissionMode?: PermissionMode;
+  updatedAt: number;
+  // Which file this row was built from, so opening the session resolves to
+  // the same one rather than re-racing the other panes.
+  transcript: string;
+}
+
+// Replay cap. Opening a month-old session must not flood the socket, and a
+// phone cannot render ten thousand bubbles anyway.
+export const REPLAY_LIMIT = 200;