mixdog 0.9.2 → 0.9.3

package/src/tui/input-editing.mjs

@@ -122,14 +122,52 @@ export function lineEnd(text, offset) {
   return end === -1 ? value.length : end;
 }
 
-export function caretPosition(text, offset, width) {
+// Return the [start,end) run of same-class characters (word-like vs
+// non-word-like) surrounding `offset`, used by double-click word selection.
+// Mirrors typical desktop double-click behavior: clicking inside a run of
+// letters/digits selects that whole run; clicking on a run of punctuation or
+// whitespace selects that run instead (still deterministic, never empty).
+export function wordRangeAt(text, offset) {
+  const value = String(text || '');
+  const units = graphemeUnits(value);
+  if (units.length === 0) return { start: 0, end: 0 };
+  const off = clampOffset(value, offset);
+  let idx = units.findIndex((u) => off >= u.start && off < u.end);
+  if (idx === -1) {
+    idx = units.length - 1;
+    for (let i = 0; i < units.length; i += 1) {
+      if (units[i].start >= off) { idx = i > 0 ? i - 1 : 0; break; }
+    }
+  }
+  const targetIsWord = wordLike(units[idx].segment);
+  let start = idx;
+  while (start > 0 && wordLike(units[start - 1].segment) === targetIsWord) start -= 1;
+  let end = idx;
+  while (end < units.length - 1 && wordLike(units[end + 1].segment) === targetIsWord) end += 1;
+  return { start: units[start].start, end: units[end].end };
+}
+
+// `hasTrailingContent` (default derived from the full text) decides whether a
+// caret that lands FLUSH on the last column (col === w) rolls to the next row.
+// It must reflect whether ANY rendered cell follows this offset in the FULL
+// text — not just the sliced prefix — otherwise a caret at a mid-text soft-wrap
+// boundary reports {row N, col w} while ink already rendered the next glyph on
+// row N+1, dropping the caret outside the box. PromptInput also appends a
+// trailing space cell when the cursor sits at end-of-input, so "end of text"
+// still has a following cell there; callers pass hasTrailingContent=true for
+// that case.
+export function caretPosition(text, offset, width, hasTrailingContent = undefined) {
   const value = String(text || '');
   const before = value.slice(0, offset);
   const w = safeWidth(width);
+  const followsInFullText = hasTrailingContent === undefined
+    ? offset < value.length
+    : hasTrailingContent === true;
   let row = 0;
   let col = 0;
-
-  for (const { segment } of graphemeSegmenter.segment(before)) {
+  const segments = [...graphemeSegmenter.segment(before)];
+  for (let i = 0; i < segments.length; i += 1) {
+    const { segment } = segments[i];
     if (segment === '\n') {
       row += 1;
       col = 0;
@@ -139,15 +177,24 @@ export function caretPosition(text, offset, width) {
     const segmentWidth = stringWidth(segment);
     if (segmentWidth === 0) continue;
 
+    // Mirror ink's wrap-ansi wrapWord (wrap="hard", wordWrap:false): a glyph
+    // that would overflow the row is pushed WHOLE to the next row (col never
+    // exceeds w for wide chars — no half-column left behind), and a glyph that
+    // lands flush on the last column starts a new row ONLY when more rendered
+    // content follows. Whether content follows is decided from the FULL text
+    // (followsInFullText), not the sliced prefix, so a caret at a mid-text wrap
+    // boundary rolls to row N+1 exactly as ink renders it. The old
+    // `col >= w → row += floor(col/w)` over-counted a row for width-2 glyphs at
+    // odd widths (col could reach w+1), landing the cursor one row too low.
     if (col > 0 && col + segmentWidth > w) {
       row += 1;
       col = 0;
     }
-
     col += segmentWidth;
-    if (col >= w) {
-      row += Math.floor(col / w);
-      col %= w;
+    const moreFollows = i < segments.length - 1 || followsInFullText;
+    if (col === w && moreFollows) {
+      row += 1;
+      col = 0;
     }
   }
 
@@ -185,13 +232,16 @@ function boundaryPositions(text, width) {
   for (const unit of graphemeUnits(value)) offsets.push(unit.end);
 
   const seen = new Set();
-  return offsets
+  const positions = offsets
     .filter((offset) => {
       if (seen.has(offset)) return false;
       seen.add(offset);
       return true;
     })
+    // Decide the flush-boundary advance from the FULL text so a soft-wrap
+    // offset reports {row N+1, col 0} (matching ink) instead of {row N, col w}.
     .map((offset) => ({ offset, ...caretPosition(value, offset, width) }));
+  return positions;
 }
 
 export function verticalOffset(text, offset, width, direction, preferredColumn = null) {

package/src/tui/input-editing.selection.test.mjs

@@ -0,0 +1,75 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  moveCursor,
+  previousWordOffset,
+  nextWordOffset,
+  selectionRange,
+  verticalOffset,
+  wordRangeAt,
+  lineStart,
+  lineEnd,
+} from './input-editing.mjs';
+
+// Whole-word extend (Ctrl+Shift+Left/Right) relies on moveCursor(extend:true)
+// starting/keeping an anchor while jumping by word.
+test('ctrl+shift+right extends selection by whole word', () => {
+  const draft = { value: 'hello world foo', cursor: 0, selectionAnchor: null };
+  const next = moveCursor(draft, nextWordOffset(draft.value, draft.cursor), { extend: true });
+  assert.equal(next.cursor, 'hello'.length);
+  assert.equal(next.selectionAnchor, 0);
+  assert.deepEqual(selectionRange(next), { start: 0, end: 5 });
+});
+
+test('ctrl+shift+left extends selection backward by whole word', () => {
+  const value = 'hello world';
+  const draft = { value, cursor: value.length, selectionAnchor: null };
+  const next = moveCursor(draft, previousWordOffset(value, value.length), { extend: true });
+  assert.equal(next.selectionAnchor, value.length);
+  assert.deepEqual(selectionRange(next), { start: 'hello '.length, end: value.length });
+});
+
+// Shift+Up on the first line yields no vertical move (targetRow < 0) → callers
+// then extend to document start (offset 0).
+test('verticalOffset returns same cursor on first line (up)', () => {
+  const value = 'line1\nline2';
+  const moved = verticalOffset(value, 2, 80, -1, null);
+  assert.equal(moved.cursor, 2, 'no vertical move available above first line');
+});
+
+test('shift+up to document start extends selection to offset 0', () => {
+  const value = 'abc';
+  const draft = { value, cursor: 2, selectionAnchor: null };
+  const next = moveCursor(draft, 0, { extend: true });
+  assert.deepEqual(selectionRange(next), { start: 0, end: 2 });
+});
+
+test('shift+down to document end extends selection to value.length', () => {
+  const value = 'abc';
+  const draft = { value, cursor: 1, selectionAnchor: null };
+  const next = moveCursor(draft, value.length, { extend: true });
+  assert.deepEqual(selectionRange(next), { start: 1, end: 3 });
+});
+
+// Double-click word select: clicking anywhere inside a word run selects the
+// whole run, and a click on punctuation/whitespace selects that run instead.
+test('wordRangeAt selects the word run under the offset', () => {
+  const value = 'hello world foo';
+  assert.deepEqual(wordRangeAt(value, 2), { start: 0, end: 5 });
+  assert.deepEqual(wordRangeAt(value, 6), { start: 6, end: 11 });
+  assert.deepEqual(wordRangeAt(value, 0), { start: 0, end: 5 });
+  assert.deepEqual(wordRangeAt(value, value.length), { start: 12, end: 15 });
+});
+
+test('wordRangeAt selects a punctuation/whitespace run distinctly from words', () => {
+  const value = 'foo---bar';
+  assert.deepEqual(wordRangeAt(value, 4), { start: 3, end: 6 });
+});
+
+// Triple-click line select uses lineStart/lineEnd directly.
+test('lineStart/lineEnd bound the current line for triple-click select', () => {
+  const value = 'line1\nline2\nline3';
+  const offset = value.indexOf('line2') + 2;
+  assert.equal(lineStart(value, offset), 6);
+  assert.equal(lineEnd(value, offset), 11);
+});

package/src/tui/keyboard-protocol.mjs

@@ -1,7 +1,7 @@
 /**
  * src/tui/keyboard-protocol.mjs — terminal extended-keys capability gate.
  *
- * We do NOT query the terminal. Instead, mirroring Claude Code, we enable the
+ * We do NOT query the terminal. Instead, we enable the
  * kitty keyboard protocol AND xterm modifyOtherKeys SYNCHRONOUSLY at the moment
  * raw mode turns on (see App.jsx's mount effect), gated by the allowlist below.
  * Writing both enables unconditionally is safe — a terminal honors whichever it
@@ -22,7 +22,7 @@ export const POP_KITTY = '\x1b[<u';
 export const DISABLE_MODIFY_OTHER_KEYS = '\x1b[>4;0m';
 
 // Allowlist of terminals known to honor kitty and/or xterm modifyOtherKeys.
-// Mirrors Claude Code's supportsExtendedKeys allowlist. VS Code's xterm.js
+// VS Code's xterm.js
 // integrated terminal mishandles these sequences, so it is excluded first.
 // Honors the MIXDOG_TUI_EXTENDED_KEYS opt-out (=0) / override (=1).
 export function supportsExtendedKeys() {

package/src/tui/lib/voice-recorder.mjs

@@ -80,28 +80,42 @@ export function isVoiceEnabled() {
 }
 
 // Coalesce ensure*'s onProgress ({ phase, downloaded, total } | { phase:'extra', ... })
-// into a throttled (2s) human-readable pushNotice call so a multi-hundred-MB
-// model download doesn't spam the notice toast on every chunk.
-function makeThrottledProgressNotice(pushNotice, intervalMs = 2000) {
+// into a sticky, in-place input-hint-line progress bar (setProgressHint) so a
+// multi-hundred-MB model download doesn't spam the notice toast on every
+// chunk. Falls back to the old throttled (2s) toast-spam behavior when the
+// caller (e.g. the channels pipeline) doesn't have a progress-hint slot to
+// render into — only pushNotice is guaranteed to exist everywhere.
+const PROGRESS_BAR_CELLS = 6;
+function renderProgressBarText(phase, downloaded, total) {
+  const label = phaseLabel(phase);
+  if (total > 0) {
+    const ratio = Math.max(0, Math.min(1, downloaded / total));
+    const filled = Math.round(ratio * PROGRESS_BAR_CELLS);
+    const bar = '▓'.repeat(filled) + '░'.repeat(PROGRESS_BAR_CELLS - filled);
+    return `⬇ Voice ${label} ${bar} ${Math.round(ratio * 100)}%`;
+  }
+  return `⬇ Voice ${label} …`;
+}
+function phaseLabel(phase) {
+  if (phase === 'model') return 'model';
+  if (phase === 'ffmpeg') return 'ffmpeg';
+  if (phase === 'extra') return 'extra data';
+  return 'whisper runtime';
+}
+function makeThrottledProgressNotice({ pushNotice, setProgressHint } = {}, intervalMs = 500) {
   let lastEmitAt = 0;
-  const phaseLabel = (phase) => {
-    if (phase === 'model') return 'model';
-    if (phase === 'ffmpeg') return 'ffmpeg';
-    if (phase === 'extra') return 'extra data';
-    return 'whisper runtime';
-  };
   return (progress = {}) => {
-    if (typeof pushNotice !== 'function') return;
     const now = Date.now();
     if (now - lastEmitAt < intervalMs) return;
     lastEmitAt = now;
     const total = Number(progress.total) || 0;
     const downloaded = Number(progress.downloaded) || 0;
-    const label = phaseLabel(progress.phase);
-    const text = total > 0
-      ? `Voice: downloading ${label}… ${Math.min(100, Math.round((downloaded / total) * 100))}%`
-      : `Voice: downloading ${label}…`;
-    pushNotice(text, 'info');
+    const text = renderProgressBarText(progress.phase, downloaded, total);
+    if (typeof setProgressHint === 'function') {
+      setProgressHint(text, 'info');
+      return;
+    }
+    if (typeof pushNotice === 'function') pushNotice(text, 'info');
   };
 }
 
@@ -112,12 +126,12 @@ function makeThrottledProgressNotice(pushNotice, intervalMs = 2000) {
  * runtime descriptor (resolveVoiceRuntime shape) once `installed` is true;
  * throws on any ensure* failure (manifest fetch, sha256 mismatch, etc.).
  */
-export async function ensureVoiceRuntimeReady({ dataDir = resolvePluginData(), pushNotice } = {}) {
+export async function ensureVoiceRuntimeReady({ dataDir = resolvePluginData(), pushNotice, setProgressHint } = {}) {
   const fetcher = await loadVoiceRuntimeFetcher();
   let runtime = fetcher.resolveVoiceRuntime(dataDir);
   if (runtime.installed) return runtime;
 
-  const onProgress = makeThrottledProgressNotice(pushNotice);
+  const onProgress = makeThrottledProgressNotice({ pushNotice, setProgressHint });
   if (!runtime.binary || !runtime.serverCmd) {
     await fetcher.ensureWhisperRuntime(dataDir, onProgress);
   }
@@ -147,7 +161,7 @@ export async function ensureVoiceRuntimeReady({ dataDir = resolvePluginData(), p
  * Returns the NEW enabled state (true/false) on success, or null when the
  * toggle could not run (install already in flight) or failed.
  */
-export async function toggleVoice({ pushNotice } = {}) {
+export async function toggleVoice({ pushNotice, setProgressHint } = {}) {
   const dataDir = resolvePluginData();
   if (isVoiceEnabled()) {
     // Med-5: updateSection is a synchronous file write (readAllForRmW +
@@ -172,11 +186,13 @@ export async function toggleVoice({ pushNotice } = {}) {
   }
   _voiceInstallBusy = true;
   try {
-    await ensureVoiceRuntimeReady({ dataDir, pushNotice });
+    await ensureVoiceRuntimeReady({ dataDir, pushNotice, setProgressHint });
     updateSection('voice', (current) => ({ ...current, enabled: true }));
+    setProgressHint?.('');
     pushNotice?.('Voice ON — Ctrl+Space to record', 'info');
     return true;
   } catch (err) {
+    setProgressHint?.('');
     pushNotice?.(`Voice setup failed: ${err?.message || err}`, 'error');
     return null;
   } finally {

package/src/tui/markdown/format-token.mjs

@@ -108,8 +108,8 @@ function decodeEntities(s) {
 
 // ── Fenced code block rendering ─────────────────────────────────────────────
 // Gutter-indented, syntax-highlighted body with NO background band and no ```
-// fences (codex/claude-code convention). Diff/patch languages (and bodies that
-// look like unified diffs) keep the diff highlighter; other languages use
+// fences. Diff/patch languages (and bodies that look like unified diffs) keep
+// the diff highlighter; other languages use
 // cli-highlight (highlight.js) themed from our syntax* palette; unknown
 // languages fall back to flat `mdCodeBlock` body color.
 const DIFF_LANGS = new Set(['diff', 'patch', 'udiff', 'git-diff', 'gitdiff']);
@@ -567,7 +567,7 @@ function collectHighlightedBodyLines(text, hljsLang, bandWidth) {
 const CODE_GUTTER = '  ';
 
 /**
- * Render a fenced `code` token (codex/claude-code convention): an optional
+ * Render a fenced `code` token: an optional
  * subtle language label row, then the wrapped, syntax/diff/flat-highlighted
  * body. Every row is left-indented by a 2-col gutter. NO background band, no
  * full-width padding, and no visible ``` fence lines.
@@ -653,7 +653,7 @@ export function formatToken(token, listBaseIndent = 0, orderedListNumber = null,
   const ex = extraColorizers();
   switch (token.type) {
     case 'blockquote': {
-      // Block structure carries no color (claude-code policy): a dim bar plus
+      // Block structure carries no color: a dim bar plus
       // body-colored italic text. Color is reserved for inline codespan/link.
       const bar = chalk.dim(BLOCKQUOTE_BAR);
       const quotePrefix = `${BLOCKQUOTE_BAR} `;
@@ -673,12 +673,11 @@ export function formatToken(token, listBaseIndent = 0, orderedListNumber = null,
       return renderCodeBlock(token, width);
     case 'codespan':
       // inline code — accent color only (no background tint; a bg box behind
-      // inline spans reads as awkward against body text, matches claude-code's
-      // codespan = color-only treatment).
+      // inline spans reads as awkward against body text).
       return accent(decodeEntities(token.text));
     case 'em':
-      // Italic only — no color tint (matches codex/claude-code; a colored em
-      // clashes per-theme and reads loud against body prose).
+      // Italic only — no color tint (a colored em clashes per-theme and
+      // reads loud against body prose).
       return chalk.italic((token.tokens ?? []).map((t) => formatToken(t, 0, null, parent)).join(''));
     case 'strong':
       // Bold only — no color tint (stays body-colored, just heavier weight).

package/src/tui/markdown/format-token.test.mjs

@@ -39,7 +39,7 @@ test('short code line is gutter-indented with no background band', () => {
   const width = 60;
   const token = lexFirst('```js\nshort\n```\n', 'code');
   const out = formatToken(token, 0, null, null, width);
-  // No background band: codex/claude-code render code with no `48;2;` bg.
+  // No background band: fenced code renders with no `48;2;` bg SGR.
   assert.ok(!out.includes('48;2;'), 'no background SGR');
   const bodyLine = stripAnsi(out).split('\n').find((l) => l.includes('short'));
   assert.ok(bodyLine, 'body line present');
@@ -305,8 +305,8 @@ test('strong and em use distinct mdStrong / mdEmph colors', () => {
   const emTok = lexFirst('*ital*', 'paragraph');
   const strongOut = formatToken(strongTok);
   const emOut = formatToken(emTok);
-  // Bold/italic carry weight/style only — NO color tint (codex/claude-code
-  // convention; a colored strong/em clashes per-theme and reads too loud).
+  // Bold/italic carry weight/style only — NO color tint (a colored
+  // strong/em clashes per-theme and reads too loud).
   assert.ok(strongOut.includes('\x1b[1m'), 'strong is bold');
   assert.ok(emOut.includes('\x1b[3m'), 'em is italic');
   assert.ok(!strongOut.includes(rgbSgr(theme.mdStrong)), 'strong is not color-tinted');

package/src/tui/paste-attachments.mjs

@@ -67,6 +67,44 @@ export function imageReferenceIds(input) {
   return new Set([...String(input || '').matchAll(re)].map((m) => Number(m[1]) || 0).filter(Boolean));
 }
 
+// --- Large pasted-text folding ------------------------------------------
+// A big paste is replaced in the prompt by a compact token so the editor does
+// not choke on thousands of raw characters; the original text is stored in an
+// App-level map (mirroring pastedImages) and expanded back on submit.
+const PASTE_TOKEN_MIN_LINES = 3;
+const PASTE_TOKEN_MIN_CHARS = 200;
+
+export function shouldFoldPastedText(text) {
+  const value = String(text ?? '');
+  if (!value) return false;
+  const lineCount = value.split('\n').length;
+  return lineCount >= PASTE_TOKEN_MIN_LINES || value.length > PASTE_TOKEN_MIN_CHARS;
+}
+
+export function formatPastedTextRef(id, text) {
+  const lines = String(text ?? '').split('\n').length;
+  return `[Pasted text #${id} +${lines} lines]`;
+}
+
+export function pastedTextReferenceIds(input) {
+  const re = /\[Pasted text #(\d+) \+\d+ lines\]/g;
+  return new Set([...String(input || '').matchAll(re)].map((m) => Number(m[1]) || 0).filter(Boolean));
+}
+
+// Expand every intact pasted-text token in `value` back to its original text.
+// Broken / partially-deleted tokens simply do not match and are left as-is.
+export function expandPastedTextTokens(value, pastedTexts = {}) {
+  let out = String(value ?? '');
+  if (!pastedTexts || typeof pastedTexts !== 'object') return out;
+  const re = /\[Pasted text #(\d+) \+\d+ lines\]/g;
+  out = out.replace(re, (match, idRaw) => {
+    const entry = pastedTexts[Number(idRaw)] || pastedTexts[idRaw];
+    if (entry && typeof entry.text === 'string') return entry.text;
+    return match;
+  });
+  return out;
+}
+
 export function buildPromptContentWithImages(text, pastedImages = {}) {
   const value = String(text ?? '');
   const refs = imageReferenceIds(value);

package/src/tui/paste-fix.test.mjs

@@ -0,0 +1,119 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import stringWidth from 'string-width';
+import {
+  shouldFoldPastedText,
+  formatPastedTextRef,
+  pastedTextReferenceIds,
+  expandPastedTextTokens,
+} from './paste-attachments.mjs';
+import { caretPosition } from './input-editing.mjs';
+
+// --- Part 1: pasted-text token folding ----------------------------------
+
+test('shouldFoldPastedText fires on >=3 lines or >200 chars', () => {
+  assert.equal(shouldFoldPastedText('a\nb\nc'), true);        // 3 lines
+  assert.equal(shouldFoldPastedText('a\nb'), false);          // 2 lines, short
+  assert.equal(shouldFoldPastedText('x'.repeat(201)), true);  // > 200 chars
+  assert.equal(shouldFoldPastedText('x'.repeat(200)), false); // == 200, not over
+  assert.equal(shouldFoldPastedText(''), false);
+});
+
+test('token round-trips through format + expand', () => {
+  const original = 'line1\nline2\nline3';
+  const token = formatPastedTextRef(7, original);
+  assert.equal(token, '[Pasted text #7 +3 lines]');
+  const refs = pastedTextReferenceIds(`before ${token} after`);
+  assert.deepEqual([...refs], [7]);
+  const map = { 7: { id: 7, text: original } };
+  assert.equal(
+    expandPastedTextTokens(`before ${token} after`, map),
+    `before ${original} after`,
+  );
+});
+
+test('broken / partially-deleted tokens do not expand', () => {
+  const map = { 3: { id: 3, text: 'HIDDEN' } };
+  // Missing the "+N lines" tail — not a valid token, left verbatim.
+  assert.equal(expandPastedTextTokens('[Pasted text #3]', map), '[Pasted text #3]');
+  // Truncated bracket.
+  assert.equal(expandPastedTextTokens('[Pasted text #3 +2 lines', map), '[Pasted text #3 +2 lines');
+  // Unknown id stays as-is.
+  assert.equal(expandPastedTextTokens('[Pasted text #9 +2 lines]', map), '[Pasted text #9 +2 lines]');
+});
+
+// --- Part 2: caret row math vs ink wrap-ansi (hard, wordWrap:false) -------
+
+// Faithful re-implementation of wrap-ansi's wrapWord loop for a single
+// space-free line (the prompt caret math walks graphemes the same way). ink
+// renders <Text wrap="hard"> which calls wrapAnsi(text, w, {hard,wordWrap:false}).
+// For a run with no spaces the whole line goes through wrapWord, so the visual
+// row count is what this produces.
+function inkWrapWordRows(line, columns) {
+  const chars = Array.from(new Intl.Segmenter(undefined, { granularity: 'grapheme' }).segment(line), (s) => s.segment);
+  let rows = 1;
+  let visible = 0;
+  for (let i = 0; i < chars.length; i += 1) {
+    const cw = stringWidth(chars[i]);
+    if (visible + cw <= columns) {
+      // stays on current row
+    } else {
+      rows += 1;
+      visible = 0;
+    }
+    visible += cw;
+    if (visible === columns && i < chars.length - 1) {
+      rows += 1;
+      visible = 0;
+    }
+  }
+  return rows;
+}
+
+// caretPosition row for the END of the string == (visual row count - 1).
+function caretRowsForWholeString(text, w) {
+  return caretPosition(text, text.length, w).row + 1;
+}
+
+test('caret rows agree with ink wrap for wide-char lines at odd widths', () => {
+  // A width where a width-2 glyph cannot sit flush on the last column exposes
+  // the mismatch: caretPosition must NOT advance an extra row when the char is
+  // simply pushed to the next line (ink does the same — it never leaves a
+  // half-column then over-counts).
+  const cases = [
+    { text: '가'.repeat(30), w: 41 },
+    { text: '가'.repeat(30), w: 40 },
+    { text: '가나다'.repeat(10) + 'ascii', w: 13 },
+    { text: '한글'.repeat(8), w: 7 },
+    { text: '가'.repeat(5), w: 2 },
+  ];
+  for (const { text, w } of cases) {
+    assert.equal(
+      caretRowsForWholeString(text, w),
+      inkWrapWordRows(text, w),
+      `width ${w} on ${JSON.stringify(text.slice(0, 6))}…`,
+    );
+  }
+});
+
+// Cursor exactly at a soft-wrap boundary MID-text: ink renders the following
+// glyph on the next row, so the caret must report {row N+1, col 0}, never
+// {row N, col == w} (which would sit outside the box).
+test('caret at mid-text wrap boundary rolls to next row (col 0)', () => {
+  const value = '가나다라마';        // 5 wide glyphs, width 2 each
+  const w = 4;                        // 2 glyphs per row
+  // offset 2 = after '나' (each glyph is ONE UTF-16 unit) = end of visual
+  // row 0; content ('다라마') follows, so the caret rolls to the next row.
+  const at = caretPosition(value, 2, w);
+  assert.deepEqual(at, { row: 1, col: 0 }, 'boundary caret must sit on next row');
+  // offset 4 = after '라' = end of visual row 1 (rows 0-1 are full).
+  assert.deepEqual(caretPosition(value, 4, w), { row: 2, col: 0 }, 'second boundary rolls too');
+  // Cursor at the very end of a FLUSH-ending text ('가나다라' fills rows 0-1
+  // exactly) with a trailing cell (PromptInput appends one) also rolls.
+  const flush = '가나다라';
+  const end = caretPosition(flush, flush.length, w, true);
+  assert.deepEqual(end, { row: 2, col: 0 }, 'flush end with trailing cell rolls to next row');
+  // Non-flush end ('마' leaves col 2) must NOT roll even with a trailing cell.
+  const nonFlush = caretPosition(value, value.length, w, true);
+  assert.deepEqual(nonFlush, { row: 2, col: 2 }, 'non-flush end stays on its row');
+});

package/src/tui/themes/base.mjs

@@ -35,8 +35,8 @@ export const basePalette = {
   // Picker/list focus row. This is intentionally stronger than text selection.
   selectionText: 'rgb(230,238,255)', // readable on selectionBackground
   selectionBackground: 'rgb(38,79,120)', // classic dark-mode selection blue
-  // Mouse/drag text-selection overlay. Claude Code keeps this role separate:
-  // it replaces the cell background while text remains copy-highlight readable.
+  // Mouse/drag text-selection overlay: a separate role from selectionBackground
+  // so it replaces the cell background while text remains copy-highlight readable.
   selectionHighlightText: 'rgb(255,255,255)',
   selectionHighlightBackground: 'rgb(38,79,120)',
   inactive: 'rgb(132,139,152)', // light_grey

package/src/tui/themes/kanagawa.mjs

@@ -13,10 +13,10 @@ import { basePalette } from './base.mjs';
 export const kanagawaPalette = {
   ...basePalette,
   background: 'transparent', // sumiInk3 #1F1F28
-  claude: 'rgb(210,126,153)', // sakuraPink accent (opencode)
+  claude: 'rgb(210,126,153)', // sakuraPink accent
   logo: 'rgb(232,156,182)', // welcome banner — brighter than accent
   claudeShimmer: 'rgb(156,171,202)', // springViolet2 #9CABCA (lighter accent)
-  mixdogOrange: 'rgb(210,126,153)', // sakuraPink accent (opencode)
+  mixdogOrange: 'rgb(210,126,153)', // sakuraPink accent
   mixdogAmber: 'rgb(156,171,202)', // lighter accent
   mixdogIvory: 'rgb(220,215,186)', // fujiWhite #DCD7BA
   spinnerGlyph: 'rgb(228,104,118)', // most-emphasized: waveRed
@@ -57,7 +57,7 @@ export const kanagawaPalette = {
   mdLink: 'rgb(126,156,216)', // crystalBlue
   mdLinkText: 'rgb(118,148,106)', // waveAqua #76946A
   mdStrong: 'rgb(215,166,87)', // roninYellow #D7A657
-  mdEmph: 'rgb(195,141,157)', // carpYellow opencode #C38D9D
+  mdEmph: 'rgb(195,141,157)', // carpYellow #C38D9D
   mdDiffAdded: 'rgb(152,187,108)', // springGreen
   mdDiffRemoved: 'rgb(255,93,98)', // peachRed
   mdDiffHunk: 'rgb(45,79,103)', // waveBlue #2D4F67
@@ -71,7 +71,7 @@ export const kanagawaPalette = {
   syntaxVariable: 'rgb(220,215,186)', // fujiWhite
   syntaxString: 'rgb(152,187,108)', // springGreen
   syntaxNumber: 'rgb(215,166,87)', // roninYellow #D7A657
-  syntaxType: 'rgb(195,141,157)', // carpYellow opencode #C38D9D
+  syntaxType: 'rgb(195,141,157)', // carpYellow #C38D9D
   syntaxOperator: 'rgb(210,126,153)', // sakuraPink
   syntaxPunctuation: 'rgb(220,215,186)', // fg
   userMessageBackground: 'rgb(42,42,55)', // sumiInk4 #2A2A37

package/src/tui/themes/teal.mjs

@@ -1,16 +1,15 @@
 /**
- * src/tui/themes/teal.mjs — Teal (pi style).
+ * src/tui/themes/teal.mjs — Teal.
  *
- * Faithful port of pi's `dark.json` (refs/pi .../theme/dark.json). Values are
- * taken verbatim: accent teal #8abeb7, body text #d4d4d4, page bg #18181e,
+ * Values: accent teal #8abeb7, body text #d4d4d4, page bg #18181e,
  * green #b5bd68, red #cc6666, warning pure yellow #ffff00, blue #81a2be,
- * mdHeading #f0c674, gray #808080. Syntax uses pi's VS Code Dark+ palette
+ * mdHeading #f0c674, gray #808080. Syntax uses a VS Code Dark+-style palette
  * (keyword #569CD6, string #CE9178, function #DCDCAA, etc.). Spreads
  * `basePalette` first so the full key set is always present.
  */
 import { basePalette } from './base.mjs';
 
-/** Teal — pi-style teal accent with soft body text. */
+/** Teal — teal accent with soft body text. */
 export const tealPalette = {
   ...basePalette,
   background: 'transparent', // export.pageBg #18181e

package/src/tui/themes/utils.mjs

@@ -1,7 +1,7 @@
 /**
  * src/tui/themes/utils.mjs — palette post-processing helpers.
  *
- * Reference pattern (Claude Code / opencode / pi):
+ * Design goals:
  * - keep body text neutral and highly readable;
  * - keep strong live-state colors for spinners/status;
  * - use accent colors sparingly for headings, links and syntax, preferably