zames_pro 2.73.11 → 2.75.0

package/dist/tui/run-login.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { LoginForm } from './LoginForm.js';
+import { TextPrompt } from './TextPrompt.js';
+/**
+ * Show the Ink login form and resolve with the credentials (or null when the
+ * operator cancelled / stdin is not a TTY). Non-TTY resolves null so the
+ * caller falls back to its own prompt.
+ */
+export async function runLoginForm(opts) {
+    if (!(process.stdin.isTTY && process.stdout.isTTY))
+        return null;
+    return await new Promise((resolve) => {
+        let done = false;
+        const app = render(_jsx(LoginForm, { t: opts.t, initialUsername: opts.initialUsername, initialPassword: opts.initialPassword, note: opts.note, onResult: (res) => {
+                done = true;
+                resolve(res);
+            } }), { exitOnCtrlC: false });
+        app.waitUntilExit().then(() => {
+            if (!done)
+                resolve(null);
+        });
+    });
+}
+/**
+ * Show a one-line Ink text prompt (label + input) and resolve with the value,
+ * or null on Esc / non-TTY. Used for the MFA code so it stays in the TUI.
+ */
+export async function runTextPrompt(opts) {
+    if (!(process.stdin.isTTY && process.stdout.isTTY))
+        return null;
+    return await new Promise((resolve) => {
+        let done = false;
+        const app = render(_jsx(TextPrompt, { t: opts.t, label: opts.label, secret: opts.secret, onResult: (v) => {
+                done = true;
+                resolve(v);
+            } }), { exitOnCtrlC: false });
+        app.waitUntilExit().then(() => {
+            if (!done)
+                resolve(null);
+        });
+    });
+}

package/dist/tui/run-select.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { SelectList } from './SelectList.js';
+export async function selectListInk(opts) {
+    if (!(process.stdin.isTTY && process.stdout.isTTY))
+        return null;
+    return await new Promise((resolve) => {
+        let done = false;
+        const app = render(_jsx(SelectList, { ...opts, onSelect: (v) => {
+                done = true;
+                resolve(v);
+            } }), { exitOnCtrlC: false });
+        app.waitUntilExit().then(() => {
+            if (!done)
+                resolve(null);
+        });
+    });
+}

package/dist/tui/store.js

@@ -0,0 +1,104 @@
+// The TUI STATE STORE — the bridge between the imperative agent code and the
+// React/Ink render tree.
+//
+// Why a store instead of React state:
+//   * the agent loop calls the UI from OUTSIDE React (`printAbove`, `toolCall`,
+//     `thinking`, ...), i.e. imperatively;
+//   * Ink re-renders from React state, which can only be set from inside a
+//     component or via a setter we own.
+// So the imperative API writes into this store and the Ink tree subscribes
+// via `useSyncExternalStore`. One direction (calls -> store -> render) means no
+// conflict between the two worlds.
+//
+// The store keeps the WHOLE app state in one immutable snapshot object so
+// `useSyncExternalStore` gets a stable reference between changes (a new object
+// is produced only on an actual mutation).
+import { initialEditState } from './edit.js';
+function initialState() {
+    return {
+        log: [],
+        title: 'zames',
+        version: '',
+        workdir: '',
+        scroll: 0,
+        busy: false,
+        locked: false,
+        statusText: '',
+        sendState: '',
+        animBase: '',
+        animStart: 0,
+        pendingText: null,
+        edit: initialEditState(),
+        pastes: [],
+        attachments: [],
+        history: [],
+        prompt: '> ',
+        commands: [],
+        locale: 'ru',
+        contextText: null,
+        contextLevel: null,
+        queueLength: 0,
+        tasks: '',
+        provider: '',
+        mouseScroll: true,
+        thinkingEnabled: false,
+        searchEnabled: false,
+        statusLine: '',
+        codeBlocks: [],
+        codeFocus: -1,
+        columns: process.stdout.columns || 80,
+    };
+}
+/**
+ * A minimal external store for the Ink tree.
+ *
+ * Mutations go through `set(partial)` which shallow-merges into a NEW snapshot
+ * object, so `useSyncExternalStore` sees a changed reference and re-renders.
+ * A render that changes nothing produces no new object and no repaint.
+ */
+export class TuiStore {
+    state = initialState();
+    listeners = new Set();
+    nextLogId = 1;
+    subscribe = (cb) => {
+        this.listeners.add(cb);
+        return () => this.listeners.delete(cb);
+    };
+    getSnapshot = () => this.state;
+    /** Shallow-merge a partial update and notify subscribers. */
+    set(partial) {
+        let changed = false;
+        for (const k of Object.keys(partial)) {
+            if (partial[k] !== this.state[k]) {
+                changed = true;
+                break;
+            }
+        }
+        if (!changed)
+            return;
+        this.state = { ...this.state, ...partial };
+        this.emit();
+    }
+    /** Functional update over the whole snapshot. */
+    update(fn) {
+        this.set(fn(this.state));
+    }
+    /** Append one permanent log entry (an Ink `<Static>` item). */
+    pushLog(kind, text, raw = false) {
+        const entry = { id: this.nextLogId++, kind, text, raw };
+        this.state = { ...this.state, log: [...this.state.log, entry] };
+        this.emit();
+    }
+    /** Append several entries in one notification (cheaper than N pushes). */
+    pushLogs(entries) {
+        if (!entries.length)
+            return;
+        const withIds = entries.map((e) => ({ ...e, id: this.nextLogId++ }));
+        this.state = { ...this.state, log: [...this.state.log, ...withIds] };
+        this.emit();
+    }
+    emit() {
+        for (const cb of this.listeners)
+            cb();
+    }
+}

