omniharness-cli 0.1.85 → 0.1.86

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/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));
@@ -426,7 +433,7 @@ export function TerminalInterface({ engine }) {
             if (kittyTimer)
                 clearTimeout(kittyTimer);
             stdin?.off('data', onProbe);
-            stdout.off('resize', onResize);
+            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.86",
   "description": "OmniHarness — local-first agent orchestration harness for OmniRoute.",
   "license": "MIT",
   "type": "module",