@indianic/dialout 1.8.1 → 1.10.0

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

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACtC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,QAAQ,CAAC;IAEjB,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC;IAC5B,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,SAAS,EAAE,MAAM,CAAC;IAGlB,UAAU,EAAE,MAAM,CAAC;CACpB;AAID,eAAO,MAAM,YAAY,MAAM,CAAC"}
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACtC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,QAAQ,CAAC;IAEjB,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC;IAC5B,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,SAAS,EAAE,MAAM,CAAC;IAGlB,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,MAAM,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;CAC5B;AAID,eAAO,MAAM,YAAY,MAAM,CAAC"}

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

@@ -1,6 +1,6 @@
 {
   "name": "@indianic/dialout-shared",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Types and constants shared by the Dialout server, agent and mobile app.",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"

package/node_modules/@indianic/dialout-shared/src/.omc/state/sessions/ebad4a54-74e6-4430-8f1c-4e4268aa5d4d/pre-tool-advisory-throttle.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "entries": {
+    "79a93d4a2f8f50b95f852280616242fee1855dc99a3c75211917f55e72e95fae": {
+      "last_emitted_at_ms": 1792572432915,
+      "message": "Use parallel execution for independent tasks. Use run_in_background for long operations (npm install, builds, tests)."
+    }
+  },
+  "updated_at": "2026-10-21T08:47:12.915Z"
+}

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

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { composeWithAttachments, safeAttachmentName, splitAttachments } from './attachments';
+
+const P1 = '/Users/me/.dialout/attachments/2026-10-21/a1b2c3d4-shot.png';
+const P2 = '/Users/me/.dialout/attachments/2026-10-21/0f0f0f0f-spec.pdf';
+
+describe('attachments', () => {
+  it('makes names safe for disk and for a CLI line', () => {
+    expect(safeAttachmentName('Screen Shot 2026-10-21 at 3.04 PM.PNG')).toBe('Screen-Shot-2026-10-21-at-3.04-PM.png');
+    expect(safeAttachmentName('../../etc/passwd')).toBe('passwd');
+    expect(safeAttachmentName('.env')).toBe('env');
+    expect(safeAttachmentName('')).toBe('file');
+    expect(safeAttachmentName('a'.repeat(200) + '.jpeg').length).toBeLessThanOrEqual(80);
+    expect(safeAttachmentName('résumé (final).pdf')).toBe('resume-final.pdf');
+  });
+
+  it('references files the way each CLI reads them, on one line', () => {
+    expect(composeWithAttachments('claude', 'Fix this\nlayout', [P1])).toBe(`Fix this layout @${P1}`);
+    expect(composeWithAttachments('codex', 'Look', [P1, P2])).toBe(`Look (attached: ${P1}, ${P2})`);
+    expect(composeWithAttachments('claude', '', [P1])).toBe(`@${P1}`);
+    expect(composeWithAttachments('grok', 'hi', [])).toBe('hi');
+  });
+
+  it('turns references back into chips, leaving other paths alone', () => {
+    const a = splitAttachments(composeWithAttachments('claude', 'Fix /src/app.ts please', [P1, P2]));
+    expect(a.text).toBe('Fix /src/app.ts please');
+    expect(a.files.map((f) => [f.name, f.image])).toEqual([['shot.png', true], ['spec.pdf', false]]);
+    const b = splitAttachments(composeWithAttachments('codex', 'Look', [P1]));
+    expect(b.text).toBe('Look');
+    expect(b.files[0].path).toBe(P1);
+    expect(splitAttachments('nothing here (attached: soon)').text).toBe('nothing here (attached: soon)');
+  });
+});

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

