mixdog 0.9.1 → 0.9.2

package/vendor/ink/build/ink.js

@@ -85,7 +85,7 @@ const stripKittyQueryResponsesAndTrailingPartial = (buffer) => {
 // desynchronizes the incremental erase used for frames that exactly fill the
 // 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';
+const isWindowsConsole = process.platform === 'win32' || Boolean(process.env.WT_SESSION);
 const shouldClearTerminalForFrame = ({ isTty, viewportRows, previousOutputHeight, nextOutputHeight, isUnmounting, }) => {
     if (!isTty) {
         return false;
@@ -336,7 +336,9 @@ export default class Ink {
                 a.y2 === rect.y2 &&
                 a.clipY1 === rect.clipY1 &&
                 a.clipY2 === rect.clipY2 &&
-                a.captureText === rect.captureText);
+                a.captureText === rect.captureText &&
+                a.selectionForeground === rect.selectionForeground &&
+                a.selectionBackground === rect.selectionBackground);
         if (same) {
             if (!options.immediate) {
                 return;
@@ -380,9 +382,22 @@ export default class Ink {
         });
     };
     // [mixdog fork] Given a 0-based cell (x, y), return the inclusive rect of the
-    // word (maximal run of non-whitespace cells) on that single row, or null if
-    // the cell is whitespace/empty or out of range. Reuses the cached cell-value
-    // rows from the last render so it works without retaining the Output instance.
+    // word at that cell on that single row, or null if the cell is whitespace/empty
+    // or out of range. Reuses the cached cell-value rows from the last render so it
+    // works without retaining the Output instance.
+    //
+    // Ported from claude-code's selection.ts charClass/wordBoundsAt (3-class word
+    // model) onto mixdog's rect(linear) infra. Instead of a naive "non-space run",
+    // expansion stops at a CHARACTER-CLASS change:
+    //   class 1 = WORD_CHAR — letters (any script), digits, and the punctuation
+    //             iTerm2 treats as word-part by default (/-+~_.\), so a path like
+    //             `/usr/bin/bash` or `~/.claude/config.json` selects whole.
+    //   class 2 = other punctuation — so `->` selects just `->`, not the words
+    //             on either side.
+    //   class 0 = space/empty. claude-code treats a space run as selectable
+    //             (class 0), but mixdog intentionally returns null on empty/space
+    //             so a double-click on blank does nothing (safer for our transcript
+    //             where most alt-screen cells are padding).
     getWordRectAt = (x, y) => {
         const rows = this.lastPlainRows;
         if (!rows)
@@ -390,16 +405,89 @@ export default class Ink {
         const cells = rows[y];
         if (!Array.isArray(cells))
             return null;
-        const isWordChar = (v) => !!v && !/^\s$/u.test(v);
-        if (!isWordChar(cells[x]))
+        // Unicode-aware word-char set (matches selection.ts WORD_CHAR).
+        const WORD_CHAR = /[\p{L}\p{N}_/.\-+~\\]/u;
+        const charClass = (v) => {
+            if (!v || v === ' ')
+                return 0;
+            return WORD_CHAR.test(v) ? 1 : 2;
+        };
+        // [mixdog fork] Wide/CJK glyphs occupy 2+ grid cells: the HEAD cell
+        // holds the glyph and each TRAILING cell is stored as '' (spacer tail)
+        // carrying the glyph's styles — see output.js ~L237-243 for how wide
+        // chars are laid into the grid. A '' cell is a wide-char TAIL only when
+        // it directly follows a non-empty non-space glyph (class !== 0); a ''
+        // after '' or after a space is genuine blank padding. This mirrors
+        // selection.ts wordBoundsAt's SpacerTail step-back (L172-178) and
+        // expansion step-over (L206-221) on mixdog's string-cell grid.
+        const isWideTail = (i) => i > 0 && cells[i] === '' && charClass(cells[i - 1]) !== 0;
+        // On entry: if the click landed on a spacer tail, step back to the head
+        // so charClass sees the actual glyph. Genuine blank padding is left
+        // alone, preserving the null-on-blank behavior below.
+        let sx = x;
+        if (isWideTail(sx))
+            sx = sx - 1;
+        const cls = charClass(cells[sx]);
+        // Preserve mixdog's null-on-space/empty behavior (class 0).
+        if (cls === 0)
             return null;
-        let x1 = x, x2 = x;
-        while (x1 - 1 >= 0 && isWordChar(cells[x1 - 1]))
-            x1--;
-        while (x2 + 1 < cells.length && isWordChar(cells[x2 + 1]))
-            x2++;
+        let x1 = sx, x2 = sx;
+        // Expand left: step OVER a spacer tail to the wide-char head and include
+        // both columns when the head matches the class; otherwise stop at a
+        // class change.
+        while (x1 - 1 >= 0) {
+            const p = x1 - 1;
+            if (isWideTail(p)) {
+                if (p - 1 >= 0 && charClass(cells[p - 1]) === cls) {
+                    x1 = p - 1;
+                    continue;
+                }
+                break;
+            }
+            if (charClass(cells[p]) === cls) {
+                x1 = p;
+                continue;
+            }
+            break;
+        }
+        // Expand right: INCLUDE a spacer tail that follows an in-run glyph so x2
+        // covers the wide glyph's full width; otherwise stop at a class change.
+        while (x2 + 1 < cells.length) {
+            const n = x2 + 1;
+            if (isWideTail(n)) {
+                x2 = n;
+                continue;
+            }
+            if (charClass(cells[n]) === cls) {
+                x2 = n;
+                continue;
+            }
+            break;
+        }
         return { x1, y1: y, x2, y2: y };
     };
+    // [mixdog fork] Given a 0-based row y, return the inclusive rect of the whole
+    // logical line at that row (mirrors claude-code's selectLineAt intent on
+    // mixdog's rect infra). x1 is always 0; x2 is the last non-space content cell
+    // so trailing padding isn't selected. Returns null for an empty/blank row.
+    // Exposed symmetrically to getWordRectAt (index.jsx wires it into the store).
+    getLineRectAt = (y) => {
+        const rows = this.lastPlainRows;
+        if (!rows)
+            return null;
+        const cells = rows[y];
+        if (!Array.isArray(cells))
+            return null;
+        let x2 = -1;
+        for (let x = 0; x < cells.length; x++) {
+            const v = cells[x];
+            if (v && !/^\s$/u.test(v))
+                x2 = x;
+        }
+        if (x2 < 0)
+            return null;
+        return { x1: 0, y1: y, x2, y2: y };
+    };
     restoreLastOutput = () => {
         if (!this.interactive) {
             return;

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

@@ -1,4 +1,7 @@
-import widestLine from 'widest-line';
+// [mixdog fork] use the shared display-width policy so ink's text measurement
+// matches OUR wrap/row math for circled digits / arrows. Kept in sync with
+// src/tui/display-width.mjs.
+import { displayWidestLine as widestLine } from './display-width.js';
 const cache = new Map();
 const measureText = (text) => {
     if (text.length === 0) {

package/vendor/ink/build/output.js

@@ -1,6 +1,41 @@
 import sliceAnsi from 'slice-ansi';
-import stringWidth from 'string-width';
 import { styledCharsFromTokens, styledCharsToString, tokenize, } from '@alcalzone/ansi-tokenize';
+// [mixdog fork] use the shared display-width policy so ink's per-character
+// advance + width cache treat circled digits / arrows as 2 cells under Windows
+// Terminal, matching OUR wrap/row math. See display-width.js (kept in sync with
+// src/tui/display-width.mjs).
+import { displayStringWidth as stringWidth } from './display-width.js';
+const RGB_COLOR_RE = /^rgb\(\s*(\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\s*\)$/;
+const rgbStyle = (value, type, fallback) => {
+    const match = RGB_COLOR_RE.exec(String(value || ''));
+    const parts = match
+        ? match.slice(1, 4).map(part => Math.max(0, Math.min(255, Number(part) || 0)))
+        : fallback;
+    const sgr = type === 'foreground' ? 38 : 48;
+    const reset = type === 'foreground' ? '\x1b[39m' : '\x1b[49m';
+    return { code: `\x1b[${sgr};2;${parts[0]};${parts[1]};${parts[2]}m`, endCode: reset };
+};
+const intersectClips = (clips) => {
+    if (clips.length === 0) {
+        return undefined;
+    }
+    const out = {};
+    for (const clip of clips) {
+        if (typeof clip?.x1 === 'number') {
+            out.x1 = typeof out.x1 === 'number' ? Math.max(out.x1, clip.x1) : clip.x1;
+        }
+        if (typeof clip?.x2 === 'number') {
+            out.x2 = typeof out.x2 === 'number' ? Math.min(out.x2, clip.x2) : clip.x2;
+        }
+        if (typeof clip?.y1 === 'number') {
+            out.y1 = typeof out.y1 === 'number' ? Math.max(out.y1, clip.y1) : clip.y1;
+        }
+        if (typeof clip?.y2 === 'number') {
+            out.y2 = typeof out.y2 === 'number' ? Math.min(out.y2, clip.y2) : clip.y2;
+        }
+    }
+    return out;
+};
 class OutputCaches {
     widths = new Map();
     blockWidths = new Map();
@@ -112,10 +147,19 @@ export default class Output {
                 const { text, transformers } = operation;
                 let { x, y } = operation;
                 let lines = text.split('\n');
-                const clip = clips.at(-1);
+                // [mixdog fork] Nested overflow:hidden boxes must be clipped to
+                // the INTERSECTION of every active ancestor clip. Using only the
+                // innermost clip lets child components such as ToolExecution /
+                // TurnDone (which have their own overflow hidden rows) escape the
+                // transcript viewport and paint over command/prompt/status rows.
+                const clip = intersectClips(clips);
                 if (clip) {
                     const clipHorizontally = typeof clip?.x1 === 'number' && typeof clip?.x2 === 'number';
                     const clipVertically = typeof clip?.y1 === 'number' && typeof clip?.y2 === 'number';
+                    if ((clipHorizontally && clip.x2 <= clip.x1) ||
+                        (clipVertically && clip.y2 <= clip.y1)) {
+                        continue;
+                    }
                     // If text is positioned outside of clipping area altogether,
                     // skip to the next operation to avoid unnecessary calculations
                     if (clipHorizontally) {
@@ -218,15 +262,34 @@ export default class Output {
         // dim text, and status colors do not bleed through.
         const sel = this.selection;
         let selectedText = null;
+        // [mixdog fork] noSelect exclusion (claude-code skips gutter / line-number
+        // / diff-sigil cells from both highlight and copy via screen.noSelect):
+        // mixdog's cell model has NO noSelect marker — the Output grid stores only
+        // {value, styles} per cell, with no flag distinguishing gutter cells from
+        // content. Inferring gutters from position/content would be a fragile
+        // heuristic (line numbers, diff +/- sigils, and real content are
+        // indistinguishable at the cell level), so this is deliberately NOT
+        // implemented. It needs a noSelect bit threaded through the render
+        // pipeline before it can be done cleanly.
         if (sel) {
             const captureSelectedText = sel.captureText !== false;
             if (!captureSelectedText) {
                 selectedText = undefined;
             }
-            const selectionStyles = [
-                { code: '', endCode: '' },
-                { code: '', endCode: '' },
-            ];
+            // [mixdog fork] Port applySelectionOverlay's fg-preserving principle
+            // from claude-code's selection.ts: REPLACE only the background and
+            // PRESERVE each cell's own foreground/attribute styles, so syntax
+            // highlighting, OSC-8 links, and dim text stay readable under the
+            // selection. The old code forced a black fg + light bg, flattening
+            // every colored glyph to one color. selectionForeground is now
+            // intentionally unused (kept in the setter API for compatibility).
+            const selectionBg = rgbStyle(sel.selectionBackground, 'background', [245, 245, 245]);
+            // A style entry sets the background when its opening SGR code begins
+            // with a background parameter: 40-47 (basic), 48 (256/truecolor),
+            // 49 (default), or 100-107 (bright). ansi-tokenize emits one entry
+            // per SGR attribute, so a prefix test on `.code` cleanly isolates the
+            // bg-only entries we want to drop before appending the selection bg.
+            const isBackgroundStyle = (s) => typeof s?.code === 'string' && /^\x1b\[(?:4[0-9]|10[0-7])[;m]/.test(s.code);
             const linear = sel.mode === 'linear';
             const start = linear && (sel.y1 > sel.y2 || (sel.y1 === sel.y2 && sel.x1 > sel.x2))
                 ? { x: sel.x2, y: sel.y2 }
@@ -281,9 +344,16 @@ export default class Output {
                     if (contentStart === -1 || x < contentStart || x > contentEnd) {
                         continue;
                     }
+                    // [mixdog fork] fg-preserving highlight: keep the cell's own
+                    // style entries (foreground color, bold/dim/underline, link
+                    // attrs) and swap ONLY the background. Drop any existing
+                    // background entry so the two bgs don't fight, then append the
+                    // selection bg last so it wins for this cell.
+                    const baseStyles = Array.isArray(cell.styles) ? cell.styles : [];
+                    const preserved = baseStyles.filter(style => !isBackgroundStyle(style));
                     row[x] = {
                         ...cell,
-                        styles: selectionStyles,
+                        styles: [...preserved, selectionBg],
                     };
                 }
                 // Trailing spaces in a selected row are padding, not content.
@@ -302,6 +372,20 @@ export default class Output {
                 while (selRows.length > 0 && selRows[selRows.length - 1].trim() === '') {
                     selRows.pop();
                 }
+                // [mixdog fork] SOFT-WRAP JOIN (claude-code getSelectedText):
+                // claude-code rejoins word-wrapped continuation rows into one
+                // logical line using screen.softWrap, a per-row bitmap set at
+                // wrap time marking a row as a continuation of the one above.
+                // mixdog's rect(linear) render model carries NO softWrap metadata
+                // — the Output grid is a flat array of visual rows with no record
+                // of which line breaks were inserted by wrapping vs. present in
+                // the source. Detecting "this row filled to content width AND the
+                // next continues the same logical block" from cell values alone is
+                // a guess (a source line that legitimately fills the width would be
+                // wrongly glued to the next). Per the correctness-over-cleverness
+                // rule we keep the honest per-visual-row '\n' join rather than
+                // fabricate wrap boundaries. Revisit if the render pipeline starts
+                // emitting a softWrap bit per row.
                 selectedText = selRows.join('\n');
             }
         }
@@ -317,8 +401,30 @@ export default class Output {
         const generatedOutput = output
             .map(line => {
             // See https://github.com/vadimdemedes/ink/pull/564#issuecomment-1637022742
-            const lineWithoutEmptyItems = line.filter(item => item !== undefined);
-            return styledCharsToString(lineWithoutEmptyItems).trimEnd();
+            // [mixdog fork] Keep the serialized row inside Output.width as a
+            // final invariant. Component-level width budgeting can miss
+            // background fills, resize races, or wide-char edge cases; if the
+            // terminal receives a row wider than its modeled width it may
+            // soft-wrap/scroll outside Ink's cursor-origin model.
+            const lineWithinWidth = [];
+            let usedWidth = 0;
+            for (const item of line) {
+                if (item === undefined) {
+                    continue;
+                }
+                const value = item.value ?? '';
+                if (value === '') {
+                    lineWithinWidth.push(item);
+                    continue;
+                }
+                const itemWidth = Math.max(1, this.caches.getStringWidth(value));
+                if (usedWidth + itemWidth > this.width) {
+                    break;
+                }
+                lineWithinWidth.push(item);
+                usedWidth += itemWidth;
+            }
+            return styledCharsToString(lineWithinWidth).trimEnd();
         })
             .join('\n');
         return {

package/vendor/ink/build/render-node-to-output.js

@@ -1,4 +1,7 @@
-import widestLine from 'widest-line';
+// [mixdog fork] use the shared display-width policy so the wrap decision here
+// agrees with measure-text.js and output.js. Kept in sync with
+// src/tui/display-width.mjs.
+import { displayWidestLine as widestLine } from './display-width.js';
 import indentString from 'indent-string';
 import Yoga from 'yoga-layout';
 import wrapText from './wrap-text.js';

package/vendor/ink/build/render.js

@@ -41,6 +41,10 @@ const render = (node, options) => {
         getSelectionText: () => instance.selectedText,
         // [mixdog fork] resolve the word rect at a cell for double-click select.
         getWordRectAt: (x, y) => instance.getWordRectAt(x, y),
+        // [mixdog fork] resolve the whole-line rect at a row for triple-click /
+        // line select. Symmetric to getWordRectAt; index.jsx wires it into the
+        // store as store.getLineRectAt.
+        getLineRectAt: (y) => instance.getLineRectAt(y),
     };
 };
 export default render;

package/src/output-styles/extreme-simple.md

@@ -1,20 +0,0 @@
----
-name: extreme-simple
-title: Extreme Simple
-description: Ultra-short completion sentence
-aliases: extreme, extreme simple
-keep-coding-instructions: true
----
-
-# Output Style
-
-Extreme — one ultra-short completion sentence. The most minimal of the styles.
-
-- Reply with a single completion sentence whenever possible.
-- Preferred pattern: `<target> 변경되었습니다. <verification> 통과 완료입니다.`
-- If verification was not run, use one short sentence saying the change is done
-  and verification was not run.
-- No headings, bullets, labels, explanations, tool traces, or metadata unless
-  the user explicitly asks.
-- Preserve only the single decisive path, command, symbol, API name, code, or
-  error verbatim.

package/src/rules/lead/04-workflow.md

@@ -1,51 +0,0 @@
-# Workflow
-
-Priority:
-- When an `# Active Workflow` block is present, it is the binding session
-  workflow and takes precedence over all other workflow guidance.
-
-Delegation:
-- Lead is the supervisor of agents, responsible for task delegation,
-  coordination, judgment, and final decisions.
-- As supervisor, prefer delegating implementation work to an agent; keep direct
-  work limited to coordination and User Workflow exceptions such as
-  one-or-two-step edits, pre-planning, config changes, and final git deployment.
-- Implementation edits to product/runtime/TUI code MUST be delegated to a
-  Worker/Heavy Worker, even when small. Lead may directly edit only rules, docs,
-  config, and final deployment/git steps, unless the user explicitly asks Lead
-  to patch directly.
-- Delegation split: different code paths / entry points / file groups are
-  separate scopes — implementation AND analysis, review, debugging split the
-  same way. With 2+ independent scopes, spawn each scoped agent in the
-  SAME turn, not one after another. Shared functions or cross-cutting concerns
-  do NOT justify collapsing them into one delegation: split per path, and Lead
-  verifies the cross-cutting parts (shared state, telemetry consistency, etc.)
-  directly. "One agent must see the whole context" is not a valid reason to
-  merge; the only legitimate single-scope case is a genuinely inseparable
-  dependency — and then state the reason.
-- Follow-up work on the same path or scope MUST reuse the existing agent (same
-  tag). Spawn a new agent only for a genuinely separate scope.
-- Pick the agent role defined in the User Workflow section that fits the task
-  (worker, heavy-worker, reviewer, debugger, …) when spawning.
-- Write agent-facing briefs and follow-up task messages in English.
-- Agent briefs must be bounded: state the goal/success criteria, known starting
-  files or anchors if available, allowed/forbidden changes, expected
-  deliverable, and verification boundary. For heavy-worker, include known first
-  components to inspect and the stopping condition; complex work must not
-  become open-ended.
-
-Agent lifecycle:
-- After spawning async agent(s), END THE TURN immediately. Do not poll
-  status/read, guess the outcome, or start dependent work — treat the result as
-  unknown until the completion notification resumes you. status/read are manual
-  recovery only, never progress checks.
-- Unless instructed otherwise, wait for the spawned agent(s); once their results
-  are collected, automatically continue with the next turn.
-
-Agent result handling:
-- Cross-check material agent responses before using them for decisions or
-  summarizing them to the user.
-- When an agent returns, always synthesize its result into a concise report for
-  the user (outcome + key changes/evidence). Never forward the raw agent output.
-- If anything here conflicts with the User Workflow section, this Workflow takes
-  precedence, except that the `# Active Workflow` block always wins.

package/src/workflows/default/workflow.json

@@ -1,13 +0,0 @@
-{
-  "id": "default",
-  "name": "Default",
-  "description": "Default Mixdog agent workflow.",
-  "entry": "WORKFLOW.md",
-  "agents": [
-    "maintainer",
-    "worker",
-    "heavy-worker",
-    "reviewer",
-    "debugger"
-  ]
-}

package/src/workflows/solo/workflow.json

@@ -1,7 +0,0 @@
-{
-  "id": "solo",
-  "name": "Solo",
-  "description": "Lead-only workflow; delegation to any agent is forbidden.",
-  "entry": "WORKFLOW.md",
-  "agents": []
-}