omniharness-cli 0.1.85 → 0.1.87

package/dist/cli.js

@@ -7,6 +7,7 @@ import { ownVersion, runUpdate } from './update.js';
 import { readActiveCombo } from './config/settings.js';
 import { OmniRouteClient } from './config/omniRoute.js';
 import { doctor, helpText, models } from './doctor.js';
+import { debounceResizeEvents } from './ui/resizeDebounce.js';
 // A crash anywhere below would otherwise surface as a raw Node stack trace, or
 // as an unhandled rejection that terminates the process without saying why.
 // A CLI should fail with a sentence.
@@ -81,8 +82,12 @@ else {
         // The cost is that quitting no longer restores the pre-launch screen. For
         // a tool whose output you are meant to read back, that is the right trade.
         //
+        // Coalesce resize delivery before Ink's own internal listener ever sees
+        // it — see resizeDebounce.ts. Only meaningful for a real terminal; a
+        // non-TTY stdout never emits 'resize' and patching it would be inert.
+        const stdout = process.stdout.isTTY ? debounceResizeEvents(process.stdout, 80) : process.stdout;
         // The app owns Ctrl+C so idle quits but an in-flight run is cancelled first.
-        const { waitUntilExit } = render(_jsx(TerminalInterface, { engine: engine }), { exitOnCtrlC: false });
+        const { waitUntilExit } = render(_jsx(TerminalInterface, { engine: engine }), { stdout, exitOnCtrlC: false });
         await waitUntilExit();
     })();
 }

package/dist/ui/debounce.js

@@ -0,0 +1,18 @@
+export function debounce(fn, delayMs) {
+    let timer;
+    const debounced = ((...args) => {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = undefined;
+            fn(...args);
+        }, delayMs);
+    });
+    debounced.cancel = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = undefined;
+    };
+    return debounced;
+}
+//# sourceMappingURL=debounce.js.map

package/dist/ui/keys.js

