mixdog 0.9.1 → 0.9.3

package/src/tui/markdown/streaming-markdown.mjs

@@ -0,0 +1,167 @@
+/**
+ * Pure streaming-markdown layout shared by StreamingMarkdown (render) and row
+ * estimation (measure). Stable-prefix state is keyed by streamKey (assistant id).
+ */
+import { marked } from 'marked';
+import { configureMarked, hasMarkdownSyntax } from './render-ansi.mjs';
+import { trimPartialClosingFences } from './stream-fence.mjs';
+
+const stablePrefixByStreamKey = new Map();
+const STABLE_PREFIX_LRU_MAX = 32;
+
+/** Lockstep with App streaming row estimate (leading/trailing newline trim). */
+export function streamingLayoutText(text) {
+  return String(text ?? '').replace(/^\n+|\n+$/g, '');
+}
+
+function isWhitespaceOnlyText(text) {
+  return !String(text ?? '').trim();
+}
+
+function touchStablePrefixKey(key, value) {
+  if (!key) return;
+  if (stablePrefixByStreamKey.has(key)) stablePrefixByStreamKey.delete(key);
+  stablePrefixByStreamKey.set(key, value);
+  while (stablePrefixByStreamKey.size > STABLE_PREFIX_LRU_MAX) {
+    const oldest = stablePrefixByStreamKey.keys().next().value;
+    if (oldest === undefined) break;
+    stablePrefixByStreamKey.delete(oldest);
+  }
+}
+
+function getStablePrefixKey(key) {
+  if (!key || !stablePrefixByStreamKey.has(key)) return '';
+  const value = stablePrefixByStreamKey.get(key);
+  stablePrefixByStreamKey.delete(key);
+  stablePrefixByStreamKey.set(key, value);
+  return value;
+}
+
+function hasOpenFence(text) {
+  let ticks = 0;
+  let tildes = 0;
+  for (const line of String(text ?? '').split('\n')) {
+    if (/^\s*```/.test(line)) ticks += 1;
+    if (/^\s*~~~/.test(line)) tildes += 1;
+  }
+  return ticks % 2 === 1 || tildes % 2 === 1;
+}
+
+function hasOpenInlineCode(text) {
+  let count = 0;
+  const value = String(text ?? '');
+  for (let i = 0; i < value.length; i++) {
+    const ch = value[i];
+    if (ch === '\\') {
+      i += 1;
+      continue;
+    }
+    if (ch !== '`') continue;
+    let run = 1;
+    while (value[i + run] === '`') run += 1;
+    if (run === 1) count += 1;
+    i += run - 1;
+  }
+  return count % 2 === 1;
+}
+
+function hasUnclosedDelimiter(text, marker) {
+  let count = 0;
+  const value = String(text ?? '');
+  for (let i = 0; i < value.length; i++) {
+    if (value[i] === '\\') {
+      i += 1;
+      continue;
+    }
+    if (value.startsWith(marker, i)) {
+      count += 1;
+      i += marker.length - 1;
+    }
+  }
+  return count % 2 === 1;
+}
+
+export function balanceStreamingMarkdown(text) {
+  const value = String(text ?? '');
+  if (!value || hasOpenFence(value)) return value;
+  if (hasOpenInlineCode(value)) return `${value}\``;
+  let rendered = value;
+  if (hasUnclosedDelimiter(rendered, '**')) rendered += '**';
+  if (hasUnclosedDelimiter(rendered, '__')) rendered += '__';
+  return rendered;
+}
+
+export function resetStreamingMarkdownStablePrefix(streamKey) {
+  if (streamKey == null || streamKey === '') return;
+  stablePrefixByStreamKey.delete(String(streamKey));
+}
+
+export function resetAllStreamingMarkdownStablePrefixes() {
+  stablePrefixByStreamKey.clear();
+}
+
+export function resolveStreamingMarkdownParts(text, streamKey) {
+  const t = streamingLayoutText(text);
+  const key = streamKey == null || streamKey === '' ? null : String(streamKey);
+
+  if (!t) {
+    if (key) stablePrefixByStreamKey.delete(key);
+    return {
+      plain: true,
+      stablePrefix: '',
+      unstableSuffix: '',
+      unstableForRender: '',
+    };
+  }
+
+  if (!hasMarkdownSyntax(t)) {
+    if (key) stablePrefixByStreamKey.delete(key);
+    return {
+      plain: true,
+      stablePrefix: '',
+      unstableSuffix: t,
+      unstableForRender: t,
+    };
+  }
+
+  let stablePrefix = key ? getStablePrefixKey(key) : '';
+  if (!t.startsWith(stablePrefix)) {
+    stablePrefix = '';
+  }
+
+  try {
+    configureMarked();
+    const boundary = stablePrefix.length;
+    const tokens = marked.lexer(t.substring(boundary));
+    trimPartialClosingFences(tokens);
+    let lastContentIdx = tokens.length - 1;
+    while (lastContentIdx >= 0 && tokens[lastContentIdx]?.type === 'space') lastContentIdx -= 1;
+    let firstContentIdx = 0;
+    while (firstContentIdx < tokens.length && tokens[firstContentIdx]?.type === 'space') {
+      firstContentIdx += 1;
+    }
+    let advance = 0;
+    for (let i = firstContentIdx; i < lastContentIdx; i++) {
+      advance += tokens[i]?.raw?.length ?? 0;
+    }
+    if (advance > 0) {
+      stablePrefix = t.substring(0, boundary + advance);
+      if (isWhitespaceOnlyText(stablePrefix)) stablePrefix = '';
+      if (key && stablePrefix) touchStablePrefixKey(key, stablePrefix);
+      else if (key && !stablePrefix) stablePrefixByStreamKey.delete(key);
+    }
+  } catch {
+    stablePrefix = '';
+    if (key) stablePrefixByStreamKey.delete(key);
+  }
+
+  if (isWhitespaceOnlyText(stablePrefix)) stablePrefix = '';
+
+  const unstableSuffix = t.substring(stablePrefix.length);
+  return {
+    plain: false,
+    stablePrefix,
+    unstableSuffix,
+    unstableForRender: balanceStreamingMarkdown(unstableSuffix),
+  };
+}

package/src/tui/markdown/streaming-markdown.test.mjs

@@ -0,0 +1,70 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { assistantBodyWidth } from './table-layout.mjs';
+import {
+  measureMarkdownRenderedRows,
+  measureStreamingMarkdownRenderedRows,
+} from './measure-rendered-rows.mjs';
+import { resolveStreamingMarkdownParts, streamingLayoutText } from './streaming-markdown.mjs';
+import { setThemeSetting } from '../theme.mjs';
+
+setThemeSetting('basic', { persist: false });
+
+function measureStreamingLayoutFromParts(text, columns, streamKey) {
+  const parts = resolveStreamingMarkdownParts(text, streamKey);
+  if (parts.plain) {
+    return measureMarkdownRenderedRows(text, columns);
+  }
+  let rows = 0;
+  let childCount = 0;
+  if (parts.stablePrefix) {
+    rows += measureMarkdownRenderedRows(parts.stablePrefix, columns);
+    childCount += 1;
+  }
+  if (parts.unstableSuffix) {
+    rows += measureMarkdownRenderedRows(parts.unstableForRender, columns, { trimPartialFences: true });
+    childCount += 1;
+  }
+  if (childCount === 2) rows += 1;
+  return Math.max(1, rows);
+}
+
+test('streaming row estimate matches shared layout parts at body width', () => {
+  const columns = 40;
+  const bodyWidth = assistantBodyWidth(columns);
+  const cases = [
+    { key: 'bold-wrap', text: `**${'m'.repeat(bodyWidth + 12)}` },
+    { key: 'partial-fence', text: `\`\`\`js\n${'w'.repeat(bodyWidth + 6)}\n\`` },
+  ];
+  for (const { key, text } of cases) {
+    const estimate = measureStreamingMarkdownRenderedRows(text, columns, key);
+    const layout = measureStreamingLayoutFromParts(text, columns, key);
+    assert.strictEqual(estimate, layout, `${key}: estimate must match render layout parts`);
+  }
+});
+
+test('partial code fence streaming measure uses trimPartialFences on unstable suffix', () => {
+  const columns = 48;
+  const bodyWidth = assistantBodyWidth(columns);
+  const streamKey = 'test-stream-fence';
+  const text = `\`\`\`js\n${'n'.repeat(bodyWidth + 8)}\n\``;
+  const estimate = measureStreamingMarkdownRenderedRows(text, columns, streamKey);
+  const parts = resolveStreamingMarkdownParts(text, streamKey);
+  const manual = measureMarkdownRenderedRows(parts.unstableForRender, columns, { trimPartialFences: true });
+  assert.strictEqual(estimate, Math.max(1, manual));
+});
+
+test('leading blank lines do not create an empty stable child or extra gap row', () => {
+  const columns = 40;
+  const streamKey = 'test-leading-blank';
+  const raw = '\n\n**streaming body**';
+  const trimmed = streamingLayoutText(raw);
+  const parts = resolveStreamingMarkdownParts(raw, streamKey);
+  assert.strictEqual(parts.stablePrefix, '', 'leading newlines must not promote whitespace-only stable');
+  assert.ok(parts.unstableSuffix.includes('streaming body'));
+  const estimate = measureStreamingMarkdownRenderedRows(raw, columns, streamKey);
+  const trimmedEstimate = measureStreamingMarkdownRenderedRows(trimmed, columns, streamKey);
+  assert.strictEqual(estimate, trimmedEstimate, 'raw vs trimmed leading newlines must match');
+  const layout = measureStreamingLayoutFromParts(raw, columns, streamKey);
+  assert.strictEqual(estimate, layout);
+});

package/src/tui/markdown/table-layout.mjs

@@ -15,9 +15,9 @@
  * caller (the component resolves it from useStdout()/forceWidth).
  */
 import stripAnsi from 'strip-ansi';
-import stringWidth from 'string-width';
 import wrapAnsi from 'wrap-ansi';
 import { formatToken, padAligned } from './format-token.mjs';
+import { displayWidth } from '../display-width.mjs';
 
 export const SAFETY_MARGIN = 4;
 export const MIN_COLUMN_WIDTH = 3;
@@ -51,10 +51,10 @@ export function hardWrapLines(text, width) {
   const out = [];
   for (const softLine of wrapText(input, max, { hard: true })) {
     let rest = softLine;
-    while (rest.length > 0 && stringWidth(rest) > max) {
+    while (rest.length > 0 && displayWidth(rest) > max) {
       let take = 1;
       for (let i = 1; i <= rest.length; i++) {
-        if (stringWidth(rest.slice(0, i)) <= max) take = i;
+        if (displayWidth(rest.slice(0, i)) <= max) take = i;
         else break;
       }
       out.push(rest.slice(0, take));
@@ -81,10 +81,10 @@ export function buildTableRender(token, terminalWidth) {
     const text = getPlainText(tokens);
     const words = text.split(/\s+/).filter((w) => w.length > 0);
     if (words.length === 0) return MIN_COLUMN_WIDTH;
-    return Math.max(...words.map((w) => stringWidth(w)), MIN_COLUMN_WIDTH);
+    return Math.max(...words.map((w) => displayWidth(w)), MIN_COLUMN_WIDTH);
   };
   const getIdealWidth = (tokens) =>
-    Math.max(stringWidth(getPlainText(tokens)), MIN_COLUMN_WIDTH);
+    Math.max(displayWidth(getPlainText(tokens)), MIN_COLUMN_WIDTH);
 
   // Step 1: min (longest word) and ideal (full content) widths per column.
   const minWidths = token.header.map((header, colIndex) => {
@@ -157,7 +157,7 @@ export function buildTableRender(token, terminalWidth) {
         const lineText = contentLineIdx >= 0 && contentLineIdx < lines.length ? lines[contentLineIdx] : '';
         const colWidth = columnWidths[colIndex];
         const align = isHeader ? 'center' : token.align?.[colIndex] ?? 'left';
-        line += ' ' + padAligned(lineText, stringWidth(lineText), colWidth, align) + ' │';
+        line += ' ' + padAligned(lineText, displayWidth(lineText), colWidth, align) + ' │';
       }
       result.push(line);
     }
@@ -184,7 +184,7 @@ export function buildTableRender(token, terminalWidth) {
     const separatorWidth = Math.min(Math.max(0, width - 1), 40);
     const separator = '─'.repeat(separatorWidth);
     const wrapIndent = '  ';
-    const indentWidth = stringWidth(wrapIndent);
+    const indentWidth = displayWidth(wrapIndent);
     const pushFitted = (rawLine) => {
       for (const part of hardWrapLines(rawLine, width)) lines.push(part);
     };
@@ -195,7 +195,7 @@ export function buildTableRender(token, terminalWidth) {
         const rawValue = formatCell(cell.tokens).trimEnd();
         const value = rawValue.replace(/\n+/g, ' ').replace(/\s+/g, ' ').trim();
         const prefix = `${ANSI_BOLD_START}${label}:${ANSI_BOLD_END} `;
-        const prefixWidth = stringWidth(stripAnsi(prefix));
+        const prefixWidth = displayWidth(stripAnsi(prefix));
         const firstValueWidth = Math.max(1, width - prefixWidth);
         const contValueWidth = Math.max(1, width - indentWidth);
         const firstValueLines = hardWrapLines(value, firstValueWidth);
@@ -231,7 +231,7 @@ export function buildTableRender(token, terminalWidth) {
   tableLines.push(renderBorderLine('bottom'));
 
   // Safety: if any line would overflow (resize race), fall back to vertical.
-  const maxLineWidth = Math.max(...tableLines.map((l) => stringWidth(stripAnsi(l))));
+  const maxLineWidth = Math.max(...tableLines.map((l) => displayWidth(stripAnsi(l))));
   if (maxLineWidth > width - SAFETY_MARGIN) {
     return { lines: renderVerticalLines(), useVerticalFormat: true };
   }

package/src/tui/paste-attachments.mjs

@@ -67,15 +67,42 @@ export function imageReferenceIds(input) {
   return new Set([...String(input || '').matchAll(re)].map((m) => Number(m[1]) || 0).filter(Boolean));
 }
 
-export function promptContentText(content) {
-  if (typeof content === 'string') return content;
-  if (!Array.isArray(content)) return String(content ?? '');
-  return content.map((part) => {
-    if (typeof part === 'string') return part;
-    if (part?.type === 'text') return part.text || '';
-    if (part?.type === 'image') return `[image: ${part.mimeType || part.mediaType || part.source?.media_type || 'image'}]`;
-    return part?.text || '';
-  }).filter(Boolean).join('\n');
+// --- 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 = {}) {

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/prompt-history-store.mjs

@@ -0,0 +1,129 @@
+/**
+ * Persistent TUI prompt input history, scoped by project working directory.
+ * Stored under MIXDOG data dir (not the repo working tree).
+ */
+import { createHash } from 'node:crypto';
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { resolvePluginData } from '../runtime/shared/plugin-paths.mjs';
+
+export const PROMPT_HISTORY_LIMIT = 50;
+
+export function promptHistoryKey(value) {
+  return String(value || '').trim().replace(/\s+/g, ' ');
+}
+
+/** Stable map key for cwd-scoped prompt history buckets. */
+export function promptHistoryCwdKey(rawPath) {
+  const text = String(rawPath || '').trim();
+  if (!text) return '';
+  const abs = resolve(text);
+  return process.platform === 'win32'
+    ? abs.replace(/[\\/]+$/, '').toLowerCase()
+    : abs.replace(/\/+$/, '');
+}
+
+function historyFilePath(cwd) {
+  const key = promptHistoryCwdKey(cwd);
+  if (!key) return '';
+  const digest = createHash('sha256').update(key, 'utf8').digest('hex').slice(0, 32);
+  return join(resolvePluginData(), 'tui-prompt-history', `${digest}.json`);
+}
+
+function readEntries(filePath) {
+  if (!filePath || !existsSync(filePath)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+    const entries = Array.isArray(parsed?.entries) ? parsed.entries : [];
+    return entries
+      .map((entry) => String(entry || '').trim())
+      .filter((entry) => promptHistoryKey(entry));
+  } catch {
+    return [];
+  }
+}
+
+function writeEntries(filePath, entries) {
+  if (!filePath) return false;
+  try {
+    // Prompt text may be sensitive; restrict directory/file to the owning user.
+    mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 });
+    const payload = { version: 1, entries };
+    const tmp = `${filePath}.${process.pid}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(payload, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    renameSync(tmp, filePath);
+    try {
+      chmodSync(filePath, 0o600);
+    } catch {
+      /* best-effort; Windows may ignore mode bits */
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * In-memory session list (newest first). Dedupes by promptHistoryKey.
+ */
+export function pushSessionPromptHistory(sessionTexts, value, limit = PROMPT_HISTORY_LIMIT) {
+  const text = String(value || '').trim();
+  const key = promptHistoryKey(text);
+  if (!key) return Array.isArray(sessionTexts) ? sessionTexts : [];
+  const base = Array.isArray(sessionTexts) ? sessionTexts : [];
+  const next = base.filter((entry) => promptHistoryKey(entry) !== key);
+  next.unshift(text);
+  return next.length > limit ? next.slice(0, limit) : next;
+}
+
+/**
+ * Merge session-derived prompts (newest first) with persisted prompts from
+ * older sessions. Dedupes by promptHistoryKey; session wins ordering.
+ */
+export function buildMergedPromptHistory(sessionTexts, persistedTexts, limit = PROMPT_HISTORY_LIMIT) {
+  const seen = new Set();
+  const history = [];
+
+  const push = (raw) => {
+    if (history.length >= limit) return;
+    const text = String(raw || '').trim();
+    const key = promptHistoryKey(text);
+    if (!key || seen.has(key)) return;
+    seen.add(key);
+    history.push(text);
+  };
+
+  for (const text of sessionTexts) push(text);
+
+  const persisted = Array.isArray(persistedTexts) ? persistedTexts : [];
+  for (let i = persisted.length - 1; i >= 0; i -= 1) {
+    push(persisted[i]);
+  }
+
+  return history;
+}
+
+export function loadPromptHistory(cwd) {
+  const filePath = historyFilePath(cwd);
+  const entries = readEntries(filePath);
+  if (entries.length <= PROMPT_HISTORY_LIMIT) return entries;
+  return entries.slice(-PROMPT_HISTORY_LIMIT);
+}
+
+/**
+ * Append a submitted prompt for cwd. Skips empty keys; removes prior duplicate
+ * keys (promptHistoryKey); caps at PROMPT_HISTORY_LIMIT.
+ * Returns the saved entry list (oldest → newest) on success, or null on failure.
+ */
+export function appendPromptHistory(cwd, value) {
+  const key = promptHistoryKey(value);
+  if (!key) return null;
+  const filePath = historyFilePath(cwd);
+  const entries = readEntries(filePath).filter((entry) => promptHistoryKey(entry) !== key);
+  entries.push(String(value).trim());
+  const trimmed = entries.length > PROMPT_HISTORY_LIMIT
+    ? entries.slice(-PROMPT_HISTORY_LIMIT)
+    : entries;
+  return writeEntries(filePath, trimmed) ? trimmed : null;
+}
+

package/src/tui/prompt-history-store.test.mjs

@@ -0,0 +1,52 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  appendPromptHistory,
+  buildMergedPromptHistory,
+  loadPromptHistory,
+  pushSessionPromptHistory,
+  promptHistoryKey,
+} from './prompt-history-store.mjs';
+
+test('promptHistoryKey normalizes whitespace', () => {
+  assert.equal(promptHistoryKey('  hello   world  '), 'hello world');
+  assert.equal(promptHistoryKey('   '), '');
+});
+
+test('buildMergedPromptHistory prefers session order and dedupes', () => {
+  const merged = buildMergedPromptHistory(
+    ['newest', 'older'],
+    ['stale', 'newest', 'from-disk'],
+    50,
+  );
+  assert.deepEqual(merged, ['newest', 'older', 'from-disk', 'stale']);
+});
+
+test('appendPromptHistory persists per cwd across reload', () => {
+  const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-prompt-history-'));
+  const previous = process.env.MIXDOG_DATA_DIR;
+  process.env.MIXDOG_DATA_DIR = dataDir;
+  try {
+    const cwd = join(dataDir, 'project-a');
+    assert.deepEqual(appendPromptHistory(cwd, 'first prompt'), ['first prompt']);
+    assert.deepEqual(appendPromptHistory(cwd, 'second prompt'), ['first prompt', 'second prompt']);
+    assert.deepEqual(appendPromptHistory(cwd, 'first   prompt'), ['second prompt', 'first   prompt']);
+    const loaded = loadPromptHistory(cwd);
+    assert.deepEqual(loaded, ['second prompt', 'first   prompt']);
+  } finally {
+    if (previous === undefined) delete process.env.MIXDOG_DATA_DIR;
+    else process.env.MIXDOG_DATA_DIR = previous;
+    rmSync(dataDir, { recursive: true, force: true });
+  }
+});
+
+test('pushSessionPromptHistory is cwd-session newest-first with dedupe', () => {
+  let session = pushSessionPromptHistory([], 'alpha');
+  session = pushSessionPromptHistory(session, 'beta');
+  session = pushSessionPromptHistory(session, 'alpha');
+  assert.deepEqual(session, ['alpha', 'beta']);
+});
+