feat(cli): Phase 2.6.F — platform floor + the full-screen TUI renderer (ink 7)

apps/cli/package.json

@@ -59,6 +59,7 @@
     "quickjs-emscripten-core": "catalog:",
     "react": "catalog:",
     "smol-toml": "catalog:",
+    "string-width": "catalog:",
     "yaml": "catalog:",
     "zod": "catalog:"
   },

apps/cli/src/commands/chat-alt-hoist.test.ts

@@ -1,3 +1,4 @@
+import { createSuspendPort, type SuspendPort } from '../render/suspend.js';
 import { describe, expect, it, vi } from 'vitest';
 
 import {
@@ -32,12 +33,15 @@ describe('withHoistedAltScreen (2.6.F Step 4b-3, ADR-0068 §c)', () => {
     readonly lifecycle: ReplLifecycle;
     readonly fireExit: () => void; // the captured process.on('exit') listener
     readonly fireSignal: (signo: number) => void; // the captured SIGTERM/SIGHUP/SIGQUIT listener
+    readonly fireInterrupt: () => void; // the captured SIGINT listener (the rebuild-window net)
     readonly removeExit: ReturnType<typeof vi.fn>;
     readonly removeSignal: ReturnType<typeof vi.fn>;
+    readonly removeInterrupt: ReturnType<typeof vi.fn>;
     readonly setRawMode: ReturnType<typeof vi.fn>;
     readonly exit: ReturnType<typeof vi.fn>;
     readonly onProcessExit: ReturnType<typeof vi.fn>;
     readonly onTerminationSignal: ReturnType<typeof vi.fn>;
+    readonly onInterrupt: ReturnType<typeof vi.fn>;
   }
 
   const harness = (): Harness => {
@@ -59,16 +63,25 @@ describe('withHoistedAltScreen (2.6.F Step 4b-3, ADR-0068 §c)', () => {
       signalCb = cb;
       return removeSignal;
     });
+    let interruptCb: () => void = () => undefined;
+    const removeInterrupt = vi.fn();
+    const onInterrupt = vi.fn((cb: () => void) => {
+      interruptCb = cb;
+      return removeInterrupt;
+    });
     return {
       writes,
       outs,
       errs,
       events,
-      lifecycle: { onProcessExit, onTerminationSignal, setRawMode, exit },
+      lifecycle: { onProcessExit, onTerminationSignal, onInterrupt, setRawMode, exit },
       fireExit: () => exitCb(),
       fireSignal: (signo) => signalCb(signo),
+      fireInterrupt: () => interruptCb(),
       removeExit,
       removeSignal,
+      removeInterrupt,
+      onInterrupt,
       setRawMode,
       exit,
       onProcessExit,
@@ -99,10 +112,16 @@ describe('withHoistedAltScreen (2.6.F Step 4b-3, ADR-0068 §c)', () => {
       alt.clearBetween(); // a /clear swap mid-loop
       return Promise.resolve({ summaryText: 'session over' });
     });
-    // Enter → clear (swap) → exit, then the summary on the PRIMARY buffer (after the exit).
-    expect(h.writes).toEqual([ENTER_SEQ, CLEAR_ALT_SCREEN, EXIT_SEQ]);
-    expect(h.outs).toEqual(['session over\n']);
-    // The last write (the alt-exit) precedes the summary print — the summary lands on the primary buffer.
+    // Enter → clear (swap) → exit, THEN the summary. Asserted on the COMBINED `events` log, not on `writes` and `outs`
+    // separately: the whole claim of this test is a CROSS-SINK order, and two per-sink assertions cannot see it — the
+    // summary could print into the still-entered alt buffer (where DECRST-1049 discards it) and both arrays would be
+    // unchanged. That is the regression this test exists to catch, and it could not (whole-phase Opus review).
+    expect(h.events).toEqual([
+      `write:${ENTER_SEQ}`,
+      `write:${CLEAR_ALT_SCREEN}`,
+      `write:${EXIT_SEQ}`,
+      'out:session over\n',
+    ]);
     expect(h.removeExit).toHaveBeenCalledTimes(1); // the exit net was removed (cannot outlive the loop)
     expect(h.removeSignal).toHaveBeenCalledTimes(1);
   });
@@ -200,4 +219,123 @@ describe('withHoistedAltScreen (2.6.F Step 4b-3, ADR-0068 §c)', () => {
     expect(h.removeExit).toHaveBeenCalledTimes(1);
     expect(h.removeSignal).toHaveBeenCalledTimes(1);
   });
+
+  /**
+   * THE REBUILD WINDOW (2.6.F Step 6g, whole-phase Opus review). SIGINT belongs to ink: while a tree is mounted,
+   * `driveInk`'s `onSigintGated` runs the cooperative `/cancel`, and during a `/scrollback` or `/edit` hatch it
+   * DROPS the signal so the suspension can reclaim the terminal. But a `/clear` or `/models` rebuild unmounts ink
+   * and mounts a fresh tree, and in that window nothing listens for SIGINT — Node's default action kills the process
+   * WITHOUT firing `'exit'`, so the `onProcessExit` net never runs and the alt buffer, mouse reporting and the hidden
+   * cursor are stranded on the user's shell.
+   */
+  it('a THROWING alt.enter() still runs the finally — the nets are removed and the summary is not lost', async () => {
+    // `enter()`'s write can throw on a dead TTY. It used to run BEFORE the try, so the `finally` never ran, and the
+    // nets (had any been registered) would have outlived the loop. Flagged by the PR bot once 6h-1 made `enter` throw.
+    const h = harness();
+    const throwing = {
+      ...opts(h, true),
+      write: (s_: string) => {
+        if (s_.includes(ENTER_ALT_SCREEN)) throw new Error('EIO');
+        h.writes.push(s_);
+      },
+    };
+    await expect(
+      withHoistedAltScreen(throwing, () => Promise.resolve({ summaryText: 'never runs' })),
+    ).rejects.toThrow('EIO');
+    expect(h.writes).toEqual([]); // nothing entered ⇒ nothing exited
+    expect(h.outs).toEqual([]); // the loop never ran, so there is no summary
+  });
+
+  describe('the SIGINT net covers the window where no ink tree is mounted', () => {
+    /** A port that reports whether an ink tree is attached — exactly what `createSuspendPort().current()` does. */
+    const portWith = (attached: boolean): SuspendPort => {
+      const port = createSuspendPort();
+      if (attached) port.attach((cb) => cb());
+      return port;
+    };
+
+    it('restores the terminal and exits 130 when NO ink tree is attached', async () => {
+      const h = harness();
+      await withHoistedAltScreen(
+        {
+          active: true,
+          write: (s_) => h.writes.push(s_),
+          lifecycle: h.lifecycle,
+          writeOut: () => undefined,
+          writeErr: () => undefined,
+          suspendPort: portWith(false),
+        },
+        () => {
+          h.fireInterrupt();
+          return Promise.resolve({});
+        },
+      );
+      expect(h.exit).toHaveBeenCalledWith(130);
+      expect(h.writes.join('')).toContain(DISABLE_MOUSE);
+      expect(h.writes.join('')).toContain(EXIT_ALT_SCREEN);
+      expect(h.setRawMode).toHaveBeenCalledWith(false);
+    });
+
+    it('DEFERS to ink when a tree IS attached — Ctrl-C there is the cooperative /cancel, not a kill', async () => {
+      const h = harness();
+      await withHoistedAltScreen(
+        {
+          active: true,
+          write: (s_) => h.writes.push(s_),
+          lifecycle: h.lifecycle,
+          writeOut: () => undefined,
+          writeErr: () => undefined,
+          suspendPort: portWith(true),
+        },
+        () => {
+          h.fireInterrupt();
+          return Promise.resolve({});
+        },
+      );
+      expect(h.exit).not.toHaveBeenCalled();
+    });
+
+    it('registers no SIGINT net when the alt screen is inactive (inline / --json)', async () => {
+      const h = harness();
+      await withHoistedAltScreen(
+        {
+          active: false,
+          write: (s_) => h.writes.push(s_),
+          lifecycle: h.lifecycle,
+          writeOut: () => undefined,
+          writeErr: () => undefined,
+          suspendPort: portWith(false),
+        },
+        () => Promise.resolve({}),
+      );
+      expect(h.onInterrupt).not.toHaveBeenCalled();
+    });
+
+    it('removes the SIGINT net when the loop ends — it must not outlive the hoist', async () => {
+      const h = harness();
+      await withHoistedAltScreen(
+        {
+          active: true,
+          write: (s_) => h.writes.push(s_),
+          lifecycle: h.lifecycle,
+          writeOut: () => undefined,
+          writeErr: () => undefined,
+          suspendPort: portWith(false),
+        },
+        () => Promise.resolve({}),
+      );
+      expect(h.removeInterrupt).toHaveBeenCalledTimes(1);
+    });
+
+    it('the PRODUCTION lifecycle registers SIGINT separately from the termination signals', () => {
+      const before = process.listenerCount('SIGINT');
+      const off = defaultReplLifecycle.onInterrupt(() => undefined);
+      try {
+        expect(process.listenerCount('SIGINT')).toBe(before + 1);
+      } finally {
+        off(); // always remove the real `process` listener, even if the assertion above throws
+      }
+      expect(process.listenerCount('SIGINT')).toBe(before);
+    });
+  });
 });

