mixdog 0.9.2 → 0.9.4

package/src/workflows/default/WORKFLOW.md

@@ -26,16 +26,23 @@ Lead supervises: delegates, coordinates, judges, decides. Route by complexity:
    - SEQUENTIAL within a single complex scope — split it into ordered steps
      rather than handing it off in one shot, with a build/test-green gate
      between steps.
-   - Reuse the existing agent (same tag) for follow-up on the same scope; spawn
-     new only for a separate scope. Write briefs per the lead-tool brief
-     contract (token-optimized labeled fragments).
+   - Write briefs per the Lead brief contract (token-optimized labeled
+     fragments).
    - After spawning async agent(s), END THE TURN — do not poll, guess, or start
-     dependent work until the completion notification resumes you (status/read
-     are manual recovery only). Then wait and continue automatically.
+     dependent work until the completion notification resumes you. Then wait
+     and continue automatically.
 3. Review — pair one reviewer 1:1 with each implementation scope, spawned in the
-   same turn. Cross-check implementation and review results yourself before
-   acting on them. Send fixes back to the original scope and repeat until clean.
-   Skip review only for simple, low-risk tasks.
+   same turn; never defer or batch the reviewer call — wait for its result.
+   Fact-check the agent response and cross-check implementation and review
+   results yourself before acting on them. Send fixes back to the original
+   scope and loop verify -> fix -> re-verify until clean. Skip review only for
+   simple, low-risk tasks. If the user asks for debugging, or a bug survives
+   2+ fix cycles, have the debugger investigate first instead of another fix
+   round.
 4. Report — deliver the final report: synthesize results (outcome + key
    evidence; never forward raw agent output), state the final state, and ask the
-   user whether to ship/deploy when relevant.
+   user whether to ship/deploy when relevant. Only after user feedback with no
+   issues prepare deploy/build/commit.
+
+On any major change or direction shift mid-work, pause and re-consult the user
+before continuing.

package/src/workflows/sequential/WORKFLOW.md

@@ -29,18 +29,23 @@ Lead supervises: delegates, coordinates, judges, decides. Route by complexity:
    - SEQUENTIAL within a single complex scope — split it into ordered steps
      rather than handing it off in one shot, with a build/test-green gate
      between steps.
-   - Reuse the existing agent (same tag) for follow-up on the same scope; spawn
-     new only for a separate scope. Write briefs per the lead-tool brief
-     contract (token-optimized labeled fragments).
+   - Write briefs per the Lead brief contract (token-optimized labeled
+     fragments).
    - After spawning an async agent, END THE TURN — do not poll, guess, or start
-     dependent or subsequent work until the completion notification resumes you
-     (status/read are manual recovery only). Then wait and continue
-     automatically.
+     dependent or subsequent work until the completion notification resumes
+     you. Then wait and continue automatically.
 3. Review — after each implementation scope completes, pair one reviewer 1:1
-   with that scope (spawned on its own turn, not batched). Cross-check
-   implementation and review results yourself before acting on them. Send fixes
-   back to the original scope and repeat until clean. Skip review only for
-   simple, low-risk tasks.
+   with that scope (spawned on its own turn, not batched); never defer the
+   reviewer call — wait for its result. Fact-check the agent response and
+   cross-check implementation and review results yourself before acting on
+   them. Send fixes back to the original scope and loop verify -> fix ->
+   re-verify until clean. Skip review only for simple, low-risk tasks. If the
+   user asks for debugging, or a bug survives 2+ fix cycles, have the debugger
+   investigate first instead of another fix round.
 4. Report — deliver the final report: synthesize results (outcome + key
    evidence; never forward raw agent output), state the final state, and ask the
-   user whether to ship/deploy when relevant.
+   user whether to ship/deploy when relevant. Only after user feedback with no
+   issues prepare deploy/build/commit.
+
+On any major change or direction shift mid-work, pause and re-consult the user
+before continuing.

package/src/workflows/solo/WORKFLOW.md

@@ -14,7 +14,11 @@ agents:
 3. Verify — Lead checks the result directly, fixes issues directly, and repeats
    until the work is clean or a blocker must be reported.
 4. Report — Lead summarizes the final state, verification result, and any
