ompchamber 3.1.1 → 3.3.0

package/src/shared/lib/fs/diff-parser.ts

@@ -31,12 +31,29 @@ interface PendingChange {
  * which is what this used to do — left the row painted red/green and counted in
  * `+n/-n`, so the toggle changed the glyphs and nothing else.
  */
-export function parseUnifiedDiff(rawDiff: string, ignoreWhitespace: boolean = false): {
+export interface ParseDiffOptions {
+  /** Fold `-`/`+` pairs that differ only in whitespace back into context. */
+  ignoreWhitespace?: boolean;
+  /**
+   * Which view the caller renders. Both views are built from one flush so a
+   * decision cannot land in one and not the other, but building the one nobody
+   * shows doubled the allocations on a full-context diff — an 80k-line file
+   * produced ~60k discarded `SplitDiffRow` objects. `'both'` is the default so
+   * the counts and the shared flush stay exactly as they were.
+   */
+  views?: 'unified' | 'split' | 'both';
+}
+
+export function parseUnifiedDiff(rawDiff: string, options: ParseDiffOptions = {}): {
   lines: DiffLine[];
   splitRows: SplitDiffRow[];
   additions: number;
   deletions: number;
 } {
+  const ignoreWhitespace = options.ignoreWhitespace ?? false;
+  const views = options.views ?? 'both';
+  const wantUnified = views !== 'split';
+  const wantSplit = views !== 'unified';
   const lines: DiffLine[] = [];
   const splitRows: SplitDiffRow[] = [];
   let additions = 0;
@@ -73,43 +90,47 @@ export function parseUnifiedDiff(rawDiff: string, ignoreWhitespace: boolean = fa
       }
     }
 
-    for (let i = 0; i < delBuffer.length; i++) {
-      const del = delBuffer[i];
-      const add = addBuffer[i];
-      if (folded[i] && add) {
-        // Show it as unchanged on both sides: the change is still in the file,
-        // the reader asked not to be shown formatting noise.
-        lines.push({
-          type: 'context',
-          // The new form, so the row reads as the file's current state.
-          text: add.text,
-          oldLineNumber: del.lineNumber,
-          newLineNumber: add.lineNumber,
-        });
-        continue;
+    if (wantUnified) {
+      for (let i = 0; i < delBuffer.length; i++) {
+        const del = delBuffer[i];
+        const add = addBuffer[i];
+        if (folded[i] && add) {
+          // Show it as unchanged on both sides: the change is still in the file,
+          // the reader asked not to be shown formatting noise.
+          lines.push({
+            type: 'context',
+            // The new form, so the row reads as the file's current state.
+            text: add.text,
+            oldLineNumber: del.lineNumber,
+            newLineNumber: add.lineNumber,
+          });
+          continue;
+        }
+        lines.push({ type: 'del', text: del.text, oldLineNumber: del.lineNumber });
+      }
+      for (let i = 0; i < addBuffer.length; i++) {
+        const add = addBuffer[i];
+        if (folded[i]) continue;
+        lines.push({ type: 'add', text: add.text, newLineNumber: add.lineNumber });
       }
-      lines.push({ type: 'del', text: del.text, oldLineNumber: del.lineNumber });
-    }
-    for (let i = 0; i < addBuffer.length; i++) {
-      const add = addBuffer[i];
-      if (folded[i]) continue;
-      lines.push({ type: 'add', text: add.text, newLineNumber: add.lineNumber });
     }
 
-    for (let i = 0; i < maxLen; i++) {
-      const del = delBuffer[i];
-      const add = addBuffer[i];
-      if (folded[i] && del && add) {
+    if (wantSplit) {
+      for (let i = 0; i < maxLen; i++) {
+        const del = delBuffer[i];
+        const add = addBuffer[i];
+        if (folded[i] && del && add) {
+          splitRows.push({
+            left: { type: 'context', text: del.text, lineNumber: del.lineNumber },
+            right: { type: 'context', text: add.text, lineNumber: add.lineNumber },
+          });
+          continue;
+        }
         splitRows.push({
-          left: { type: 'context', text: del.text, lineNumber: del.lineNumber },
-          right: { type: 'context', text: add.text, lineNumber: add.lineNumber },
+          left: del ? { type: 'del', text: del.text, lineNumber: del.lineNumber } : undefined,
+          right: add ? { type: 'add', text: add.text, lineNumber: add.lineNumber } : undefined,
         });
-        continue;
       }
-      splitRows.push({
-        left: del ? { type: 'del', text: del.text, lineNumber: del.lineNumber } : undefined,
-        right: add ? { type: 'add', text: add.text, lineNumber: add.lineNumber } : undefined,
-      });
     }
     delBuffer = [];
     addBuffer = [];
@@ -156,16 +177,20 @@ export function parseUnifiedDiff(rawDiff: string, ignoreWhitespace: boolean = fa
     } else {
       flushBuffers();
       const text = rawLine.startsWith(' ') ? rawLine.slice(1) : rawLine;
-      lines.push({
-        type: 'context',
-        text,
-        oldLineNumber: oldCounter,
-        newLineNumber: newCounter,
-      });
-      splitRows.push({
-        left: { type: 'context', text, lineNumber: oldCounter },
-        right: { type: 'context', text, lineNumber: newCounter },
-      });
+      if (wantUnified) {
+        lines.push({
+          type: 'context',
+          text,
+          oldLineNumber: oldCounter,
+          newLineNumber: newCounter,
+        });
+      }
+      if (wantSplit) {
+        splitRows.push({
+          left: { type: 'context', text, lineNumber: oldCounter },
+          right: { type: 'context', text, lineNumber: newCounter },
+        });
+      }
       oldCounter++;
       newCounter++;
     }

package/src/shared/lib/omp/subagent/parse.test.ts

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Covers `readSubagentProgressFrame`, the one reader every subagent-progress
+ * consumer goes through (sidebar roster, transcript hook, server liveness).
+ *
+ * The wrapper shape is the whole point: omp's `subagent_progress` frame nests
+ * the child's `AgentProgress` under `payload.progress` and puts NO `id` on the
+ * wrapper, so a reader that parses the wrapper alone yields an id-less object
+ * with none of the reported fields — silently, because every field is
+ * optional. The payload below is a verbatim frame captured from omp 18.3.2.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { parseSubagentProgress, readSubagentProgressFrame } from '@/shared/lib/omp/subagent/parse';
+
+/** One `subagent_progress` frame as omp emits it (trimmed to the read fields). */
+const REAL_FRAME = {
+  index: 0,
+  agent: 'scout',
+  agentSource: 'user',
+  task: 'Complete assignment thoroughly:\n\n# Target\nCount files.',
+  parentToolCallId: 'call_00_LsrwnITatwhVYX5NElPf2544',
+  detached: true,
+  assignment: '# Target\nCount files.',
+  sessionFile: '/tmp/sessions/parent/CountTsx.jsonl',
+  progress: {
+    index: 0,
+    id: 'CountTsx',
+    agent: 'scout',
+    agentSource: 'user',
+    status: 'running',
+    task: 'Complete assignment thoroughly:\n\n# Target\nCount files.',
+    recentTools: [],
+    recentOutput: [],
+    toolCount: 3,
+    requests: 2,
+    tokens: 10400,
+    cost: 0.003,
+    durationMs: 8700,
+    modelRole: 'smol',
+    resolvedModelIdentity: 'kenari/deepseek-v4-flash',
+    resolvedThinkingLevel: 'low',
+    resolvedModel: 'kenari/deepseek-v4-flash:low',
+    resolvedModelIsFallback: false,
+  },
+};
+
+describe('readSubagentProgressFrame', () => {
+  test('unwraps the nested AgentProgress and keeps the fields it reports', () => {
+    const progress = readSubagentProgressFrame(REAL_FRAME);
+    expect(progress?.id).toBe('CountTsx');
+    expect(progress?.resolvedModel).toBe('kenari/deepseek-v4-flash:low');
+    expect(progress?.resolvedThinkingLevel).toBe('low');
+    expect(progress?.status).toBe('running');
+    expect(progress?.tokens).toBe(10400);
+  });
+
+  test('reads a bare AgentProgress payload (snapshot field, not a frame)', () => {
+    const progress = readSubagentProgressFrame(REAL_FRAME.progress);
+    expect(progress?.id).toBe('CountTsx');
+    expect(progress?.resolvedThinkingLevel).toBe('low');
+  });
+
+  test('keeps the wrapper id when the nested snapshot omits it', () => {
+    const progress = readSubagentProgressFrame({ id: 'Wrapped', progress: { status: 'running' } });
+    expect(progress?.id).toBe('Wrapped');
+    expect(progress?.status).toBe('running');
+  });
+
+  test('returns undefined for a payload carrying no progress fields at all', () => {
+    expect(readSubagentProgressFrame({ event: { type: 'message_end' } })).toBeUndefined();
+    expect(readSubagentProgressFrame(null)).toBeUndefined();
+    expect(readSubagentProgressFrame('nonsense')).toBeUndefined();
+  });
+});
+
+describe('parseSubagentProgress', () => {
+  test('carries the resolved thinking level and drops a non-string one', () => {
+    expect(parseSubagentProgress({ resolvedThinkingLevel: 'max' })?.resolvedThinkingLevel).toBe('max');
+    expect(parseSubagentProgress({ resolvedThinkingLevel: null })?.resolvedThinkingLevel).toBeUndefined();
+    expect(parseSubagentProgress({ resolvedThinkingLevel: 3 })?.resolvedThinkingLevel).toBeUndefined();
+  });
+});

package/src/shared/lib/omp/subagent/parse.ts

@@ -81,6 +81,8 @@ export function parseSubagentProgress(value: unknown): SubagentProgress | undefi
   if (modelRole !== undefined) out.modelRole = modelRole;
   const resolvedModel = asString(value.resolvedModel);
   if (resolvedModel !== undefined) out.resolvedModel = resolvedModel;
+  const resolvedThinkingLevel = asString(value.resolvedThinkingLevel);
+  if (resolvedThinkingLevel !== undefined) out.resolvedThinkingLevel = resolvedThinkingLevel;
   if (typeof value.resolvedModelIsFallback === 'boolean') out.resolvedModelIsFallback = value.resolvedModelIsFallback;
   if (isRecord(value.retryState)) {
     const attempt = asNumber(value.retryState.attempt);
@@ -180,6 +182,21 @@ export function parseSubagentLifecycle(value: unknown): SubagentInfo | undefined
   return info;
 }
 
+/**
+ * Read a progress frame's payload: `SubagentProgressPayload` nests the
+ * AgentProgress it reports under `progress`, while a bare AgentProgress (and a
+ * `get_subagents` snapshot's own field) is the object itself. Both shapes reach
+ * the same listeners, so unwrap here rather than at each call site — the outer
+ * wrapper's `id`/`index` fill in what the nested snapshot omits.
+ */
+export function readSubagentProgressFrame(payload: unknown): SubagentProgress | undefined {
+  const direct = parseSubagentProgress(payload);
+  if (!isRecord(payload) || !isRecord(payload.progress)) return direct;
+  const nested = parseSubagentProgress(payload.progress);
+  if (!nested) return direct;
+  return { ...nested, id: nested.id ?? direct?.id, index: nested.index ?? direct?.index };
+}
+
 /** Extract a compact live-activity entry from a subagent_event payload. */
 export function parseSubagentActivityEvent(value: unknown): SubagentActivityEvent | null {
   if (!isRecord(value)) return null;

package/src/shared/lib/omp/subagent/transcript-client.test.ts

@@ -0,0 +1,100 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Covers the subagent transcript conversion's thinking-level stamping.
+ *
+ * A subagent transcript records its level as a separate `thinking_level_change`
+ * entry, never as a per-message field, so `convertMessages` has to walk the
+ * records and stamp the level in effect — otherwise the footer has no level to
+ * show and drops the segment entirely. The child's own level is the only
+ * correct one: a subagent routinely runs at a different level than the chat
+ * that spawned it, so borrowing the parent's would mislabel every row.
+ *
+ * Also pins the non-message entry handling the walk sits beside: a change
+ * record must be consumed, not converted into a row.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { convertMessages, mergeMessages } from '@/shared/lib/omp/subagent/transcript-client';
+import type { ChatMessageData } from '@/shared/types';
+
+/** An assistant message entry carrying text, as omp writes it to the JSONL. */
+function assistantEntry(id: string, text: string): Record<string, unknown> {
+  return {
+    type: 'message',
+    id,
+    timestamp: 1790403839189,
+    message: {
+      role: 'assistant',
+      model: 'deepseek-v4-flash',
+      provider: 'kenari',
+      content: [{ type: 'text', text }],
+    },
+  };
+}
+
+function changeEntry(level: unknown): Record<string, unknown> {
+  return { type: 'thinking_level_change', id: `chg-${String(level)}`, thinkingLevel: level, configured: null };
+}
+
+describe('convertMessages thinking-level stamping', () => {
+  test('stamps the level in effect onto assistant rows', () => {
+    const rows = convertMessages([changeEntry('low'), assistantEntry('a1', 'first'), assistantEntry('a2', 'second')], false);
+    expect(rows.map((row) => row.thinkingLevel)).toEqual(['low', 'low']);
+  });
+
+  test('follows a mid-transcript change, so each turn keeps the level that served it', () => {
+    const rows = convertMessages([
+      changeEntry('low'),
+      assistantEntry('a1', 'first'),
+      changeEntry('high'),
+      assistantEntry('a2', 'second'),
+    ], false);
+    expect(rows[0].thinkingLevel).toBe('low');
+    expect(rows[1].thinkingLevel).toBe('high');
+  });
+
+  test('normalizes a null level record to "off" rather than dropping the segment', () => {
+    const rows = convertMessages([changeEntry(null), assistantEntry('a1', 'first')], false);
+    expect(rows[0].thinkingLevel).toBe('off');
+  });
+
+  test('leaves user rows unstamped and the level absent before any record', () => {
+    const rows = convertMessages([
+      { type: 'message', id: 'u1', message: { role: 'user', content: 'hi' } },
+      assistantEntry('a1', 'answer'),
+      changeEntry('max'),
+      assistantEntry('a2', 'later'),
+    ], false);
+    expect(rows[0].role).toBe('user');
+    expect(rows[0].thinkingLevel).toBeUndefined();
+    expect(rows[1].thinkingLevel).toBeUndefined();
+    expect(rows[2].thinkingLevel).toBe('max');
+  });
+
+  test('consumes the change record instead of turning it into a row', () => {
+    const rows = convertMessages([changeEntry('low')], false);
+    expect(rows).toHaveLength(0);
+  });
+});
+
+describe('mergeMessages', () => {
+  test('replaces a streamed row in place so its stamped level survives finalization', () => {
+    const streamed = convertMessages([changeEntry('low'), assistantEntry('a1', 'partial')], true);
+    const final = convertMessages([changeEntry('low'), assistantEntry('a1', 'complete answer')], false);
+    const merged = mergeMessages(streamed, final);
+    expect(merged).toHaveLength(1);
+    expect(merged[0].content).toBe('complete answer');
+    expect(merged[0].thinkingLevel).toBe('low');
+  });
+
+  test('appends a row whose id is new', () => {
+    const prev: ChatMessageData[] = convertMessages([changeEntry('low'), assistantEntry('a1', 'first')], false);
+    const merged = mergeMessages(prev, convertMessages([changeEntry('low'), assistantEntry('a2', 'second')], false));
+    expect(merged.map((row) => row.id)).toEqual(['a1', 'a2']);
+  });
+});

package/src/shared/lib/omp/subagent/transcript-client.ts

@@ -13,6 +13,7 @@
 import type { ChatMessageData, SubagentMessagesPage } from '@/shared/types';
 import { toChatMessage } from '@/shared/lib/omp/session/mapper';
 import { extractText } from '@/shared/lib/omp/session/parse-message-blocks';
+import { normalizeThinkingLevel } from '@/shared/lib/models/thinking-levels';
 import { isRecord } from '@/shared/lib/util/guards';
 
 /** Normalize one wire message: the RPC may hand back bare omp AgentMessages
@@ -29,9 +30,20 @@ function normalizeRawMessage(value: unknown): Record<string, unknown> | null {
 
 export function convertMessages(raw: unknown[], streaming: boolean): ChatMessageData[] {
   const out: ChatMessageData[] = [];
+  // omp records the thinking level as its own `thinking_level_change` entry
+  // (session state), not as a per-message field. Walk the records in order and
+  // stamp the level in effect onto each non-user turn, so a subagent footer
+  // shows the level that served that turn — the child's own level, never the
+  // parent session's. Mirrors the server's main-session loader
+  // (`loadSessionMessages`).
+  let currentLevel: string | undefined;
   for (const item of raw) {
     if (isRecord(item)) {
       const entryType = typeof item.type === 'string' ? item.type : '';
+      if (entryType === 'thinking_level_change') {
+        currentLevel = normalizeThinkingLevel(item.thinkingLevel);
+        continue;
+      }
       if (entryType === 'custom' || entryType === 'custom_message') {
         const customType = typeof item.customType === 'string' ? item.customType : '';
         if (customType === 'session_exit') {
@@ -77,7 +89,11 @@ export function convertMessages(raw: unknown[], streaming: boolean): ChatMessage
     }
 
     const converted = toChatMessage(record, streaming);
-    if (converted) out.push(converted);
+    if (!converted) continue;
+    if (currentLevel !== undefined && converted.role !== 'user') {
+      converted.thinkingLevel = currentLevel;
+    }
+    out.push(converted);
   }
   return out;
 }

package/src/shared/lib/settings/diff.test.ts

@@ -4,7 +4,7 @@ import { diffSettings } from '@/shared/lib/settings/diff';
 
 describe('diffSettings', () => {
   test('an object patch persists only the keys it actually changed', () => {
-    const prev = { theme: 'paper', soundAlerts: true, binaryPath: '/bin/omp' };
+    const prev = { theme: 'paper', soundAlerts: true, editorFont: 'Fira Code' };
     const next = { ...prev, theme: 'nord-dark' };
     expect(diffSettings(prev, next, { theme: 'nord-dark' })).toEqual({ theme: 'nord-dark' });
   });

package/src/shared/lib/workspace/terminal/keys.test.ts

@@ -0,0 +1,189 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The bytes the terminal key bar sends.
+ *
+ * Every expectation here is copied from xterm's own `evaluateKeyboardEvent`
+ * (`@xterm/xterm/src/common/input/Keyboard.ts`), because the shell cannot tell a
+ * bar button from a physical key: a sequence that merely looks plausible works
+ * in bash and breaks in vim. Three of those rules are the ones this file exists
+ * to pin — a modifier is a CSI PARAMETER and not an ESC prefix, application
+ * cursor mode swaps in the SS3 spelling, and Ctrl on a literal key is a latch
+ * for typed text rather than a byte to fold.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  NO_MODIFIERS,
+  TERMINAL_KEYS,
+  TERMINAL_SYMBOLS,
+  applyModifiers,
+  ctrlCharacter,
+  resolveKeySequence,
+  type TerminalModifiers,
+} from '@/shared/lib/workspace/terminal/keys';
+
+const CTRL: TerminalModifiers = { ctrl: true, alt: false };
+const ALT: TerminalModifiers = { ctrl: false, alt: true };
+
+describe('resolveKeySequence — cursor keys', () => {
+  test('unmodified arrows use CSI', () => {
+    expect(resolveKeySequence('up')).toBe('\x1b[A');
+    expect(resolveKeySequence('down')).toBe('\x1b[B');
+    expect(resolveKeySequence('right')).toBe('\x1b[C');
+    expect(resolveKeySequence('left')).toBe('\x1b[D');
+  });
+
+  test('application cursor mode swaps in the SS3 spelling', () => {
+    const options = { applicationCursorKeys: true };
+    expect(resolveKeySequence('up', options)).toBe('\x1bOA');
+    expect(resolveKeySequence('left', options)).toBe('\x1bOD');
+  });
+
+  test('Home and End always use the terminfo spelling, DECCKM or not', () => {
+    // `TERM=xterm-256color` declares khome/kend as SS3, so the CSI form is a
+    // sequence the shell does not bind: zsh rings the bell and ignores it.
+    expect(resolveKeySequence('home')).toBe('\x1bOH');
+    expect(resolveKeySequence('end')).toBe('\x1bOF');
+    expect(resolveKeySequence('home', { applicationCursorKeys: true })).toBe('\x1bOH');
+    expect(resolveKeySequence('end', { applicationCursorKeys: true })).toBe('\x1bOF');
+  });
+
+  test('a modifier beats application cursor mode, as xterm does', () => {
+    const options = { applicationCursorKeys: true, modifiers: CTRL };
+    expect(resolveKeySequence('up', options)).toBe('\x1b[1;5A');
+  });
+
+  test('a modifier is a CSI parameter, never an ESC prefix', () => {
+    expect(resolveKeySequence('up', { modifiers: CTRL })).toBe('\x1b[1;5A');
+    expect(resolveKeySequence('up', { modifiers: ALT })).toBe('\x1b[1;3A');
+    expect(resolveKeySequence('up', { modifiers: { ctrl: true, alt: true } })).toBe('\x1b[1;7A');
+  });
+});
+
+describe('resolveKeySequence — keys with a fixed spelling', () => {
+  test('an unmodified page/delete key drops its leading 1', () => {
+    expect(resolveKeySequence('delete')).toBe('\x1b[3~');
+    expect(resolveKeySequence('pageUp')).toBe('\x1b[5~');
+    expect(resolveKeySequence('pageDown')).toBe('\x1b[6~');
+  });
+
+  test('page keys carry their prefix once modified', () => {
+    expect(resolveKeySequence('pageUp', { modifiers: CTRL })).toBe('\x1b[5;5~');
+    expect(resolveKeySequence('delete', { modifiers: ALT })).toBe('\x1b[3;3~');
+  });
+
+  test('a page key has no SS3 form, so DECCKM does not touch it', () => {
+    expect(resolveKeySequence('pageUp', { applicationCursorKeys: true })).toBe('\x1b[5~');
+  });
+
+  test('escape, tab and shift-tab are literal', () => {
+    expect(resolveKeySequence('escape')).toBe('\x1b');
+    expect(resolveKeySequence('tab')).toBe('\t');
+    expect(resolveKeySequence('shiftTab')).toBe('\x1b[Z');
+  });
+});
+
+describe('resolveKeySequence — modifiers on a literal key', () => {
+  test('Ctrl does NOT fold a literal key into a control byte', () => {
+    // The `^C` button is the only Ctrl+C. A tapped `|` stays a pipe: folding it
+    // would send FS (0x1c), which is not a pipe and not a signal.
+    expect(resolveKeySequence('pipe', { modifiers: CTRL })).toBe('|');
+    expect(resolveKeySequence('underscore', { modifiers: CTRL })).toBe('_');
+  });
+
+  test('Alt on a literal key is the ESC prefix', () => {
+    expect(resolveKeySequence('pipe', { modifiers: ALT })).toBe('\x1b|');
+    expect(resolveKeySequence('escape', { modifiers: ALT })).toBe('\x1b\x1b');
+  });
+
+  test('the dedicated control keys are already the folded byte', () => {
+    expect(resolveKeySequence('interrupt')).toBe('\x03');
+    expect(resolveKeySequence('eof')).toBe('\x04');
+    expect(resolveKeySequence('clear')).toBe('\x0c');
+  });
+});
+
+describe('resolveKeySequence — defaults and coverage', () => {
+  test('no options means no modifier and no application mode', () => {
+    // `pageUp` is the plain CSI default; Home/End carry a terminfo spelling.
+    expect(resolveKeySequence('pageUp')).toBe('\x1b[5~');
+    expect(NO_MODIFIERS).toEqual({ ctrl: false, alt: false });
+  });
+
+  test('every control key resolves to bytes', () => {
+    for (const def of TERMINAL_KEYS) {
+      expect(resolveKeySequence(def.id).length, def.id).toBeGreaterThan(0);
+    }
+  });
+
+  test('every symbol resolves to its own literal', () => {
+    for (const def of TERMINAL_SYMBOLS) {
+      expect(resolveKeySequence(def.id), def.id).toBe(def.sequence);
+    }
+  });
+
+  test('the symbol layer covers the characters a phone buries', () => {
+    const labels = new Set(TERMINAL_SYMBOLS.map((def) => def.label));
+    for (const required of ['|', '~', '\\', '$', '*', '?', '&', '<', '>', '`', '{', '}', '[', ']', '"', "'"]) {
+      expect(labels.has(required), required).toBe(true);
+    }
+  });
+
+  test('a symbol under a latched Alt is an ESC prefix, like any literal', () => {
+    expect(resolveKeySequence('dollar', { modifiers: ALT })).toBe('\x1b$');
+  });
+
+  test('an unknown id sends nothing rather than a guess', () => {
+    expect(resolveKeySequence('nope' as never)).toBe('');
+  });
+});
+
+describe('ctrlCharacter', () => {
+  test('letters fold case-insensitively onto C0', () => {
+    expect(ctrlCharacter('c')).toBe('\x03');
+    expect(ctrlCharacter('C')).toBe('\x03');
+    expect(ctrlCharacter('a')).toBe('\x01');
+    expect(ctrlCharacter('z')).toBe('\x1a');
+  });
+
+  test('the symbol set matches the terminal, not the ASCII table', () => {
+    expect(ctrlCharacter('@')).toBe('\x00');
+    expect(ctrlCharacter(' ')).toBe('\x00');
+    expect(ctrlCharacter('[')).toBe('\x1b');
+    expect(ctrlCharacter('_')).toBe('\x1f');
+    expect(ctrlCharacter('?')).toBe('\x7f');
+    expect(ctrlCharacter('!')).toBeNull();
+    expect(ctrlCharacter('ab')).toBeNull();
+  });
+});
+
+describe('applyModifiers', () => {
+  test('a latched Ctrl folds a typed letter', () => {
+    expect(applyModifiers('c', CTRL)).toBe('\x03');
+    expect(applyModifiers('r', CTRL)).toBe('\x12');
+  });
+
+  test('a latched Alt prefixes ESC', () => {
+    expect(applyModifiers('b', ALT)).toBe('\x1bb');
+    expect(applyModifiers('f', { ctrl: true, alt: true })).toBe('\x1b\x06');
+  });
+
+  test('no modifier is the identity', () => {
+    expect(applyModifiers('c', NO_MODIFIERS)).toBe('c');
+  });
+
+  test('a paste is left intact — the latch does not corrupt it', () => {
+    const pasted = 'bun run build\n';
+    expect(applyModifiers(pasted, CTRL)).toBe(pasted);
+    expect(applyModifiers(pasted, ALT)).toBe(pasted);
+  });
+
+  test('a character with no control code passes through', () => {
+    expect(applyModifiers('!', CTRL)).toBe('!');
+  });
+});