apps/cli/src/commands/chat.test.ts

@@ -31,7 +31,12 @@ import type { GlobalOptions } from '../process/options.js';
 import { selectChatDriver } from '../render/tui/chat-ink.js';
 import { createChatStore, type ChatStoreController } from '../render/tui/chat-store.js';
 import { captureIo, parseNdjson } from '../test-support.js';
-import { ENTER_ALT_SCREEN, EXIT_ALT_SCREEN } from '../render/alt-screen.js';
+import {
+  DISABLE_MOUSE,
+  ENABLE_MOUSE,
+  ENTER_ALT_SCREEN,
+  EXIT_ALT_SCREEN,
+} from '../render/alt-screen.js';
 import {
   chatCommand,
   chatIsInteractive,
@@ -141,6 +146,7 @@ const INERT_HOIST = {
   lifecycle: {
     onProcessExit: (): (() => void) => () => undefined,
     onTerminationSignal: (): (() => void) => () => undefined,
+    onInterrupt: (): (() => void) => () => undefined,
     setRawMode: (): void => undefined,
     exit: (): void => undefined,
   },
@@ -692,6 +698,74 @@ describe('chatCommand', () => {
     expect(recC.writes).toEqual([]);
   });
 
+  it('MOUSE: on by default, and `--no-mouse` reaches the real controller (2.6.F Step 5e, ADR-0068 §e)', async () => {
+    const exitDrive: ChatDriver = async (ctx) => {
+      ctx.startSession();
+      await ctx.processLine('/exit');
+      return { kind: ctx.stopReason() };
+    };
+    // The opt-out IS the safety mechanism this feature exists for: mouse reporting disables the emulator's native
+    // click-drag selection. The unit tests pin `resolveMouseMode` and the controller in isolation; this pins the
+    // ASSEMBLY — `deps.global.noMouse` → `resolveMouseMode` → `withHoistedAltScreen` → `enter()`. A mis-threaded field
+    // stays `boolean | undefined`-typed and would compile (Step-5e Opus review).
+    const a = deps([], [textTurn('hi')]);
+    const recA = recordingHoist();
+    await chatCommand(
+      { agent: undefined },
+      {
+        ...a.d,
+        ...recA.hoist,
+        io: { ...a.d.io, stdoutIsTty: true },
+        openSessionStore: () => ({ store: a.store, db: client.db, close: () => undefined }),
+        drive: exitDrive,
+      },
+    );
+    expect(recA.writes.join('')).toContain(ENABLE_MOUSE); // the phase default arms the wheel
+
+    const b = deps([], [textTurn('hi')]);
+    const recB = recordingHoist();
+    await chatCommand(
+      { agent: undefined },
+      {
+        ...b.d,
+        ...recB.hoist,
+        io: { ...b.d.io, stdoutIsTty: true },
+        global: { ...globalOptions(cwd), noMouse: true },
+        openSessionStore: () => ({ store: b.store, db: client.db, close: () => undefined }),
+        drive: exitDrive,
+      },
+    );
+    const written = recB.writes.join('');
+    expect(written).not.toContain(ENABLE_MOUSE); // the wheel is never armed…
+    expect(written).toContain(ENTER_ALT_SCREEN); // …while the full-screen renderer is untouched
+    expect(written).toContain(DISABLE_MOUSE); // …and the teardown still disables, unconditionally
+  });
+
+  it('MOUSE: `[preferences].mouse = false` reaches the real controller (the durable opt-out)', async () => {
+    const exitDrive: ChatDriver = async (ctx) => {
+      ctx.startSession();
+      await ctx.processLine('/exit');
+      return { kind: ctx.stopReason() };
+    };
+    const c = deps([], [textTurn('hi')]);
+    const cfg = join(cwd, 'mouse-off.toml');
+    writeFileSync(cfg, '[preferences]\nmouse = false\n');
+    const rec = recordingHoist();
+    await chatCommand(
+      { agent: undefined },
+      {
+        ...c.d,
+        ...rec.hoist,
+        io: { ...c.d.io, stdoutIsTty: true },
+        global: { ...globalOptions(cwd), configPath: cfg },
+        openSessionStore: () => ({ store: c.store, db: client.db, close: () => undefined }),
+        drive: exitDrive,
+      },
+    );
+    expect(rec.writes.join('')).not.toContain(ENABLE_MOUSE);
+    expect(rec.writes.join('')).toContain(ENTER_ALT_SCREEN);
+  });
+
   it('the [preferences].alt_screen preference SURVIVES a /clear re-drive (Step-4a threading regression, ADR-0068 §e)', async () => {
     // The fabricated-outcome driver bypasses driveInk, so `ctx.altScreen` here is the raw threaded config pref (not
     // the resolved mode) — exactly what pins the wiring: config.altScreen must reach BOTH the initial AND the
@@ -1047,6 +1121,88 @@ describe('chatCommand', () => {
     ).rejects.toThrow('db open boom');
     expect(closed()).toBe(1); // the pre-loop catch tore the live connection down before rethrowing
   });
+
+  /**
+   * THE CAPS-LIFT, ON `relavium chat` (2.6.F Step 6h, Sonnet review).
+   *
+   * `drive-home.test.ts` proves it for the Home. It proved NOTHING for this surface: reverting `transcriptBoundFor`
+   * to always return the inline bound — restoring the exact 4 000-character clipping defect ADR-0068 exists to fix —
+   * left 2 062 of 2 063 tests green, the single failure being the Home's. `chat.ts` threads the bound through FOUR
+   * call sites (a fresh session, a resume, a `/clear` rebuild, a `/models` reseat) and none was covered.
+   *
+   * The headless `linesDriver` never subscribes the view store to the session stream (only `driveInk`/`drivePlain`
+   * do), so this drives the REAL store `chatCommand` built — with the REAL bound it was given — through the reducer.
+   */
+  describe('the transcript bound `relavium chat` gives its view store', () => {
+    const LONG = 'X'.repeat(10_000);
+
+    /** Run one turn's worth of events through the store the command created, and return the baked entry. */
+    const bakeLongAnswer = (store: ChatStoreController): string => {
+      store.apply({
+        type: 'session:turn_started',
+        sessionId: 's',
+        sequenceNumber: 1,
+        timestamp: '2026-01-01T00:00:00.000Z',
+      });
+      store.apply({
+        type: 'agent:token',
+        sessionId: 's',
+        sequenceNumber: 2,
+        timestamp: '2026-01-01T00:00:01.000Z',
+        token: LONG,
+        model: 'm',
+        nodeId: 'n',
+      });
+      store.apply({
+        type: 'session:turn_completed',
+        sessionId: 's',
+        sequenceNumber: 3,
+        timestamp: '2026-01-01T00:00:02.000Z',
+        stopReason: 'stop',
+        tokensUsed: { input: 1, output: 1 },
+      });
+      const transcript = store.getSnapshot().state.transcript;
+      return transcript.find((e) => e.role === 'assistant')?.text ?? '';
+    };
+
+    const capturedStore = async (
+      over: Partial<ChatCommandDeps> = {},
+    ): Promise<ChatStoreController> => {
+      let live: ChatStoreController | undefined;
+      const capture: ChatDriver = async (ctx) => {
+        live = ctx.store;
+        ctx.startSession();
+        await ctx.processLine('/exit');
+        return { kind: 'exit' };
+      };
+      const { d } = deps([], []);
+      await chatCommand(
+        { agent: undefined },
+        { ...d, ...INERT_HOIST, io: { ...d.io, stdoutIsTty: true }, drive: capture, ...over },
+      );
+      if (live === undefined) throw new Error('the driver never ran');
+      return live;
+    };
+
+    it('the alt-screen chat keeps all 10 000 characters', async () => {
+      expect(bakeLongAnswer(await capturedStore())).toHaveLength(10_000);
+    });
+
+    it('`--no-alt-screen` keeps the historical trailing tail — the inline renderer has no viewport', async () => {
+      const store = await capturedStore({
+        global: { ...globalOptions(cwd), noAltScreen: true },
+      });
+      const text = bakeLongAnswer(store);
+      expect(text).toHaveLength(4001);
+      expect(text.startsWith('…')).toBe(true);
+    });
+
+    it('a NON-TTY (a pipe / `--json`) also keeps the tail — it never projects a viewport', async () => {
+      const { d } = deps([], []);
+      const store = await capturedStore({ io: { ...d.io, stdoutIsTty: false } });
+      expect(bakeLongAnswer(store)).toHaveLength(4001);
+    });
+  });
 });
 
 describe('chatResumeCommand (2.N)', () => {