mixdog 0.9.140 → 0.9.141

package/LICENSES/MIT.txt

@@ -12,6 +12,10 @@ component listed here. Each component keeps its own copyright notice.
   https://github.com/microsoft/vscode-codicons
   Copyright (c) Microsoft Corporation
 
+  Octicons
+  https://github.com/primer/octicons
+  Copyright (c) GitHub, Inc.
+
   GitHub Pull Requests and Issues (VS Code extension)
   https://github.com/microsoft/vscode-pull-request-github
   Copyright (c) Microsoft Corporation. All rights reserved.

package/NOTICE.md

@@ -1,10 +1,8 @@
 # NOTICE
 
-Mixdog itself is MIT-licensed (see `LICENSE`). The license sections below
-cover third-party code and data that Mixdog actually carries. The closing
-"Behavioral references" section records projects that only informed the
-implementation, with no code taken. Everything is kept here in one place so
-the individual source files stay free of scattered attribution comments.
+Mixdog itself is MIT-licensed (see `LICENSE`). The sections below cover the
+third-party code and data that Mixdog actually carries, kept here in one place
+so the individual source files stay free of scattered attribution comments.
 
 Full license texts live in `LICENSES/`:
 
@@ -47,6 +45,15 @@ The chrome-level UI glyph font used by the desktop and web renderer. The code
 is MIT; the icons themselves are licensed under Creative Commons Attribution
 4.0 International (CC BY 4.0).
 
+### Octicons — Copyright (c) GitHub, Inc.
+
+<https://github.com/primer/octicons>
+
+The five changed-file status glyphs in
+`apps/desktop/src/renderer/ScmStatusIcon.tsx` carry Octicons 16px path data
+unmodified: `diffAdded`, `diffModified`, `diffRemoved`, `diffRenamed` and
+`alert`.
+
 ### GitHub Pull Requests extension — Copyright (c) Microsoft Corporation
 
 <https://github.com/microsoft/vscode-pull-request-github>