-   remaining risk or requested next step.
+   remaining risk or requested next step. Only after user feedback with no
+   issues prepare deploy/build/commit.
+
+On any major change or direction shift mid-work, pause and re-consult the user
+before continuing.
 
 Delegation rule:
 - Do not delegate, spawn, send, or ask any agent to perform work.

package/vendor/ink/build/display-width.js

@@ -16,11 +16,21 @@
  * overrides and wins. OFF ⇒ identical to plain string-width.
  */
 import stringWidth from 'string-width';
+// [mixdog fork] Grapheme segmenter for cluster-aware width math (e.g. `↔️` =
+// U+2194 U+FE0F is one cluster, counted once). Kept in sync with
+// src/tui/display-width.mjs.
+const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
 
 function isProblemCodePoint(cp) {
     return (cp >= 0x2460 && cp <= 0x24ff) || (cp >= 0x2190 && cp <= 0x21ff);
 }
 
+// [mixdog fork] Fast precheck for the problem ranges above. Lets the hot path
+// bail before the per-grapheme segmenter loop when a string (the common
+// ASCII/status-text case) contains no widenable glyph. Kept in sync with
+// src/tui/display-width.mjs.
+const PROBLEM_RE = /[\u2190-\u21ff\u2460-\u24ff]/;
+
 function resolveAmbiguousWidePolicy(env = process.env) {
     const override = env?.MIXDOG_TUI_AMBIGUOUS_WIDE;
     if (override === '1')
@@ -38,10 +48,16 @@ export function displayWidthWith(str, wide) {
     const base = stringWidth(s);
     if (!wide)
         return base;
+    // Fast bail: no problem glyph ⇒ segmenting can only return `base`.
+    if (!PROBLEM_RE.test(s))
+        return base;
     let extra = 0;
-    for (const ch of s) {
-        const cp = ch.codePointAt(0);
-        if (isProblemCodePoint(cp) && stringWidth(ch) === 1)
+    // Widen per GRAPHEME CLUSTER, not per code point (kept in sync with
+    // src/tui/display-width.mjs): a clustered glyph like `↔️` (U+2194 U+FE0F)
+    // is counted once, and only when the whole cluster still measures 1 cell.
+    for (const { segment } of graphemeSegmenter.segment(s)) {
+        const cp = segment.codePointAt(0);
+        if (isProblemCodePoint(cp) && stringWidth(segment) === 1)
             extra += 1;
     }
     return base + extra;

package/vendor/ink/build/ink.js

@@ -86,16 +86,25 @@ const stripKittyQueryResponsesAndTrailingPartial = (buffer) => {
 // viewport, leaving stale copies of previous frames behind (#969). Keep the
 // pre-7.0 behavior of fully clearing between fullscreen frames there.
 const isWindowsConsole = process.platform === 'win32' || Boolean(process.env.WT_SESSION);
-const shouldClearTerminalForFrame = ({ isTty, viewportRows, previousOutputHeight, nextOutputHeight, isUnmounting, }) => {
+const shouldClearTerminalForFrame = ({ isTty, viewportRows, previousViewportRows, previousOutputHeight, nextOutputHeight, isUnmounting, }) => {
     if (!isTty) {
         return false;
     }
+    const priorViewportRows = previousViewportRows ?? viewportRows;
     const hadPreviousFrame = previousOutputHeight > 0;
-    const wasFullscreen = previousOutputHeight >= viewportRows;
-    const wasOverflowing = previousOutputHeight > viewportRows;
+    const wasFullscreen = previousOutputHeight >= priorViewportRows;
+    const wasOverflowing = previousOutputHeight > priorViewportRows;
     const isOverflowing = nextOutputHeight > viewportRows;
     const isFullscreen = nextOutputHeight >= viewportRows;
     const isLeavingFullscreen = wasFullscreen && nextOutputHeight < viewportRows;
+    // [mixdog fork] A frame that SHRINKS by more than a line while at/over the
+    // viewport can leave stale wrapped rows below the new content on ANY
+    // terminal (not just Windows) — the incremental erase only clears the exact
+    // delta and a hardware wrap can desync it by a cell. Force a full clear on a
+    // meaningful height shrink near/at the viewport edge, cross-platform.
+    const isShrinkingAtViewport = hadPreviousFrame &&
+        nextOutputHeight < previousOutputHeight &&
+        (wasFullscreen || isFullscreen || wasOverflowing || isOverflowing);
     const shouldClearOnUnmount = isUnmounting && wasFullscreen;
     if (isWindowsConsole && (wasFullscreen || isFullscreen)) {
         return true;
@@ -106,6 +115,8 @@ const shouldClearTerminalForFrame = ({ isTty, viewportRows, previousOutputHeight
         (isOverflowing && hadPreviousFrame) ||
         // Clear when shrinking from fullscreen to non-fullscreen output.
         isLeavingFullscreen ||
+        // Clear on any height shrink at/over the viewport (cross-platform).
+        isShrinkingAtViewport ||
         // Preserve legacy unmount behavior for fullscreen frames: final teardown
         // render should clear once to avoid leaving a scrolled viewport state.
         shouldClearOnUnmount);
@@ -155,6 +166,7 @@ export default class Ink {
     lastOutputToRender;
     lastOutputHeight;
     lastTerminalWidth;
+    lastTerminalHeight;
     container;
     rootNode;
     // This variable is used only in debug mode to store full static output
@@ -165,6 +177,9 @@ export default class Ink {
     beforeExitHandler;
     restoreConsole;
     unsubscribeResize;
+    // [mixdog fork] Deferred repaint safety-net timer for resized(); cancelled
+    // by onRender when a real (App-driven) render lands first.
+    resizeRepaintTimer;
     throttledOnRender;
     hasPendingThrottledRender = false;
     kittyProtocolEnabled = false;
@@ -259,6 +274,7 @@ export default class Ink {
         this.lastOutputToRender = '';
         this.lastOutputHeight = 0;
         this.lastTerminalWidth = getWindowSize(this.options.stdout).columns;
+        this.lastTerminalHeight = getWindowSize(this.options.stdout).rows;
         // This variable is used only in debug mode to store full static output
         // so that it's rerendered every time, not just new static parts, like in non-debug mode
         this.fullStaticOutput = '';
@@ -293,16 +309,56 @@ export default class Ink {
     }
     resized = () => {
         const currentWidth = getWindowSize(this.options.stdout).columns;
-        if (currentWidth < this.lastTerminalWidth) {
-            // We clear the screen when decreasing terminal width to prevent duplicate overlapping re-renders.
+        const currentHeight = getWindowSize(this.options.stdout).rows;
+        if (currentWidth !== this.lastTerminalWidth || currentHeight !== this.lastTerminalHeight) {
+            // [mixdog fork] On viewport size change, full-clear the alt screen to
+            // drop the stale frame, but DO NOT immediately re-render with the old
+            // React tree at the new size. Ink's own onRender() here fires before
+            // App's debounced resizeState state update, so it paints a frame laid
+            // out for the PREVIOUS dimensions into the NEW viewport — that is the
+            // 2-frame jump/re-settle on resize. Clearing (no re-render) leaves a
+            // blank screen for the sub-frame until App's setResizeState commit
+            // drives a single, correctly-sized App-owned render. Layout listeners
+            // still fire so consumers observe the new size synchronously.
             this.log.clear();
+            this.log.reset?.();
+            // this.log.clear() only erases the PRIOR log frame's row span. On a
+            // fullscreen/alt-screen grow the newly exposed rows (below the old
+            // frame) are never touched by that erase, so stale scrollback can
+            // remain visible until the next full repaint — which, with the
+            // immediate onRender suppressed, may be shorter or delayed. Issue a
+            // true whole-screen clear so the viewport is uniformly blank until
+            // App's correctly-sized render lands.
+            this.writeBestEffort(this.options.stdout, ansiEscapes.clearTerminal);
             this.lastOutput = '';
             this.lastOutputToRender = '';
+            this.lastOutputHeight = 0;
+            this.calculateLayout();
+            dom.emitLayoutListeners(this.rootNode);
+            this.lastTerminalWidth = currentWidth;
+            this.lastTerminalHeight = currentHeight;
+            // Safety net: the early return delegates the repaint to App's stdout
+            // 'resize' listener (debounced setResizeState). If that render never
+            // arrives (listener not mounted yet, batched-away no-op, consumer
+            // without a resize handler), the screen would sit blank. Schedule a
+            // deferred onRender() that repaints with whatever tree is current;
+            // it is cancelled below whenever a real render happens first, so in
+            // the normal path it never fires and the immediate render stays
+            // suppressed.
+            if (this.resizeRepaintTimer) clearTimeout(this.resizeRepaintTimer);
+            this.resizeRepaintTimer = setTimeout(() => {
+                this.resizeRepaintTimer = undefined;
+                if (this.isUnmounted || this.isUnmounting) return;
+                this.onRender();
+            }, 200);
+            if (typeof this.resizeRepaintTimer.unref === 'function') this.resizeRepaintTimer.unref();
+            return;
         }
         this.calculateLayout();
         dom.emitLayoutListeners(this.rootNode);
         this.onRender();
         this.lastTerminalWidth = currentWidth;
+        this.lastTerminalHeight = currentHeight;
     };
     resolveExitPromise = () => { };
     rejectExitPromise = () => { };
@@ -508,6 +564,12 @@ export default class Ink {
     };
     onRender = () => {
         this.hasPendingThrottledRender = false;
+        // A real render is happening: cancel the resize safety-net timer so the
+        // deferred repaint never double-fires in the normal path.
+        if (this.resizeRepaintTimer) {
+            clearTimeout(this.resizeRepaintTimer);
+            this.resizeRepaintTimer = undefined;
+        }
         if (this.isUnmounted) {
             return;
         }
@@ -737,6 +799,12 @@ export default class Ink {
             if (typeof this.unsubscribeResize === 'function') {
                 this.unsubscribeResize();
             }
+            // [mixdog fork] Drop the resize safety-net timer so a deferred
+            // repaint cannot fire against a torn-down tree.
+            if (this.resizeRepaintTimer) {
+                clearTimeout(this.resizeRepaintTimer);
+                this.resizeRepaintTimer = undefined;
+            }
             // Cancel any in-progress auto-detection before checking protocol state
             if (this.cancelKittyDetection) {
                 this.cancelKittyDetection();
@@ -957,21 +1025,50 @@ export default class Ink {
         // Detect fullscreen: output fills or exceeds terminal height.
         // Only apply when writing to a real TTY — piped output always gets trailing newlines.
         const viewportRows = isTty ? getWindowSize(this.options.stdout).rows : 24;
+        const viewportColumns = isTty ? getWindowSize(this.options.stdout).columns : this.lastTerminalWidth;
+        // [mixdog fork] Capture the previous viewport rows (as tracked at the
+        // end of the last frame) before we update it below, so wasFullscreen/
+        // wasOverflowing classify the PREVIOUS frame against the viewport it
+        // was actually rendered into, not the current (possibly resized) one.
+        const previousViewportRows = this.lastTerminalHeight ?? viewportRows;
         const isFullscreen = isTty && outputHeight >= viewportRows;
         const outputToRender = isFullscreen ? output : output + '\n';
         const shouldClearTerminal = shouldClearTerminalForFrame({
             isTty,
             viewportRows,
+            previousViewportRows,
             previousOutputHeight: this.lastOutputHeight,
             nextOutputHeight: outputHeight,
             isUnmounting: this.isUnmounting,
         });
+        const viewportUnchanged = viewportRows === previousViewportRows && viewportColumns === this.lastTerminalWidth;
+        if (isTty) {
+            this.lastTerminalHeight = viewportRows;
+        }
+        // [mixdog fork] Skip redundant full clears: on Windows every fullscreen
+        // frame takes the clearTerminal path, so a commit with IDENTICAL output
+        // (e.g. post-mount tuiReady flip with no layout change) still blanked and
+        // rewrote the whole screen — visible as boot flicker. Nothing changed →
+        // nothing to write. [mixdog fork] Also require the viewport (rows AND
+        // columns) to be unchanged since the last frame: a resize can arrive
+        // with identical output text but must still force a full clear to
+        // avoid ghosting stale cells left outside the new viewport.
+        if (shouldClearTerminal &&
+            !this.isUnmounting &&
+            output === this.lastOutput &&
+            staticOutput === '' &&
+            !this.log.isCursorDirty() &&
+            viewportUnchanged) {
+            return;
+        }
         if (shouldClearTerminal) {
             const sync = this.shouldSync();
             if (sync) {
                 this.options.stdout.write(bsu);
             }
-            this.options.stdout.write(ansiEscapes.clearTerminal + this.fullStaticOutput + output);
+            // [mixdog fork] Reset SGR before erasing so stale style/background
+            // from the previous frame doesn't leak onto the cleared cells.
+            this.options.stdout.write('\u001B[0m' + ansiEscapes.clearTerminal + this.fullStaticOutput + output);
             this.lastOutput = output;
             this.lastOutputToRender = outputToRender;
             this.lastOutputHeight = outputHeight;

package/vendor/ink/build/log-update.js

@@ -62,7 +62,9 @@ const createStandard = (stream, { showCursor = false } = {}) => {
     };
     render.clear = () => {
         const prefix = buildReturnToBottomPrefix(cursorWasShown, previousLineCount, previousCursorPosition);
-        stream.write(prefix + ansiEscapes.eraseLines(previousLineCount));
+        // [mixdog fork] Reset SGR before erasing so stale style/background from
+        // the previous frame doesn't leak onto the cleared cells.
+        stream.write(prefix + '\u001B[0m' + ansiEscapes.eraseLines(previousLineCount));
         previousOutput = '';
         previousLineCount = 0;
         previousCursorPosition = undefined;
@@ -171,7 +173,17 @@ const createIncremental = (stream, { showCursor = false } = {}) => {
         if (visibleCount < previousVisible) {
             const previousHadTrailingNewline = previousOutput.endsWith('\n');
             const extraSlot = previousHadTrailingNewline ? 1 : 0;
-            buffer.push(ansiEscapes.eraseLines(previousVisible - visibleCount + extraSlot), ansiEscapes.cursorUp(visibleCount));
+            // [mixdog fork] Defensive erase on height shrink: clear ONE extra
+            // physical line beyond the counted delta. A hardware line-wrap (wide
+            // glyph at the viewport edge) can occupy a physical row the logical
+            // line count doesn't account for, leaving a ghost row below the new
+            // content. Not Windows-specific — the wrap desync happens on any
+            // terminal. We erase the extra line with eraseLine at the current
+            // (bottom) row FIRST — this does NOT move the cursor — then run the
+            // normal eraseLines walk. This keeps the post-erase cursor origin
+            // identical to upstream (cursorUp(visibleCount) still lands right),
+            // so only a stray trailing row is removed, layout is untouched.
+            buffer.push(ansiEscapes.eraseLine, ansiEscapes.eraseLines(previousVisible - visibleCount + extraSlot), ansiEscapes.cursorUp(visibleCount));
         }
         else {
             buffer.push(ansiEscapes.cursorUp(previousLines.length - 1));
@@ -205,7 +217,9 @@ const createIncremental = (stream, { showCursor = false } = {}) => {
     };
     render.clear = () => {
         const prefix = buildReturnToBottomPrefix(cursorWasShown, previousLines.length, previousCursorPosition);
-        stream.write(prefix + ansiEscapes.eraseLines(previousLines.length));
+        // [mixdog fork] Reset SGR before erasing so stale style/background from
+        // the previous frame doesn't leak onto the cleared cells.
+        stream.write(prefix + '\u001B[0m' + ansiEscapes.eraseLines(previousLines.length));
         previousOutput = '';
         previousLines = [];
         previousCursorPosition = undefined;

package/vendor/ink/build/wrap-text.js

@@ -1,6 +1,127 @@
 import wrapAnsi from 'wrap-ansi';
 import cliTruncate from 'cli-truncate';
+import stripAnsi from 'strip-ansi';
+import { AMBIGUOUS_WIDE, displayStringWidth } from './display-width.js';
 const cache = {};
+// [mixdog fork] wrap-ansi / cli-truncate measure with plain string-width, which
+// counts our problem glyphs (circled digits U+2460–U+24FF, arrows U+2190–U+21FF)
+// as 1 cell while the terminal draws 2. When the policy is ON, their column math
+// under-counts and a wrapped/truncated line can still overflow by one cell,
+// pushing content past the box edge (the ghosting/overlap). We can't cleanly
+// fork wrap-ansi, so we compensate at THIS boundary: re-check each produced line
+// with displayStringWidth. For wrap/hard modes the overflow is REFLOWED onto a
+// new line (no visible content is dropped); only truncate-end may cut.
+const PROBLEM_RE = /[\u2190-\u21ff\u2460-\u24ff]/;
+const ANSI_RE = /^\u001B(?:\[[0-9;]*m|\].*?(?:\u0007|\u001B\\))/;
+const segmenter = new Intl.Segmenter();
+// SGR reset — appended after a mid-line cut so an open style doesn't leak past
+// the split point onto the reflowed remainder / following cells.
+const SGR_RESET = '\u001B[0m';
+// OSC 8 hyperlink open (with a URL) and universal close. Cutting inside a link
+// must close it on head and re-open it on tail, exactly like an open SGR style.
+const OSC8_CLOSE = '\u001B]8;;\u0007';
+const OSC8_RE = /^\u001B\]8;;([^\u0007\u001B]*)(?:\u0007|\u001B\\)/;
+// Split one ANSI line at the first grapheme boundary where VISIBLE displayWidth
+// would exceed `max`. Walks grapheme CLUSTERS (not code points) so a clustered
+// glyph (e.g. `↔️` = U+2194 U+FE0F) is measured/kept whole. Returns
+// { head, tail }: head fits within max (with an SGR reset appended when any
+// style is still open at the cut so styling doesn't bleed); tail is the
+// remaining visible content, prefixed with the carried-over open SGR codes so
+// it renders with the same style it was cut from. ANSI escapes cost 0 width.
+const splitAtDisplayWidth = (line, max) => {
+    if (displayStringWidth(line) <= max)
+        return { head: line, tail: '' };
+    let head = '';
+    let width = 0;
+    let rest = line;
+    // Track SGR open codes seen so far so the tail can re-open them. An empty
+    // params reset ('' or '0') clears the carry; anything else accumulates.
+    let openSgr = '';
+    let sawOpenStyle = false;
+    // Track an open OSC 8 hyperlink (empty URL '...8;;\u0007' closes it).
+    let openLink = '';
+    while (rest.length > 0) {
+        const m = ANSI_RE.exec(rest);
+        if (m) {
+            head += m[0];
+            const sgr = /^\u001B\[([0-9;]*)m$/.exec(m[0]);
+            if (sgr) {
+                const params = sgr[1];
+                if (params === '' || params === '0') {
+                    openSgr = '';
+                    sawOpenStyle = false;
+                }
+                else {
+                    openSgr += m[0];
+                    sawOpenStyle = true;
+                }
+            }
+            else {
+                const osc = OSC8_RE.exec(m[0]);
+                if (osc)
+                    openLink = osc[1] ? m[0] : '';
+            }
+            rest = rest.slice(m[0].length);
+            continue;
+        }
+        const { segment } = segmenter.segment(rest)[Symbol.iterator]().next().value;
+        const w = displayStringWidth(segment);
+        // Progress guarantee: if nothing visible has landed on head yet, force
+        // the first grapheme through even when it alone exceeds max (a 1-cluster
+        // overflow is unavoidable and preferable to a zero-progress loop).
+        if (width + w > max && width > 0)
+            break;
+        head += segment;
+        width += w;
+        rest = rest.slice(segment.length);
+    }
+    // Close any style / link still open at the cut, and re-open on the tail.
+    if (openLink)
+        head += OSC8_CLOSE;
+    if (sawOpenStyle)
+        head += SGR_RESET;
+    const carry = openSgr + openLink;
+    const tail = rest.length > 0 ? carry + rest : '';
+    return { head, tail };
+};
+// wrap/hard: no visible content may be dropped. Repeatedly split each produced
+// line at the display-width budget and REFLOW the overflow onto following lines.
+const reflowToDisplayWidth = (line, max) => {
+    const out = [];
+    let cur = line;
+    while (displayStringWidth(cur) > max) {
+        const { head, tail } = splitAtDisplayWidth(cur, max);
+        // splitAtDisplayWidth now always advances (forces >=1 grapheme onto
+        // head), so head carries visible content and tail shrinks each pass.
+        // Belt-and-braces: if tail failed to shrink, flush the remainder. Push
+        // `head` (not raw `cur`) — head carries the SGR/OSC8 close sequences, so
+        // even a single overwide styled/linked glyph doesn't leak its style.
+        if (tail === '' || tail === cur) {
+            out.push(head || cur);
+            return out;
+        }
+        out.push(head);
+        cur = tail;
+    }
+    out.push(cur);
+    return out;
+};
+// truncate-end: cutting is the intended behavior — drop the overflow but still
+// cut on grapheme boundaries and close open styles.
+const hardCutToDisplayWidth = (line, max) => splitAtDisplayWidth(line, max).head;
+// Re-enforce the display-width budget on every produced line when the policy is
+// ON and the source contains a problem glyph. No-op otherwise (byte-identical
+// to upstream wrap-ansi output), so terminals without the wide policy are
+// unaffected.
+const enforceDisplayWidth = (wrapped, maxWidth, mode) => {
+    if (!AMBIGUOUS_WIDE || !PROBLEM_RE.test(stripAnsi(wrapped)))
+        return wrapped;
+    const lines = wrapped.split('\n');
+    if (mode === 'truncate')
+        return lines.map((line) => hardCutToDisplayWidth(line, maxWidth)).join('\n');
+    // wrap/hard: reflow overflow, never drop.
+    return lines.flatMap((line) => reflowToDisplayWidth(line, maxWidth)).join('\n');
+};
 const wrapText = (text, maxWidth, wrapType) => {
     const cacheKey = text + String(maxWidth) + String(wrapType);
     const cachedText = cache[cacheKey];
@@ -13,6 +134,7 @@ const wrapText = (text, maxWidth, wrapType) => {
             trim: false,
             hard: true,
         });
+        wrappedText = enforceDisplayWidth(wrappedText, maxWidth, 'wrap');
     }
     if (wrapType === 'hard') {
         wrappedText = wrapAnsi(text, maxWidth, {
@@ -20,6 +142,7 @@ const wrapText = (text, maxWidth, wrapType) => {
             hard: true,
             wordWrap: false,
         });
+        wrappedText = enforceDisplayWidth(wrappedText, maxWidth, 'wrap');
     }
     if (wrapType.startsWith('truncate')) {
         let position = 'end';
@@ -30,6 +153,8 @@ const wrapText = (text, maxWidth, wrapType) => {
             position = 'start';
         }
         wrappedText = cliTruncate(text, maxWidth, { position });
+        if (position === 'end')
+            wrappedText = enforceDisplayWidth(wrappedText, maxWidth, 'truncate');
     }
     cache[cacheKey] = wrappedText;
     return wrappedText;

package/scripts/_test-folder-dialog.mjs

@@ -1,30 +0,0 @@
-import { spawn } from 'node:child_process';
-import { readFileSync } from 'node:fs';
-
-const src = readFileSync('src/standalone/folder-dialog.mjs', 'utf8');
-const fn = src.match(/function powershellScript[\s\S]*?return \[([\s\S]*?)\]\.join/);
-if (!fn) throw new Error('parse failed');
-// Re-eval powershellScript by importing - use dynamic compile
-const modUrl = new URL('../src/standalone/folder-dialog.mjs', import.meta.url);
-// Call pickFolder with a hook - instead duplicate minimal import
-const { pickFolder } = await import(modUrl.href);
-
-const child = spawn('powershell.exe', [
-  '-NoLogo', '-NoProfile', '-STA', '-Command',
-  [
-    '$ErrorActionPreference = "Continue"',
-    'try {',
-    ...readFileSync('src/standalone/folder-dialog.mjs', 'utf8')
-      .split('\n')
-      .filter((l) => l.includes('Add-Type -AssemblyName') || l.includes('Add-Type -TypeDefinition') || l.includes('GetDialogOwnerCenter')),
-    '} catch { Write-Error $_; exit 1 }',
-  ].join('; '),
-], { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
-
-let err = '';
-child.stderr.on('data', (d) => { err += d.toString(); });
-child.on('close', (code) => {
-  console.log('code', code);
-  console.log(err.slice(0, 2000));
-});
-

package/scripts/fix-brief-fn.mjs

@@ -1,35 +0,0 @@
-import fs from "node:fs";
-const p = "src/runtime/shared/tool-surface.mjs";
-let s = fs.readFileSync(p, "utf8");
-const start = s.indexOf("export function summarizeAgentSurfaceBrief");
-const end = s.indexOf("function pluralize", start);
-if (start < 0 || end < 0) throw new Error("markers");
-const clean = `export function summarizeAgentSurfaceBrief(name, args, resultText, { isError = false, isResponse = false } = {}) {
-  const a = parseToolArgs(args);
-  const action = String(a?.type || a?.action || "").toLowerCase();
-  const text = String(resultText ?? "").trim();
-
-  if (isResponse && text) {
-    const fromResult = summarizeToolResult(name, args, text, isError);
-    if (fromResult) return truncateAgentSurfaceBrief(stripInlineMarkdown(fromResult));
-    const line = firstAgentResultLine(text);
-    if (line) return truncateAgentSurfaceBrief(stripInlineMarkdown(line));
-  }
-
-  const outbound = firstText(a?.prompt, a?.message);
-  if (outbound && (action === "spawn" || action === "send" || !action)) {
-    return truncateAgentSurfaceBrief(outbound);
-  }
-
-  if ((action === "spawn" || action === "send") && text && !isResponse) {
-    const fromResult = summarizeToolResult(name, args, text, isError);
-    if (fromResult) return truncateAgentSurfaceBrief(stripInlineMarkdown(fromResult));
-  }
-
-  return "";
-}
-
-`;
-s = s.slice(0, start) + clean + s.slice(end);
-fs.writeFileSync(p, s);
-console.log("summarizeAgentSurfaceBrief cleaned");

package/scripts/fix-format-tool-surface.mjs

@@ -1,24 +0,0 @@
-import fs from "node:fs";
-const p = "src/runtime/shared/tool-surface.mjs";
-let s = fs.readFileSync(p, "utf8");
-const block = `export function formatToolSurface(name, args, opts = {}) {
-  const parsed = parseToolArgs(args);
-  return {
-    label: displayToolName(name, parsed),
-    summary: summarizeToolArgs(name, parsed, opts),
-    normalizedName: normalizeToolName(name),
-    args: parsed,
-  };
-}
-
-`;
-while (s.includes(block)) {
-  s = s.replace(block, "");
-}
-const anchor = `/** Collapsed agent/worker surface card: one-line brief under the header (30-40 chars). */`;
-if (!s.includes(anchor)) throw new Error("anchor missing");
-if (!s.includes("export function formatToolSurface")) {
-  s = s.replace(anchor, block + anchor);
-}
-fs.writeFileSync(p, s);
-console.log("fixed formatToolSurface");

package/scripts/fix-tool-exec-visible.mjs

@@ -1,42 +0,0 @@
-import fs from "node:fs";
-const p = "src/tui/components/ToolExecution.jsx";
-let s = fs.readFileSync(p, "utf8");
-const bad = `  let visibleDetailLines = detailLines;
-  if (isSkillSurface && !showRawResult) {
-    visibleDetailLines = [];
-  } else if (isAgentSurfaceCard && !showRawResult) {
-    if (agentSurfaceBrief) {
-      visibleDetailLines = [agentSurfaceBrief];
-    } else if (pending) {
-      visibleDetailLines = [pendingDetailPlaceholder || 'Running'];
-    } else {
-      visibleDetailLines = [];
-    }
-  }
-  } else if (isAgentSurfaceCard && !showRawResult) {
-  } else if (isAgentSurfaceCard && !showRawResult) {
-    const agentDetailFallback = collapsedDetail
-      || (pending ? (pendingDetailPlaceholder || 'Running') : 'Finished');
-    const agentDetailLine = agentSurfaceBrief
-      || truncateToWidth(String(agentDetailFallback), Math.min(AGENT_SURFACE_BRIEF_MAX, maxResultChars));
-    visibleDetailLines = [agentDetailLine];
-  }`;
-const good = `  let visibleDetailLines = detailLines;
-  if (isSkillSurface && !showRawResult) {
-    visibleDetailLines = [];
-  } else if (isAgentSurfaceCard && !showRawResult) {
-    const agentDetailFallback = collapsedDetail
-      || (pending ? (pendingDetailPlaceholder || 'Running') : 'Finished');
-    const agentDetailLine = agentSurfaceBrief
-      || truncateToWidth(String(agentDetailFallback), Math.min(AGENT_SURFACE_BRIEF_MAX, maxResultChars));
-    visibleDetailLines = [agentDetailLine];
-  }`;
-if (s.includes(bad)) {
-  s = s.replace(bad, good);
-  fs.writeFileSync(p, s);
-  console.log("ToolExecution fixed");
-} else if (s.includes("agentDetailFallback")) {
-  console.log("ToolExecution already ok");
-} else {
-  throw new Error("ToolExecution pattern not found");
-}