@@ -0,0 +1,82 @@
+// Files and images attached to an AI chat message.
+//
+// A coding CLI cannot receive a file over its TUI, but every one of them can
+// read a file by path: Claude Code natively (`@/path` mentions, images
+// included), Codex and Grok through their read/view tools. So an attachment
+// is uploaded to the machine the agent runs on, saved under
+// ~/.dialout/attachments, and the message carries its path. The same rules
+// are used by the web app, the phone app and the agent.
+
+/** Per file. Images from a phone camera fit comfortably; videos do not belong here. */
+export const ATTACHMENT_MAX_BYTES = 15 * 1024 * 1024;
+export const ATTACHMENT_MAX_FILES = 8;
+/** Where the agent keeps them, relative to the user's home. */
+export const ATTACHMENT_DIR = '.dialout/attachments';
+
+const IMAGE_EXT = /\.(png|jpe?g|gif|webp|heic|heif|bmp|svg)$/i;
+
+export function isImageName(name: string): boolean {
+  return IMAGE_EXT.test(name);
+}
+
+/**
+ * A name safe to put on disk and inside a message: letters, digits, dot,
+ * dash and underscore only, no leading dots, at most 80 characters with the
+ * extension kept. No spaces, so a path never has to be quoted for a CLI.
+ */
+export function safeAttachmentName(name: string): string {
+  const base = String(name || '').split(/[\\/]/).pop() || '';
+  const dot = base.lastIndexOf('.');
+  const ext = dot > 0 ? base.slice(dot).toLowerCase().replace(/[^a-z0-9.]/g, '').slice(0, 10) : '';
+  const stem = (dot > 0 ? base.slice(0, dot) : base)
+    .normalize('NFKD').replace(/[\u0300-\u036f]/g, '').replace(/[^\w.-]+/g, '-').replace(/^[.-]+|[.-]+$/g, '').replace(/-{2,}/g, '-')
+    .slice(0, 80 - ext.length);
+  return `${stem || 'file'}${ext}`;
+}
+
+/**
+ * The message with its attachments referenced the way each CLI reads them.
+ * One line on purpose: a newline typed into a TUI can submit the message
+ * half-written.
+ */
+export function composeWithAttachments(kind: string, text: string, paths: string[]): string {
+  const body = text.replace(/\s*\n+\s*/g, ' ').trim();
+  if (!paths.length) return body;
+  const refs = kind === 'claude'
+    ? paths.map((p) => `@${p}`).join(' ')
+    : `(attached: ${paths.join(', ')})`;
+  return body ? `${body} ${refs}` : refs;
+}
+
+export type AttachmentRef = { path: string; name: string; image: boolean };
+
+const IN_DIR = /^(?:~|\/[^\s,()]*?)\/\.dialout\/attachments\/[^\s,()]+$/;
+
+/**
+ * Pull attachment paths back out of a sent message, so a chat bubble can show
+ * them as chips instead of long paths. Only paths inside the attachments
+ * folder count; any other path the user typed stays text.
+ */
+export function splitAttachments(message: string): { text: string; files: AttachmentRef[] } {
+  const files: AttachmentRef[] = [];
+  const seen = new Set<string>();
+  const text = message
+    .replace(/\(attached:\s*([^)]*)\)/g, (whole, list: string) => {
+      const paths = list.split(',').map((s) => s.trim()).filter((s) => IN_DIR.test(s));
+      if (!paths.length) return whole;
+      for (const p of paths) add(p);
+      return '';
+    })
+    .replace(/@?((?:~|\/[^\s,()]*?)\/\.dialout\/attachments\/[^\s,()]+)/g, (_w, p: string) => { add(p); return ''; })
+    .replace(/\s{2,}/g, ' ')
+    .trim();
+  function add(p: string) {
+    if (seen.has(p)) return;
+    seen.add(p);
+    const file = p.split('/').pop() || p;
+    // Saved names carry an 8-character id prefix ("a1b2c3d4-shot.png").
+    const name = file.replace(/^[0-9a-f]{8}-/, '');
+    files.push({ path: p, name, image: isImageName(name) });
+  }
+  return { text, files };
+}

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

@@ -1,3 +1,4 @@
+import type { PanePrompt } from './pane-prompt';
 import type { AiEvent } from './events';
 
 // How a client folds ai_session_events messages into its transcript.