package/dist/tui/types.js

@@ -0,0 +1,10 @@
+// The UI EDITOR interface — the shared surface of the legacy `LineEditor`
+// (src/input.ts) and the new Ink-based `TuiEditor` (src/tui/TuiEditor.tsx).
+//
+// index.ts and run-task.ts talk to the UI ONLY through this interface, so the
+// rendering engine (hand-rolled ANSI vs React/Ink) can be swapped without
+// touching the agent code. Both classes implement every member below.
+//
+// Only the members the agent actually uses are listed; the concrete classes may
+// expose more (internal render helpers, etc.).
+export {};

package/dist/tui/useMouseWheel.js

@@ -0,0 +1,164 @@
+// A hook that reads the terminal's MOUSE-WHEEL events and scrolls the log.
+//
+// Ink 8 does NOT parse mouse events (its `useInput` only handles keys), and it
+// STRIPS unknown CSI sequences, so the wheel never reaches a component. To
+// scroll the chat with the wheel we therefore:
+//   1. enable SGR mouse reporting on the terminal (ESC[?1000h ESC[?1006h);
+//   2. listen to the RAW stdin bytes ourselves (Ink's own listener ignores
+//      them, so there is no conflict).
+//
+// The SGR encoding is `ESC [ < Cb ; Cx ; Cy M` where Cb 64 = wheel up and
+// 65 = wheel down (plus modifier bits). We only need Cb.
+//
+// ALTERNATE-SCROLL: while the app is in the ALTERNATE SCREEN (full-screen
+// mode), terminals turn the mouse wheel into ARROW KEYS by default (DECSET
+// 1007, "alternate scroll mode"). Ink parses those arrows as normal Up/Down,
+// and the input editor at a buffer edge maps them to HISTORY -- so the wheel
+// scrolled the INPUT HISTORY instead of the log (the operator's bug).
+//
+// Two clear, MUTUALLY EXCLUSIVE modes (a terminal cannot do both at once):
+//   - SELECT (ui.mouseScroll=false): mouse reporting stays OFF, so the
+//     terminal owns the mouse -- drag-select works natively and the wheel is
+//     inert (no arrows, no history jump).
+//   - SCROLL (ui.mouseScroll=true): mouse reporting ON, so the wheel arrives
+//     as SGR events and scrolls the log; drag-select then needs SHIFT.
+//
+// THE CRITICAL DETAIL (this bug kept coming back): the mode sequences must be
+// written ONCE per mode change, NEVER per render. An earlier version listed
+// `onWheel` in the effect deps, but callers pass an inline arrow, so the
+// effect re-ran on EVERY render (the status spinner re-renders constantly) --
+// each cleanup wrote `1007h` (alternate-scroll ON) before the next setup wrote
+// `1007l`. A wheel notch that landed in that window became an ARROW and
+// scrolled the input history: the intermittent "either scroll or selection"
+// behaviour. The effect therefore depends ONLY on the mode + stdin, and the
+// callback is read from a ref (set in its own effect) so a new closure never tears
+// the terminal mode down.
+//
+// ORDER MATTERS: some terminals only apply `1007l` while mouse reporting is
+// enabled, so we enable 1000/1006 FIRST, then disable 1007. In SELECT mode we
+// actually want reporting off, so we send the on/off pair ONCE (the 1007l then
+// "sticks") and then leave reporting off.
+import { useEffect, useRef } from 'react';
+import { useStdin } from 'ink';
+/** True when a chunk contains an SGR mouse wheel event; returns the delta. */
+export function parseWheel(chunk) {
+    // Count wheel-ups (down) and wheel-downs (up) in the chunk.
+    let delta = 0;
+    const re = /\x1b\[<(\d+);\d+;\d+[Mm]/g;
+    let m;
+    while ((m = re.exec(chunk)) !== null) {
+        const cb = Number(m[1]);
+        // Button code 64 = wheel up (scroll back), 65 = wheel down (scroll fwd).
+        const button = cb & 0b11000011;
+        if (button === 64)
+            delta += 1;
+        else if (button === 65)
+            delta -= 1;
+    }
+    return delta;
+}
+/**
+ * The part of an SGR mouse sequence at the END of `chunk` that is still
+ * INCOMPLETE (no `M`/`m` terminator yet), or '' when the chunk ends cleanly.
+ * A terminal may split one sequence across two `data` events; scanning each
+ * chunk alone dropped the wheel notch (the hook keeps this tail and prepends
+ * it to the next chunk).
+ */
+export function incompleteTail(chunk) {
+    const start = chunk.lastIndexOf('\u001b[<');
+    if (start === -1)
+        return '';
+    // Complete if an `M`/`m` follows the introducer before the chunk ends.
+    if (/[Mm]/.test(chunk.slice(start + 3)))
+        return '';
+    return chunk.slice(start);
+}
+const ESC = String.fromCharCode(27);
+/**
+ * The terminal-mode sequences the hook writes for a given mode. Exported PURE
+ * so a test can pin the exact bytes AND their order:
+ *   - SELECT (enabled=false): NO `1000h/1006h` in the STEADY state, `on`
+ *     only applies `1007l` (the one-time prime), and `off` guarantees the
+ *     reporting bits are clear on unmount;
+ *   - SCROLL (enabled=true): `1000h 1006h 1007l` in the STEADY state.
+ */
+export function mouseModeSequences(enabled) {
+    // 1000 = button-event tracking, 1006 = SGR extended coords, 1007 off always
+    // (being in alt-screen otherwise turns the wheel into arrows => history).
+    const reportingOn = ESC + '[?1000h' + ESC + '[?1006h';
+    const reportingOff = ESC + '[?1006l' + ESC + '[?1000l';
+    const alternateScrollOff = ESC + '[?1007l';
+    const alternateScrollOn = ESC + '[?1007h';
+    if (enabled) {
+        return {
+            on: reportingOn + alternateScrollOff,
+            off: reportingOff + alternateScrollOn,
+        };
+    }
+    // SELECT: the on/off pair is applied ONCE at mount so the 1007l sticks even
+    // though reporting is then off (some terminals ignore 1007l while reporting
+    // is off). After the prime the steady state has reporting OFF, and the
+    // listener is not bound, so nothing consumes the native selection.
+    return {
+        on: reportingOn + alternateScrollOff + reportingOff,
+        off: reportingOff + alternateScrollOn,
+    };
+}
+/**
+ * Subscribe to wheel events on the given terminal and call `onWheel(delta)`
+ * where delta > 0 means "scroll up / back".
+ *
+ * Two mutually exclusive modes:
+ *   - `enabled=false` (SELECT): mouse reporting stays OFF, native drag-select
+ *     works, the wheel is inert. The listener is still bound so an accidental
+ *     SGR byte from a previous mode never leaks into the editor as an arrow.
+ *   - `enabled=true` (SCROLL): reporting is on, the wheel scrolls the log
+ *     (via `onWheel`), drag-select needs Shift.
+ *
+ * The terminal mode is written ONCE per `enabled` change. The wheel listener
+ * is bound once and reads the latest `onWheel` from a ref, so an inline
+ * callback (a new identity every render) does NOT re-run the effect -- a
+ * re-run would momentarily re-enable alternate-scroll and let a wheel notch
+ * scroll the input history.
+ */
+export function useMouseWheel(onWheel, enabled = false) {
+    const { stdin, isRawModeSupported } = useStdin();
+    // The latest callback, without making the mode effect depend on its
+    // identity (callers pass an inline arrow).
+    const onWheelRef = useRef(onWheel);
+    useEffect(() => {
+        onWheelRef.current = onWheel;
+    }, [onWheel]);
+    useEffect(() => {
+        if (!isRawModeSupported)
+            return;
+        const seq = mouseModeSequences(enabled);
+        process.stdout.write(seq.on);
+        // A sequence may be split across two chunks; carry the incomplete tail.
+        let carry = '';
+        const onData = (data) => {
+            const s = typeof data === 'string' ? data : data.toString('utf-8');
+            const buf = carry + s;
+            carry = incompleteTail(buf);
+            const scan = carry ? buf.slice(0, buf.length - carry.length) : buf;
+            if (!scan.includes('\u001b[<'))
+                return;
+            // SELECT mode ignores the wheel entirely (the event never reaches the
+            // editor either -- there is no reporting to generate it in the first
+            // place, but a stale SGR byte from a previous mode is swallowed here).
+            if (!enabled)
+                return;
+            const delta = parseWheel(scan);
+            if (delta !== 0)
+                onWheelRef.current(delta);
+        };
+        stdin.on('data', onData);
+        return () => {
+            stdin.removeListener('data', onData);
+            // Disable mouse reporting on unmount so normal selection works again.
+            process.stdout.write(seq.off);
+        };
+        // `onWheel` is deliberately NOT a dependency: it is read via the ref so an
+        // inline callback does not tear the terminal mode down on every render.
+    }, [stdin, isRawModeSupported, enabled]);
+}

package/dist/tui/widgets.js

@@ -0,0 +1,60 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+// ---- palette (kept in one place so every menu is consistent) ----
+export const UI = {
+    accent: '#c8b06a',
+    accentDim: '#7a6b45',
+    text: '#cfc9b0',
+    dim: '#5b616e',
+    border: '#4a5058',
+    on: '#6fd0b0',
+    off: '#5b616e',
+    ok: '#a9c08c',
+    warn: '#c9a86a',
+    err: '#c98a80',
+    system: '#808896',
+    title: '#9fb8d8',
+};
+/** `[x]` / `[ ]` — a checkbox for a boolean value. */
+export function Checkbox({ checked, focused, }) {
+    return (_jsx(Text, { color: checked ? UI.on : UI.off, bold: focused, children: checked ? '[x]' : '[ ]' }));
+}
+/** `‹ value ›` — an inline SELECT for an enum value. The arrows hint that
+ *  ←/→ (or Space) cycle the option. */
+export function Select({ value, focused, }) {
+    return (_jsxs(Text, { children: [_jsx(Text, { color: UI.off, children: '‹ ' }), _jsx(Text, { color: focused ? UI.accent : UI.text, bold: focused, children: value }), _jsx(Text, { color: UI.off, children: ' ›' })] }));
+}
+/** A framed panel (rounded border) with an optional title bar and footer. */
+export function Panel({ title, subtitle, footer, width, children, }) {
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: UI.border, paddingX: 1, width: width, children: [title ? (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: UI.title, bold: true, children: title }), subtitle ? _jsx(Text, { color: UI.dim, children: subtitle }) : null] })) : null, title ? (_jsx(Text, { color: "#3a3f4b", children: '─'.repeat(panelInnerCols(width)) })) : null, children, footer ? footer : null] }));
+}
+/** Inner width (minus border + paddingX) the panel divider should span. */
+function panelInnerCols(width) {
+    const cols = width || process.stdout.columns || 80;
+    return Math.max(1, cols - 6);
+}
+/** A single hint chip: `↑/↓ select`. */
+export function Hint({ keys, label, }) {
+    return (_jsxs(Text, { children: [_jsx(Text, { color: UI.accent, children: keys }), _jsx(Text, { color: UI.dim, children: ' ' + label })] }));
+}
+/** A row of hint chips separated by ` · `. */
+export function HintBar({ hints, }) {
+    return (_jsx(Text, { children: hints.map(([k, l], i) => (_jsxs(Text, { children: [i > 0 ? _jsx(Text, { color: UI.dim, children: '  ·  ' }) : null, _jsx(Text, { color: UI.accent, children: k }), _jsx(Text, { color: UI.dim, children: ' ' + l })] }, i))) }));
+}
+/**
+ * A CODE BLOCK with a syntax-highlighted body and a copy affordance.
+ *
+ * The agent's answers are printed as pre-rendered ANSI (markdown.ts already
+ * highlights with cli-highlight), so the live log does NOT use this component —
+ * it exists for menus/panels that show a snippet inline (and for a future
+ * structured log). Copying is a KEY, not a button: a terminal has no pointer.
+ * Pass `onCopy` and show `hint` so the operator learns the binding.
+ */
+export function CodeBlock({ code, lang, highlighted, width, hint, focused, onCopy, }) {
+    // React cannot call `onCopy` from a keydown here (Ink has no per-element
+    // focus ring by default); the caller wires the key and passes `focused` to
+    // show which block it will copy. `onCopy` is kept so a future focus manager
+    // can invoke it without changing the call sites.
+    void onCopy;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: focused ? UI.accent : UI.border, paddingX: 1, width: width, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: UI.dim, children: lang || 'code' }), hint ? _jsx(Text, { color: UI.accent, children: hint }) : null] }), (highlighted || code).split(String.fromCharCode(10)).map((line, i) => (_jsx(Text, { children: line || ' ' }, i)))] }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.73.11",
+  "version": "2.75.0",
   "description": "Terminal coding agent that drives a real browser to chat with DeepSeek, Qwen and other web LLMs — no API key required. Reads and edits files, runs commands, commits to git, like Claude Code / Codex CLI.",
   "type": "module",
   "bin": {
@@ -34,6 +34,7 @@
     "test:watch": "tsx --test --watch test/*.test.ts",
     "self-smoke": "tsx scripts/self-smoke.mts",
     "qwen-smoke": "tsx scripts/qwen-smoke.mts",
+    "qwen-models-smoke": "tsx scripts/qwen-models-smoke.mts",
     "render-demo": "tsx scripts/render-demo.mts",
     "render-how": "tsx scripts/render-how-it-works.mts",
     "build:readme": "tsx scripts/build-readme.mts",
@@ -66,16 +67,18 @@
   ],
   "license": "MIT",
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "packageManager": "npm@11.19.0",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.1",
     "chalk": "^5.3.0",
     "cli-highlight": "^2.1.11",