@@ -98,44 +105,3 @@ upstream NOTICE file is preserved as `LICENSES/codex-NOTICE.txt`.
 The Apache-2.0 terms require this notice to travel with any redistribution of
 the derived files. Full license text: `LICENSES/Apache-2.0.txt`
 (<https://www.apache.org/licenses/LICENSE-2.0>).
-
-## Behavioral references
-
-The projects below informed Mixdog through publicly observable behavior, a
-published wire contract, or a documented algorithm. No source code from them
-is present in Mixdog, so no license obligation travels with the result; they
-are recorded here because the source files themselves carry no attribution
-comments.
-
-- **Chromium** — the workspace tab strip follows Chromium's tab-strip layout
-  semantics: two layout domains around the crossover width, the active-tab
-  floor, the inactive sliver floor, the left-to-right remainder grant and the
-  icon visibility ladder. The implementation is independent TypeScript and CSS
-  on Mixdog's own constants (`apps/desktop/src/renderer/WorkspaceTabStrip.tsx`,
-  `apps/desktop/src/renderer/desktop/04-workspace-tabs.css`).
-- **GitHub Desktop** — the Source Control dock grammar: commit-form layout,
-  changed-file status glyph semantics, single-sentence path colouring, history
-  context-menu gating, and detached-checkout / tag rules. Painted entirely on
-  Mixdog's own semantic tokens.
-- **OpenCode** — transcript auto-scroll gesture grammar, virtual-timeline
-  anchoring and the streaming-markdown projection model.
-- **Orca** — editor-surface and tab-hierarchy structure, the terminal host
-  portal, the keep-awake power-save blocker and the hosted-review link
-  derivation.
-- **Files** — the folder pane's grouping keys, date-span labels, size buckets
-  and discrete layout size ladder
-  (`apps/desktop/src/renderer/FolderPane.lazy.tsx`).
-- **Claude Code** (Anthropic) — terminal input tokenizing and keypress
-  parsing, the TUI selection word model in `vendor/ink`, and interactive turn
-  semantics such as queued-message recall, message-selector rewind and
-  background-task lifetime. The Anthropic OAuth route additionally sends the
-  client identity that Anthropic's token edge validates; those values are a
-  wire requirement, not a derivation.
-- **opencode-antigravity-auth** — MIT
-  (<https://github.com/NoeFabris/opencode-antigravity-auth>). The Google Cloud
-  Code Assist wire contract used by the Antigravity OAuth provider: OAuth
-  client parameters, endpoint fallback order, client impersonation headers,
-  request envelope and thinking-signature handling.
-- **assistant-ui, Chatbox, Cherry Studio, Jan, Zed** — the heading-size and
-  list-density survey behind the desktop markdown ladder in
-  `apps/desktop/src/renderer/desktop/22-markdown.css`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.140",
+  "version": "0.9.141",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/scripts/manifest-cache-key.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+/**
+ * Version-neutral digest for release cache keys.
+ *
+ * Deploy rewrites the version field of package.json / package-lock.json on
+ * every release, so a cache key built from hashFiles() over those manifests is
+ * guaranteed to miss on the one run that needs it: the desktop bundle and the
+ * five prepared platform runtimes were rebuilt from scratch each release even
+ * though their inputs were byte-identical apart from the version string.
+ * Hashing the same manifests with the package identity stripped keeps the key
+ * pinned to the dependency tree that actually decides the output.
+ */
+import { createHash } from 'node:crypto'
+import { readFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+import { normalizeRuntimeLockfile } from './runtime-dependency-cache-key.mjs'
+
+export const MANIFEST_CACHE_SCHEMA = 1
+
+export function manifestCacheKey(manifests) {
+  const digest = createHash('sha256')
+  digest.update(`manifest-v${MANIFEST_CACHE_SCHEMA}`)
+  for (const manifest of manifests) {
+    digest.update(JSON.stringify(normalizeRuntimeLockfile(manifest)))
+  }
+  return digest.digest('hex')
+}
+
+const invokedPath = process.argv[1] ? pathToFileURL(resolve(process.argv[1])).href : ''
+if (invokedPath === import.meta.url) {
+  const manifestPaths = process.argv.slice(2)
+  if (!manifestPaths.length) {
+    throw new Error('Usage: manifest-cache-key.mjs <package.json|package-lock.json>...')
+  }
+  Promise.all(manifestPaths.map((path) => readFile(resolve(path))))
+    .then((manifests) => process.stdout.write(`${manifestCacheKey(manifests)}\n`))
+    .catch((error) => {
+      process.stderr.write(`Manifest cache key failed: ${error?.message || error}\n`)
+      process.exitCode = 1
+    })
+}

package/src/runtime/agent/orchestrator/providers/grok-oauth-tokens.mjs

@@ -110,7 +110,7 @@ export function resolveGrokOAuthResponsesTransport() {
 // Retired model aliases xAI no longer exposes by their old ids. The live
 // catalog surfaces the coding model as grok-build-0.1; map the legacy ids to
 // it so a stale config selection doesn't hit a model-not-found. Exact table,
-// not a heuristic. Mirrors openclaw extensions/xai/model-definitions.ts.
+// not a heuristic.
 const RETIRED_MODEL_ALIASES = Object.freeze({
     'grok-code-fast-1': 'grok-build-0.1',
     'grok-code-fast': 'grok-build-0.1',

package/src/runtime/agent/orchestrator/providers/retry-classifier.mjs

@@ -215,10 +215,10 @@ export function isNonTerminalStreamClose(err) {
 /**
  * Should this failed stream be re-issued as a NON-STREAMING request?
  *
- * cc's last safety net: when a stream dies it repeats the same request with
- * `stream:false` instead of failing the turn (claude.ts, gated off only when
+ * A last safety net: when a stream dies, repeat the same request with
+ * `stream:false` instead of failing the turn (gated off only when
  * streaming tool execution could double-run a tool). MixDog dispatches tools
- * eagerly, so this stays deliberately narrower than cc: only a stream that
+ * eagerly, so this stays deliberately narrow: only a stream that
  * exposed NOTHING qualifies. An exposed stream is already covered by the
  * loop-level retraction replay (send-with-recovery), which asks the owner to
  * withdraw the rendered characters first.

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

@@ -3,9 +3,8 @@ import { TOOL_OUTPUT_MAX_BYTES } from './tool-output-limit.mjs';
 
 // Read tool caps.
 //
-// READ_MAX_SIZE_BYTES (10 MB) — fast-path file-size threshold mirroring
-// Reference FAST_PATH_MAX_SIZE (readFileInRange.ts:44). Files at or below
-// this size use readFile + in-memory split by default, which CC measured at
+// READ_MAX_SIZE_BYTES (10 MB) — fast-path file-size threshold. Files at or below
+// this size use readFile + in-memory split by default, measured at
 // ~2x faster than createReadStream + readline for typical source. Explicit
 // offset/limit windows on files above READ_STREAM_RANGE_MIN_BYTES take the
 // streaming path too, so a targeted read avoids materialising a whole

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

@@ -1,7 +1,6 @@
-// Optional-sharp image resize / downsample helper. Mirrors reference
-// imageResizer.ts (maybeResizeAndDownsampleImageBuffer +
-// readImageWithTokenBudget) so a `read` on an image returns a viewable,
-// budget-bounded image block instead of refusing oversized originals.
+// Optional-sharp image resize / downsample helper: a `read` on an image
+// returns a viewable, budget-bounded image block instead of refusing
+// oversized originals.
 //
 // sharp is a direct runtime dependency. Entry points still degrade to `null`
 // when a platform-native binding cannot load so a damaged install reports the

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/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/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

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/dist/index.mjs

@@ -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/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) {