@@ -102,10 +102,22 @@ export function parseRawKey(chunk) {
     return null;
 }
 /**
- * True when `value` is a CSI-u encoded key or protocol response (kitty key
- * events, push/pop echoes, query answers), never plain text to insert.
+ * True when `value` is a CSI-u encoded key, a protocol response (kitty key
+ * events, push/pop echoes, query answers), or a DECRQM mode-report reply
+ * (`CSI ? Ps ; Pm $ y`, e.g. the answer to the synchronized-output query) —
+ * never plain text to insert.
+ *
+ * `value` here is Ink's own parsed form, which strips the leading ESC before
+ * handing the rest to `useInput`. A terminal's reply to a query this project
+ * sends (synchronized output, in particular) arrives on the same stdin the
+ * editor reads from, and if nothing recognises it in this stripped form it is
+ * treated as pasted text and typed into whatever the user was editing — the
+ * escape sequence itself, landing in the input box. Some terminals are slow
+ * to answer that specific query, so this has to keep matching however late
+ * the reply arrives, not just during a short probe window at startup.
  */
 export function isEncodedKey(value) {
-    return /^\[\d+(?:;\d+)*u$|^\[[><?]\d+(?:;\d+)*u$/.test(value);
+    return /^\[\d+(?:;\d+)*u$|^\[[><?]\d+(?:;\d+)*u$/.test(value)
+        || /^\[\?\d+;\d\$y$/.test(value);
 }
 //# sourceMappingURL=keys.js.map

package/dist/ui/resizeDebounce.js

@@ -0,0 +1,52 @@
+import { debounce } from './debounce.js';
+/**
+ * Coalesce `resize` event delivery on a TTY stream so every listener — Ink's
+ * own internal one included — sees one event per burst instead of one per raw
+ * OS-level tick.
+ *
+ * Ink attaches its own `resize` listener directly to whatever stream is
+ * handed to `render()`, and on every single tick it recalculates its Yoga
+ * layout and writes a fresh frame — independent of anything application state
+ * does. That is not reachable by debouncing a `useState` call in a component:
+ * the redraw happens inside Ink regardless.
+ *
+ * A maximise or restore on Windows Terminal does not deliver one resize
+ * event. It animates through the transition and fires a burst of
+ * intermediate sizes a few milliseconds apart. Reacting to each one means
+ * Ink redraws against a size that is already stale by the time the escape
+ * sequences reach the terminal, and the frames land on top of one another
+ * instead of replacing one another — duplicated prompt boxes, fragments of an
+ * earlier frame still on screen once the window settles.
+ *
+ * The only place to fix that is before Ink's own listener ever sees the
+ * event — so this patches `.on` / `.off` for `resize` specifically, on the
+ * same stream object Ink and application code both subscribe to. `write`,
+ * `columns`, `rows`, `isTTY` and every other event pass through untouched.
+ */
+export function debounceResizeEvents(stream, delayMs) {
+    const realOn = stream.on.bind(stream);
+    const realOff = stream.off.bind(stream);
+    // Keyed on the caller's own listener, so .off(listener) still finds and
+    // cancels the right debounced wrapper — the caller never sees the wrapper.
+    const wrapped = new WeakMap();
+    stream.on = ((event, listener) => {
+        if (event !== 'resize')
+            return realOn(event, listener);
+        const debounced = debounce(listener, delayMs);
+        wrapped.set(listener, debounced);
+        return realOn(event, debounced);
+    });
+    stream.off = ((event, listener) => {
+        if (event !== 'resize')
+            return realOff(event, listener);
+        const debounced = wrapped.get(listener);
+        if (debounced) {
+            debounced.cancel();
+            wrapped.delete(listener);
+            return realOff(event, debounced);
+        }
+        return realOff(event, listener);
+    });
+    return stream;
+}
+//# sourceMappingURL=resizeDebounce.js.map

package/dist/ui/terminalInterface.js

@@ -320,6 +320,13 @@ export function TerminalInterface({ engine }) {
         return () => { alive = false; };
     }, []);
     useEffect(() => {
+        // The real fix for a resize storm (maximise/restore firing a burst of
+        // intermediate sizes) lives one layer down, in resizeDebounce.ts: it
+        // coalesces delivery of the raw 'resize' event on the stream itself,
+        // before Ink's own internal listener — which redraws unconditionally on
+        // every tick, independent of any component state — ever sees it. This
+        // handler can stay a plain listener because of that; by the time it
+        // fires, the event has already been coalesced upstream.
         const onResize = () => {
             setWidth(widthOf(stdout));
             setRows(rowsOf(stdout));
@@ -327,22 +334,41 @@ export function TerminalInterface({ engine }) {
         stdout.on('resize', onResize);
         stdout.write(KITTY_PUSH);
         let kittyTimer;
-        // One probe pass: kitty keyboard protocol + synchronized output (DECSET 2026).
-        const onProbe = (chunk) => {
-            const text = chunk.toString();
-            if (isSyncOutputReply(text) && syncRestoreRef.current === null) {
-                syncRestoreRef.current = wrapSynchronizedOutput(stdout);
-            }
-            if (!isKittyQueryResponse(text))
+        // Two independent probes, not one shared listener. They used to be a
+        // single handler torn down together after 300ms, on the assumption both
+        // replies would have arrived by then. Some terminals answer the
+        // synchronized-output query well after that — observed landing right
+        // around a resize, though the terminal's own reasons for the delay are
+        // opaque from here — and a listener already removed cannot catch a late
+        // reply. Two things followed from that: synchronized output silently
+        // never turned on for the rest of the session, and the reply itself, with
+        // nothing left to claim it, reached Ink's own useInput and got typed into
+        // the input box as literal text (the isEncodedKey guard now recognises
+        // and drops that shape regardless, but the actual fix is to keep
+        // listening for it rather than lean on that alone).
+        const onSyncProbe = (chunk) => {
+            if (syncRestoreRef.current !== null)
+                return;
+            if (!isSyncOutputReply(chunk.toString()))
+                return;
+            syncRestoreRef.current = wrapSynchronizedOutput(stdout);
+            stdin?.off('data', onSyncProbe);
+        };
+        // The kitty check is a UI decision — whether Ctrl+letter and a distinct
+        // Shift+Tab are available — that has to resolve one way or the other, so
+        // it keeps a bounded timeout; "no answer in 300ms" is itself the answer.
+        const onKittyProbe = (chunk) => {
+            if (!isKittyQueryResponse(chunk.toString()))
                 return;
             if (kittyTimer)
                 clearTimeout(kittyTimer);
-            stdin?.off('data', onProbe);
+            stdin?.off('data', onKittyProbe);
             setKitty(true);
         };
         if (stdin) {
-            stdin.on('data', onProbe);
-            kittyTimer = setTimeout(() => { setKitty(false); stdin.off('data', onProbe); }, 300);
+            stdin.on('data', onSyncProbe);
+            stdin.on('data', onKittyProbe);
+            kittyTimer = setTimeout(() => { setKitty(false); stdin.off('data', onKittyProbe); }, 300);
             stdout.write(SYNC_QUERY);
             stdout.write(KITTY_QUERY);
         }
@@ -425,8 +451,9 @@ export function TerminalInterface({ engine }) {
         return () => {
             if (kittyTimer)
                 clearTimeout(kittyTimer);
-            stdin?.off('data', onProbe);
-            stdout.off('resize', onResize);
+            stdin?.off('data', onSyncProbe);
+            stdin?.off('data', onKittyProbe);
+            stdout.off('resize', onResize); // resizeDebounce cancels the coalesced timer on .off itself
             const pendingApproval = approvalResolve.current;
             approvalResolve.current = null;
             pendingApproval?.({ approved: false });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omniharness-cli",
-  "version": "0.1.85",
+  "version": "0.1.87",
   "description": "OmniHarness — local-first agent orchestration harness for OmniRoute.",
   "license": "MIT",
   "type": "module",