mixdog 0.9.140 → 0.9.142

package/src/runtime/agent/orchestrator/tools/builtin/read-single-tool.mjs

@@ -20,9 +20,8 @@ function snapshotBodyWasReturnedByRead(snapshot) {
         || source.startsWith('apply_patch_');
 }
 
-// BOM-only read-encoding detection. Mirrors CC fileRead.ts:34
-// (buffer[0]===0xff && buffer[1]===0xfe -> 'utf16le') / file.ts
-// detectFileEncoding. STRICTLY a leading-BOM rule — no content sniffing
+// BOM-only read-encoding detection: buffer[0]===0xff && buffer[1]===0xfe
+// means 'utf16le', and so on. STRICTLY a leading-BOM rule — no content sniffing
 // and no heuristic fallback.
 // Returns the decoder name plus the BOM byte length to strip before
 // decoding. utf8-with-BOM (EF BB BF) keeps the utf-8 decoder; its leading

package/src/runtime/agent/orchestrator/tools/builtin/read-special-files.mjs

@@ -170,7 +170,7 @@ export async function extractIpynbText(fullPath, { maxOutputBytes = DEFAULT_READ
                         const rawTxt = data['text/plain']
                             ? (Array.isArray(data['text/plain']) ? data['text/plain'].join('') : data['text/plain'])
                             : (Array.isArray(out.text) ? out.text.join('') : out.text);
-                        // Port CC behaviour: a single huge output is replaced
+                        // A single huge output is replaced
                         // with a jq hint rather than dumped inline.
                         if (typeof rawTxt === 'string' && rawTxt.length > IPYNB_OUTPUT_MAX_CHARS) {
                             block += `\n# Output: [large output omitted — ${rawTxt.length} chars; inspect with: cat "${fullPath}" | jq '.cells[${cellIndex}].outputs']`;

package/src/runtime/agent/orchestrator/tools/builtin/read-tool.mjs

@@ -116,7 +116,7 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
         _recordReadSnapshot,
         READ_MAX_OUTPUT_BYTES,
     } = helpers;
-    // CC `file_path` alias — official SDK schema uses `file_path`;
+    // `file_path` alias — the official SDK schema uses `file_path`;
     // mixdog has historically used `path`. Honor `file_path` so a
     // CC-trained agent's call shape works without translation.
     const usedFilePathAlias = typeof args.file_path === 'string' && !args.path;
@@ -232,8 +232,8 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
         // result is sliced back into the original per-entry windows
         // for response assembly. Non-same-path entries are untouched.
         const rawEntries = args.path.map((r) => {
-            // CC `file_path` alias on a per-entry batch: file_path is
-            // 1-based (CC schema), so decrement a positive offset to
+            // `file_path` alias on a per-entry batch: file_path is
+            // 1-based (SDK schema), so decrement a positive offset to
             // match the 0-based `path` form. Mirrors the scalar
             // alias adjustment at line 57.
             const entryUsesFilePathAlias = typeof r?.file_path === 'string' && !r?.path;

package/src/runtime/agent/orchestrator/tools/shell-command.mjs

@@ -599,7 +599,7 @@ export function execShellCommand({
       if (grace.unref) grace.unref();
     };
     child.once('exit', _onChildExit);
-    // Auto-background transition (CC startBackgrounding analogue). Two triggers
+    // Auto-background transition. Two triggers
     // resolve the call immediately with a 'backgrounded' result while the
     // child keeps running, adopted into the shell-jobs registry but still
     // owned by this CLI process:
@@ -904,7 +904,7 @@ export function execShellCommand({
     if (abortSignal) {
       abortHandler = () => {
         // Interrupt (the user typed a NEW message while this was running) is a
-        // "also look at this" signal, not "stop that" — CC backgrounds instead
+        // "also look at this" signal, not "stop that" — it backgrounds instead
         // of killing there, and throwing away a long build the user never asked
         // to stop is the worse outcome. Explicit cancellation (ESC) keeps the
         // kill. The promotion reuses the timeout path's guards verbatim so a

package/src/runtime/agent/orchestrator/tools/shell-exec-output.mjs

@@ -337,7 +337,7 @@ export class TaskOutput {
   }
 
   // Direct mode has no JS write path, so byte counters must come from the
-  // filesystem (CC "poll the file tail" analogue).
+  // filesystem (a "poll the file tail" approach).
   _refreshDirectSizes() {
     if (!this.direct) return;
     try { this.stdoutFileSize = statSync(this.stdoutPath).size; } catch {}
@@ -531,7 +531,7 @@ export class ExecResult {
     // renderer in builtin/bash-tool.mjs turns this into a model-visible marker.
     this.failurePhase = opts.failurePhase || null;
     this.failureReason = opts.failureReason || null;
-    // Auto-background transition (CC startBackgrounding analogue). When a
+    // Auto-background transition. When a
     // foreground command outlives autoBackgroundMs the call settles with
     // backgrounded:true + the jobId for manual task control. The
     // child stays owned by the CLI process; stdout/stderr keep flowing to

package/src/runtime/agent/orchestrator/tools/shell-policy.mjs

@@ -55,7 +55,7 @@ const BLOCKED_PATTERNS = [
   // cmd `del /s` / `rd /s`) are NOT blocked outright — each is target-checked
   // by a dedicated guard below via _isDangerousDeleteTarget, blocking only
   // filesystem-root / home / top-level-system / whole-cwd targets (CC-level).
-  // `git reset --hard` is likewise no longer hard-blocked (CC prompts; the
+  // `git reset --hard` is likewise no longer hard-blocked (a prompt suffices; the
   // agent workflow already gates destructive git ops).
   // Bare `git push --force` (and `--force=`) still blocks; the safer
   // `--force-with-lease` / `--force-if-includes` variants pass.

package/src/runtime/channels/lib/parent-bridge.mjs

@@ -28,11 +28,11 @@ function setChannelNotifySink(fn) {
 
 function createParentBridge({ getInstanceId, ipcProcess = process }) {
   function sendNotifyToParent(method, params) {
-    // CC channel schema requires meta: Record<string,string> (channelNotification.ts).
+    // The channel schema requires meta: Record<string,string>.
     // Coerce every meta value to string so a non-string (e.g. a Discord
     // interaction.type number) can't fail zod and silently drop the notify.
     // silent_to_agent stays boolean — an internal routing flag the daemon
-    // router / agentNotify consume (=== true) before the CC zod boundary.
+    // router / agentNotify consume (=== true) before the zod boundary.
     const outParams = normalizeChannelNotifyParams(method, params);
     if (_notifySink) {
       try { _notifySink(method, outParams); }

package/src/runtime/channels/lib/runtime-paths.mjs

@@ -289,7 +289,7 @@ function refreshActiveInstance(instanceId, meta, options) {
         }
         preservedExtra.gateway_server_pid = prevGatewayServerPid;
         // Clear session-scoped gateway metrics when the transcript changes —
-        // a new CC session must not inherit the previous session's context
+        // a new session must not inherit the previous session's context
         // usage before the gateway re-advertises.
         const metricTranscript =
           typeof prevForPreserve?.gateway_transcript_path === 'string' && prevForPreserve.gateway_transcript_path

package/src/standalone/agent-tool/shard-spread.mjs

@@ -611,9 +611,11 @@ export function createAgentShardSpread({ mgr, log = null } = {}) {
   const createRemoteSession = createRemoteAgentSession;
   const remote = (id) => handles.get(String(id || '')) || null;
 
-  // mgr facade: prototype delegation keeps every manager method reachable;
-  // only session-addressed methods gain the remote-handle routing.
-  const wrapped = Object.create(mgr);
+  // mgr is normally an ESM module namespace. Copy its enumerable exports onto
+  // a writable facade before overriding the session-addressed methods. Using
+  // the namespace as a prototype makes assignment hit its immutable exports
+  // under Node 24 (Electron 41), so even `wrapped.getSession = ...` throws.
+  const wrapped = Object.assign(Object.create(null), mgr);
   wrapped.getSession = (id) => {
     const handle = remote(id);
     return handle ? handle.facade : mgr.getSession(id);

package/src/standalone/agent-tool/shard-spread.test.mjs

@@ -1,7 +1,22 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
 
-import { remoteTurnHandoffReady } from './shard-spread.mjs';
+import { createAgentShardSpread, remoteTurnHandoffReady } from './shard-spread.mjs';
+
+test('manager wrapper owns writable overrides when the source manager is immutable', () => {
+  const localSession = { id: 'local-session' };
+  const createSession = () => localSession;
+  const mgr = Object.freeze({
+    createSession,
+    getSession: (id) => (id === localSession.id ? localSession : null),
+  });
+
+  const spread = createAgentShardSpread({ mgr });
+
+  assert.equal(Object.hasOwn(spread.mgr, 'getSession'), true);
+  assert.equal(spread.mgr.getSession(localSession.id), localSession);
+  assert.equal(spread.mgr.createSession, createSession);
+});
 
 test('remote turn waits through the turndone-to-save gap for assistant content', () => {
   assert.equal(remoteTurnHandoffReady({

package/src/tui/App.jsx

@@ -104,7 +104,7 @@ import {
   TRANSCRIPT_MEASURED_ROWS,
   selectionRectsEqual,
   shiftSelectionRectY,
-  comparePoints,
+  compareCellOrder,
   upperBound,
   resolveAnchorScrollOffset,
   transcriptItemVariantKey,
@@ -641,8 +641,8 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false, on
   // | null. Press decides it; motion/release stay in that region.
   // anchorSpan: for word/line multi-click selections, the initial word/line
   // bounds ({ lo:{x,y}, hi:{x,y}, kind:'word'|'line' }) so a subsequent drag
-  // extends the selection whole-word/whole-line from that span (see selection.ts
-  // extendSelection). Null ⇔ ordinary char-drag selection.
+  // extends the selection whole-word/whole-line from that span. Null ⇔ an
+  // ordinary char-drag selection.
   const dragRef = useRef({ anchor: null, anchorScroll: 0, last: null, active: false, rect: null, region: null, anchorSpan: null });
   const transcriptViewportRef = useRef({ top: 0, bottom: 0 });
   const panelTransitionRef = useRef({ signature: '', reserve: 0, clearRows: 0, guardRows: 0, epoch: 0 });

package/src/tui/app/transcript-window.mjs

@@ -135,11 +135,10 @@ export function shiftSelectionRectY(rect, deltaY) {
   return { ...rect, y1: rect.y1 + dy, y2: rect.y2 + dy };
 }
 
-// Reading-order compare (row then col): -1 if a<b, 1 if a>b, 0 equal.
-export function comparePoints(a, b) {
-  if (a.y !== b.y) return a.y < b.y ? -1 : 1;
-  if (a.x !== b.x) return a.x < b.x ? -1 : 1;
-  return 0;
+// Reading order over grid cells: the row decides, the column breaks ties.
+// Returns the sign of the difference, so it drops straight into comparisons.
+export function compareCellOrder(a, b) {
+  return a.y === b.y ? Math.sign(a.x - b.x) : Math.sign(a.y - b.y);
 }
 
 

package/src/tui/app/use-mouse-input.mjs

@@ -590,7 +590,7 @@ export function useMouseInput({
           const now = Date.now();
           // Shift+click on an existing word/line (anchorSpan) selection extends
           // that selection by whole words/lines to the click point, preserving
-          // the original anchor span (mirrors selection.ts extendSelection).
+          // the original anchor span.
           if (
             extendHeld
             && dragRef.current.region === region
@@ -660,7 +660,7 @@ export function useMouseInput({
             // words/lines from this span (see buildSpanRect). Leave the drag
             // ARMED (active:true): a release without motion keeps this highlight
             // (buildSpanRect returns the span for an in-span target), while
-            // any motion extends it. Mirrors selectWordAt/selectLineAt setting
+            // any motion extends it. The word/line select sets
             // isDragging=true + anchorSpan; the mouse-up finalizes.
             const kind = clickCount === 2 ? 'word' : 'line';
             const wr = kind === 'word' ? store.getWordRectAt?.(x, y) : store.getLineRectAt?.(y);

package/src/tui/app/use-transcript-scroll.mjs

@@ -16,7 +16,7 @@ import {
   accumulateDirectionalScrollDelta,
   selectionRectsEqual,
   shiftSelectionRectY,
-  comparePoints,
+  compareCellOrder,
   upperBound,
   transcriptRowAt,
 } from './transcript-window.mjs';
@@ -101,7 +101,7 @@ export function useTranscriptScroll({
   // Synchronous sibling of harvestStitchRowsSoon: snapshot the rows CURRENTLY
   // under the selection into the stitch buffer immediately, keyed by the given
   // (pre-scroll) offset. Called right before a scroll shifts those rows out of
-  // view — mirrors selection.ts captureScrolledRows, which grabs the outgoing
+  // view — the harvest has to grab the outgoing
   // rows BEFORE scrollBy overwrites them. The deferred harvest could never see
   // rows that a fast drag/wheel scrolled past between paint and its setTimeout.
   // selectionRows is harvested by the renderer UNCONDITIONALLY (even on the
@@ -373,35 +373,43 @@ export function useTranscriptScroll({
     };
   }, []);
 
-  // Port of selection.ts extendSelection onto the linear-rect model, hoisted to
-  // component scope so BOTH the mouse handler (motion/release) AND the
-  // auto-scroll path (scrollTranscriptRows) can rebuild a span-aware rect. Grows
-  // a word/line multi-click selection from its anchor span to the word/line under
-  // the cursor: target ends before the span → extend backward (span.hi→targetLo);
-  // target starts after → extend forward (span.lo→targetHi); overlapping → the
-  // span. The moving end snaps to the word (getWordRectAt) or line (getLineRectAt)
-  // at the cursor; a miss (blank/gutter) falls back to the raw cell. spanScroll
-  // re-anchors the span to the current transcript scroll (status never scrolls) so
-  // the original word/line tracks the content while dragging/auto-scrolling.
+  // Grow a word/line multi-click selection from its anchor span out to the
+  // word/line under the cursor. Hoisted to component scope so BOTH the mouse
+  // handler (motion/release) AND the auto-scroll path can rebuild a span-aware
+  // rect. The moving end snaps to the word or line under the cursor and falls
+  // back to the raw cell on a miss; spanScroll re-anchors the stored span to
+  // the current transcript scroll (the status band never scrolls) so the
+  // original word keeps tracking its content while dragging or auto-scrolling.
   const buildSpanRect = useCallback((span, x, y, region, spanScroll = 0) => {
-    const conv = (pt) => (region === 'status' ? pt : selectionPointAtCurrentScroll(pt, spanScroll));
-    const spanLo = conv(span.lo);
-    const spanHi = conv(span.hi);
-    let mLo;
-    let mHi;
-    if (span.kind === 'word') {
-      const wr = store.getWordRectAt?.(x, y);
-      if (wr) { mLo = { x: wr.x1, y: wr.y1 }; mHi = { x: wr.x2, y: wr.y2 }; }
-      else { mLo = { x, y }; mHi = { x, y }; }
+    const atCurrentScroll = (point) => (
+      region === 'status' ? point : selectionPointAtCurrentScroll(point, spanScroll)
+    );
+    const anchorStart = atCurrentScroll(span.lo);
+    const anchorEnd = atCurrentScroll(span.hi);
+
+    const snapped = span.kind === 'word'
+      ? store.getWordRectAt?.(x, y)
+      : store.getLineRectAt?.(y);
+    let targetStart;
+    let targetEnd;
+    if (snapped) {
+      targetStart = { x: snapped.x1, y: snapped.y1 };
+      targetEnd = { x: snapped.x2, y: snapped.y2 };
+    } else if (span.kind === 'word') {
+      targetStart = { x, y };
+      targetEnd = { x, y };
     } else {
-      const lr = store.getLineRectAt?.(y);
-      if (lr) { mLo = { x: lr.x1, y: lr.y1 }; mHi = { x: lr.x2, y: lr.y2 }; }
-      else { mLo = { x: 0, y }; mHi = { x: Math.max(0, frameColumns - 1), y }; }
+      targetStart = { x: 0, y };
+      targetEnd = { x: Math.max(0, frameColumns - 1), y };
     }
-    const rect = (a, b) => ({ mode: 'linear', x1: a.x, y1: a.y, x2: b.x, y2: b.y });
-    if (comparePoints(mHi, spanLo) < 0) return rect(spanHi, mLo);
-    if (comparePoints(mLo, spanHi) > 0) return rect(spanLo, mHi);
-    return rect(spanLo, spanHi);
+
+    // The anchor span always stays whole; the rect reaches from it toward the
+    // target when the target sits clear of it on either side, and collapses
+    // back to the anchor when the two overlap.
+    const linear = (from, to) => ({ mode: 'linear', x1: from.x, y1: from.y, x2: to.x, y2: to.y });
+    if (compareCellOrder(targetEnd, anchorStart) < 0) return linear(anchorEnd, targetStart);
+    if (compareCellOrder(targetStart, anchorEnd) > 0) return linear(anchorStart, targetEnd);
+    return linear(anchorStart, anchorEnd);
   }, [store, frameColumns, selectionPointAtCurrentScroll]);
 
   const transcriptViewportRows = useCallback(() => {
@@ -538,7 +546,7 @@ export function useTranscriptScroll({
     }
     // Before the scroll moves selected rows out of view, snapshot the rows
     // currently under the selection into the stitch buffer keyed by the
-    // PRE-scroll offset (ref selection.ts captureScrolledRows). Runs for BOTH
+    // PRE-scroll offset. Runs for BOTH
     // an active drag and a wheel-shift of a released selection, so Ctrl+C
     // reconstructs the full text no matter how far it scrolled off-screen.
     if (appliedDelta !== 0 && dragRef.current.region === 'transcript' && dragRef.current.rect) {

package/src/tui/components/tool-output-format.mjs

@@ -35,11 +35,11 @@ import { buildTableRender } from '../markdown/table-layout.mjs';
 const DEFAULT_MARKDOWN_WIDTH = 80;
 
 // Hard ceilings so a pathological tool result can never lock the render loop.
-// CC uses ~MAX_LINES*width*4 for the collapsed fold; for the EXPANDED body we
+// The collapsed fold budgets roughly MAX_LINES*width*4; for the EXPANDED body we
 // cap total characters processed and total lines kept, with an explicit marker.
 const MAX_EXPANDED_CHARS = 256 * 1024; // 256 KB of text gets per-line processing
 const MAX_EXPANDED_LINES = 4000; // logical-line safety ceiling; physical mount cap is separate
-const MAX_JSON_FORMAT_LENGTH = 10_000; // mirror CC's tryJsonFormatContent cap
+const MAX_JSON_FORMAT_LENGTH = 10_000; // JSON pretty-format cap
 const MAX_HIGHLIGHT_LINE_CHARS = 2000; // skip token-scan on absurdly long lines
 // Lockstep with ToolExecution collapsed fit budget (MIN_RESULT_LINE_CHARS).
 const MIN_EXPANDED_BODY_COLS = 24;

package/src/tui/dist/index.mjs

@@ -2061,7 +2061,7 @@ var tealPalette = {
   error: "rgb(204,102,102)",
   // red #cc6666
   warning: "rgb(255,255,0)",
-  // yellow #ffff00 (pi uses pure yellow)
+  // yellow #ffff00 (pure yellow by design)
   suggestion: "rgb(129,162,190)",
   // mdLink #81a2be
   panelTitle: "rgb(138,190,183)",
@@ -12937,10 +12937,8 @@ function shiftSelectionRectY(rect, deltaY) {
   if (!rect || dy === 0) return rect || null;
   return { ...rect, y1: rect.y1 + dy, y2: rect.y2 + dy };
 }
-function comparePoints(a, b) {
-  if (a.y !== b.y) return a.y < b.y ? -1 : 1;
-  if (a.x !== b.x) return a.x < b.x ? -1 : 1;
-  return 0;
+function compareCellOrder(a, b) {
+  return a.y === b.y ? Math.sign(a.x - b.x) : Math.sign(a.y - b.y);
 }
 function lowerBound(values, target) {
   let lo = 0;
@@ -14173,34 +14171,26 @@ function useTranscriptScroll({
     };
   }, []);
   const buildSpanRect = useCallback3((span, x, y, region, spanScroll = 0) => {
-    const conv = (pt) => region === "status" ? pt : selectionPointAtCurrentScroll(pt, spanScroll);
-    const spanLo = conv(span.lo);
-    const spanHi = conv(span.hi);
-    let mLo;
-    let mHi;
-    if (span.kind === "word") {
-      const wr = store.getWordRectAt?.(x, y);
-      if (wr) {
-        mLo = { x: wr.x1, y: wr.y1 };
-        mHi = { x: wr.x2, y: wr.y2 };
-      } else {
-        mLo = { x, y };
-        mHi = { x, y };
-      }
+    const atCurrentScroll = (point) => region === "status" ? point : selectionPointAtCurrentScroll(point, spanScroll);
+    const anchorStart = atCurrentScroll(span.lo);
+    const anchorEnd = atCurrentScroll(span.hi);
+    const snapped = span.kind === "word" ? store.getWordRectAt?.(x, y) : store.getLineRectAt?.(y);
+    let targetStart;
+    let targetEnd;
+    if (snapped) {
+      targetStart = { x: snapped.x1, y: snapped.y1 };
+      targetEnd = { x: snapped.x2, y: snapped.y2 };
+    } else if (span.kind === "word") {
+      targetStart = { x, y };
+      targetEnd = { x, y };
     } else {
-      const lr = store.getLineRectAt?.(y);
-      if (lr) {
-        mLo = { x: lr.x1, y: lr.y1 };
-        mHi = { x: lr.x2, y: lr.y2 };
-      } else {
-        mLo = { x: 0, y };
-        mHi = { x: Math.max(0, frameColumns - 1), y };
-      }
+      targetStart = { x: 0, y };
+      targetEnd = { x: Math.max(0, frameColumns - 1), y };
     }
-    const rect = (a, b) => ({ mode: "linear", x1: a.x, y1: a.y, x2: b.x, y2: b.y });
-    if (comparePoints(mHi, spanLo) < 0) return rect(spanHi, mLo);
-    if (comparePoints(mLo, spanHi) > 0) return rect(spanLo, mHi);
-    return rect(spanLo, spanHi);
+    const linear = (from, to) => ({ mode: "linear", x1: from.x, y1: from.y, x2: to.x, y2: to.y });
+    if (compareCellOrder(targetEnd, anchorStart) < 0) return linear(anchorEnd, targetStart);
+    if (compareCellOrder(targetStart, anchorEnd) > 0) return linear(anchorStart, targetEnd);
+    return linear(anchorStart, anchorEnd);
   }, [store, frameColumns, selectionPointAtCurrentScroll]);
   const transcriptViewportRows = useCallback3(() => {
     const top = Math.max(0, Number(transcriptViewportRef.current?.top) || 0);

package/src/tui/themes/teal.mjs

@@ -38,7 +38,7 @@ export const tealPalette = {
   promptBorder: 'rgb(80,80,80)', // borderMuted/darkGray #505050
   success: 'rgb(181,189,104)', // green #b5bd68
   error: 'rgb(204,102,102)', // red #cc6666
-  warning: 'rgb(255,255,0)', // yellow #ffff00 (pi uses pure yellow)
+  warning: 'rgb(255,255,0)', // yellow #ffff00 (pure yellow by design)
   suggestion: 'rgb(129,162,190)', // mdLink #81a2be
   panelTitle: 'rgb(138,190,183)', // accent
   permission: 'rgb(204,102,102)', // red

package/vendor/ink/build/ink.js

@@ -14,6 +14,7 @@ import reconciler from './reconciler.js';
 import render from './renderer.js';
 import * as dom from './dom.js';
 import { hideCursorEscape, showCursorEscape } from './cursor-helpers.js';
+import { wordRectAt } from './selection-rect.js';
 import logUpdate, { frameLog } from './log-update.js';
 import { bsu, esu, shouldSynchronize } from './write-synchronized.js';
 import instances from './instances.js';
@@ -451,91 +452,12 @@ export default class Ink {
             this.rootNode.onRender();
         });
     };
-    // [mixdog fork] Given a 0-based cell (x, y), return the inclusive rect of the
-    // 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.
-    //
-    // Selection word model (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. A space run could be treated 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)
-            return null;
-        const cells = rows[y];
-        if (!Array.isArray(cells))
-            return null;
-        // 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 = 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] Inclusive rect of the word at cell (x, y) on that row, or
+    // null when the cell is blank or out of range. Reuses the cached cell-value
+    // rows from the last render, so it works without retaining the Output
+    // instance; the class model and wide-glyph handling live in
+    // selection-rect.js.
+    getWordRectAt = (x, y) => wordRectAt(this.lastPlainRows, x, y);
     // [mixdog fork] Given a 0-based row y, return the inclusive rect of the whole
     // logical line at that row (select-line intent on
     // mixdog's rect infra). x1 is always 0; x2 is the last non-space content cell

package/vendor/ink/build/output.js

@@ -302,15 +302,13 @@ export default class Output {
         // text is trailing-space-trimmed and partial first/last rows respect
         // x1/x2. Null when there is no selection (mirrors selectedText).
         let selectionRows = null;
-        // [mixdog fork] noSelect exclusion (skip 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.
+        // [mixdog fork] Excluding gutter / line-number / diff-sigil cells from
+        // the highlight and the copy is deliberately NOT implemented: the Output
+        // grid stores only {value, styles} per cell, with no flag distinguishing
+        // chrome from content. Inferring gutters from position or content would
+        // be a fragile heuristic (line numbers, diff +/- sigils and real content
+        // are indistinguishable at the cell level), so this needs an explicit
+        // no-select bit threaded through the render pipeline first.
         if (sel) {
             const captureSelectedText = sel.captureText !== false;
             if (!captureSelectedText) {

package/vendor/ink/build/selection-rect.js

@@ -0,0 +1,80 @@
+/**
+ * selection-rect.js — double-click word bounds over the rendered cell grid.
+ *
+ * The grid stores one string per column. A wide glyph (CJK, emoji) keeps its
+ * text in the HEAD column and leaves the column it overhangs as '' — a
+ * continuation cell that carries the head's styling. Everything here works in
+ * GLYPH units so a wide character is never split down the middle.
+ *
+ * Expansion stops at a character-class change rather than at whitespace, which
+ * is what terminals do: double-clicking `foo` takes `foo`, `->` takes `->`, and
+ * a path stays whole because terminals count a few punctuation marks as
+ * word-forming. iTerm2 publishes that default set as / - + ~ _ . and the
+ * backslash is added here so Windows paths behave the same way.
+ */
+
+const CLASS_BLANK = 0;
+const CLASS_WORD = 1;
+const CLASS_SYMBOL = 2;
+
+const WORD_PUNCTUATION = new Set(['_', '/', '.', '-', '+', '~', '\\']);
+const LETTER_OR_DIGIT = /[\p{L}\p{N}]/u;
+
+function carriesWordPunctuation(value) {
+  for (const character of value) {
+    if (WORD_PUNCTUATION.has(character)) return true;
+  }
+  return false;
+}
+
+/** Blank, word-forming, or plain symbol. Empty and space are both blank. */
+export function cellClass(value) {
+  if (!value || value === ' ') return CLASS_BLANK;
+  return LETTER_OR_DIGIT.test(value) || carriesWordPunctuation(value)
+    ? CLASS_WORD
+    : CLASS_SYMBOL;
+}
+
+/**
+ * The glyph occupying `column`, as inclusive head/tail columns. A continuation
+ * cell is an empty string directly after a non-blank glyph; anything else that
+ * is empty — column 0, a run of empties, an empty after a space — is padding
+ * and stands alone.
+ */
+function glyphAt(cells, column) {
+  const continues = (index) => index > 0
+    && cells[index] === ''
+    && cellClass(cells[index - 1]) !== CLASS_BLANK;
+  const head = continues(column) ? column - 1 : column;
+  return { head, tail: continues(head + 1) ? head + 1 : head };
+}
+
+/**
+ * Inclusive rect of the word at (x, y), or null when the cell is blank or out
+ * of range. Blank cells deliberately yield nothing so a double-click on the
+ * padding around transcript content does not select a run of spaces.
+ */
+export function wordRectAt(rows, x, y) {
+  const cells = Array.isArray(rows?.[y]) ? rows[y] : null;
+  if (!cells) return null;
+
+  const origin = glyphAt(cells, x);
+  const wordClass = cellClass(cells[origin.head]);
+  if (wordClass === CLASS_BLANK) return null;
+
+  let first = origin.head;
+  while (first > 0) {
+    const previous = glyphAt(cells, first - 1);
+    if (cellClass(cells[previous.head]) !== wordClass) break;
+    first = previous.head;
+  }
+
+  let last = origin.tail;
+  while (last + 1 < cells.length) {
+    const next = glyphAt(cells, last + 1);
+    if (cellClass(cells[next.head]) !== wordClass) break;
+    last = next.tail;
+  }
+
+  return { x1: first, y1: y, x2: last, y2: y };
+}