@agfpd/iapeer 0.2.72 → 0.2.74

package/README.md

@@ -2,10 +2,28 @@
 
 Ядро мультиагентной системы на одном хосте: реестр пиров, единый демон-роутер для обмена сообщениями между ними и команды управления — создание, запуск, усыпление, перезапуск, подключение к внешним каналам. Пиром может быть AI-агент (Claude, Codex), человек (через Telegram) или служебный процесс; все адресуются одинаково через один протокол.
 
+## Ключевые возможности
+
+iapeer держит AI-агентов как **живые интерактивные сессии настоящего CLI** (Claude Code, Codex CLI) — со всем поведением реального CLI, а не headless-режим одноразовых вызовов (`claude -p`, `codex exec`). Поскольку это реальный интерактивный CLI, пиры работают в рамках обычной подписки на Claude Code (изменение тарификации headless-режима от 15 июня 2026 интерактивный CLI не затрагивает).
+
+Отдельные свойства ниже встречаются и в других инструментах; сильная сторона iapeer — их **комбинация целиком**:
+
+1. **Реальный интерактивный CLI в фоне.** Каждый AI-пир — полноценная сессия Claude Code или Codex CLI, поднятая в фоне и доступная по сообщению.
+
+2. **Постоянная сессия (persistent).** На входящее демон поднимает пира через возобновление (`--continue` / `--resume`) — диалог **продолжается**, а не начинается заново; контекст и история сохраняются между обращениями.
+
+3. **Событийный warm-on-demand жизненный цикл.** Сессия «тёплая» → быстро обрабатывает входящие; после ~часа простоя демон закрывает её (idle-reap); новое входящее → демон поднимает заново **автоматически**, с возобновлением контекста. Жизненным циклом правит поток сообщений, а не присутствие человека: это не привязанный к разработчику TUI и не одноразовый воркер на задачу. Ресурсы заняты, только пока пир работает.
+
+4. **Переносимость пиров между рантаймами.** Личность пира (`personality`) отделена от рантайма: один пир присутствует и в Claude, и в Codex, а основной рантайм переключается командой (`claude ↔ codex`) без потери идентичности и адресации.
+
+5. **Подключение человека к живой сессии.** `iapeer attach` открывает **живую** сессию пира прямо в вашем терминале через pty-супервизор — мышь, прокрутка и цвета работают нативно; отсоединение (`Ctrl-]`) сессию не закрывает.
+
+Целиком эту связку — событийный warm-on-demand жизненный цикл (не attached-разработчиком TUI и не воркер-на-задачу), переносимость пиров между рантаймами и единую ткань обмена (протокол IAP, память-vault с поиском, Telegram-мост) — даёт iapeer.
+
 ## Документация
 
 Документация проекта — в [`docs/`](docs/README.md): продуктовая часть (что это и как пользоваться) и механика изнутри ([`docs/internals/`](docs/internals/README.md)). Этот репозиторий — кодовая реализация.
 
 ## Статус
 