+    "ink": "^8.0.0",
     "markdansi": "^0.3.4",
     "ora": "^8.0.1",
-    "playwright": "^1.48.0"
+    "playwright": "^1.48.0",
+    "react": "^19.3.0"
   },
   "publishConfig": {
     "access": "public"
@@ -91,6 +94,7 @@
   "devDependencies": {
     "@eslint/js": "^9.39.5",
     "@types/node": "^26.6.2",
+    "@types/react": "^19.3.0",
     "eslint": "^9.39.5",
     "eslint-config-prettier": "^10.1.8",
     "globals": "^17.12.0",

package/scripts/coverage-gate.mts

@@ -39,6 +39,16 @@ const FLOORS = {
   // C3: the pure /config subcommand dispatcher — silent routing regressions
   // (a wrong subcommand branch) are invisible without tests.
   'config-command.ts': 85,
+  // The Ink TUI's PURE halves: the editor state transitions (tui/edit.ts) and
+  // the key dispatcher (tui/keys.ts). A silent regression there breaks the
+  // operator's editing without any UI test catching it. NOTE: the gate keys on
+  // the BASENAME (its regex has no slash), so these are 'edit.ts' / 'keys.ts' /
+  // 'store.ts' — unique in the tree today.
+  'edit.ts': 85,
+  'keys.ts': 85,
+  'store.ts': 85,
+  'banner.ts': 85,
+  'tool-summary.ts': 85,
   // N12: web.ts holds the SSRF guard and the DuckDuckGo/HTML parsers — a
   // regression there is silent. Floors sit below the current values.
   'web.ts': 40,

package/scripts/inline-status-driver.mts

@@ -0,0 +1,31 @@
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { Term } from '../test/vt100.mts'
+const NL = String.fromCharCode(10)
+const term = new Term(12, 60)
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/inline-status.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: { ...process.env, COLUMNS: '60', LINES: '12' },
+  },
+)
+child.stdout.on('data', (d) => term.write(d.toString('utf-8')))
+child.stderr.on('data', (d) => term.write(d.toString('utf-8')))
+setTimeout(() => {
+  const g = term.grid
+  if (g[term.r]) g[term.r][term.c] = String.fromCharCode(9673)
+  process.stdout.write(
+    g
+      .map((r) => r.join('').replace(/\s+$/, ''))
+      .map((l, n) => String(n).padStart(2) + '| ' + l)
+      .join(NL) +
+      NL +
+      'CURSOR row=' +
+      term.r +
+      NL,
+  )
+  child.kill('SIGTERM')
+}, 5000)
+child.on('close', () => process.exit(0))

package/scripts/inline-status.tsx

@@ -0,0 +1,33 @@
+import React from 'react'
+import { render } from 'ink'
+import { TuiStore } from '../src/tui/store.js'
+import { TuiApp } from '../src/tui/TuiApp.js'
+import { initialEditState } from '../src/tui/edit.js'
+const store = new TuiStore()
+store.set({
+  title: 'z',
+  version: '1',
+  workdir: '/tmp',
+  prompt: '> ',
+  locale: 'en',
+  commands: [],
+  edit: { ...initialEditState(), buf: 'abc' },
+  statusText: 'STATUS HERE',
+})
+const p = {
+  onSubmit: () => {},
+  onEscape: () => {},
+  onCtrlC: () => {},
+  onCopyCode: () => {},
+  onAttach: () => null,
+  onClipboard: () => Promise.resolve(null),
+  onHistoryChange: () => {},
+  onClearScreen: () => {},
+  attachments: [],
+  onPastesChange: () => {},
+}
+render(React.createElement(TuiApp, { store, inputProps: p }), {
+  exitOnCtrlC: false,
+  patchConsole: false,
+})
+setInterval(() => {}, 1 << 30)

package/scripts/mouse-churn.mts

@@ -0,0 +1,34 @@
+// Prove the mouse-mode churn is ZERO: mount the REAL TuiEditor, force several
+// store updates (like the 1s badge refresh does), and COUNT how many times the
+// raw stdout receives the mouse-mode sequences. With the effect depending on
+// an inline onWheel, the count grew per render (the wheel-vs-history bug);
+// with the ref fix, each mode byte is written ONCE.
+//
+// Exit code 0 = OK, 1 = churn detected. Prints a one-line verdict so the pty
+// test can assert on it.
+
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+
+const child = spawn(
+  'script',
+  ['-qec', 'npx tsx scripts/tui-mouse-churn-probe.tsx', '/dev/null'],
+  {
+    cwd: path.resolve('.'),
+    env: { ...process.env, COLUMNS: '80', LIMES: '24' },
+  },
+)
+let out = ''
+child.stdout.on('data', (d) => (out += d.toString('utf-8')))
+child.stderr.on('data', (d) => (out += d.toString('utf-8')))
+setTimeout(() => child.kill('SIGTERM'), 8000)
+child.on('close', () => {
+  const count = (seq: string): number => out.split(seq).length - 1
+  const on = count('\u001b[?1000h')
+  const altOff = count('\u001b[?1007l')
+  const altOn = count('\u001b[?1007h')
+  console.log('MOUSE_CHURN 1000h=' + on + ' 1007l=' + altOff + ' 1007h=' + altOn)
+  const ok = on === 1 && altOff === 1 && altOn === 0
+  console.log(ok ? 'MOUSE_CHURN_OK' : 'MOUSE_CHURN_FAIL')
+  process.exit(ok ? 0 : 1)
+})