@@ -37,6 +38,12 @@ export interface EventsMeta {
   sessionKey?: string;
   /** Who/where, sent with a replay so a captured log can be labelled. */
   session?: { kind: string; folder: string; gitBranch: string; title: string };
+  /**
+   * What the agent's TUI is asking right now, read from its pane (see
+   * pane-prompt.ts). null = nothing asked any more; absent = not reported
+   * (agents before 1.9, or a message that is only about events).
+   */
+  prompt?: PanePrompt | null;
 }
 
 export const EMPTY_TRANSCRIPT: TranscriptState = { events: [], firstSeq: null, earlier: 0 };

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

@@ -12,7 +12,7 @@ export { REPLAY_LIMIT } from './session';
 
 export type { CommandSource, AiCommand, McpServerInfo, AiCapabilities } from './capabilities';
 
-export { NOTIFY_COOLDOWN_MS, shouldNotifyAi } from './notify';
+export { NOTIFY_COOLDOWN_MS, shouldNotifyAi, shouldNotifyPrompt } from './notify';
 
 export type { ToolItem, ChatBlock } from './chat-blocks';
 export { groupEvents, toolGroupStartsOpen } from './chat-blocks';
@@ -40,3 +40,12 @@ export {
 
 export type { TranscriptState, EventsMeta } from './event-merge';
 export { EMPTY_TRANSCRIPT, mergeEvents } from './event-merge';
+
+export type { PanePrompt, PanePromptOption, PromptKey } from './pane-prompt';
+export { PROMPT_KEYS, detectPanePrompt, isSafeKeyList, promptKeys } from './pane-prompt';
+
+export type { AttachmentRef } from './attachments';
+export {
+  ATTACHMENT_DIR, ATTACHMENT_MAX_BYTES, ATTACHMENT_MAX_FILES,
+  composeWithAttachments, isImageName, safeAttachmentName, splitAttachments,
+} from './attachments';

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { shouldNotifyAi } from './notify';
+import { NOTIFY_COOLDOWN_MS, shouldNotifyAi, shouldNotifyPrompt } from './notify';
 
 // This is the logic most capable of annoying someone into turning
 // notifications off, so every rule gets a case.
@@ -47,3 +47,14 @@ describe('shouldNotifyAi', () => {
     expect(shouldNotifyAi('working', 'waiting_input', NOW - 200_000, NOW)).toBe(true);
   });
 });
+
+describe('shouldNotifyPrompt', () => {
+  it('fires for a new question, not on first sight, not twice, not inside the cooldown', () => {
+    expect(shouldNotifyPrompt(undefined, 'a', undefined, 1000)).toBe(false);
+    expect(shouldNotifyPrompt(null, 'a', undefined, 1000)).toBe(true);
+    expect(shouldNotifyPrompt('a', 'a', undefined, 1000)).toBe(false);
+    expect(shouldNotifyPrompt('a', null, undefined, 1000)).toBe(false);
+    expect(shouldNotifyPrompt('a', 'b', 1000, 1000 + NOTIFY_COOLDOWN_MS - 1)).toBe(false);
+    expect(shouldNotifyPrompt('a', 'b', 1000, 1000 + NOTIFY_COOLDOWN_MS)).toBe(true);
+  });
+});

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

@@ -28,3 +28,21 @@ export function shouldNotifyAi(
   if (lastNotifiedAt && nowMs - lastNotifiedAt < NOTIFY_COOLDOWN_MS) return false;
   return true;
 }
+
+/**
+ * A new question on an agent's screen (a pane prompt id not seen before) is
+ * always news, whatever the status said: a session nobody has open reports
+ * 'idle' until asked, so the working → waiting rule above never sees it.
+ * Still not on first sight (reconnect bursts) and still rate-limited.
+ */
+export function shouldNotifyPrompt(
+  previousPromptId: string | null | undefined,
+  nextPromptId: string | null | undefined,
+  lastNotifiedAt: number | undefined,
+  nowMs: number,
+): boolean {
+  if (previousPromptId === undefined) return false;
+  if (!nextPromptId || nextPromptId === previousPromptId) return false;
+  if (lastNotifiedAt && nowMs - lastNotifiedAt < NOTIFY_COOLDOWN_MS) return false;
+  return true;
+}

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