-Версия — **0.2.58**. Платформа — macOS/launchd.
+Версия — **0.2.73**. Платформа — macOS/launchd.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.2.72",
+  "version": "0.2.74",
   "description": "Foundation core for the iapeer multi-agent ecosystem: identity, registry, storage, codec.",
   "type": "module",
   "bin": {

package/src/launch/bootdeliver.test.ts

@@ -12,7 +12,7 @@
 // key-by-key retype), not the tty discipline.
 
 import { afterEach, describe, expect, test } from 'bun:test'
-import { mkdtempSync, readFileSync, rmSync, statSync } from 'fs'
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'fs'
 import { tmpdir } from 'os'
 import { join } from 'path'
 import { spawnSync } from 'child_process'
@@ -89,6 +89,11 @@ describe('boot first-message delivery (load-buffer + bracketed paste)', () => {
         readyGateSecs: 8,
         logDir: join(root, 'logs'),
       }
+      // pty-supervisor hosting is the DEFAULT now; this fixture exercises the legacy TMUX boot/delivery
+      // path (load-buffer + bracketed paste) explicitly, so opt this peer OUT of pty with a .no-pty-host
+      // marker (otherwise launch hosts it under the supervisor and the tmux-path assertions never apply).
+      mkdirSync(cfg.logDir, { recursive: true })
+      writeFileSync(join(cfg.logDir, `${spec.identity}.no-pty-host`), '')
       try {
         const r = await launch(spec, catAdapter(recv), firstMessage, cfg)
         expect(r.status).toBe('READY')

package/src/launch/index.ts

@@ -249,20 +249,21 @@ export const launch: LaunchFn = async (
   //       at a not-yet-created dir. Symmetric to the cfg.logDir mkdir before pipe-pane.
   mkdirSync(dirname(sock), { recursive: true })
 
-  // ── SPAWN-FLIP (cutover Block 2, Ф0a) — per-peer `.pty-host` flag, DARK by default ────────────────
-  // A flag-on tui peer is HOSTED by the supervisor (it owns the pty + boot-driver + pane-log) instead
+  // ── PTY-SUPERVISOR HOSTING — the DEFAULT (opt-out per-peer via `.no-pty-host`) ─────────────────────
+  // By default a tui peer is HOSTED by the supervisor (it owns the pty + boot-driver + pane-log) instead
   // of `tmux new-session`. The supervisor serves the SAME launch-composed argv+env (buildLaunchInvocation,
   // the single source the tmux path also uses), so the hosted session is parity-identical. Readiness is
   // read off the pane-log model (the supervisor's boot-driver answers startup dialogs internally);
   // delivery goes over the supervisor socket. UNCONDITIONAL SPAWN-FALLBACK: any host-bringup failure
-  // falls through to the tmux path below — a flipped peer is NEVER worse than tmux ON SPAWN. Flag-off →
-  // this whole block is skipped and the tmux path is byte-identical (golden). Routers (telegram/
-  // notifier) are ALSO hostable flag-on (cutover infra-track): launchd STILL owns their lifecycle via
-  // run-infra (H4) — the supervisor only provides the pty + delivery socket + pane-log; the router
-  // branch below skips every TUI phase (no boot dialogs — BOOT_ADAPTERS has no router entry so the
-  // supervisor's boot-driver is skipped; no transcript ready-gate — newestActivityMtime=null). @xterm
-  // stays out of THIS process (ptyHost: @xterm-free start + deliver + sessionAlive; readiness's @xterm
-  // import is dynamic and only loads here, flag-on — and the router branch never reaches it).
+  // falls through to the tmux path below — a hosted peer is NEVER worse than tmux ON SPAWN. Opt-OUT
+  // (`.no-pty-host` marker) → this whole block is skipped and the tmux path is byte-identical (golden);
+  // it is the dev/debug escape valid only while tmux still exists. Routers (telegram/notifier) are ALSO
+  // hosted by default (cutover infra-track): launchd STILL owns their lifecycle via run-infra (H4) — the
+  // supervisor only provides the pty + delivery socket + pane-log; the router branch below skips every
+  // TUI phase (no boot dialogs — BOOT_ADAPTERS has no router entry so the supervisor's boot-driver is
+  // skipped; no transcript ready-gate — newestActivityMtime=null). @xterm stays out of THIS process
+  // (ptyHost: @xterm-free start + deliver + sessionAlive; readiness's @xterm import is dynamic and only
+  // loads here, default-on — and the router branch never reaches it).
   if ((adapter.kind === 'tui' || adapter.kind === 'router') && ptyHostEnabled(cfg.logDir, identity)) {
     const invocation = buildLaunchInvocation(spec, adapter, cfg)
     mkdirSync(cfg.logDir, { recursive: true, mode: 0o700 }) // the supervisor writes the pane-log here

package/src/launch/ptyHost.test.ts

@@ -5,27 +5,32 @@ import { join } from 'node:path'
 import { ptyHostEnabled } from './ptyHost.ts'
 import { readyGatePtyFlipEnabled } from './readyGateModel.ts'
 
-describe('ptyHostEnabled — the spawn-flip per-peer flag', () => {
-  test('off by default; on when the .pty-host marker exists', () => {
+describe('ptyHostEnabled — pty-hosting is the DEFAULT, .no-pty-host opts out', () => {
+  test('ON by default (no marker needed); OFF when the .no-pty-host opt-out marker exists; per-peer', () => {
     const dir = mkdtempSync(join(tmpdir(), 'ptyhost-flag-'))
     try {
+      expect(ptyHostEnabled(dir, 'codex-x')).toBe(true) // DEFAULT: hosted out of the box, no marker
+      writeFileSync(join(dir, 'codex-x.no-pty-host'), '') // explicit opt-OUT → tmux
       expect(ptyHostEnabled(dir, 'codex-x')).toBe(false)
-      writeFileSync(join(dir, 'codex-x.pty-host'), '')
-      expect(ptyHostEnabled(dir, 'codex-x')).toBe(true)
-      expect(ptyHostEnabled(dir, 'codex-y')).toBe(false) // per-peer, not global
+      expect(ptyHostEnabled(dir, 'codex-y')).toBe(true) // opt-out is per-peer, not global — y stays default-on
     } finally {
       rmSync(dir, { recursive: true, force: true })
     }
   })
 
-  test('DISTINCT from the ready-gate flip marker — a readygate-flipped peer is NOT pty-hosted', () => {
+  test('legacy .pty-host opt-in marker is REDUNDANT (ignored); .pty-readygate is orthogonal; only .no-pty-host flips to tmux', () => {
     const dir = mkdtempSync(join(tmpdir(), 'ptyhost-distinct-'))
     try {
-      writeFileSync(join(dir, 'codex-perplex.pty-readygate'), '') // ready-gate flipped, still tmux-hosted
-      expect(readyGatePtyFlipEnabled(dir, 'codex-perplex')).toBe(true)
-      expect(ptyHostEnabled(dir, 'codex-perplex')).toBe(false) // the .pty-host marker is separate
+      // legacy opt-in marker no longer decides anything — pty is the default with or without it
       writeFileSync(join(dir, 'codex-perplex.pty-host'), '')
-      expect(ptyHostEnabled(dir, 'codex-perplex')).toBe(true) // now supervisor-hosted too
+      expect(ptyHostEnabled(dir, 'codex-perplex')).toBe(true)
+      // the ready-gate viewport-source marker is a SEPARATE concern — it does not decide pty-hosting
+      writeFileSync(join(dir, 'codex-perplex.pty-readygate'), '')
+      expect(readyGatePtyFlipEnabled(dir, 'codex-perplex')).toBe(true)
+      expect(ptyHostEnabled(dir, 'codex-perplex')).toBe(true) // still hosted (default)
+      // only the explicit opt-out marker flips it back to tmux
+      writeFileSync(join(dir, 'codex-perplex.no-pty-host'), '')
+      expect(ptyHostEnabled(dir, 'codex-perplex')).toBe(false)
     } finally {
       rmSync(dir, { recursive: true, force: true })
     }

package/src/launch/ptyHost.ts

@@ -26,12 +26,17 @@ import type { RuntimeAdapter } from './types.ts'
 export const HOST_COLS = 220
 export const HOST_ROWS = 50
 
-/** Per-peer spawn-flip flag: marker `<logDir>/<identity>.pty-host`. Present → launch hosts the session
- *  under the supervisor instead of `tmux new-session`. DISTINCT from `.pty-readygate` (the ready-gate
- *  viewport-source flip): a readygate-flipped peer is still tmux-HOSTED and stays under observer
- *  cross-check; only a `.pty-host` peer is supervisor-hosted (cross-check retires for it). */
+/** Per-peer pty-hosting decision. pty-supervisor hosting is the DEFAULT — a fresh peer is hosted under
+ *  the supervisor (not `tmux new-session`) WITHOUT any marker (Артур: «pty из коробки»). A peer opts OUT
+ *  to the legacy tmux path with a `<logDir>/<identity>.no-pty-host` marker (the dev/debug escape, valid
+ *  only while tmux still exists). Read in TWO places, both of which want "is this peer pty-hosted": the
+ *  spawn-gate (launch — host vs tmux) and the shadow observer (skip pty-hosted peers, they have no tmux
+ *  to compare; an opt-OUT peer is tmux → compared). Legacy `.pty-host` opt-in markers are now REDUNDANT
+ *  (pty is the default) and harmless — ignored here, so the 29 migrated peers keep hosting unchanged.
+ *  The golden spawn-fallback (startPtyHost fail → tmux, in launch) is SEPARATE and unaffected: a
+ *  pty-default peer whose host bring-up fails still falls through to tmux — never worse on spawn. */
 export function ptyHostEnabled(logDir: string, identity: string): boolean {
-  return existsSync(`${logDir}/${identity}.pty-host`)
+  return !existsSync(`${logDir}/${identity}.no-pty-host`)
 }
 
 /** The supervisor's run dir (session sockets/pids/serve-specs). Env-isolatable via IAPEER_ROOT. */

package/src/launch/sockdir.test.ts

@@ -4,7 +4,7 @@
 // not-yet-created dir (prod sock=/tmp always exists; this bit a sandbox pilot).
 
 import { afterEach, describe, expect, test } from 'bun:test'
-import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'fs'
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs'
 import { tmpdir } from 'os'
 import { dirname, join } from 'path'
 import { spawnSync } from 'child_process'
@@ -51,6 +51,11 @@ describe('launch creates a missing socket dir', () => {
       alwaysOn: true,
     }
 
+    // pty-supervisor hosting is the DEFAULT; this regression tests the legacy TMUX new-session sock-dir
+    // mkdir, so opt this peer OUT of pty with a .no-pty-host marker (else it is pty-hosted and the tmux
+    // mkdir never runs).
+    mkdirSync(cfg.logDir, { recursive: true })
+    writeFileSync(join(cfg.logDir, `${spec.identity}.no-pty-host`), '')
     try {
       // The regression assertion: before the fix the dir was NOT created and
       // `tmux new-session -S <sock>` failed silently; now launch mkdir's it. (We assert

package/src/shadow/enumerate-skip.test.ts

@@ -1,10 +1,11 @@
 // Spawn-flip cutover Block 2, Ф0b-3 slice 3b — the fidelity observer SKIPS supervisor-hosted peers.
 //
-// The observer compares the pty-model vs LIVE TMUX. A `.pty-host`-designated peer has no tmux to
-// compare against, and during a flip a lingering tmux socket for it would surface FALSE divergences.
-// This proves the explicit skip fires IN enumerate even in that race (a live tmux session + a pane-log
-// present): the marked peer is NOT enrolled, while an unmarked sibling IS. Real-tmux, guarded (a clean
-// CI runner has no tmux; the release machine has it — same pattern as routesend-wake).
+// The observer compares the pty-model vs LIVE TMUX. pty-hosting is now the DEFAULT, so a normal
+// (unmarked) peer has no tmux to compare against — and during a flip a lingering tmux socket for it
+// would surface FALSE divergences. This proves the skip fires IN enumerate even in that race (a live
+// tmux session + a pane-log present): the default peer is NOT enrolled, while a `.no-pty-host` opt-out
+// (tmux) sibling IS. Real-tmux, guarded (a clean CI runner has no tmux; the release machine has it —
+// same pattern as routesend-wake).
 import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
 import { spawnSync } from 'node:child_process'
 import { closeSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
@@ -17,8 +18,8 @@ const tmuxAvailable = spawnSync('tmux', ['-V'], { stdio: 'ignore' }).status ===
 
 let sockDir: string
 let logDir: string
-const KEEP = 'keepobs' // unmarked → observed
-const SKIP = 'skipobs' // .pty-host marker → skipped
+const KEEP = 'keepobs' // .no-pty-host opt-out (tmux) → observed
+const SKIP = 'skipobs' // default (no marker) → pty-hosted → skipped
 const addrOf = (p: string) => `codex-${p}`
 const sockOf = (p: string) => buildSocketPath('codex', p, sockDir)
 
@@ -43,9 +44,10 @@ beforeAll(() => {
     startTmux(p)
     writeFileSync(join(logDir, `${addrOf(p)}.log`), '')
   }
-  // SKIP additionally carries the `.pty-host` designation — even WITH a live tmux session, the observer
-  // must not enroll it (the flip-transition race the skip guards against).
-  writeFileSync(join(logDir, `${addrOf(SKIP)}.pty-host`), '')
+  // KEEP carries the `.no-pty-host` opt-OUT → it is on tmux, so the observer MUST compare it. SKIP is a
+  // DEFAULT (unmarked) peer → pty-hosted → skipped even WITH a lingering live tmux session (the
+  // flip-transition race the skip guards against).
+  writeFileSync(join(logDir, `${addrOf(KEEP)}.no-pty-host`), '')
 })
 
 afterAll(() => {
@@ -54,12 +56,12 @@ afterAll(() => {
   rmSync(logDir, { recursive: true, force: true })
 })
 
-describe.if(tmuxAvailable)('observer enumerate skips supervisor-hosted (.pty-host) peers', () => {
-  test('a .pty-host peer is NOT enrolled even with a live tmux session + pane-log; an unmarked one IS', () => {
+describe.if(tmuxAvailable)('observer enumerate skips pty-default peers, compares .no-pty-host (tmux) peers', () => {
+  test('a default (unmarked, pty-hosted) peer is NOT enrolled despite a live tmux session; a .no-pty-host opt-out one IS', () => {
     const models = new Map<string, any>()
     enumerate(models, { sockDir, logDir, eventLogDir: logDir })
-    expect(models.has(addrOf(KEEP))).toBe(true) // unmarked → observed (live tmux + log present)
-    expect(models.has(addrOf(SKIP))).toBe(false) // .pty-host designation → skipped despite live tmux
+    expect(models.has(addrOf(KEEP))).toBe(true) // .no-pty-host opt-out (tmux) → observed (live tmux + log)
+    expect(models.has(addrOf(SKIP))).toBe(false) // default pty-hosted → skipped despite lingering live tmux
     for (const o of models.values()) { try { if (o.fd != null) closeSync(o.fd) } catch { /* */ } }
   })
 })

package/src/shadow/index.ts

@@ -61,9 +61,11 @@ export function enumerate(models: Map<string, Obs>, opts: ShadowOptions, tracker
   for (const p of peers) {
     const addr = buildProcessAddress(p.runtime, p.personality)
     // SPAWN-FLIP Ф0b-3: NEVER measure a supervisor-HOSTED peer. The observer's premise is pty-model vs
-    // LIVE TMUX; a `.pty-host`-designated peer has no tmux to compare against, and during a flip a
-    // lingering tmux socket for it would surface false divergences. Skip by the migration DESIGNATION
-    // (marker), BEFORE `live` — a peer flipped while enrolled then falls out of `live` and is reaped.
+    // LIVE TMUX, so it only compares peers that are actually on tmux. pty-hosting is now the DEFAULT, so
+    // ptyHostEnabled is true for a normal peer (hosted → skip) and false only for an explicit `.no-pty-host`
+    // opt-OUT peer (tmux → compared). Skip BEFORE `live` — a peer that flips falls out of `live` and is
+    // reaped. (Post-migration the whole fleet is pty-default, so this skips everything and the observer is
+    // effectively retired until/unless a peer opts back to tmux.)
     if (ptyHostEnabled(opts.logDir, addr)) continue
     live.add(addr)
     if (models.has(addr)) continue

package/src/supervisor/daemon.ts

@@ -39,6 +39,29 @@ const TICK_CMD = ['sh', '-c', 'i=0; while true; do printf "STREAMTICK_%d\\r\\n"
 // answer off its model. 'tick' (and any unknown runtime) has no entry → no driver → the hermetic
 // spawn/attach tests and the bare conduit are untouched.
 const BOOT_ADAPTERS: Record<string, BootPredicates> = { codex: codexAdapter, claude: claudeAdapter }
+
+// SCROLLBACK SPINNER STRIP (serve-side, repaint snapshot only). claude's TUI redraws its bottom status
+// block WITHOUT a scroll-region (DECSTBM), so as the conversation scrolls, stale spinner frames
+// ("✶ Gerund… (Nm Ns · ↓ N tokens)" / "… (esc to interrupt)") get pushed into the @xterm scrollback ring
+// and ACCUMULATE — surfacing as repeated/broken lines when a reattaching operator scrolls history UP
+// (the live viewport is clean; only the served history is polluted). We drop those lines from the
+// SCROLLBACK part of the serialized repaint snapshot, keeping the last `viewportRows` segments (the LIVE
+// status block, incl. the current spinner) verbatim. Matched by STRUCTURE — a gerund + … + the
+// elapsed/token or esc-to-interrupt tail — NOT a word-list (claude rotates 100+ spinner gerunds). The
+// live byte stream, pane-log and transcript are untouched; only the human-attach repaint is filtered.
+const SPINNER_STATUS_LINE = /…[^\n]{0,48}\((?:esc to interrupt|\d+m? ?\d*s ?·)/
+const ANSI_SEQ = /\x1b\[[0-9;:?]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g
+export function stripSpinnerScrollback(serialized: string, viewportRows: number): string {
+  const segs = serialized.split('\r\n')
+  if (segs.length <= viewportRows) return serialized // no scrollback to clean
+  const scrollbackEnd = segs.length - viewportRows // keep the last viewportRows (live viewport) verbatim
+  const out: string[] = []
+  for (let i = 0; i < segs.length; i++) {
+    if (i < scrollbackEnd && SPINNER_STATUS_LINE.test(segs[i].replace(ANSI_SEQ, ''))) continue
+    out.push(segs[i])
+  }
+  return out.join('\r\n')
+}
 // Poll cadence mirrors the launch primitive's proven 2 s boot loop (index.ts:377). The supervisor
 // model is strictly FRESHER than capture-pane (bytes land in @xterm synchronously as they arrive),
 // so 2 s leaves ample repaint time — the claude resume-picker never over-Downs, since bootDialogKeys
@@ -220,7 +243,7 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
   /** Repaint a (re)attaching client from the headless snapshot: clear+home, then the full grid.
    *  Backpressure-safe — a ~90 KB heavy snapshot MUST NOT drop past the socket buffer (port-dep #2). */
   const repaint = (s: { write(b: Buffer): number }): void => {
-    const snap = '\x1b[2J\x1b[3J\x1b[H' + ser.serialize()
+    const snap = '\x1b[2J\x1b[3J\x1b[H' + stripSpinnerScrollback(ser.serialize(), xterm.rows)
     sendClient(s, frame(FRAME_DATA, Buffer.from(snap, 'utf8')))
   }
 

package/src/supervisor/spinner-strip.test.ts

@@ -0,0 +1,52 @@
+// Scrollback spinner strip (serve-side repaint snapshot). claude's TUI redraws its status block without
+// a scroll-region, so stale spinner frames accumulate in the @xterm scrollback ring and pollute a
+// reattaching operator's scroll-up. stripSpinnerScrollback drops those frames from the SCROLLBACK part
+// of the serialized snapshot while keeping the live viewport (incl. the current spinner) verbatim,
+// matched by STRUCTURE (gerund + … + elapsed/token or esc-to-interrupt tail), not a word-list.
+import { describe, expect, test } from 'bun:test'
+import { stripSpinnerScrollback } from './daemon.ts'
+
+describe('stripSpinnerScrollback — drop stale spinner frames from served scrollback', () => {
+  test('strips scrollback spinner-status lines (elapsed + tokens), keeps real history + the live viewport', () => {
+    const lines = [
+      'real history line 1',
+      '\x1b[38;2;215;119;87m✶\x1b[39m Metamorphosing… (4m 24s · ↓ 18.4k tokens)', // scrollback spinner → drop
+      'real history line 2',
+      '· Quantumizing… (6m 57s · ↓ 30.0k tokens)', // scrollback spinner → drop
+      // last 3 = viewport (the LIVE status block, kept verbatim incl. the current spinner)
+      'real history line 3',
+      '────────────',
+      '✽ Brewing… (1m 59s · ↓ 6.5k tokens)',
+    ].join('\r\n')
+    const out = stripSpinnerScrollback(lines, 3).split('\r\n')
+    expect(out).toContain('real history line 1')
+    expect(out).toContain('real history line 2')
+    expect(out).toContain('real history line 3')
+    expect(out).toContain('✽ Brewing… (1m 59s · ↓ 6.5k tokens)') // viewport live spinner KEPT
+    expect(out.some(l => /Metamorphosing/.test(l))).toBe(false)
+    expect(out.some(l => /Quantumizing/.test(l))).toBe(false)
+  })
+
+  test('strips the (esc to interrupt) tail variant in scrollback', () => {
+    const lines = ['history', '· Running… (esc to interrupt · 1.2k tokens)', 'vp1', 'vp2', 'vp3'].join('\r\n')
+    const out = stripSpinnerScrollback(lines, 3)
+    expect(out.includes('Running…')).toBe(false)
+    expect(out.includes('history')).toBe(true)
+  })
+
+  test('does NOT over-strip — real content with … or (…) but no spinner tail is kept', () => {
+    const lines = [
+      'мы обсудили тайминг… он занял время', // … but no elapsed/token tail
+      'итого вышло (5 долларов)', //          (…) but no elapsed/esc tail
+      'vp1', 'vp2', 'vp3',
+    ].join('\r\n')
+    const out = stripSpinnerScrollback(lines, 3).split('\r\n')
+    expect(out).toContain('мы обсудили тайминг… он занял время')
+    expect(out).toContain('итого вышло (5 долларов)')
+  })
+
+  test('the LIVE spinner in the viewport is never stripped (no scrollback → unchanged)', () => {
+    const lines = ['✶ Vibing… (3s · ↓ 1 tokens)', 'vp2', 'vp3'].join('\r\n')
+    expect(stripSpinnerScrollback(lines, 3)).toBe(lines) // segs <= viewportRows → returned verbatim
+  })
+})