elanous 0.2.28 → 0.2.29

package/src/harness/harness-gc.ts

@@ -304,11 +304,37 @@ export function runHarnessGcTick(opts: HarnessGcOptions = {}, deps: HarnessGcDep
   } finally { release(); }
 }
 
-function cliArgs(args: string[]): HarnessGcOptions {
-  const opts: HarnessGcOptions = {};
+interface HarnessGcCliOptions extends HarnessGcOptions {
+  human: boolean;
+  json: boolean;
+}
+
+export function formatHarnessGcReport(result: HarnessGcResult): string {
+  const value = (count: number | undefined): string => count === undefined ? 'unknown' : String(count);
+  const lines = [
+    `Harness GC · ${result.outcome}${result.reason ? ` (${result.reason})` : ''}`,
+    `repos=${result.repos} removed=${result.removed} preserved=${result.preserved} deferred=${result.deferred} failed=${result.failed}`,
+    `unseenOutsideWindow=${value(result.unseenOutsideWindow)} unseenOutsidePrefix=${value(result.unseenOutsidePrefix)}`,
+    `orphanScanUnavailable=${result.orphanScanUnavailable} budgetMs=${result.budgetMs} elapsedMs=${result.elapsedMs} budgetExhausted=${result.budgetExhausted ?? false}`,
+  ];
+  if (result.repositories.length === 0) lines.push('orphanScan=not-requested (no repository result)');
+  for (const repo of result.repositories) {
+    lines.push(`repo=${repo.gitDir} orphanScan=${repo.orphanScan} removed=${repo.removed} preserved=${repo.preserved} deferred=${repo.deferred} failed=${repo.failed}`);
+  }
+  for (const failure of result.repoFailures ?? []) lines.push(`repoFailure=${failure.gitDir}: ${failure.error}`);
+  return lines.join('\n');
+}
+
+export function formatHarnessGcOutput(result: HarnessGcResult, format: Pick<HarnessGcCliOptions, 'human' | 'json'>): string {
+  return format.human && !format.json ? formatHarnessGcReport(result) : JSON.stringify(result);
+}
+
+function cliArgs(args: string[]): HarnessGcCliOptions {
+  const opts: HarnessGcCliOptions = { human: false, json: false };
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    if (arg === '--json') continue;
+    if (arg === '--json') { opts.json = true; continue; }
+    if (arg === '--human') { opts.human = true; continue; }
     if (arg === '--dry-run') { opts.dryRun = true; continue; }
     if (arg === '--repo') { (opts.repos ??= []).push(args[++i] ?? ''); continue; }
     const key = arg === '--window' ? 'window' : arg === '--max-remove' ? 'maxRemove' : arg === '--budget-ms' ? 'budgetMs' : null;
@@ -321,8 +347,9 @@ function cliArgs(args: string[]): HarnessGcOptions {
 
 if (import.meta.main) {
   try {
-    const result = runHarnessGcTick(cliArgs(process.argv.slice(2)));
-    console.log(JSON.stringify(result));
+    const opts = cliArgs(process.argv.slice(2));
+    const result = runHarnessGcTick(opts);
+    console.log(formatHarnessGcOutput(result, opts));
     if (result.outcome === 'fail') process.exitCode = 1;
   } catch (error) {
     console.log(JSON.stringify({ outcome: 'fail', reason: String(error) }));

package/src/index.ts

@@ -72,6 +72,7 @@ import { registerPodCommands } from './cli/pod-cli.js';
 import { registerBrowserAnnotateCommand } from './cli/browser-annotate-cli.js';
 import { registerPendingQuestionsCommand } from './cli/pending-questions-cli.js';
 import { registerUsageCommand } from './cli/usage-cli.js';
+import { registerUsageDailyCommand } from './cli/usage-daily-cli.js';
 import { registerLiveCommands } from './cli/live-cli.js';
 import { registerResearchCommand } from './cli/research-cli.js';
 import { registerReleaseCommands } from './cli/release-cli.js';
@@ -915,6 +916,7 @@ registerPodCommands(program);
 registerBrowserAnnotateCommand(program);
 registerPendingQuestionsCommand(program);
 registerUsageCommand(program);
+registerUsageDailyCommand(program);
 // main() → program.parseAsync() → live detail action; --test was applied before dispatch.
 registerLiveCommands(program);
 registerResearchCommand(program);
@@ -1473,6 +1475,8 @@ program
     '--test',
     '격리 테스트 인스턴스로 실행 — cwd 의 git 트리(worktree 포함)에서 `<트리>/.elanous-test` 를 루트로 잡고 state·config 두 축을 함께 격리한다. config 사본이 없으면 자동 물질화. `--test=<dir>` 로 루트 직접 지정 가능(값 문법은 `=` 형태 하나 — 모호함 없음). ELANOUS_STATE_DIR/--config-dir 을 손으로 줄 필요가 없다.',
   )
+  // Documentation-only — `readDashboardNameFlag` 가 Commander «전»에 argv 에서 걷어낸다.
+  .option('--name <name>', '대시보드 TUI 의 PTY 행(tui:<pid>)에 별명을 달고 뜬다 — `elanous pty list` 에 보이고 `pty snapshot <name>` 으로 부른다. 뜬 뒤 바꾸려면 `elanous pty rename <ref> <name>`.')
   .option('--help-all', '시스템 명령을 제외한 모든 최상위 명령 표시');
 program.addHelpText('after', acpServerHelpText());
 
@@ -11608,6 +11612,15 @@ async function main(): Promise<void> {
   //    ⇒ 이제 규칙이 «문법»뿐이라(북마크 스토어를 안 본다) 인자도 없다.
   rawArgs = stripRemoteFlags(rawArgs);
 
+  // `elanous --name <name>` — 대시보드 TUI 의 자기 PTY 행(`tui:<pid>`) 별명. 루트 실행 플래그라
+  //   Commander «전»에 걷어낸다(하위 명령이 앞이면 손대지 않는다 — dashboard-name-flag.ts 머리말).
+  const dashboardName = (await import('./cli/dashboard-name-flag.js')).readDashboardNameFlag(rawArgs);
+  if (dashboardName.error) {
+    console.error(dashboardName.error);
+    process.exit(1);
+  }
+  rawArgs = dashboardName.args;
+
   // M2.4 — remote-daemon path. `ELANOUS_REMOTE=mbp.tailnet:31415` (or
   // a full ws:// URL) makes the dashboard attach to a remote daemon
   // instead of booting an in-process ACP pair. Token + no-auth
@@ -11784,7 +11797,7 @@ async function main(): Promise<void> {
   // dashboard the user is actually looking at. Off unless this boots
   // (no producer in headless/daemon paths). fail-soft·비블로킹.
   bootTimer.begin();
-  try { (await import('./capture/tui-self-report.js')).startTuiSelfReport(); } catch { /* fail-soft */ }
+  try { (await import('./capture/tui-self-report.js')).startTuiSelfReport(dashboardName.name ? { nickname: dashboardName.name } : {}); } catch { /* fail-soft */ }
   bootTimer.phase('self-report');
 
   // Dashboard handles sync inline — only returns on quit

package/src/input/external-input-queue.ts

@@ -0,0 +1,219 @@
+// ── 외부 주입 입력의 별도 대기열 (TUI OP 도그푸드 결함 #6 · 2026-10-14) ──────────────
+//
+// S: 바깥 프로세스가 `elanous pty text <tui:pid> "<글>" --enter` 로 넣은 입력은 TUI 제어 대상의
+//    `write()` → `injectKey` 로 «키보드와 같은» 키 큐에 들어간다.
+// C: 그래서 사용자가 치던 composer 버퍼·턴 중 typeahead 버퍼에 글자가 «이어 붙는다»
+//    (10-14 13:37 실측: 사용자가 치던 줄 끝에 외부 지시가 붙어 한 메시지로 나갔다).
+// A: 제어 대상의 `write()` 가 키 주입 «전»에 이 라우터를 먼저 묻는다.
+//    - 글 한 줄(제어 문자 없음 · 끝 CR 하나 허용)이 아니면 → 종전대로 키 주입(`pty key`·메뉴 몰기 무변경)
+//    - composer 가 안 떠 있음(턴 밖 패널·모달 모드) → 종전대로 키 주입(드라이버 회귀 방지)
+//    - Enter 가 붙은 글: 턴 중 · 사용자 버퍼에 글자가 있음 · 앞선 외부 항목이 대기 중 → «별도 항목»으로 대기열,
+//      composer 가 비어 있으면 출처(`terminal`/`pty`)를 단 «별도 제출»로 즉시 보냄
+//    - Enter 없는 글: 빈 composer 면 종전대로 채우고, 바쁘면(턴 중·버퍼에 글자) «거부»한다 —
+//      나중에 사용자 composer 에 채우면 다시 섞이므로 대기시키지 않는다(IPC 가 실패로 정산 → rc≠0).
+//    대기열은 «턴이 끝나고 composer 가 비었을 때» 한 건씩 나간다 — 사용자 버퍼는 건드리지 않는다.
+//
+// ⚠️ herdr/tmux 처럼 «터미널 자체»에 쓰는 길은 키보드와 구별할 수 없다 — 이 라우터는
+//    elanous 제어 IPC(`pty text`) 경로만 가른다.
+
+import { debug } from '../debug/log.js';
+import type { InputSourceRef } from './input-source-kind.js';
+
+export interface ExternalInputItem {
+  readonly text: string;
+  readonly at: number;
+}
+
+export interface ExternalInputHost {
+  /** 턴(스트리밍)이 도는 중인가. */
+  isTurnActive(): boolean;
+  /** 살아 있는 composer 의 현재 버퍼. composer 가 안 떠 있으면 undefined. */
+  composerText(): string | undefined;
+  /** 아직 소비되지 않은 키가 키 큐에 있나 — 있으면 composer 가 비어 보여도 사용자 키가 오는 중이다. */
+  hasPendingKeys(): boolean;
+  /** 별도 메시지로 제출한다. 못 보냈으면 false(항목은 대기열에 남는다). */
+  submit(text: string, source: InputSourceRef): boolean;
+  /** 대기열이 바뀌었다 — 화면 표지를 다시 그린다. */
+  onQueueChange?(pending: readonly ExternalInputItem[], event: 'queued' | 'delivered'): void;
+}
+
+export type ExternalInputRoute = 'passthrough' | 'submitted' | 'queued';
+export type ExternalInputDecision = 'passthrough' | 'submit-now' | 'queue' | 'reject';
+
+const EXTERNAL_INPUT_SOURCE: InputSourceRef = { kind: 'terminal', provider: 'pty' };
+export const EXTERNAL_INPUT_QUEUE_LIMIT = 50;
+const PUMP_MS = 250;
+/** 머리 항목이 turn-active 때문에 이만큼 못 나가면 한 번만 경고한다. 자동 해제는 하지 않는다. */
+export const STALE_TURN_SUSPECTED_MS = 10 * 60 * 1000;
+
+/** 글 한 줄인가 — 제어 문자 없음 · 끝 CR 하나만 허용. 아니면 null(키 주입 경로). */
+export function parseExternalTextLine(chars: string): { text: string; submit: boolean } | null {
+  const submit = chars.endsWith('\r');
+  const text = submit ? chars.slice(0, -1) : chars;
+  // ⚠️ 공백만 있는 글도 «글»이다 — trim 하면 대기열을 우회해 사용자 초안에 붙는다.
+  if (!text) return null;
+  // eslint-disable-next-line no-control-regex
+  if (/[\x00-\x1f\x7f]/.test(text)) return null;
+  return { text, submit };
+}
+
+/** 라우팅 판정(순수). */
+export function decideExternalInputRoute(input: {
+  line: { text: string; submit: boolean } | null;
+  hostRegistered: boolean;
+  pendingCount: number;
+  turnActive: boolean;
+  composerText: string | undefined;
+  pendingKeys?: boolean;
+}): { decision: ExternalInputDecision; reason: string } {
+  if (!input.line) return { decision: 'passthrough', reason: 'not-text-line' };
+  if (!input.hostRegistered) return { decision: 'passthrough', reason: 'no-host' };
+  // 턴 밖에서 composer 가 안 떠 있으면(패널·모달) 그 화면을 모는 키 입력이다 — 종전 경로.
+  if (!input.turnActive && input.composerText === undefined) return { decision: 'passthrough', reason: 'composer-not-live' };
+  const busyReason = input.turnActive ? 'turn-active'
+    // ⚠️ 공백만 있는 초안도 사용자 버퍼다 — trim 하지 않는다.
+    : input.composerText !== '' ? 'user-buffer-nonempty'
+    // composer 가 비어 보여도 키 큐에 사용자 키가 남아 있으면 그 키가 먼저다.
+    : input.pendingKeys ? 'user-keys-pending'
+    // FIFO — 앞선 외부 항목을 뒤 항목이 앞지르지 않는다.
+    : input.pendingCount > 0 ? 'queue-nonempty'
+    : null;
+  if (!input.line.submit) {
+    return busyReason ? { decision: 'reject', reason: `${busyReason}-no-enter` } : { decision: 'passthrough', reason: 'idle-empty-no-enter' };
+  }
+  return busyReason ? { decision: 'queue', reason: busyReason } : { decision: 'submit-now', reason: 'idle-empty' };
+}
+
+/** 대기열 머리를 지금 내보내도 되나(순수) — 턴 밖 ⊕ composer 가 떠 있고 비어 있음. */
+function canDeliverExternalInput(turnActive: boolean, composerText: string | undefined, pendingKeys: boolean): boolean {
+  return !turnActive && composerText === '' && !pendingKeys;
+}
+
+/** «외부 입력 N건 대기» 표지 문면. 비면 null. */
+export function renderExternalInputQueueNotice(pending: readonly ExternalInputItem[]): string | null {
+  if (pending.length === 0) return null;
+  const head = pending[0]!.text;
+  const shown = [...head].length > 40 ? `${[...head].slice(0, 40).join('')}…` : head;
+  return `⤵ 외부 입력 ${pending.length}건 대기 · "${shown}" · 턴이 끝나고 입력창이 비면 별도 메시지로 전송`;
+}
+
+export interface ExternalInputQueueDeps {
+  now?: () => number;
+  /** 펌프 스케줄러 — 정지 함수를 돌려준다. 시험이 손으로 돌린다. */
+  schedule?: (tick: () => void, ms: number) => () => void;
+  log?: (event: string, data: Record<string, unknown>) => void;
+}
+
+export function createExternalInputQueue(deps: ExternalInputQueueDeps = {}) {
+  const now = deps.now ?? Date.now;
+  const log = deps.log ?? ((event, data) => debug.log('tui.external-input', event, data));
+  const schedule = deps.schedule ?? ((tick, ms) => {
+    const t = setInterval(tick, ms);
+    (t as { unref?: () => void }).unref?.();
+    return () => clearInterval(t);
+  });
+  let host: ExternalInputHost | null = null;
+  let pending: ExternalInputItem[] = [];
+  let stopPump: (() => void) | null = null;
+  // 경고는 머리 항목 «하나»에 한 번 — 머리가 실제로 바뀔 때만 다시 경고할 수 있다(제출 실패로 남은 같은 머리는 유지).
+  let staleTurnWarnedHead: ExternalInputItem | null = null;
+
+  const notify = (event: 'queued' | 'delivered'): void => {
+    try { host?.onQueueChange?.(pending, event); } catch { /* fail-soft — 표지 실패가 입력을 막지 않는다 */ }
+  };
+  const ensurePump = (): void => {
+    if (pending.length > 0 && !stopPump) stopPump = schedule(pump, PUMP_MS);
+    if (pending.length === 0 && stopPump) { stopPump(); stopPump = null; }
+  };
+
+  /** 대기열 머리 한 건을 내보낸다(조건이 맞을 때만). 내보냈으면 true. */
+  function pump(): boolean {
+    const h = host;
+    const head = pending[0];
+    if (!h || !head) { ensurePump(); return false; }
+    let turnActive: boolean; let composer: string | undefined; let pendingKeys: boolean;
+    try { turnActive = h.isTurnActive(); composer = h.composerText(); pendingKeys = h.hasPendingKeys(); } catch { return false; }
+    if (!canDeliverExternalInput(turnActive, composer, pendingKeys)) {
+      if (turnActive && staleTurnWarnedHead !== head) {
+        const waitedMs = now() - head.at;
+        if (waitedMs >= STALE_TURN_SUSPECTED_MS) {
+          staleTurnWarnedHead = head;
+          log('stale-turn-suspected', { waitedMs, pending: pending.length });
+        }
+      }
+      return false;
+    }
+    let ok = false;
+    try { ok = h.submit(head.text, EXTERNAL_INPUT_SOURCE); } catch { ok = false; }
+    if (!ok) { log('deliver-failed', { length: head.text.length, pending: pending.length }); return false; }
+    pending = pending.slice(1);
+    log('delivered', { length: head.text.length, waitedMs: now() - head.at, pending: pending.length });
+    notify('delivered');
+    ensurePump();
+    return true;
+  }
+
+  return {
+    register(next: ExternalInputHost): () => void {
+      host = next;
+      log('host-registered', { pending: pending.length });
+      ensurePump();
+      return () => {
+        if (host !== next) return;
+        host = null;
+        log('host-unregistered', { pending: pending.length });
+      };
+    },
+    /** 제어 대상 `write()` 가 키 주입 «전»에 부른다. 'passthrough' 면 호출측이 종전대로 키를 넣는다. */
+    route(chars: string): ExternalInputRoute {
+      // `pty key`(input-key)는 «키»다 — 공백·`j` 처럼 출력 가능한 키도 종전대로 넣는다.
+      if (keyCommandDepth > 0) return 'passthrough';
+      const line = parseExternalTextLine(chars);
+      let turnActive = false; let composer: string | undefined; let pendingKeys = false;
+      if (host && line) {
+        try { turnActive = host.isTurnActive(); composer = host.composerText(); pendingKeys = host.hasPendingKeys(); }
+        catch { return 'passthrough'; }
+      }
+      const { decision, reason } = decideExternalInputRoute({
+        line, hostRegistered: host !== null, pendingCount: pending.length, turnActive, composerText: composer, pendingKeys,
+      });
+      const base = { reason, length: chars.length, submit: line?.submit ?? false, turnActive, pendingKeys, userBufferLength: composer?.length ?? null };
+      if (decision === 'passthrough') {
+        log('route', { ...base, route: 'passthrough', pending: pending.length });
+        return 'passthrough';
+      }
+      if (decision === 'reject') {
+        log('route', { ...base, route: 'rejected', pending: pending.length });
+        throw new Error('tui-busy-text-without-enter');
+      }
+      if (decision === 'submit-now' && line && host) {
+        let ok = false;
+        try { ok = host.submit(line.text, EXTERNAL_INPUT_SOURCE); } catch { ok = false; }
+        if (ok) { log('route', { ...base, route: 'submitted', pending: pending.length }); return 'submitted'; }
+      }
+      if (pending.length >= EXTERNAL_INPUT_QUEUE_LIMIT) {
+        log('queue-full', { ...base, pending: pending.length });
+        throw new Error('tui-external-input-queue-full');
+      }
+      pending = [...pending, { text: line!.text, at: now() }];
+      log('route', { ...base, route: 'queued', pending: pending.length });
+      notify('queued');
+      ensurePump();
+      return 'queued';
+    },
+    pump,
+    pending: (): readonly ExternalInputItem[] => pending,
+  };
+}
+
+let keyCommandDepth = 0;
+/** 제어 IPC 의 `input-key` 가 이 안에서 쓴다 — 라우터는 그 쓰기를 글이 아니라 키로 보고 그대로 통과시킨다. */
+export function withExternalKeyCommand<T>(fn: () => T): T {
+  keyCommandDepth++;
+  try { return fn(); } finally { keyCommandDepth--; }
+}
+
+const shared = createExternalInputQueue();
+
+export function registerExternalInputHost(host: ExternalInputHost): () => void { return shared.register(host); }
+export function routeExternalInput(chars: string): ExternalInputRoute { return shared.route(chars); }

package/src/interactive-terminal-modal.ts

@@ -58,6 +58,13 @@ export interface InteractiveTerminalModalSpec {
   /** Ghostty-compatible terminfo name. Defaults via PreviewTerminal
    *  to xterm-256color. */
   termName?: string;
+  /** Register this popup in the shared PTY inventory. */
+  useRegistry?: boolean;
+  registryKind?: string;
+  registryNickname?: string;
+  registryOrigin?: { originRoot: string; controller?: string };
+  registryPurpose?: string;
+  registrySeat?: string;
   /** Override bounds. Default: 85% of termCols/termRows, centered. */
   bounds?: ModalBounds;
   /** MT1 — named size preset (mutually exclusive with `bounds`; when
@@ -206,6 +213,12 @@ export function createInteractiveTerminalModal(
     shellArgs: spec.shellArgs,
     env: spec.env,
     termName: spec.termName,
+    useRegistry: spec.useRegistry,
+    registryKind: spec.registryKind,
+    registryNickname: spec.registryNickname,
+    registryOrigin: spec.registryOrigin,
+    registryPurpose: spec.registryPurpose,
+    registrySeat: spec.registrySeat,
     onUpdate: () => {
       // First output → leave the placeholder state. Stops the
       // spinner timer + flushes a render so the real PTY frame

package/src/llm/route-decision.ts

@@ -46,6 +46,31 @@ export function currentRouteDecision(surface: string): RouteDecision | null {
   return lastBySurface.get(surface) ?? null;
 }
 
+/** A `/model` choice scoped to this process's surface (TUI-MODEL-SESSION-SCOPE · 10-14).
+ * It reaches the turn as `explicitModel`, so it wins over the Codex tier policy —
+ * a config-only `llm.model` change is ignored by that policy (10-14 OPT: `/model luna`
+ * wrote config, every turn still ran sol). Not persisted; `/model … --global` writes config. */
+export interface SessionModelPin {
+  provider: LLMProviderName;
+  model: string;
+}
+
+const pinBySurface = new Map<string, SessionModelPin>();
+
+export function setSessionModelPin(surface: string, pin: SessionModelPin | null): void {
+  if (pin) pinBySurface.set(surface, pin);
+  else pinBySurface.delete(surface);
+}
+
+/** The surface's pinned model, or null when none — or when the active provider
+ * has since changed (a pin only makes sense on the provider it was chosen for). */
+export function sessionModelPin(surface: string, activeProvider?: LLMProviderName): SessionModelPin | null {
+  const pin = pinBySurface.get(surface);
+  if (!pin) return null;
+  if (activeProvider !== undefined && pin.provider !== activeProvider) return null;
+  return pin;
+}
+
 export interface ResolveRouteDecisionInput {
   provider: LLMProviderName;
   configuredModel?: string;

package/src/llm-stream-retry-display.ts

@@ -0,0 +1,59 @@
+// TUI-STREAM-RETRY — 끊긴 스트림을 다시 걸 때 «이미 화면에 흘린 텍스트»를 두 번 보이지 않게 하는 관문.
+//
+// ⛔ 화면 쪽에는 «커밋하지 않고 지우는» 신호가 없다. TUI plain 경로는 `onText('', …)` 를 chunk 만 받아
+//   `('', '')` 로 바꾸고, `turn-stream-formatter` 는 그것을 «clear-and-commit»(지난 글을 영구 보존)으로 읽는다.
+//   ⇒ 되감기를 화면에 «알리는» 대신, 재시도 본문이 이미 보인 글과 겹치는 동안은 «안 내보내고»,
+//     넘어서는 순간 그 뒷부분만 이어 붙인다. 이력(turnText)은 늘 재시도 본문이 정본이다.
+//   ⚠️ 재시도 본문이 이미 보인 글과 «갈라지면» 지울 길이 없으니 커밋 경계(`onText('', '')`)를 한 번 내고
+//     새 본문을 처음부터 흘린다 — 옛 조각은 지난 서술로 남는다(관측: `llm.retry stream-retry-display-diverged`).
+
+export type RetryDisplayStep =
+  | { kind: 'emit'; delta: string }
+  | { kind: 'hold' }
+  | { kind: 'diverged'; text: string };
+
+export interface RetryDisplayGate {
+  /** 끊김 뒤 재시도 직전에 부른다 — 지금 화면에 보이는 이 턴의 글을 «확인 대기»로 둔다. */
+  arm(): void;
+  /** 텍스트 델타가 turnText 에 붙은 «뒤» 부른다. 무엇을 화면에 낼지 돌려준다. */
+  onText(delta: string, turnText: string): RetryDisplayStep;
+  /** 스트림이 끝났을 때 — 확인 대기 중인데 재시도 본문이 보인 글과 다르면 갈라짐으로 낸다. */
+  settle(turnText: string): RetryDisplayStep;
+  /** 확인 대기 중인 글자 수(관측용). */
+  heldChars(): number;
+}
+
+export function createRetryDisplayGate(): RetryDisplayGate {
+  let visible = '';
+  let replaying = false;
+  return {
+    arm() {
+      replaying = visible.length > 0;
+    },
+    onText(delta, turnText) {
+      if (!replaying) {
+        visible += delta;
+        return { kind: 'emit', delta };
+      }
+      if (visible.startsWith(turnText)) return { kind: 'hold' };
+      replaying = false;
+      if (turnText.startsWith(visible)) {
+        const rest = turnText.slice(visible.length);
+        visible = turnText;
+        return { kind: 'emit', delta: rest };
+      }
+      visible = turnText;
+      return { kind: 'diverged', text: turnText };
+    },
+    settle(turnText) {
+      if (!replaying) return { kind: 'hold' };
+      replaying = false;
+      if (visible === turnText) return { kind: 'hold' };
+      visible = turnText;
+      return { kind: 'diverged', text: turnText };
+    },
+    heldChars() {
+      return replaying ? visible.length : 0;
+    },
+  };
+}