@@ -0,0 +1,179 @@
+import { describe, expect, it } from 'vitest';
+import { detectPanePrompt, isSafeKeyList, promptKeys } from './pane-prompt';
+
+// Shapes as the CLIs draw them (spacing kept), plus the noise around them.
+const CLAUDE_BASH = `
+⏺ I'll run the tests.
+
+╭──────────────────────────────────────────────────────────────╮
+│ Bash command                                                 │
+│                                                              │
+│   npm test                                                   │
+│   Run the test suite                                         │
+│                                                              │
+│ Do you want to proceed?                                      │
+│ ❯ 1. Yes                                                     │
+│   2. Yes, and don't ask again for npm test commands in /app  │
+│   3. No, and tell Claude what to do differently (esc)        │
+╰──────────────────────────────────────────────────────────────╯
+`;
+
+const CLAUDE_QUESTION = `
+⏺ Let me ask a couple of things first.
+
+────────────────────────────────────────────────────────────────
+ ☐ Colour  ☐ Pet  ✔ Submit  →
+
+Which colour do you prefer?
+
+❯ 1. Red
+     Warm and loud
+  2. Green
+     Calm
+  3. Type something.
+────────────────────────────────────────────────────────────────
+  4. Chat about this
+
+Enter to select · Tab/Arrow keys to navigate · Esc to cancel
+`;
+
+const CLAUDE_TRUST = `
+ Accessing workspace:
+
+ /Users/me/code/app
+
+ Quick safety check: Is this a project you created or one you trust?
+
+ ❯ No, exit
+   Yes, I trust this folder
+
+ Enter to confirm · Esc to cancel
+`;
+
+const CODEX_APPROVAL = `
+• Running tests
+
+  Would you like to run the following command?
+
+  $ npm test
+
+› 1. Yes, proceed (y)
+  2. Yes, and don't ask again for this command (a)
+  3. No, and tell Codex what to do differently (esc)
+
+  Press enter to confirm or esc to cancel
+`;
+
+const MULTI = `
+Which features should I add?
+
+❯ 1. [ ] Dark mode
+  2. [✔] Search
+  3. [ ] Export
+  4. Submit
+
+Enter to select · ↑/↓ to navigate · Esc to cancel
+`;
+
+const IDLE_CLAUDE = `
+⏺ Done. Here is what changed:
+
+  1. Fixed the parser
+  2. Added tests
+  3. Updated docs
+
+────────────────────────────────────────────────────────────────
+❯ 
+────────────────────────────────────────────────────────────────
+  ⏵⏵ auto mode on (shift+tab to cycle)
+`;
+
+const SHELL = `
+~/code/app main
+❯ ls
+README.md  package.json  src
+~/code/app main
+❯ 
+`;
+
+describe('detectPanePrompt', () => {
+  it('reads a Claude permission prompt inside a box', () => {
+    const p = detectPanePrompt(CLAUDE_BASH)!;
+    expect(p.question).toBe('Do you want to proceed?');
+    expect(p.detail).toEqual(['Bash command', 'npm test', 'Run the test suite']);
+    expect(p.options.map((o) => o.label)).toEqual([
+      'Yes', "Yes, and don't ask again for npm test commands in /app", 'No, and tell Claude what to do differently (esc)',
+    ]);
+    expect(p.options[0].selected).toBe(true);
+    expect(p.approval).toBe(true);
+    expect(p.multi).toBe(false);
+  });
+
+  it('reads a question menu with hints, a separator and a footer', () => {
+    const p = detectPanePrompt(CLAUDE_QUESTION)!;
+    expect(p.question).toBe('Which colour do you prefer?');
+    expect(p.options.map((o) => o.label)).toEqual(['Red', 'Green', 'Type something.', 'Chat about this']);
+    expect(p.options[0].hint).toBe('Warm and loud');
+    expect(p.options[1].hint).toBe('Calm');
+    expect(p.footer).toMatch(/Enter to select/);
+    expect(p.approval).toBe(false);
+  });
+
+  it('reads an unnumbered menu when a footer vouches for it', () => {
+    const p = detectPanePrompt(CLAUDE_TRUST)!;
+    expect(p.options.map((o) => [o.n, o.label, o.selected])).toEqual([[1, 'No, exit', true], [2, 'Yes, I trust this folder', false]]);
+    expect(p.question).toMatch(/one you trust\?$/);
+  });
+
+  it('reads a Codex approval', () => {
+    const p = detectPanePrompt(CODEX_APPROVAL)!;
+    expect(p.question).toBe('Would you like to run the following command?');
+    expect(p.detail).toContain('$ npm test');
+    expect(p.options).toHaveLength(3);
+    expect(p.options[0].selected).toBe(true);
+  });
+
+  it('marks multi-select rows', () => {
+    const p = detectPanePrompt(MULTI)!;
+    expect(p.multi).toBe(true);
+    expect(p.options.map((o) => o.checked)).toEqual([false, true, false, null]);
+    expect(p.options[1].label).toBe('Search');
+  });
+
+  it('finds a prompt under several status lines', () => {
+    const status = '\n  [Opus 5.5] │ app │ main\n  Context ░░░░ 12%\n  Usage ok\n  ⏵⏵ auto mode on (shift+tab to cycle)\n';
+    const noFooter = CLAUDE_BASH.trimEnd() + status;
+    expect(detectPanePrompt(noFooter)?.question).toBe('Do you want to proceed?');
+    expect(detectPanePrompt(CLAUDE_TRUST.trimEnd() + status)?.options).toHaveLength(2);
+  });
+
+  it('ignores an idle agent, a numbered reply and a shell prompt', () => {
+    expect(detectPanePrompt(IDLE_CLAUDE)).toBeNull();
+    expect(detectPanePrompt(SHELL)).toBeNull();
+    expect(detectPanePrompt('')).toBeNull();
+  });
+
+  it('keeps its id while the cursor moves, changes it for a new question', () => {
+    const a = detectPanePrompt(CLAUDE_BASH)!;
+    expect(detectPanePrompt(CLAUDE_BASH.replace('❯ 1. Yes', '  1. Yes').replace('│   2. Yes,', '│ ❯ 2. Yes,'))!.id).toBe(a.id);
+    expect(detectPanePrompt(CLAUDE_BASH.replace('npm test  ', 'npm run x'))!.id).not.toBe(a.id);
+  });
+});
+
+describe('promptKeys', () => {
+  it('moves from the cursor to the target, then Enter', () => {
+    const p = detectPanePrompt(CLAUDE_BASH)!;
+    expect(promptKeys(p, 1)).toEqual(['Enter']);
+    expect(promptKeys(p, 3)).toEqual(['Down', 'Down', 'Enter']);
+    const moved = detectPanePrompt(CLAUDE_BASH.replace('❯ 1. Yes', '  1. Yes').replace('│   2. Yes,', '│ ❯ 2. Yes,'))!;
+    expect(promptKeys(moved, 1)).toEqual(['Up', 'Enter']);
+  });
+
+  it('only lets named keys and single characters through', () => {
+    expect(isSafeKeyList(['Down', 'Enter', 'y', '1'])).toBe(true);
+    expect(isSafeKeyList(['rm -rf /'])).toBe(false);
+    expect(isSafeKeyList([';', 'Enter'])).toBe(false);
+    expect(isSafeKeyList([])).toBe(false);
+    expect(isSafeKeyList('Enter')).toBe(false);
+  });
+});

package/node_modules/@indianic/dialout-shared/src/pane-prompt.ts

@@ -0,0 +1,218 @@
+// A coding agent waiting on the user, read from what its TUI is showing.
+//
+// Permission prompts, plan approvals, trust prompts and question menus are
+// drawn in the terminal and most never reach the transcript, so a chat built
+// from the transcript alone looks stuck while the agent is asking something.
+// The agent captures the pane and runs it through detectPanePrompt; clients
+// render the result as tappable choices and answer with promptKeys.
+//
+// One parser for every CLI on purpose: Claude Code, Codex and Grok all draw
+// the same shape — a question, then a list with a cursor on one row
+// (❯ / › / >), usually numbered, then a footer like "Enter to confirm · Esc to
+// cancel". Recognising the shape rather than each vendor's wording is what
+// keeps this working across their releases.
+
+export interface PanePromptOption {
+  /** 1-based position in the menu. */
+  n: number;
+  label: string;
+  /** Indented line(s) under the option: its explanation. */
+  hint?: string;
+  /** The row the cursor is on. */
+  selected: boolean;
+  /** Multi-select rows: ticked or not. null for an ordinary row. */
+  checked: boolean | null;
+}
+
+export interface PanePrompt {
+  /** Changes when the question or its choices change (not when the cursor moves). */
+  id: string;
+  /** Context above the question: "Bash command", the command itself, a file name. */
+  detail: string[];
+  question: string;
+  options: PanePromptOption[];
+  /** Some rows are checkboxes: a tap toggles rather than answers. */
+  multi: boolean;
+  /** The menu's own key hint, shown small under the choices. */
+  footer: string;
+  /** Approval-shaped (run/edit/trust) rather than a question to answer. */
+  approval: boolean;
+}
+
+// Box-drawing borders some CLIs draw around a prompt: stripped before parsing,
+// keeping the indentation inside the box (it tells options from their hints).
+const BORDER_LEFT = /^\s*[│┃║] ?/u;
+const BORDER_RIGHT = /\s*[│┃║]\s*$/u;
+/** Lines under a prompt that may still belong to the TUI (status lines). */
+const TRAILING = 14;
+const SEPARATOR = /^[\s─━═╌┄┈\-_╭╮╰╯┌┐└┘╔╗╚╝]{4,}$/u;
+const FOOTER = /(enter to (confirm|select|submit)|esc to (cancel|exit|interrupt)|to navigate|press enter|↑\/↓|tab\/arrow|y\/n)/i;
+const CHECK_ON = /^\[(x|✔|✓|■|●)\]|^[◉☑✔✓■]/iu;
+const CHECK_OFF = /^\[ \]|^[◯○☐□]/u;
+const APPROVAL = /\b(proceed|allow|approve|permission|trust|run|execute|edit|create|delete|make this edit|overwrite|apply)\b/i;
+
+// "❯ 1. Yes"  "  2. No (esc)"  "› 1. Yes, proceed (y)"
+const NUMBERED = /^(\s*)([❯›>▶→➜●])?\s*(\d{1,2})[.)]\s+(.+?)\s*$/u;
+// "❯ Yes, I trust this folder"  /  "  No, exit" — unnumbered rows
+const BARE = /^(\s*)(?:([❯›>▶→➜●])\s+)?(\S.*?)\s*$/u;
+
+function clean(line: string): string {
+  return line.replace(BORDER_LEFT, '').replace(BORDER_RIGHT, '').replace(/\s+$/, '');
+}
+
+function hash(s: string): string {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < s.length; i++) { h ^= s.charCodeAt(i); h = Math.imul(h, 0x01000193); }
+  return (h >>> 0).toString(36);
+}
+
+function checkState(label: string): { label: string; checked: boolean | null } {
+  if (CHECK_ON.test(label)) return { label: label.replace(CHECK_ON, '').trim(), checked: true };
+  if (CHECK_OFF.test(label)) return { label: label.replace(CHECK_OFF, '').trim(), checked: false };
+  return { label, checked: null };
+}
+
+/** Pull the question and its context from the lines above the menu. */
+function above(lines: string[], end: number): { question: string; detail: string[] } {
+  const block: string[] = [];
+  for (let i = end - 1; i >= 0 && block.length < 8; i--) {
+    const l = lines[i].trim();
+    if (SEPARATOR.test(l)) break;
+    if (!l) { if (block.length) { const prev = lines[i - 1]?.trim(); if (!prev || SEPARATOR.test(prev)) break; } continue; }
+    // A tab strip like "☐ Colour  ☐ Pet  ✔ Submit" is navigation, not content.
+    if (/[☐☒✔✓].*\s{2,}[☐☒✔✓]/u.test(l)) continue;
+    block.unshift(l);
+  }
+  if (!block.length) return { question: '', detail: [] };
+  let qi = -1;
+  for (let i = block.length - 1; i >= 0; i--) if (/\?\s*$/.test(block[i])) { qi = i; break; }
+  if (qi < 0) qi = block.length - 1;
+  return { question: block[qi], detail: block.filter((_, i) => i !== qi) };
+}
+
+type Menu = { opts: PanePromptOption[]; start: number };
+
+/** "❯ 1. Yes / 2. No" with indented hints under rows, scanning up from `bottom`. */
+function numberedMenu(lines: string[], bottom: number): Menu | null {
+  const opts: PanePromptOption[] = [];
+  let hints: string[] = [];
+  let start = -1;
+  let labelCol = 4;
+  let separators = 0;
+  for (let i = bottom; i >= 0; i--) {
+    const raw = lines[i];
+    if (!raw.trim()) { if (opts.length || hints.length) break; continue; }
+    if (SEPARATOR.test(raw.trim())) { if (++separators > 2) break; continue; }
+    const m = raw.match(NUMBERED);
+    if (m) {
+      const ck = checkState(m[4]);
+      opts.unshift({ n: Number(m[3]), label: ck.label, hint: hints.length ? hints.join(' ') : undefined, selected: !!m[2], checked: ck.checked });
+      hints = [];
+      labelCol = raw.indexOf(m[4]);
+      start = i;
+      continue;
+    }
+    // Deeper than an option's label: that option's explanation (it sits
+    // below its option, so it is seen first when scanning upwards).
+    if (raw.search(/\S/) >= Math.max(4, labelCol) && hints.length < 3) { hints.unshift(raw.trim()); continue; }
+    break;
+  }
+  if (opts.length < 2) return null;
+  // Must count 1, 2, 3… — a numbered list in prose is not a menu.
+  if (opts[0].n !== 1 || opts.some((o, i) => o.n !== i + 1)) return null;
+  return { opts, start };
+}
+
+/** Unnumbered rows with one cursor, only trusted when a key-hint footer is under them. */
+function bareMenu(lines: string[], bottom: number): Menu | null {
+  const opts: PanePromptOption[] = [];
+  let start = -1;
+  let indent = -1;
+  for (let i = bottom; i >= 0 && opts.length < 9; i--) {
+    const raw = lines[i];
+    if (!raw.trim()) { if (opts.length) break; continue; }
+    const b = raw.match(BARE);
+    // The question above the rows ends in "?" or ":"; it is not a row.
+    if (!b || (!b[2] && /[?:]\s*$/.test(b[3]))) break;
+    const col = raw.indexOf(b[3]);
+    if (indent >= 0 && Math.abs(col - indent) > 1) break;
+    indent = col;
+    const ck = checkState(b[3]);
+    opts.unshift({ n: 0, label: ck.label, selected: !!b[2], checked: ck.checked });
+    start = i;
+  }
+  if (opts.length < 2 || opts.filter((o) => o.selected).length !== 1) return null;
+  opts.forEach((o, i) => { o.n = i + 1; });
+  return { opts, start };
+}
+
+/**
+ * The prompt on screen, or null. Looks only at the bottom of the pane (a
+ * prompt is always the last thing drawn) and demands a cursor-marked list:
+ * either numbered from 1 with the cursor on a row, or any list followed by a
+ * key-hint footer. A shell prompt ("❯ ") or a numbered list in the agent's
+ * reply has neither, which is what keeps false positives out.
+ */
+export function detectPanePrompt(pane: string): PanePrompt | null {
+  const all = pane.replace(/\r/g, '').split('\n').map(clean);
+  while (all.length && !all[all.length - 1].trim()) all.pop();
+  const lines = all.slice(-45);
+  if (lines.length < 2) return null;
+
+  const footerAt = (() => {
+    // Status lines can sit under a prompt (Claude Code's statusline is
+    // user-configured and may be several lines), so look a little way up.
+    for (let i = lines.length - 1; i >= Math.max(0, lines.length - TRAILING); i--) if (FOOTER.test(lines[i])) return i;
+    return -1;
+  })();
+
+  let menu: Menu | null = null;
+  if (footerAt >= 0) menu = numberedMenu(lines, footerAt - 1) || bareMenu(lines, footerAt - 1);
+  else {
+    // No footer: the menu may still have status lines under it.
+    for (let b = lines.length - 1; b >= Math.max(0, lines.length - TRAILING) && !menu; b--) {
+      const m = numberedMenu(lines, b);
+      if (m && m.opts.some((o) => o.selected)) menu = m;
+    }
+  }
+  if (!menu) return null;
+  const { opts, start } = menu;
+  if (!opts.some((o) => o.selected) && footerAt < 0) return null;
+
+  const { question, detail } = above(lines, start);
+  const footer = footerAt >= 0 ? lines[footerAt].trim() : '';
+  const multi = opts.some((o) => o.checked !== null);
+  const text = [question, ...detail, ...opts.map((o) => `${o.n}${o.label}${o.checked}`), footer].join('\n');
+  return {
+    id: hash(text),
+    detail,
+    question: question || 'The agent is waiting for you',
+    options: opts,
+    multi,
+    footer,
+    approval: APPROVAL.test([question, ...detail].join(' ')) && !/type something/i.test(opts.map((o) => o.label).join(' ')),
+  };
+}
+
+/** Key names the agent may send to a pane, besides single characters. */
+export const PROMPT_KEYS = ['Up', 'Down', 'Left', 'Right', 'Enter', 'Escape', 'Tab', 'BTab', 'Space', 'BSpace', 'C-c'] as const;
+export type PromptKey = (typeof PROMPT_KEYS)[number];
+
+/** A key list is safe to hand to `tmux send-keys`: named keys or one printable character each. */
+export function isSafeKeyList(keys: unknown): keys is string[] {
+  return Array.isArray(keys) && keys.length > 0 && keys.length <= 40
+    && keys.every((k) => typeof k === 'string' && ((PROMPT_KEYS as readonly string[]).includes(k) || /^[A-Za-z0-9]$/.test(k)));
+}
+
+/**
+ * Keys that choose option `n` (1-based): move the cursor from where it is to
+ * that row with arrows, then Enter. Arrows rather than the digit shortcut
+ * because every menu honours arrows, and only some honour digits. On a
+ * multi-select row Enter toggles it; the menu stays up and is re-read.
+ */
+export function promptKeys(p: PanePrompt, n: number): string[] {
+  const from = Math.max(0, p.options.findIndex((o) => o.selected));
+  const to = Math.max(0, Math.min(p.options.length - 1, n - 1));
+  const move = to > from ? Array(to - from).fill('Down') : Array(from - to).fill('Up');
+  return [...move, 'Enter'];
+}

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

@@ -1,6 +1,7 @@
 import type { AiKind } from './kinds';
 import type { AiStatus } from './events';
 import type { PermissionMode } from './permission';
+import type { PanePrompt } from './pane-prompt';
 
 export interface AiSessionSummary {
   tmuxName: string;
@@ -26,6 +27,12 @@ export interface AiSessionSummary {
   // 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;
+  /**
+   * A menu the agent's TUI is showing (permission, plan approval, question),
+   * read from the pane — the transcript never records most of these. Absent
+   * from agents before 1.9.
+   */
+  prompt?: PanePrompt | null;
 }
 
 // Replay cap. Opening a month-old session must not flood the socket, and a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indianic/dialout",
-  "version": "1.8.1",
+  "version": "1.10.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"