Add files using upload-large-folder tool

src/components/CtrlOToExpand.tsx

@@ -0,0 +1,51 @@
+import { c as _c } from "react/compiler-runtime";
+import chalk from 'chalk';
+import React, { useContext } from 'react';
+import { Text } from '../ink.js';
+import { getShortcutDisplay } from '../keybindings/shortcutFormat.js';
+import { useShortcutDisplay } from '../keybindings/useShortcutDisplay.js';
+import { KeyboardShortcutHint } from './design-system/KeyboardShortcutHint.js';
+import { InVirtualListContext } from './messageActions.js';
+
+// Context to track if we're inside a sub agent
+// Similar to MessageResponseContext, this helps us avoid showing
+// too many "(ctrl+o to expand)" hints in sub agent output
+const SubAgentContext = React.createContext(false);
+export function SubAgentProvider(t0) {
+  const $ = _c(2);
+  const {
+    children
+  } = t0;
+  let t1;
+  if ($[0] !== children) {
+    t1 = <SubAgentContext.Provider value={true}>{children}</SubAgentContext.Provider>;
+    $[0] = children;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  return t1;
+}
+export function CtrlOToExpand() {
+  const $ = _c(2);
+  const isInSubAgent = useContext(SubAgentContext);
+  const inVirtualList = useContext(InVirtualListContext);
+  const expandShortcut = useShortcutDisplay("app:toggleTranscript", "Global", "ctrl+o");
+  if (isInSubAgent || inVirtualList) {
+    return null;
+  }
+  let t0;
+  if ($[0] !== expandShortcut) {
+    t0 = <Text dimColor={true}><KeyboardShortcutHint shortcut={expandShortcut} action="expand" parens={true} /></Text>;
+    $[0] = expandShortcut;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+}
+export function ctrlOToExpand(): string {
+  const shortcut = getShortcutDisplay('app:toggleTranscript', 'Global', 'ctrl+o');
+  return chalk.dim(`(${shortcut} to expand)`);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/components/ExitFlow.tsx

@@ -0,0 +1,48 @@
+import { c as _c } from "react/compiler-runtime";
+import sample from 'lodash-es/sample.js';
+import React from 'react';
+import { gracefulShutdown } from '../utils/gracefulShutdown.js';
+import { WorktreeExitDialog } from './WorktreeExitDialog.js';
+const GOODBYE_MESSAGES = ['Goodbye!', 'See ya!', 'Bye!', 'Catch you later!'];
+function getRandomGoodbyeMessage(): string {
+  return sample(GOODBYE_MESSAGES) ?? 'Goodbye!';
+}
+type Props = {
+  onDone: (message?: string) => void;
+  onCancel?: () => void;
+  showWorktree: boolean;
+};
+export function ExitFlow(t0) {
+  const $ = _c(5);
+  const {
+    showWorktree,
+    onDone,
+    onCancel
+  } = t0;
+  let t1;
+  if ($[0] !== onDone) {
+    t1 = async function onExit(resultMessage) {
+      onDone(resultMessage ?? getRandomGoodbyeMessage());
+      await gracefulShutdown(0, "prompt_input_exit");
+    };
+    $[0] = onDone;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const onExit = t1;
+  if (showWorktree) {
+    let t2;
+    if ($[2] !== onCancel || $[3] !== onExit) {
+      t2 = <WorktreeExitDialog onDone={onExit} onCancel={onCancel} />;
+      $[2] = onCancel;
+      $[3] = onExit;
+      $[4] = t2;
+    } else {
+      t2 = $[4];
+    }
+    return t2;
+  }
+  return null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/components/ExportDialog.tsx

@@ -0,0 +1,128 @@
+import { join } from 'path';
+import React, { useCallback, useState } from 'react';
+import type { ExitState } from '../hooks/useExitOnCtrlCDWithKeybindings.js';
+import { useTerminalSize } from '../hooks/useTerminalSize.js';
+import { setClipboard } from '../ink/termio/osc.js';
+import { Box, Text } from '../ink.js';
+import { useKeybinding } from '../keybindings/useKeybinding.js';
+import { getCwd } from '../utils/cwd.js';
+import { writeFileSync_DEPRECATED } from '../utils/slowOperations.js';
+import { ConfigurableShortcutHint } from './ConfigurableShortcutHint.js';
+import { Select } from './CustomSelect/select.js';
+import { Byline } from './design-system/Byline.js';
+import { Dialog } from './design-system/Dialog.js';
+import { KeyboardShortcutHint } from './design-system/KeyboardShortcutHint.js';
+import TextInput from './TextInput.js';
+type ExportDialogProps = {
+  content: string;
+  defaultFilename: string;
+  onDone: (result: {
+    success: boolean;
+    message: string;
+  }) => void;
+};
+type ExportOption = 'clipboard' | 'file';
+export function ExportDialog({
+  content,
+  defaultFilename,
+  onDone
+}: ExportDialogProps): React.ReactNode {
+  const [, setSelectedOption] = useState<ExportOption | null>(null);
+  const [filename, setFilename] = useState<string>(defaultFilename);
+  const [cursorOffset, setCursorOffset] = useState<number>(defaultFilename.length);
+  const [showFilenameInput, setShowFilenameInput] = useState(false);
+  const {
+    columns
+  } = useTerminalSize();
+
+  // Handle going back from filename input to option selection
+  const handleGoBack = useCallback(() => {
+    setShowFilenameInput(false);
+    setSelectedOption(null);
+  }, []);
+  const handleSelectOption = async (value: string): Promise<void> => {
+    if (value === 'clipboard') {
+      // Copy to clipboard immediately
+      const raw = await setClipboard(content);
+      if (raw) process.stdout.write(raw);
+      onDone({
+        success: true,
+        message: 'Conversation copied to clipboard'
+      });
+    } else if (value === 'file') {
+      setSelectedOption('file');
+      setShowFilenameInput(true);
+    }
+  };
+  const handleFilenameSubmit = () => {
+    const finalFilename = filename.endsWith('.txt') ? filename : filename.replace(/\.[^.]+$/, '') + '.txt';
+    const filepath = join(getCwd(), finalFilename);
+    try {
+      writeFileSync_DEPRECATED(filepath, content, {
+        encoding: 'utf-8',
+        flush: true
+      });
+      onDone({
+        success: true,
+        message: `Conversation exported to: ${filepath}`
+      });
+    } catch (error) {
+      onDone({
+        success: false,
+        message: `Failed to export conversation: ${error instanceof Error ? error.message : 'Unknown error'}`
+      });
+    }
+  };
+
+  // Dialog calls onCancel when Escape is pressed. If we are in the filename
+  // input sub-screen, go back to the option list instead of closing entirely.
+  const handleCancel = useCallback(() => {
+    if (showFilenameInput) {
+      handleGoBack();
+    } else {
+      onDone({
+        success: false,
+        message: 'Export cancelled'
+      });
+    }
+  }, [showFilenameInput, handleGoBack, onDone]);
+  const options = [{
+    label: 'Copy to clipboard',
+    value: 'clipboard',
+    description: 'Copy the conversation to your system clipboard'
+  }, {
+    label: 'Save to file',
+    value: 'file',
+    description: 'Save the conversation to a file in the current directory'
+  }];
+
+  // Custom input guide that changes based on dialog state
+  function renderInputGuide(exitState: ExitState): React.ReactNode {
+    if (showFilenameInput) {
+      return <Byline>
+          <KeyboardShortcutHint shortcut="Enter" action="save" />
+          <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="go back" />
+        </Byline>;
+    }
+    if (exitState.pending) {
+      return <Text>Press {exitState.keyName} again to exit</Text>;
+    }
+    return <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="cancel" />;
+  }
+
+  // Use Settings context so 'n' key doesn't cancel (allows typing 'n' in filename input)
+  useKeybinding('confirm:no', handleCancel, {
+    context: 'Settings',
+    isActive: showFilenameInput
+  });
+  return <Dialog title="Export Conversation" subtitle="Select export method:" color="permission" onCancel={handleCancel} inputGuide={renderInputGuide} isCancelActive={!showFilenameInput}>
+      {!showFilenameInput ? <Select options={options} onChange={handleSelectOption} onCancel={handleCancel} /> : <Box flexDirection="column">
+          <Text>Enter filename:</Text>
+          <Box flexDirection="row" gap={1} marginTop={1}>
+            <Text>&gt;</Text>
+            <TextInput value={filename} onChange={setFilename} onSubmit={handleFilenameSubmit} focus={true} showCursor={true} columns={columns} cursorOffset={cursorOffset} onChangeCursorOffset={setCursorOffset} />
+          </Box>
+        </Box>}
+    </Dialog>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["join","React","useCallback","useState","ExitState","useTerminalSize","setClipboard","Box","Text","useKeybinding","getCwd","writeFileSync_DEPRECATED","ConfigurableShortcutHint","Select","Byline","Dialog","KeyboardShortcutHint","TextInput","ExportDialogProps","content","defaultFilename","onDone","result","success","message","ExportOption","ExportDialog","ReactNode","setSelectedOption","filename","setFilename","cursorOffset","setCursorOffset","length","showFilenameInput","setShowFilenameInput","columns","handleGoBack","handleSelectOption","value","Promise","raw","process","stdout","write","handleFilenameSubmit","finalFilename","endsWith","replace","filepath","encoding","flush","error","Error","handleCancel","options","label","description","renderInputGuide","exitState","pending","keyName","context","isActive"],"sources":["ExportDialog.tsx"],"sourcesContent":["import { join } from 'path'\nimport React, { useCallback, useState } from 'react'\nimport type { ExitState } from '../hooks/useExitOnCtrlCDWithKeybindings.js'\nimport { useTerminalSize } from '../hooks/useTerminalSize.js'\nimport { setClipboard } from '../ink/termio/osc.js'\nimport { Box, Text } from '../ink.js'\nimport { useKeybinding } from '../keybindings/useKeybinding.js'\nimport { getCwd } from '../utils/cwd.js'\nimport { writeFileSync_DEPRECATED } from '../utils/slowOperations.js'\nimport { ConfigurableShortcutHint } from './ConfigurableShortcutHint.js'\nimport { Select } from './CustomSelect/select.js'\nimport { Byline } from './design-system/Byline.js'\nimport { Dialog } from './design-system/Dialog.js'\nimport { KeyboardShortcutHint } from './design-system/KeyboardShortcutHint.js'\nimport TextInput from './TextInput.js'\n\ntype ExportDialogProps = {\n  content: string\n  defaultFilename: string\n  onDone: (result: { success: boolean; message: string }) => void\n}\n\ntype ExportOption = 'clipboard' | 'file'\n\nexport function ExportDialog({\n  content,\n  defaultFilename,\n  onDone,\n}: ExportDialogProps): React.ReactNode {\n  const [, setSelectedOption] = useState<ExportOption | null>(null)\n  const [filename, setFilename] = useState<string>(defaultFilename)\n  const [cursorOffset, setCursorOffset] = useState<number>(\n    defaultFilename.length,\n  )\n  const [showFilenameInput, setShowFilenameInput] = useState(false)\n  const { columns } = useTerminalSize()\n\n  // Handle going back from filename input to option selection\n  const handleGoBack = useCallback(() => {\n    setShowFilenameInput(false)\n    setSelectedOption(null)\n  }, [])\n\n  const handleSelectOption = async (value: string): Promise<void> => {\n    if (value === 'clipboard') {\n      // Copy to clipboard immediately\n      const raw = await setClipboard(content)\n      if (raw) process.stdout.write(raw)\n      onDone({ success: true, message: 'Conversation copied to clipboard' })\n    } else if (value === 'file') {\n      setSelectedOption('file')\n      setShowFilenameInput(true)\n    }\n  }\n\n  const handleFilenameSubmit = () => {\n    const finalFilename = filename.endsWith('.txt')\n      ? filename\n      : filename.replace(/\\.[^.]+$/, '') + '.txt'\n    const filepath = join(getCwd(), finalFilename)\n\n    try {\n      writeFileSync_DEPRECATED(filepath, content, {\n        encoding: 'utf-8',\n        flush: true,\n      })\n      onDone({\n        success: true,\n        message: `Conversation exported to: ${filepath}`,\n      })\n    } catch (error) {\n      onDone({\n        success: false,\n        message: `Failed to export conversation: ${error instanceof Error ? error.message : 'Unknown error'}`,\n      })\n    }\n  }\n\n  // Dialog calls onCancel when Escape is pressed. If we are in the filename\n  // input sub-screen, go back to the option list instead of closing entirely.\n  const handleCancel = useCallback(() => {\n    if (showFilenameInput) {\n      handleGoBack()\n    } else {\n      onDone({ success: false, message: 'Export cancelled' })\n    }\n  }, [showFilenameInput, handleGoBack, onDone])\n\n  const options = [\n    {\n      label: 'Copy to clipboard',\n      value: 'clipboard',\n      description: 'Copy the conversation to your system clipboard',\n    },\n    {\n      label: 'Save to file',\n      value: 'file',\n      description: 'Save the conversation to a file in the current directory',\n    },\n  ]\n\n  // Custom input guide that changes based on dialog state\n  function renderInputGuide(exitState: ExitState): React.ReactNode {\n    if (showFilenameInput) {\n      return (\n        <Byline>\n          <KeyboardShortcutHint shortcut=\"Enter\" action=\"save\" />\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Confirmation\"\n            fallback=\"Esc\"\n            description=\"go back\"\n          />\n        </Byline>\n      )\n    }\n\n    if (exitState.pending) {\n      return <Text>Press {exitState.keyName} again to exit</Text>\n    }\n\n    return (\n      <ConfigurableShortcutHint\n        action=\"confirm:no\"\n        context=\"Confirmation\"\n        fallback=\"Esc\"\n        description=\"cancel\"\n      />\n    )\n  }\n\n  // Use Settings context so 'n' key doesn't cancel (allows typing 'n' in filename input)\n  useKeybinding('confirm:no', handleCancel, {\n    context: 'Settings',\n    isActive: showFilenameInput,\n  })\n\n  return (\n    <Dialog\n      title=\"Export Conversation\"\n      subtitle=\"Select export method:\"\n      color=\"permission\"\n      onCancel={handleCancel}\n      inputGuide={renderInputGuide}\n      isCancelActive={!showFilenameInput}\n    >\n      {!showFilenameInput ? (\n        <Select\n          options={options}\n          onChange={handleSelectOption}\n          onCancel={handleCancel}\n        />\n      ) : (\n        <Box flexDirection=\"column\">\n          <Text>Enter filename:</Text>\n          <Box flexDirection=\"row\" gap={1} marginTop={1}>\n            <Text>&gt;</Text>\n            <TextInput\n              value={filename}\n              onChange={setFilename}\n              onSubmit={handleFilenameSubmit}\n              focus={true}\n              showCursor={true}\n              columns={columns}\n              cursorOffset={cursorOffset}\n              onChangeCursorOffset={setCursorOffset}\n            />\n          </Box>\n        </Box>\n      )}\n    </Dialog>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/components/FileEditToolDiff.tsx

@@ -0,0 +1,181 @@
+import { c as _c } from "react/compiler-runtime";
+import type { StructuredPatchHunk } from 'diff';
+import * as React from 'react';
+import { Suspense, use, useState } from 'react';
+import { useTerminalSize } from '../hooks/useTerminalSize.js';
+import { Box, Text } from '../ink.js';
+import type { FileEdit } from '../tools/FileEditTool/types.js';
+import { findActualString, preserveQuoteStyle } from '../tools/FileEditTool/utils.js';
+import { adjustHunkLineNumbers, CONTEXT_LINES, getPatchForDisplay } from '../utils/diff.js';
+import { logError } from '../utils/log.js';
+import { CHUNK_SIZE, openForScan, readCapped, scanForContext } from '../utils/readEditContext.js';
+import { firstLineOf } from '../utils/stringUtils.js';
+import { StructuredDiffList } from './StructuredDiffList.js';
+type Props = {
+  file_path: string;
+  edits: FileEdit[];
+};
+type DiffData = {
+  patch: StructuredPatchHunk[];
+  firstLine: string | null;
+  fileContent: string | undefined;
+};
+export function FileEditToolDiff(props) {
+  const $ = _c(7);
+  let t0;
+  if ($[0] !== props.edits || $[1] !== props.file_path) {
+    t0 = () => loadDiffData(props.file_path, props.edits);
+    $[0] = props.edits;
+    $[1] = props.file_path;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const [dataPromise] = useState(t0);
+  let t1;
+  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = <DiffFrame placeholder={true} />;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  let t2;
+  if ($[4] !== dataPromise || $[5] !== props.file_path) {
+    t2 = <Suspense fallback={t1}><DiffBody promise={dataPromise} file_path={props.file_path} /></Suspense>;
+    $[4] = dataPromise;
+    $[5] = props.file_path;
+    $[6] = t2;
+  } else {
+    t2 = $[6];
+  }
+  return t2;
+}
+function DiffBody(t0) {
+  const $ = _c(6);
+  const {
+    promise,
+    file_path
+  } = t0;
+  const {
+    patch,
+    firstLine,
+    fileContent
+  } = use(promise);
+  const {
+    columns
+  } = useTerminalSize();
+  let t1;
+  if ($[0] !== columns || $[1] !== fileContent || $[2] !== file_path || $[3] !== firstLine || $[4] !== patch) {
+    t1 = <DiffFrame><StructuredDiffList hunks={patch} dim={false} width={columns} filePath={file_path} firstLine={firstLine} fileContent={fileContent} /></DiffFrame>;
+    $[0] = columns;
+    $[1] = fileContent;
+    $[2] = file_path;
+    $[3] = firstLine;
+    $[4] = patch;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  return t1;
+}
+function DiffFrame(t0) {
+  const $ = _c(5);
+  const {
+    children,
+    placeholder
+  } = t0;
+  let t1;
+  if ($[0] !== children || $[1] !== placeholder) {
+    t1 = placeholder ? <Text dimColor={true}>…</Text> : children;
+    $[0] = children;
+    $[1] = placeholder;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  let t2;
+  if ($[3] !== t1) {
+    t2 = <Box flexDirection="column"><Box borderColor="subtle" borderStyle="dashed" flexDirection="column" borderLeft={false} borderRight={false}>{t1}</Box></Box>;
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  return t2;
+}
+async function loadDiffData(file_path: string, edits: FileEdit[]): Promise<DiffData> {
+  const valid = edits.filter(e => e.old_string != null && e.new_string != null);
+  const single = valid.length === 1 ? valid[0]! : undefined;
+
+  // SedEditPermissionRequest passes the entire file as old_string. Scanning for
+  // a needle ≥ CHUNK_SIZE allocates O(needle) for the overlap buffer — skip the
+  // file read entirely and diff the inputs we already have.
+  if (single && single.old_string.length >= CHUNK_SIZE) {
+    return diffToolInputsOnly(file_path, [single]);
+  }
+  try {
+    const handle = await openForScan(file_path);
+    if (handle === null) return diffToolInputsOnly(file_path, valid);
+    try {
+      // Multi-edit and empty old_string genuinely need full-file for sequential
+      // replacements — structuredPatch needs before/after strings. replace_all
+      // routes through the chunked path below (shows first-occurrence window;
+      // matches within the slice still replace via edit.replace_all).
+      if (!single || single.old_string === '') {
+        const file = await readCapped(handle);
+        if (file === null) return diffToolInputsOnly(file_path, valid);
+        const normalized = valid.map(e => normalizeEdit(file, e));
+        return {
+          patch: getPatchForDisplay({
+            filePath: file_path,
+            fileContents: file,
+            edits: normalized
+          }),
+          firstLine: firstLineOf(file),
+          fileContent: file
+        };
+      }
+      const ctx = await scanForContext(handle, single.old_string, CONTEXT_LINES);
+      if (ctx.truncated || ctx.content === '') {
+        return diffToolInputsOnly(file_path, [single]);
+      }
+      const normalized = normalizeEdit(ctx.content, single);
+      const hunks = getPatchForDisplay({
+        filePath: file_path,
+        fileContents: ctx.content,
+        edits: [normalized]
+      });
+      return {
+        patch: adjustHunkLineNumbers(hunks, ctx.lineOffset - 1),
+        firstLine: ctx.lineOffset === 1 ? firstLineOf(ctx.content) : null,
+        fileContent: ctx.content
+      };
+    } finally {
+      await handle.close();
+    }
+  } catch (e) {
+    logError(e as Error);
+    return diffToolInputsOnly(file_path, valid);
+  }
+}
+function diffToolInputsOnly(filePath: string, edits: FileEdit[]): DiffData {
+  return {
+    patch: edits.flatMap(e => getPatchForDisplay({
+      filePath,
+      fileContents: e.old_string,
+      edits: [e]
+    })),
+    firstLine: null,
+    fileContent: undefined
+  };
+}
+function normalizeEdit(fileContent: string, edit: FileEdit): FileEdit {
+  const actualOld = findActualString(fileContent, edit.old_string) || edit.old_string;
+  const actualNew = preserveQuoteStyle(edit.old_string, actualOld, edit.new_string);
+  return {
+    ...edit,
+    old_string: actualOld,
+    new_string: actualNew
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["StructuredPatchHunk","React","Suspense","use","useState","useTerminalSize","Box","Text","FileEdit","findActualString","preserveQuoteStyle","adjustHunkLineNumbers","CONTEXT_LINES","getPatchForDisplay","logError","CHUNK_SIZE","openForScan","readCapped","scanForContext","firstLineOf","StructuredDiffList","Props","file_path","edits","DiffData","patch","firstLine","fileContent","FileEditToolDiff","props","$","_c","t0","loadDiffData","dataPromise","t1","Symbol","for","t2","DiffBody","promise","columns","DiffFrame","children","placeholder","Promise","valid","filter","e","old_string","new_string","single","length","undefined","diffToolInputsOnly","handle","file","normalized","map","normalizeEdit","filePath","fileContents","ctx","truncated","content","hunks","lineOffset","close","Error","flatMap","edit","actualOld","actualNew"],"sources":["FileEditToolDiff.tsx"],"sourcesContent":["import type { StructuredPatchHunk } from 'diff'\nimport * as React from 'react'\nimport { Suspense, use, useState } from 'react'\nimport { useTerminalSize } from '../hooks/useTerminalSize.js'\nimport { Box, Text } from '../ink.js'\nimport type { FileEdit } from '../tools/FileEditTool/types.js'\nimport {\n  findActualString,\n  preserveQuoteStyle,\n} from '../tools/FileEditTool/utils.js'\nimport {\n  adjustHunkLineNumbers,\n  CONTEXT_LINES,\n  getPatchForDisplay,\n} from '../utils/diff.js'\nimport { logError } from '../utils/log.js'\nimport {\n  CHUNK_SIZE,\n  openForScan,\n  readCapped,\n  scanForContext,\n} from '../utils/readEditContext.js'\nimport { firstLineOf } from '../utils/stringUtils.js'\nimport { StructuredDiffList } from './StructuredDiffList.js'\n\ntype Props = {\n  file_path: string\n  edits: FileEdit[]\n}\n\ntype DiffData = {\n  patch: StructuredPatchHunk[]\n  firstLine: string | null\n  fileContent: string | undefined\n}\n\nexport function FileEditToolDiff(props: Props): React.ReactNode {\n  // Snapshot on mount — the diff must stay consistent even if the file changes\n  // while the dialog is open. useMemo on props.edits would re-read the file on\n  // every render because callers pass fresh array literals.\n  const [dataPromise] = useState(() =>\n    loadDiffData(props.file_path, props.edits),\n  )\n  return (\n    <Suspense fallback={<DiffFrame placeholder />}>\n      <DiffBody promise={dataPromise} file_path={props.file_path} />\n    </Suspense>\n  )\n}\n\nfunction DiffBody({\n  promise,\n  file_path,\n}: {\n  promise: Promise<DiffData>\n  file_path: string\n}): React.ReactNode {\n  const { patch, firstLine, fileContent } = use(promise)\n  const { columns } = useTerminalSize()\n  return (\n    <DiffFrame>\n      <StructuredDiffList\n        hunks={patch}\n        dim={false}\n        width={columns}\n        filePath={file_path}\n        firstLine={firstLine}\n        fileContent={fileContent}\n      />\n    </DiffFrame>\n  )\n}\n\nfunction DiffFrame({\n  children,\n  placeholder,\n}: {\n  children?: React.ReactNode\n  placeholder?: boolean\n}): React.ReactNode {\n  return (\n    <Box flexDirection=\"column\">\n      <Box\n        borderColor=\"subtle\"\n        borderStyle=\"dashed\"\n        flexDirection=\"column\"\n        borderLeft={false}\n        borderRight={false}\n      >\n        {placeholder ? <Text dimColor>…</Text> : children}\n      </Box>\n    </Box>\n  )\n}\n\nasync function loadDiffData(\n  file_path: string,\n  edits: FileEdit[],\n): Promise<DiffData> {\n  const valid = edits.filter(e => e.old_string != null && e.new_string != null)\n  const single = valid.length === 1 ? valid[0]! : undefined\n\n  // SedEditPermissionRequest passes the entire file as old_string. Scanning for\n  // a needle ≥ CHUNK_SIZE allocates O(needle) for the overlap buffer — skip the\n  // file read entirely and diff the inputs we already have.\n  if (single && single.old_string.length >= CHUNK_SIZE) {\n    return diffToolInputsOnly(file_path, [single])\n  }\n\n  try {\n    const handle = await openForScan(file_path)\n    if (handle === null) return diffToolInputsOnly(file_path, valid)\n    try {\n      // Multi-edit and empty old_string genuinely need full-file for sequential\n      // replacements — structuredPatch needs before/after strings. replace_all\n      // routes through the chunked path below (shows first-occurrence window;\n      // matches within the slice still replace via edit.replace_all).\n      if (!single || single.old_string === '') {\n        const file = await readCapped(handle)\n        if (file === null) return diffToolInputsOnly(file_path, valid)\n        const normalized = valid.map(e => normalizeEdit(file, e))\n        return {\n          patch: getPatchForDisplay({\n            filePath: file_path,\n            fileContents: file,\n            edits: normalized,\n          }),\n          firstLine: firstLineOf(file),\n          fileContent: file,\n        }\n      }\n\n      const ctx = await scanForContext(handle, single.old_string, CONTEXT_LINES)\n      if (ctx.truncated || ctx.content === '') {\n        return diffToolInputsOnly(file_path, [single])\n      }\n      const normalized = normalizeEdit(ctx.content, single)\n      const hunks = getPatchForDisplay({\n        filePath: file_path,\n        fileContents: ctx.content,\n        edits: [normalized],\n      })\n      return {\n        patch: adjustHunkLineNumbers(hunks, ctx.lineOffset - 1),\n        firstLine: ctx.lineOffset === 1 ? firstLineOf(ctx.content) : null,\n        fileContent: ctx.content,\n      }\n    } finally {\n      await handle.close()\n    }\n  } catch (e) {\n    logError(e as Error)\n    return diffToolInputsOnly(file_path, valid)\n  }\n}\n\nfunction diffToolInputsOnly(filePath: string, edits: FileEdit[]): DiffData {\n  return {\n    patch: edits.flatMap(e =>\n      getPatchForDisplay({\n        filePath,\n        fileContents: e.old_string,\n        edits: [e],\n      }),\n    ),\n    firstLine: null,\n    fileContent: undefined,\n  }\n}\n\nfunction normalizeEdit(fileContent: string, edit: FileEdit): FileEdit {\n  const actualOld =\n    findActualString(fileContent, edit.old_string) || edit.old_string\n  const actualNew = preserveQuoteStyle(\n    edit.old_string,\n    actualOld,\n    edit.new_string,\n  )\n  return { ...edit, old_string: actualOld, new_string: actualNew }\n}\n"],"mappings":"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","ignoreList":[]}

src/components/FileEditToolUseRejectedMessage.tsx

@@ -0,0 +1,170 @@
+import { c as _c } from "react/compiler-runtime";
+import type { StructuredPatchHunk } from 'diff';
+import { relative } from 'path';
+import * as React from 'react';
+import { useTerminalSize } from 'src/hooks/useTerminalSize.js';
+import { getCwd } from 'src/utils/cwd.js';
+import { Box, Text } from '../ink.js';
+import { HighlightedCode } from './HighlightedCode.js';
+import { MessageResponse } from './MessageResponse.js';
+import { StructuredDiffList } from './StructuredDiffList.js';
+const MAX_LINES_TO_RENDER = 10;
+type Props = {
+  file_path: string;
+  operation: 'write' | 'update';
+  // For updates - show diff
+  patch?: StructuredPatchHunk[];
+  firstLine: string | null;
+  fileContent?: string;
+  // For new file creation - show content preview
+  content?: string;
+  style?: 'condensed';
+  verbose: boolean;
+};
+export function FileEditToolUseRejectedMessage(t0) {
+  const $ = _c(38);
+  const {
+    file_path,
+    operation,
+    patch,
+    firstLine,
+    fileContent,
+    content,
+    style,
+    verbose
+  } = t0;
+  const {
+    columns
+  } = useTerminalSize();
+  let t1;
+  if ($[0] !== operation) {
+    t1 = <Text color="subtle">User rejected {operation} to </Text>;
+    $[0] = operation;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] !== file_path || $[3] !== verbose) {
+    t2 = verbose ? file_path : relative(getCwd(), file_path);
+    $[2] = file_path;
+    $[3] = verbose;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  let t3;
+  if ($[5] !== t2) {
+    t3 = <Text bold={true} color="subtle">{t2}</Text>;
+    $[5] = t2;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  let t4;
+  if ($[7] !== t1 || $[8] !== t3) {
+    t4 = <Box flexDirection="row">{t1}{t3}</Box>;
+    $[7] = t1;
+    $[8] = t3;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  const text = t4;
+  if (style === "condensed" && !verbose) {
+    let t5;
+    if ($[10] !== text) {
+      t5 = <MessageResponse>{text}</MessageResponse>;
+      $[10] = text;
+      $[11] = t5;
+    } else {
+      t5 = $[11];
+    }
+    return t5;
+  }
+  if (operation === "write" && content !== undefined) {
+    let plusLines;
+    let t5;
+    if ($[12] !== content || $[13] !== verbose) {
+      const lines = content.split("\n");
+      const numLines = lines.length;
+      plusLines = numLines - MAX_LINES_TO_RENDER;
+      t5 = verbose ? content : lines.slice(0, MAX_LINES_TO_RENDER).join("\n");
+      $[12] = content;
+      $[13] = verbose;
+      $[14] = plusLines;
+      $[15] = t5;
+    } else {
+      plusLines = $[14];
+      t5 = $[15];
+    }
+    const truncatedContent = t5;
+    const t6 = truncatedContent || "(No content)";
+    const t7 = columns - 12;
+    let t8;
+    if ($[16] !== file_path || $[17] !== t6 || $[18] !== t7) {
+      t8 = <HighlightedCode code={t6} filePath={file_path} width={t7} dim={true} />;
+      $[16] = file_path;
+      $[17] = t6;
+      $[18] = t7;
+      $[19] = t8;
+    } else {
+      t8 = $[19];
+    }
+    let t9;
+    if ($[20] !== plusLines || $[21] !== verbose) {
+      t9 = !verbose && plusLines > 0 && <Text dimColor={true}>… +{plusLines} lines</Text>;
+      $[20] = plusLines;
+      $[21] = verbose;
+      $[22] = t9;
+    } else {
+      t9 = $[22];
+    }
+    let t10;
+    if ($[23] !== t8 || $[24] !== t9 || $[25] !== text) {
+      t10 = <MessageResponse><Box flexDirection="column">{text}{t8}{t9}</Box></MessageResponse>;
+      $[23] = t8;
+      $[24] = t9;
+      $[25] = text;
+      $[26] = t10;
+    } else {
+      t10 = $[26];
+    }
+    return t10;
+  }
+  if (!patch || patch.length === 0) {
+    let t5;
+    if ($[27] !== text) {
+      t5 = <MessageResponse>{text}</MessageResponse>;
+      $[27] = text;
+      $[28] = t5;
+    } else {
+      t5 = $[28];
+    }
+    return t5;
+  }
+  const t5 = columns - 12;
+  let t6;
+  if ($[29] !== fileContent || $[30] !== file_path || $[31] !== firstLine || $[32] !== patch || $[33] !== t5) {
+    t6 = <StructuredDiffList hunks={patch} dim={true} width={t5} filePath={file_path} firstLine={firstLine} fileContent={fileContent} />;
+    $[29] = fileContent;
+    $[30] = file_path;
+    $[31] = firstLine;
+    $[32] = patch;
+    $[33] = t5;
+    $[34] = t6;
+  } else {
+    t6 = $[34];
+  }
+  let t7;
+  if ($[35] !== t6 || $[36] !== text) {
+    t7 = <MessageResponse><Box flexDirection="column">{text}{t6}</Box></MessageResponse>;
+    $[35] = t6;
+    $[36] = text;
+    $[37] = t7;
+  } else {
+    t7 = $[37];
+  }
+  return t7;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["StructuredPatchHunk","relative","React","useTerminalSize","getCwd","Box","Text","HighlightedCode","MessageResponse","StructuredDiffList","MAX_LINES_TO_RENDER","Props","file_path","operation","patch","firstLine","fileContent","content","style","verbose","FileEditToolUseRejectedMessage","t0","$","_c","columns","t1","t2","t3","t4","text","t5","undefined","plusLines","lines","split","numLines","length","slice","join","truncatedContent","t6","t7","t8","t9","t10"],"sources":["FileEditToolUseRejectedMessage.tsx"],"sourcesContent":["import type { StructuredPatchHunk } from 'diff'\nimport { relative } from 'path'\nimport * as React from 'react'\nimport { useTerminalSize } from 'src/hooks/useTerminalSize.js'\nimport { getCwd } from 'src/utils/cwd.js'\nimport { Box, Text } from '../ink.js'\nimport { HighlightedCode } from './HighlightedCode.js'\nimport { MessageResponse } from './MessageResponse.js'\nimport { StructuredDiffList } from './StructuredDiffList.js'\n\nconst MAX_LINES_TO_RENDER = 10\n\ntype Props = {\n  file_path: string\n  operation: 'write' | 'update'\n  // For updates - show diff\n  patch?: StructuredPatchHunk[]\n  firstLine: string | null\n  fileContent?: string\n  // For new file creation - show content preview\n  content?: string\n  style?: 'condensed'\n  verbose: boolean\n}\n\nexport function FileEditToolUseRejectedMessage({\n  file_path,\n  operation,\n  patch,\n  firstLine,\n  fileContent,\n  content,\n  style,\n  verbose,\n}: Props): React.ReactNode {\n  const { columns } = useTerminalSize()\n  const text = (\n    <Box flexDirection=\"row\">\n      <Text color=\"subtle\">User rejected {operation} to </Text>\n      <Text bold color=\"subtle\">\n        {verbose ? file_path : relative(getCwd(), file_path)}\n      </Text>\n    </Box>\n  )\n\n  // For condensed style, just show the text\n  if (style === 'condensed' && !verbose) {\n    return <MessageResponse>{text}</MessageResponse>\n  }\n\n  // For new file creation, show content preview (dimmed)\n  if (operation === 'write' && content !== undefined) {\n    const lines = content.split('\\n')\n    const numLines = lines.length\n    const plusLines = numLines - MAX_LINES_TO_RENDER\n    const truncatedContent = verbose\n      ? content\n      : lines.slice(0, MAX_LINES_TO_RENDER).join('\\n')\n\n    return (\n      <MessageResponse>\n        <Box flexDirection=\"column\">\n          {text}\n          <HighlightedCode\n            code={truncatedContent || '(No content)'}\n            filePath={file_path}\n            width={columns - 12}\n            dim\n          />\n          {!verbose && plusLines > 0 && (\n            <Text dimColor>… +{plusLines} lines</Text>\n          )}\n        </Box>\n      </MessageResponse>\n    )\n  }\n\n  // For updates, show diff\n  if (!patch || patch.length === 0) {\n    return <MessageResponse>{text}</MessageResponse>\n  }\n\n  return (\n    <MessageResponse>\n      <Box flexDirection=\"column\">\n        {text}\n        <StructuredDiffList\n          hunks={patch}\n          dim\n          width={columns - 12}\n          filePath={file_path}\n          firstLine={firstLine}\n          fileContent={fileContent}\n        />\n      </Box>\n    </MessageResponse>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

src/components/FilePathLink.tsx

@@ -0,0 +1,43 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import { pathToFileURL } from 'url';
+import Link from '../ink/components/Link.js';
+type Props = {
+  /** The absolute file path */
+  filePath: string;
+  /** Optional display text (defaults to filePath) */
+  children?: React.ReactNode;
+};
+
+/**
+ * Renders a file path as an OSC 8 hyperlink.
+ * This helps terminals like iTerm correctly identify file paths
+ * even when they appear inside parentheses or other text.
+ */
+export function FilePathLink(t0) {
+  const $ = _c(5);
+  const {
+    filePath,
+    children
+  } = t0;
+  let t1;
+  if ($[0] !== filePath) {
+    t1 = pathToFileURL(filePath);
+    $[0] = filePath;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const t2 = children ?? filePath;
+  let t3;
+  if ($[2] !== t1.href || $[3] !== t2) {
+    t3 = <Link url={t1.href}>{t2}</Link>;
+    $[2] = t1.href;
+    $[3] = t2;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  return t3;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/components/IdeStatusIndicator.tsx

@@ -0,0 +1,58 @@
+import { c as _c } from "react/compiler-runtime";
+import { basename } from 'path';
+import * as React from 'react';
+import { useIdeConnectionStatus } from '../hooks/useIdeConnectionStatus.js';
+import type { IDESelection } from '../hooks/useIdeSelection.js';
+import { Text } from '../ink.js';
+import type { MCPServerConnection } from '../services/mcp/types.js';
+type IdeStatusIndicatorProps = {
+  ideSelection: IDESelection | undefined;
+  mcpClients?: MCPServerConnection[];
+};
+export function IdeStatusIndicator(t0) {
+  const $ = _c(7);
+  const {
+    ideSelection,
+    mcpClients
+  } = t0;
+  const {
+    status: ideStatus
+  } = useIdeConnectionStatus(mcpClients);
+  const shouldShowIdeSelection = ideStatus === "connected" && (ideSelection?.filePath || ideSelection?.text && ideSelection.lineCount > 0);
+  if (ideStatus === null || !shouldShowIdeSelection || !ideSelection) {
+    return null;
+  }
+  if (ideSelection.text && ideSelection.lineCount > 0) {
+    const t1 = ideSelection.lineCount === 1 ? "line" : "lines";
+    let t2;
+    if ($[0] !== ideSelection.lineCount || $[1] !== t1) {
+      t2 = <Text color="ide" key="selection-indicator" wrap="truncate">⧉ {ideSelection.lineCount}{" "}{t1} selected</Text>;
+      $[0] = ideSelection.lineCount;
+      $[1] = t1;
+      $[2] = t2;
+    } else {
+      t2 = $[2];
+    }
+    return t2;
+  }
+  if (ideSelection.filePath) {
+    let t1;
+    if ($[3] !== ideSelection.filePath) {
+      t1 = basename(ideSelection.filePath);
+      $[3] = ideSelection.filePath;
+      $[4] = t1;
+    } else {
+      t1 = $[4];
+    }
+    let t2;
+    if ($[5] !== t1) {
+      t2 = <Text color="ide" key="selection-indicator" wrap="truncate">⧉ In {t1}</Text>;
+      $[5] = t1;
+      $[6] = t2;
+    } else {
+      t2 = $[6];
+    }
+    return t2;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/components/IdleReturnDialog.tsx

@@ -0,0 +1,118 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import { Box, Text } from '../ink.js';
+import { formatTokens } from '../utils/format.js';
+import { Select } from './CustomSelect/index.js';
+import { Dialog } from './design-system/Dialog.js';
+type IdleReturnAction = 'continue' | 'clear' | 'dismiss' | 'never';
+type Props = {
+  idleMinutes: number;
+  totalInputTokens: number;
+  onDone: (action: IdleReturnAction) => void;
+};
+export function IdleReturnDialog(t0) {
+  const $ = _c(16);
+  const {
+    idleMinutes,
+    totalInputTokens,
+    onDone
+  } = t0;
+  let t1;
+  if ($[0] !== idleMinutes) {
+    t1 = formatIdleDuration(idleMinutes);
+    $[0] = idleMinutes;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const formattedIdle = t1;
+  let t2;
+  if ($[2] !== totalInputTokens) {
+    t2 = formatTokens(totalInputTokens);
+    $[2] = totalInputTokens;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const formattedTokens = t2;
+  const t3 = `You've been away ${formattedIdle} and this conversation is ${formattedTokens} tokens.`;
+  let t4;
+  if ($[4] !== onDone) {
+    t4 = () => onDone("dismiss");
+    $[4] = onDone;
+    $[5] = t4;
+  } else {
+    t4 = $[5];
+  }
+  let t5;
+  if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = <Box flexDirection="column"><Text>If this is a new task, clearing context will save usage and be faster.</Text></Box>;
+    $[6] = t5;
+  } else {
+    t5 = $[6];
+  }
+  let t6;
+  if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+    t6 = {
+      value: "continue" as const,
+      label: "Continue this conversation"
+    };
+    $[7] = t6;
+  } else {
+    t6 = $[7];
+  }
+  let t7;
+  if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+    t7 = {
+      value: "clear" as const,
+      label: "Send message as a new conversation"
+    };
+    $[8] = t7;
+  } else {
+    t7 = $[8];
+  }
+  let t8;
+  if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+    t8 = [t6, t7, {
+      value: "never" as const,
+      label: "Don't ask me again"
+    }];
+    $[9] = t8;
+  } else {
+    t8 = $[9];
+  }
+  let t9;
+  if ($[10] !== onDone) {
+    t9 = <Select options={t8} onChange={value => onDone(value)} />;
+    $[10] = onDone;
+    $[11] = t9;
+  } else {
+    t9 = $[11];
+  }
+  let t10;
+  if ($[12] !== t3 || $[13] !== t4 || $[14] !== t9) {
+    t10 = <Dialog title={t3} onCancel={t4}>{t5}{t9}</Dialog>;
+    $[12] = t3;
+    $[13] = t4;
+    $[14] = t9;
+    $[15] = t10;
+  } else {
+    t10 = $[15];
+  }
+  return t10;
+}
+function formatIdleDuration(minutes: number): string {
+  if (minutes < 1) {
+    return '< 1m';
+  }
+  if (minutes < 60) {
+    return `${Math.floor(minutes)}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = Math.floor(minutes % 60);
+  if (remainingMinutes === 0) {
+    return `${hours}h`;
+  }
+  return `${hours}h ${remainingMinutes}m`;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/components/InterruptedByUser.tsx

@@ -0,0 +1,15 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { Text } from '../ink.js';
+export function InterruptedByUser() {
+  const $ = _c(1);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = <><Text dimColor={true}>Interrupted </Text>{false ? <Text dimColor={true}>· [ANT-ONLY] /issue to report a model issue</Text> : <Text dimColor={true}>· What should Claude do instead?</Text>}</>;
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  return t0;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIlRleHQiLCJJbnRlcnJ1cHRlZEJ5VXNlciIsIiQiLCJfYyIsInQwIiwiU3ltYm9sIiwiZm9yIl0sInNvdXJjZXMiOlsiSW50ZXJydXB0ZWRCeVVzZXIudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIFJlYWN0IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHsgVGV4dCB9IGZyb20gJy4uL2luay5qcydcblxuZXhwb3J0IGZ1bmN0aW9uIEludGVycnVwdGVkQnlVc2VyKCk6IFJlYWN0LlJlYWN0Tm9kZSB7XG4gIHJldHVybiAoXG4gICAgPD5cbiAgICAgIDxUZXh0IGRpbUNvbG9yPkludGVycnVwdGVkIDwvVGV4dD5cbiAgICAgIHtcImV4dGVybmFsXCIgPT09ICdhbnQnID8gKFxuICAgICAgICA8VGV4dCBkaW1Db2xvcj7CtyBbQU5ULU9OTFldIC9pc3N1ZSB0byByZXBvcnQgYSBtb2RlbCBpc3N1ZTwvVGV4dD5cbiAgICAgICkgOiAoXG4gICAgICAgIDxUZXh0IGRpbUNvbG9yPsK3IFdoYXQgc2hvdWxkIENsYXVkZSBkbyBpbnN0ZWFkPzwvVGV4dD5cbiAgICAgICl9XG4gICAgPC8+XG4gIClcbn1cbiJdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sS0FBS0EsS0FBSyxNQUFNLE9BQU87QUFDOUIsU0FBU0MsSUFBSSxRQUFRLFdBQVc7QUFFaEMsT0FBTyxTQUFBQyxrQkFBQTtFQUFBLE1BQUFDLENBQUEsR0FBQUMsRUFBQTtFQUFBLElBQUFDLEVBQUE7RUFBQSxJQUFBRixDQUFBLFFBQUFHLE1BQUEsQ0FBQUMsR0FBQTtJQUVIRixFQUFBLEtBQ0UsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFSLEtBQU8sQ0FBQyxDQUFDLFlBQVksRUFBMUIsSUFBSSxDQUNKLE1BQW9CLEdBQ25CLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBUixLQUFPLENBQUMsQ0FBQywyQ0FBMkMsRUFBekQsSUFBSSxDQUdOLEdBREMsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFSLEtBQU8sQ0FBQyxDQUFDLGdDQUFnQyxFQUE5QyxJQUFJLENBQ1AsQ0FBQyxHQUNBO0lBQUFGLENBQUEsTUFBQUUsRUFBQTtFQUFBO0lBQUFBLEVBQUEsR0FBQUYsQ0FBQTtFQUFBO0VBQUEsT0FQSEUsRUFPRztBQUFBIiwiaWdub3JlTGlzdCI6W119

src/components/InvalidConfigDialog.tsx

@@ -0,0 +1,156 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import { Box, render, Text } from '../ink.js';
+import { KeybindingSetup } from '../keybindings/KeybindingProviderSetup.js';
+import { AppStateProvider } from '../state/AppState.js';
+import type { ConfigParseError } from '../utils/errors.js';
+import { getBaseRenderOptions } from '../utils/renderOptions.js';
+import { jsonStringify, writeFileSync_DEPRECATED } from '../utils/slowOperations.js';
+import type { ThemeName } from '../utils/theme.js';
+import { Select } from './CustomSelect/index.js';
+import { Dialog } from './design-system/Dialog.js';
+interface InvalidConfigHandlerProps {
+  error: ConfigParseError;
+}
+interface InvalidConfigDialogProps {
+  filePath: string;
+  errorDescription: string;
+  onExit: () => void;
+  onReset: () => void;
+}
+
+/**
+ * Dialog shown when the Claude config file contains invalid JSON
+ */
+function InvalidConfigDialog(t0) {
+  const $ = _c(19);
+  const {
+    filePath,
+    errorDescription,
+    onExit,
+    onReset
+  } = t0;
+  let t1;
+  if ($[0] !== onExit || $[1] !== onReset) {
+    t1 = value => {
+      if (value === "exit") {
+        onExit();
+      } else {
+        onReset();
+      }
+    };
+    $[0] = onExit;
+    $[1] = onReset;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const handleSelect = t1;
+  let t2;
+  if ($[3] !== filePath) {
+    t2 = <Text>The configuration file at <Text bold={true}>{filePath}</Text> contains invalid JSON.</Text>;
+    $[3] = filePath;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  let t3;
+  if ($[5] !== errorDescription) {
+    t3 = <Text>{errorDescription}</Text>;
+    $[5] = errorDescription;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  let t4;
+  if ($[7] !== t2 || $[8] !== t3) {
+    t4 = <Box flexDirection="column" gap={1}>{t2}{t3}</Box>;
+    $[7] = t2;
+    $[8] = t3;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  let t5;
+  if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = <Text bold={true}>Choose an option:</Text>;
+    $[10] = t5;
+  } else {
+    t5 = $[10];
+  }
+  let t6;
+  if ($[11] === Symbol.for("react.memo_cache_sentinel")) {
+    t6 = [{
+      label: "Exit and fix manually",
+      value: "exit"
+    }, {
+      label: "Reset with default configuration",
+      value: "reset"
+    }];
+    $[11] = t6;
+  } else {
+    t6 = $[11];
+  }
+  let t7;
+  if ($[12] !== handleSelect || $[13] !== onExit) {
+    t7 = <Box flexDirection="column">{t5}<Select options={t6} onChange={handleSelect} onCancel={onExit} /></Box>;
+    $[12] = handleSelect;
+    $[13] = onExit;
+    $[14] = t7;
+  } else {
+    t7 = $[14];
+  }
+  let t8;
+  if ($[15] !== onExit || $[16] !== t4 || $[17] !== t7) {
+    t8 = <Dialog title="Configuration Error" color="error" onCancel={onExit}>{t4}{t7}</Dialog>;
+    $[15] = onExit;
+    $[16] = t4;
+    $[17] = t7;
+    $[18] = t8;
+  } else {
+    t8 = $[18];
+  }
+  return t8;
+}
+
+/**
+ * Safe fallback theme name for error dialogs to avoid circular dependency.
+ * Uses a hardcoded dark theme that doesn't require reading from config.
+ */
+const SAFE_ERROR_THEME_NAME: ThemeName = 'dark';
+export async function showInvalidConfigDialog({
+  error
+}: InvalidConfigHandlerProps): Promise<void> {
+  // Extend RenderOptions with theme property for this specific usage
+  type SafeRenderOptions = Parameters<typeof render>[1] & {
+    theme?: ThemeName;
+  };
+  const renderOptions: SafeRenderOptions = {
+    ...getBaseRenderOptions(false),
+    // IMPORTANT: Use hardcoded theme name to avoid circular dependency with getGlobalConfig()
+    // This allows the error dialog to show even when config file has JSON syntax errors
+    theme: SAFE_ERROR_THEME_NAME
+  };
+  await new Promise<void>(async resolve => {
+    const {
+      unmount
+    } = await render(<AppStateProvider>
+        <KeybindingSetup>
+          <InvalidConfigDialog filePath={error.filePath} errorDescription={error.message} onExit={() => {
+          unmount();
+          void resolve();
+          process.exit(1);
+        }} onReset={() => {
+          writeFileSync_DEPRECATED(error.filePath, jsonStringify(error.defaultConfig, null, 2), {
+            flush: false,
+            encoding: 'utf8'
+          });
+          unmount();
+          void resolve();
+          process.exit(0);
+        }} />
+        </KeybindingSetup>
+      </AppStateProvider>, renderOptions);
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Box","render","Text","KeybindingSetup","AppStateProvider","ConfigParseError","getBaseRenderOptions","jsonStringify","writeFileSync_DEPRECATED","ThemeName","Select","Dialog","InvalidConfigHandlerProps","error","InvalidConfigDialogProps","filePath","errorDescription","onExit","onReset","InvalidConfigDialog","t0","$","_c","t1","value","handleSelect","t2","t3","t4","t5","Symbol","for","t6","label","t7","t8","SAFE_ERROR_THEME_NAME","showInvalidConfigDialog","Promise","SafeRenderOptions","Parameters","theme","renderOptions","resolve","unmount","message","process","exit","defaultConfig","flush","encoding"],"sources":["InvalidConfigDialog.tsx"],"sourcesContent":["import React from 'react'\nimport { Box, render, Text } from '../ink.js'\nimport { KeybindingSetup } from '../keybindings/KeybindingProviderSetup.js'\nimport { AppStateProvider } from '../state/AppState.js'\nimport type { ConfigParseError } from '../utils/errors.js'\nimport { getBaseRenderOptions } from '../utils/renderOptions.js'\nimport {\n  jsonStringify,\n  writeFileSync_DEPRECATED,\n} from '../utils/slowOperations.js'\nimport type { ThemeName } from '../utils/theme.js'\nimport { Select } from './CustomSelect/index.js'\nimport { Dialog } from './design-system/Dialog.js'\n\ninterface InvalidConfigHandlerProps {\n  error: ConfigParseError\n}\n\ninterface InvalidConfigDialogProps {\n  filePath: string\n  errorDescription: string\n  onExit: () => void\n  onReset: () => void\n}\n\n/**\n * Dialog shown when the Claude config file contains invalid JSON\n */\nfunction InvalidConfigDialog({\n  filePath,\n  errorDescription,\n  onExit,\n  onReset,\n}: InvalidConfigDialogProps): React.ReactNode {\n  // Handler for Select onChange\n  const handleSelect = (value: string) => {\n    if (value === 'exit') {\n      onExit()\n    } else {\n      onReset()\n    }\n  }\n\n  return (\n    <Dialog title=\"Configuration Error\" color=\"error\" onCancel={onExit}>\n      <Box flexDirection=\"column\" gap={1}>\n        <Text>\n          The configuration file at <Text bold>{filePath}</Text> contains\n          invalid JSON.\n        </Text>\n        <Text>{errorDescription}</Text>\n      </Box>\n      <Box flexDirection=\"column\">\n        <Text bold>Choose an option:</Text>\n        <Select\n          options={[\n            { label: 'Exit and fix manually', value: 'exit' },\n            { label: 'Reset with default configuration', value: 'reset' },\n          ]}\n          onChange={handleSelect}\n          onCancel={onExit}\n        />\n      </Box>\n    </Dialog>\n  )\n}\n\n/**\n * Safe fallback theme name for error dialogs to avoid circular dependency.\n * Uses a hardcoded dark theme that doesn't require reading from config.\n */\nconst SAFE_ERROR_THEME_NAME: ThemeName = 'dark'\n\nexport async function showInvalidConfigDialog({\n  error,\n}: InvalidConfigHandlerProps): Promise<void> {\n  // Extend RenderOptions with theme property for this specific usage\n  type SafeRenderOptions = Parameters<typeof render>[1] & { theme?: ThemeName }\n\n  const renderOptions: SafeRenderOptions = {\n    ...getBaseRenderOptions(false),\n    // IMPORTANT: Use hardcoded theme name to avoid circular dependency with getGlobalConfig()\n    // This allows the error dialog to show even when config file has JSON syntax errors\n    theme: SAFE_ERROR_THEME_NAME,\n  }\n\n  await new Promise<void>(async resolve => {\n    const { unmount } = await render(\n      <AppStateProvider>\n        <KeybindingSetup>\n          <InvalidConfigDialog\n            filePath={error.filePath}\n            errorDescription={error.message}\n            onExit={() => {\n              unmount()\n              void resolve()\n              process.exit(1)\n            }}\n            onReset={() => {\n              writeFileSync_DEPRECATED(\n                error.filePath,\n                jsonStringify(error.defaultConfig, null, 2),\n                { flush: false, encoding: 'utf8' },\n              )\n              unmount()\n              void resolve()\n              process.exit(0)\n            }}\n          />\n        </KeybindingSetup>\n      </AppStateProvider>,\n      renderOptions,\n    )\n  })\n}\n"],"mappings":"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","ignoreList":[]}

src/components/InvalidSettingsDialog.tsx

@@ -0,0 +1,89 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import { Text } from '../ink.js';
+import type { ValidationError } from '../utils/settings/validation.js';
+import { Select } from './CustomSelect/index.js';
+import { Dialog } from './design-system/Dialog.js';
+import { ValidationErrorsList } from './ValidationErrorsList.js';
+type Props = {
+  settingsErrors: ValidationError[];
+  onContinue: () => void;
+  onExit: () => void;
+};
+
+/**
+ * Dialog shown when settings files have validation errors.
+ * User must choose to continue (skipping invalid files) or exit to fix them.
+ */
+export function InvalidSettingsDialog(t0) {
+  const $ = _c(13);
+  const {
+    settingsErrors,
+    onContinue,
+    onExit
+  } = t0;
+  let t1;
+  if ($[0] !== onContinue || $[1] !== onExit) {
+    t1 = function handleSelect(value) {
+      if (value === "exit") {
+        onExit();
+      } else {
+        onContinue();
+      }
+    };
+    $[0] = onContinue;
+    $[1] = onExit;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const handleSelect = t1;
+  let t2;
+  if ($[3] !== settingsErrors) {
+    t2 = <ValidationErrorsList errors={settingsErrors} />;
+    $[3] = settingsErrors;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  let t3;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = <Text dimColor={true}>Files with errors are skipped entirely, not just the invalid settings.</Text>;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  let t4;
+  if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = [{
+      label: "Exit and fix manually",
+      value: "exit"
+    }, {
+      label: "Continue without these settings",
+      value: "continue"
+    }];
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  let t5;
+  if ($[7] !== handleSelect) {
+    t5 = <Select options={t4} onChange={handleSelect} />;
+    $[7] = handleSelect;
+    $[8] = t5;
+  } else {
+    t5 = $[8];
+  }
+  let t6;
+  if ($[9] !== onExit || $[10] !== t2 || $[11] !== t5) {
+    t6 = <Dialog title="Settings Error" onCancel={onExit} color="warning">{t2}{t3}{t5}</Dialog>;
+    $[9] = onExit;
+    $[10] = t2;
+    $[11] = t5;
+    $[12] = t6;
+  } else {
+    t6 = $[12];
+  }
+  return t6;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/components/KeybindingWarnings.tsx

@@ -0,0 +1,55 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import { Box, Text } from '../ink.js';
+import { getCachedKeybindingWarnings, getKeybindingsPath, isKeybindingCustomizationEnabled } from '../keybindings/loadUserBindings.js';
+
+/**
+ * Displays keybinding validation warnings in the UI.
+ * Similar to McpParsingWarnings, this provides persistent visibility
+ * of configuration issues.
+ *
+ * Only shown when keybinding customization is enabled (ant users + feature gate).
+ */
+export function KeybindingWarnings() {
+  const $ = _c(2);
+  if (!isKeybindingCustomizationEnabled()) {
+    return null;
+  }
+  let t0;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = Symbol.for("react.early_return_sentinel");
+    bb0: {
+      const warnings = getCachedKeybindingWarnings();
+      if (warnings.length === 0) {
+        t1 = null;
+        break bb0;
+      }
+      const errors = warnings.filter(_temp);
+      const warns = warnings.filter(_temp2);
+      t0 = <Box flexDirection="column" marginTop={1} marginBottom={1}><Text bold={true} color={errors.length > 0 ? "error" : "warning"}>Keybinding Configuration Issues</Text><Box><Text dimColor={true}>Location: </Text><Text dimColor={true}>{getKeybindingsPath()}</Text></Box><Box marginLeft={1} flexDirection="column" marginTop={1}>{errors.map(_temp3)}{warns.map(_temp4)}</Box></Box>;
+    }
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t0 = $[0];
+    t1 = $[1];
+  }
+  if (t1 !== Symbol.for("react.early_return_sentinel")) {
+    return t1;
+  }
+  return t0;
+}
+function _temp4(warning, i_0) {
+  return <Box key={`warning-${i_0}`} flexDirection="column"><Box><Text dimColor={true}>└ </Text><Text color="warning">[Warning]</Text><Text dimColor={true}> {warning.message}</Text></Box>{warning.suggestion && <Box marginLeft={3}><Text dimColor={true}>→ {warning.suggestion}</Text></Box>}</Box>;
+}
+function _temp3(error, i) {
+  return <Box key={`error-${i}`} flexDirection="column"><Box><Text dimColor={true}>└ </Text><Text color="error">[Error]</Text><Text dimColor={true}> {error.message}</Text></Box>{error.suggestion && <Box marginLeft={3}><Text dimColor={true}>→ {error.suggestion}</Text></Box>}</Box>;
+}
+function _temp2(w_0) {
+  return w_0.severity === "warning";
+}
+function _temp(w) {
+  return w.severity === "error";
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/components/LanguagePicker.tsx

@@ -0,0 +1,86 @@
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import React, { useState } from 'react';
+import { Box, Text } from '../ink.js';
+import { useKeybinding } from '../keybindings/useKeybinding.js';
+import TextInput from './TextInput.js';
+type Props = {
+  initialLanguage: string | undefined;
+  onComplete: (language: string | undefined) => void;
+  onCancel: () => void;
+};
+export function LanguagePicker(t0) {
+  const $ = _c(13);
+  const {
+    initialLanguage,
+    onComplete,
+    onCancel
+  } = t0;
+  const [language, setLanguage] = useState(initialLanguage);
+  const [cursorOffset, setCursorOffset] = useState((initialLanguage ?? "").length);
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = {
+      context: "Settings"
+    };
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  useKeybinding("confirm:no", onCancel, t1);
+  let t2;
+  if ($[1] !== language || $[2] !== onComplete) {
+    t2 = function handleSubmit() {
+      const trimmed = language?.trim();
+      onComplete(trimmed || undefined);
+    };
+    $[1] = language;
+    $[2] = onComplete;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const handleSubmit = t2;
+  let t3;
+  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = <Text>Enter your preferred response and voice language:</Text>;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  let t4;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = <Text>{figures.pointer}</Text>;
+    $[5] = t4;
+  } else {
+    t4 = $[5];
+  }
+  const t5 = language ?? "";
+  let t6;
+  if ($[6] !== cursorOffset || $[7] !== handleSubmit || $[8] !== t5) {
+    t6 = <Box flexDirection="row" gap={1}>{t4}<TextInput value={t5} onChange={setLanguage} onSubmit={handleSubmit} focus={true} showCursor={true} placeholder={`e.g., Japanese, 日本語, Español${figures.ellipsis}`} columns={60} cursorOffset={cursorOffset} onChangeCursorOffset={setCursorOffset} /></Box>;
+    $[6] = cursorOffset;
+    $[7] = handleSubmit;
+    $[8] = t5;
+    $[9] = t6;
+  } else {
+    t6 = $[9];
+  }
+  let t7;
+  if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+    t7 = <Text dimColor={true}>Leave empty for default (English)</Text>;
+    $[10] = t7;
+  } else {
+    t7 = $[10];
+  }
+  let t8;
+  if ($[11] !== t6) {
+    t8 = <Box flexDirection="column" gap={1}>{t3}{t6}{t7}</Box>;
+    $[11] = t6;
+    $[12] = t8;
+  } else {
+    t8 = $[12];
+  }
+  return t8;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJmaWd1cmVzIiwiUmVhY3QiLCJ1c2VTdGF0ZSIsIkJveCIsIlRleHQiLCJ1c2VLZXliaW5kaW5nIiwiVGV4dElucHV0IiwiUHJvcHMiLCJpbml0aWFsTGFuZ3VhZ2UiLCJvbkNvbXBsZXRlIiwibGFuZ3VhZ2UiLCJvbkNhbmNlbCIsIkxhbmd1YWdlUGlja2VyIiwidDAiLCIkIiwiX2MiLCJzZXRMYW5ndWFnZSIsImN1cnNvck9mZnNldCIsInNldEN1cnNvck9mZnNldCIsImxlbmd0aCIsInQxIiwiU3ltYm9sIiwiZm9yIiwiY29udGV4dCIsInQyIiwiaGFuZGxlU3VibWl0IiwidHJpbW1lZCIsInRyaW0iLCJ1bmRlZmluZWQiLCJ0MyIsInQ0IiwicG9pbnRlciIsInQ1IiwidDYiLCJlbGxpcHNpcyIsInQ3IiwidDgiXSwic291cmNlcyI6WyJMYW5ndWFnZVBpY2tlci50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGZpZ3VyZXMgZnJvbSAnZmlndXJlcydcbmltcG9ydCBSZWFjdCwgeyB1c2VTdGF0ZSB9IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHsgQm94LCBUZXh0IH0gZnJvbSAnLi4vaW5rLmpzJ1xuaW1wb3J0IHsgdXNlS2V5YmluZGluZyB9IGZyb20gJy4uL2tleWJpbmRpbmdzL3VzZUtleWJpbmRpbmcuanMnXG5pbXBvcnQgVGV4dElucHV0IGZyb20gJy4vVGV4dElucHV0LmpzJ1xuXG50eXBlIFByb3BzID0ge1xuICBpbml0aWFsTGFuZ3VhZ2U6IHN0cmluZyB8IHVuZGVmaW5lZFxuICBvbkNvbXBsZXRlOiAobGFuZ3VhZ2U6IHN0cmluZyB8IHVuZGVmaW5lZCkgPT4gdm9pZFxuICBvbkNhbmNlbDogKCkgPT4gdm9pZFxufVxuXG5leHBvcnQgZnVuY3Rpb24gTGFuZ3VhZ2VQaWNrZXIoe1xuICBpbml0aWFsTGFuZ3VhZ2UsXG4gIG9uQ29tcGxldGUsXG4gIG9uQ2FuY2VsLFxufTogUHJvcHMpOiBSZWFjdC5SZWFjdE5vZGUge1xuICBjb25zdCBbbGFuZ3VhZ2UsIHNldExhbmd1YWdlXSA9IHVzZVN0YXRlKGluaXRpYWxMYW5ndWFnZSlcbiAgY29uc3QgW2N1cnNvck9mZnNldCwgc2V0Q3Vyc29yT2Zmc2V0XSA9IHVzZVN0YXRlKFxuICAgIChpbml0aWFsTGFuZ3VhZ2UgPz8gJycpLmxlbmd0aCxcbiAgKVxuXG4gIC8vIFVzZSBjb25maWd1cmFibGUga2V5YmluZGluZyBmb3IgRVNDIHRvIGNhbmNlbFxuICAvLyBVc2UgU2V0dGluZ3MgY29udGV4dCBzbyAnbicga2V5IGRvZXNuJ3QgdHJpZ2dlciBjYW5jZWwgKGFsbG93cyB0eXBpbmcgJ24nIGluIGlucHV0KVxuICB1c2VLZXliaW5kaW5nKCdjb25maXJtOm5vJywgb25DYW5jZWwsIHsgY29udGV4dDogJ1NldHRpbmdzJyB9KVxuXG4gIGZ1bmN0aW9uIGhhbmRsZVN1Ym1pdCgpOiB2b2lkIHtcbiAgICBjb25zdCB0cmltbWVkID0gbGFuZ3VhZ2U/LnRyaW0oKVxuICAgIG9uQ29tcGxldGUodHJpbW1lZCB8fCB1bmRlZmluZWQpXG4gIH1cblxuICByZXR1cm4gKFxuICAgIDxCb3ggZmxleERpcmVjdGlvbj1cImNvbHVtblwiIGdhcD17MX0+XG4gICAgICA8VGV4dD5FbnRlciB5b3VyIHByZWZlcnJlZCByZXNwb25zZSBhbmQgdm9pY2UgbGFuZ3VhZ2U6PC9UZXh0PlxuICAgICAgPEJveCBmbGV4RGlyZWN0aW9uPVwicm93XCIgZ2FwPXsxfT5cbiAgICAgICAgPFRleHQ+e2ZpZ3VyZXMucG9pbnRlcn08L1RleHQ+XG4gICAgICAgIDxUZXh0SW5wdXRcbiAgICAgICAgICB2YWx1ZT17bGFuZ3VhZ2UgPz8gJyd9XG4gICAgICAgICAgb25DaGFuZ2U9e3NldExhbmd1YWdlfVxuICAgICAgICAgIG9uU3VibWl0PXtoYW5kbGVTdWJtaXR9XG4gICAgICAgICAgZm9jdXM9e3RydWV9XG4gICAgICAgICAgc2hvd0N1cnNvcj17dHJ1ZX1cbiAgICAgICAgICBwbGFjZWhvbGRlcj17YGUuZy4sIEphcGFuZXNlLCDml6XmnKzoqp4sIEVzcGHDsW9sJHtmaWd1cmVzLmVsbGlwc2lzfWB9XG4gICAgICAgICAgY29sdW1ucz17NjB9XG4gICAgICAgICAgY3Vyc29yT2Zmc2V0PXtjdXJzb3JPZmZzZXR9XG4gICAgICAgICAgb25DaGFuZ2VDdXJzb3JPZmZzZXQ9e3NldEN1cnNvck9mZnNldH1cbiAgICAgICAgLz5cbiAgICAgIDwvQm94PlxuICAgICAgPFRleHQgZGltQ29sb3I+TGVhdmUgZW1wdHkgZm9yIGRlZmF1bHQgKEVuZ2xpc2gpPC9UZXh0PlxuICAgIDwvQm94PlxuICApXG59XG4iXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPQSxPQUFPLE1BQU0sU0FBUztBQUM3QixPQUFPQyxLQUFLLElBQUlDLFFBQVEsUUFBUSxPQUFPO0FBQ3ZDLFNBQVNDLEdBQUcsRUFBRUMsSUFBSSxRQUFRLFdBQVc7QUFDckMsU0FBU0MsYUFBYSxRQUFRLGlDQUFpQztBQUMvRCxPQUFPQyxTQUFTLE1BQU0sZ0JBQWdCO0FBRXRDLEtBQUtDLEtBQUssR0FBRztFQUNYQyxlQUFlLEVBQUUsTUFBTSxHQUFHLFNBQVM7RUFDbkNDLFVBQVUsRUFBRSxDQUFDQyxRQUFRLEVBQUUsTUFBTSxHQUFHLFNBQVMsRUFBRSxHQUFHLElBQUk7RUFDbERDLFFBQVEsRUFBRSxHQUFHLEdBQUcsSUFBSTtBQUN0QixDQUFDO0FBRUQsT0FBTyxTQUFBQyxlQUFBQyxFQUFBO0VBQUEsTUFBQUMsQ0FBQSxHQUFBQyxFQUFBO0VBQXdCO0lBQUFQLGVBQUE7SUFBQUMsVUFBQTtJQUFBRTtFQUFBLElBQUFFLEVBSXZCO0VBQ04sT0FBQUgsUUFBQSxFQUFBTSxXQUFBLElBQWdDZCxRQUFRLENBQUNNLGVBQWUsQ0FBQztFQUN6RCxPQUFBUyxZQUFBLEVBQUFDLGVBQUEsSUFBd0NoQixRQUFRLENBQzlDLENBQUNNLGVBQXFCLElBQXJCLEVBQXFCLEVBQUFXLE1BQ3hCLENBQUM7RUFBQSxJQUFBQyxFQUFBO0VBQUEsSUFBQU4sQ0FBQSxRQUFBTyxNQUFBLENBQUFDLEdBQUE7SUFJcUNGLEVBQUE7TUFBQUcsT0FBQSxFQUFXO0lBQVcsQ0FBQztJQUFBVCxDQUFBLE1BQUFNLEVBQUE7RUFBQTtJQUFBQSxFQUFBLEdBQUFOLENBQUE7RUFBQTtFQUE3RFQsYUFBYSxDQUFDLFlBQVksRUFBRU0sUUFBUSxFQUFFUyxFQUF1QixDQUFDO0VBQUEsSUFBQUksRUFBQTtFQUFBLElBQUFWLENBQUEsUUFBQUosUUFBQSxJQUFBSSxDQUFBLFFBQUFMLFVBQUE7SUFFOURlLEVBQUEsWUFBQUMsYUFBQTtNQUNFLE1BQUFDLE9BQUEsR0FBZ0JoQixRQUFRLEVBQUFpQixJQUFRLENBQUQsQ0FBQztNQUNoQ2xCLFVBQVUsQ0FBQ2lCLE9BQW9CLElBQXBCRSxTQUFvQixDQUFDO0lBQUEsQ0FDakM7SUFBQWQsQ0FBQSxNQUFBSixRQUFBO0lBQUFJLENBQUEsTUFBQUwsVUFBQTtJQUFBSyxDQUFBLE1BQUFVLEVBQUE7RUFBQTtJQUFBQSxFQUFBLEdBQUFWLENBQUE7RUFBQTtFQUhELE1BQUFXLFlBQUEsR0FBQUQsRUFHQztFQUFBLElBQUFLLEVBQUE7RUFBQSxJQUFBZixDQUFBLFFBQUFPLE1BQUEsQ0FBQUMsR0FBQTtJQUlHTyxFQUFBLElBQUMsSUFBSSxDQUFDLGlEQUFpRCxFQUF0RCxJQUFJLENBQXlEO0lBQUFmLENBQUEsTUFBQWUsRUFBQTtFQUFBO0lBQUFBLEVBQUEsR0FBQWYsQ0FBQTtFQUFBO0VBQUEsSUFBQWdCLEVBQUE7RUFBQSxJQUFBaEIsQ0FBQSxRQUFBTyxNQUFBLENBQUFDLEdBQUE7SUFFNURRLEVBQUEsSUFBQyxJQUFJLENBQUUsQ0FBQTlCLE9BQU8sQ0FBQStCLE9BQU8sQ0FBRSxFQUF0QixJQUFJLENBQXlCO0lBQUFqQixDQUFBLE1BQUFnQixFQUFBO0VBQUE7SUFBQUEsRUFBQSxHQUFBaEIsQ0FBQTtFQUFBO0VBRXJCLE1BQUFrQixFQUFBLEdBQUF0QixRQUFjLElBQWQsRUFBYztFQUFBLElBQUF1QixFQUFBO0VBQUEsSUFBQW5CLENBQUEsUUFBQUcsWUFBQSxJQUFBSCxDQUFBLFFBQUFXLFlBQUEsSUFBQVgsQ0FBQSxRQUFBa0IsRUFBQTtJQUh6QkMsRUFBQSxJQUFDLEdBQUcsQ0FBZSxhQUFLLENBQUwsS0FBSyxDQUFNLEdBQUMsQ0FBRCxHQUFDLENBQzdCLENBQUFILEVBQTZCLENBQzdCLENBQUMsU0FBUyxDQUNELEtBQWMsQ0FBZCxDQUFBRSxFQUFhLENBQUMsQ0FDWGhCLFFBQVcsQ0FBWEEsWUFBVSxDQUFDLENBQ1hTLFFBQVksQ0FBWkEsYUFBVyxDQUFDLENBQ2YsS0FBSSxDQUFKLEtBQUcsQ0FBQyxDQUNDLFVBQUksQ0FBSixLQUFHLENBQUMsQ0FDSCxXQUFpRCxDQUFqRCxnQ0FBK0J6QixPQUFPLENBQUFrQyxRQUFTLEVBQUMsQ0FBQyxDQUNyRCxPQUFFLENBQUYsR0FBQyxDQUFDLENBQ0dqQixZQUFZLENBQVpBLGFBQVcsQ0FBQyxDQUNKQyxvQkFBZSxDQUFmQSxnQkFBYyxDQUFDLEdBRXpDLEVBYkMsR0FBRyxDQWFFO0lBQUFKLENBQUEsTUFBQUcsWUFBQTtJQUFBSCxDQUFBLE1BQUFXLFlBQUE7SUFBQVgsQ0FBQSxNQUFBa0IsRUFBQTtJQUFBbEIsQ0FBQSxNQUFBbUIsRUFBQTtFQUFBO0lBQUFBLEVBQUEsR0FBQW5CLENBQUE7RUFBQTtFQUFBLElBQUFxQixFQUFBO0VBQUEsSUFBQXJCLENBQUEsU0FBQU8sTUFBQSxDQUFBQyxHQUFBO0lBQ05hLEVBQUEsSUFBQyxJQUFJLENBQUMsUUFBUSxDQUFSLEtBQU8sQ0FBQyxDQUFDLGlDQUFpQyxFQUEvQyxJQUFJLENBQWtEO0lBQUFyQixDQUFBLE9BQUFxQixFQUFBO0VBQUE7SUFBQUEsRUFBQSxHQUFBckIsQ0FBQTtFQUFBO0VBQUEsSUFBQXNCLEVBQUE7RUFBQSxJQUFBdEIsQ0FBQSxTQUFBbUIsRUFBQTtJQWhCekRHLEVBQUEsSUFBQyxHQUFHLENBQWUsYUFBUSxDQUFSLFFBQVEsQ0FBTSxHQUFDLENBQUQsR0FBQyxDQUNoQyxDQUFBUCxFQUE2RCxDQUM3RCxDQUFBSSxFQWFLLENBQ0wsQ0FBQUUsRUFBc0QsQ0FDeEQsRUFqQkMsR0FBRyxDQWlCRTtJQUFBckIsQ0FBQSxPQUFBbUIsRUFBQTtJQUFBbkIsQ0FBQSxPQUFBc0IsRUFBQTtFQUFBO0lBQUFBLEVBQUEsR0FBQXRCLENBQUE7RUFBQTtFQUFBLE9BakJOc0IsRUFpQk07QUFBQSIsImlnbm9yZUxpc3QiOltdfQ==

src/keybindings/KeybindingContext.tsx

@@ -0,0 +1,243 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { createContext, type RefObject, useContext, useLayoutEffect, useMemo } from 'react';
+import type { Key } from '../ink.js';
+import { type ChordResolveResult, getBindingDisplayText, resolveKeyWithChordState } from './resolver.js';
+import type { KeybindingContextName, ParsedBinding, ParsedKeystroke } from './types.js';
+
+/** Handler registration for action callbacks */
+type HandlerRegistration = {
+  action: string;
+  context: KeybindingContextName;
+  handler: () => void;
+};
+type KeybindingContextValue = {
+  /** Resolve a key input to an action name (with chord support) */
+  resolve: (input: string, key: Key, activeContexts: KeybindingContextName[]) => ChordResolveResult;
+
+  /** Update the pending chord state */
+  setPendingChord: (pending: ParsedKeystroke[] | null) => void;
+
+  /** Get display text for an action (e.g., "ctrl+t") */
+  getDisplayText: (action: string, context: KeybindingContextName) => string | undefined;
+
+  /** All parsed bindings (for help display) */
+  bindings: ParsedBinding[];
+
+  /** Current pending chord keystrokes (null if not in a chord) */
+  pendingChord: ParsedKeystroke[] | null;
+
+  /** Currently active keybinding contexts (for priority resolution) */
+  activeContexts: Set<KeybindingContextName>;
+
+  /** Register a context as active (call on mount) */
+  registerActiveContext: (context: KeybindingContextName) => void;
+
+  /** Unregister a context (call on unmount) */
+  unregisterActiveContext: (context: KeybindingContextName) => void;
+
+  /** Register a handler for an action (used by useKeybinding) */
+  registerHandler: (registration: HandlerRegistration) => () => void;
+
+  /** Invoke all handlers for an action (used by ChordInterceptor) */
+  invokeAction: (action: string) => boolean;
+};
+const KeybindingContext = createContext<KeybindingContextValue | null>(null);
+type ProviderProps = {
+  bindings: ParsedBinding[];
+  /** Ref for immediate access to pending chord (avoids React state delay) */
+  pendingChordRef: RefObject<ParsedKeystroke[] | null>;
+  /** State value for re-renders (UI updates) */
+  pendingChord: ParsedKeystroke[] | null;
+  setPendingChord: (pending: ParsedKeystroke[] | null) => void;
+  activeContexts: Set<KeybindingContextName>;
+  registerActiveContext: (context: KeybindingContextName) => void;
+  unregisterActiveContext: (context: KeybindingContextName) => void;
+  /** Ref to handler registry (used by ChordInterceptor) */
+  handlerRegistryRef: RefObject<Map<string, Set<HandlerRegistration>>>;
+  children: React.ReactNode;
+};
+export function KeybindingProvider(t0) {
+  const $ = _c(24);
+  const {
+    bindings,
+    pendingChordRef,
+    pendingChord,
+    setPendingChord,
+    activeContexts,
+    registerActiveContext,
+    unregisterActiveContext,
+    handlerRegistryRef,
+    children
+  } = t0;
+  let t1;
+  if ($[0] !== bindings) {
+    t1 = (action, context) => getBindingDisplayText(action, context, bindings);
+    $[0] = bindings;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const getDisplay = t1;
+  let t2;
+  if ($[2] !== handlerRegistryRef) {
+    t2 = registration => {
+      const registry = handlerRegistryRef.current;
+      if (!registry) {
+        return _temp;
+      }
+      if (!registry.has(registration.action)) {
+        registry.set(registration.action, new Set());
+      }
+      registry.get(registration.action).add(registration);
+      return () => {
+        const handlers = registry.get(registration.action);
+        if (handlers) {
+          handlers.delete(registration);
+          if (handlers.size === 0) {
+            registry.delete(registration.action);
+          }
+        }
+      };
+    };
+    $[2] = handlerRegistryRef;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const registerHandler = t2;
+  let t3;
+  if ($[4] !== activeContexts || $[5] !== handlerRegistryRef) {
+    t3 = action_0 => {
+      const registry_0 = handlerRegistryRef.current;
+      if (!registry_0) {
+        return false;
+      }
+      const handlers_0 = registry_0.get(action_0);
+      if (!handlers_0 || handlers_0.size === 0) {
+        return false;
+      }
+      for (const registration_0 of handlers_0) {
+        if (activeContexts.has(registration_0.context)) {
+          registration_0.handler();
+          return true;
+        }
+      }
+      return false;
+    };
+    $[4] = activeContexts;
+    $[5] = handlerRegistryRef;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  const invokeAction = t3;
+  let t4;
+  if ($[7] !== bindings || $[8] !== pendingChordRef) {
+    t4 = (input, key, contexts) => resolveKeyWithChordState(input, key, contexts, bindings, pendingChordRef.current);
+    $[7] = bindings;
+    $[8] = pendingChordRef;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  let t5;
+  if ($[10] !== activeContexts || $[11] !== bindings || $[12] !== getDisplay || $[13] !== invokeAction || $[14] !== pendingChord || $[15] !== registerActiveContext || $[16] !== registerHandler || $[17] !== setPendingChord || $[18] !== t4 || $[19] !== unregisterActiveContext) {
+    t5 = {
+      resolve: t4,
+      setPendingChord,
+      getDisplayText: getDisplay,
+      bindings,
+      pendingChord,
+      activeContexts,
+      registerActiveContext,
+      unregisterActiveContext,
+      registerHandler,
+      invokeAction
+    };
+    $[10] = activeContexts;
+    $[11] = bindings;
+    $[12] = getDisplay;
+    $[13] = invokeAction;
+    $[14] = pendingChord;
+    $[15] = registerActiveContext;
+    $[16] = registerHandler;
+    $[17] = setPendingChord;
+    $[18] = t4;
+    $[19] = unregisterActiveContext;
+    $[20] = t5;
+  } else {
+    t5 = $[20];
+  }
+  const value = t5;
+  let t6;
+  if ($[21] !== children || $[22] !== value) {
+    t6 = <KeybindingContext.Provider value={value}>{children}</KeybindingContext.Provider>;
+    $[21] = children;
+    $[22] = value;
+    $[23] = t6;
+  } else {
+    t6 = $[23];
+  }
+  return t6;
+}
+function _temp() {}
+export function useKeybindingContext() {
+  const ctx = useContext(KeybindingContext);
+  if (!ctx) {
+    throw new Error("useKeybindingContext must be used within KeybindingProvider");
+  }
+  return ctx;
+}
+
+/**
+ * Optional hook that returns undefined outside of KeybindingProvider.
+ * Useful for components that may render before provider is available.
+ */
+export function useOptionalKeybindingContext() {
+  return useContext(KeybindingContext);
+}
+
+/**
+ * Hook to register a keybinding context as active while the component is mounted.
+ *
+ * When a context is registered, its keybindings take precedence over Global bindings.
+ * This allows context-specific bindings (like ThemePicker's ctrl+t) to override
+ * global bindings (like the todo toggle) when the context is active.
+ *
+ * @example
+ * ```tsx
+ * function ThemePicker() {
+ *   useRegisterKeybindingContext('ThemePicker')
+ *   // Now ThemePicker's ctrl+t binding takes precedence over Global
+ * }
+ * ```
+ */
+export function useRegisterKeybindingContext(context, t0) {
+  const $ = _c(5);
+  const isActive = t0 === undefined ? true : t0;
+  const keybindingContext = useOptionalKeybindingContext();
+  let t1;
+  let t2;
+  if ($[0] !== context || $[1] !== isActive || $[2] !== keybindingContext) {
+    t1 = () => {
+      if (!keybindingContext || !isActive) {
+        return;
+      }
+      keybindingContext.registerActiveContext(context);
+      return () => {
+        keybindingContext.unregisterActiveContext(context);
+      };
+    };
+    t2 = [context, keybindingContext, isActive];
+    $[0] = context;
+    $[1] = isActive;
+    $[2] = keybindingContext;
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t1 = $[3];
+    t2 = $[4];
+  }
+  useLayoutEffect(t1, t2);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","createContext","RefObject","useContext","useLayoutEffect","useMemo","Key","ChordResolveResult","getBindingDisplayText","resolveKeyWithChordState","KeybindingContextName","ParsedBinding","ParsedKeystroke","HandlerRegistration","action","context","handler","KeybindingContextValue","resolve","input","key","activeContexts","setPendingChord","pending","getDisplayText","bindings","pendingChord","Set","registerActiveContext","unregisterActiveContext","registerHandler","registration","invokeAction","KeybindingContext","ProviderProps","pendingChordRef","handlerRegistryRef","Map","children","ReactNode","KeybindingProvider","t0","$","_c","t1","getDisplay","t2","registry","current","_temp","has","set","get","add","handlers","delete","size","t3","action_0","registry_0","handlers_0","registration_0","t4","contexts","t5","value","t6","useKeybindingContext","ctx","Error","useOptionalKeybindingContext","useRegisterKeybindingContext","isActive","undefined","keybindingContext"],"sources":["KeybindingContext.tsx"],"sourcesContent":["import React, {\n  createContext,\n  type RefObject,\n  useContext,\n  useLayoutEffect,\n  useMemo,\n} from 'react'\nimport type { Key } from '../ink.js'\nimport {\n  type ChordResolveResult,\n  getBindingDisplayText,\n  resolveKeyWithChordState,\n} from './resolver.js'\nimport type {\n  KeybindingContextName,\n  ParsedBinding,\n  ParsedKeystroke,\n} from './types.js'\n\n/** Handler registration for action callbacks */\ntype HandlerRegistration = {\n  action: string\n  context: KeybindingContextName\n  handler: () => void\n}\n\ntype KeybindingContextValue = {\n  /** Resolve a key input to an action name (with chord support) */\n  resolve: (\n    input: string,\n    key: Key,\n    activeContexts: KeybindingContextName[],\n  ) => ChordResolveResult\n\n  /** Update the pending chord state */\n  setPendingChord: (pending: ParsedKeystroke[] | null) => void\n\n  /** Get display text for an action (e.g., \"ctrl+t\") */\n  getDisplayText: (\n    action: string,\n    context: KeybindingContextName,\n  ) => string | undefined\n\n  /** All parsed bindings (for help display) */\n  bindings: ParsedBinding[]\n\n  /** Current pending chord keystrokes (null if not in a chord) */\n  pendingChord: ParsedKeystroke[] | null\n\n  /** Currently active keybinding contexts (for priority resolution) */\n  activeContexts: Set<KeybindingContextName>\n\n  /** Register a context as active (call on mount) */\n  registerActiveContext: (context: KeybindingContextName) => void\n\n  /** Unregister a context (call on unmount) */\n  unregisterActiveContext: (context: KeybindingContextName) => void\n\n  /** Register a handler for an action (used by useKeybinding) */\n  registerHandler: (registration: HandlerRegistration) => () => void\n\n  /** Invoke all handlers for an action (used by ChordInterceptor) */\n  invokeAction: (action: string) => boolean\n}\n\nconst KeybindingContext = createContext<KeybindingContextValue | null>(null)\n\ntype ProviderProps = {\n  bindings: ParsedBinding[]\n  /** Ref for immediate access to pending chord (avoids React state delay) */\n  pendingChordRef: RefObject<ParsedKeystroke[] | null>\n  /** State value for re-renders (UI updates) */\n  pendingChord: ParsedKeystroke[] | null\n  setPendingChord: (pending: ParsedKeystroke[] | null) => void\n  activeContexts: Set<KeybindingContextName>\n  registerActiveContext: (context: KeybindingContextName) => void\n  unregisterActiveContext: (context: KeybindingContextName) => void\n  /** Ref to handler registry (used by ChordInterceptor) */\n  handlerRegistryRef: RefObject<Map<string, Set<HandlerRegistration>>>\n  children: React.ReactNode\n}\n\nexport function KeybindingProvider({\n  bindings,\n  pendingChordRef,\n  pendingChord,\n  setPendingChord,\n  activeContexts,\n  registerActiveContext,\n  unregisterActiveContext,\n  handlerRegistryRef,\n  children,\n}: ProviderProps): React.ReactNode {\n  const value = useMemo<KeybindingContextValue>(() => {\n    const getDisplay = (action: string, context: KeybindingContextName) =>\n      getBindingDisplayText(action, context, bindings)\n\n    // Register a handler for an action\n    const registerHandler = (registration: HandlerRegistration) => {\n      const registry = handlerRegistryRef.current\n      if (!registry) return () => {}\n\n      if (!registry.has(registration.action)) {\n        registry.set(registration.action, new Set())\n      }\n      registry.get(registration.action)!.add(registration)\n\n      // Return unregister function\n      return () => {\n        const handlers = registry.get(registration.action)\n        if (handlers) {\n          handlers.delete(registration)\n          if (handlers.size === 0) {\n            registry.delete(registration.action)\n          }\n        }\n      }\n    }\n\n    // Invoke all handlers for an action\n    const invokeAction = (action: string): boolean => {\n      const registry = handlerRegistryRef.current\n      if (!registry) return false\n\n      const handlers = registry.get(action)\n      if (!handlers || handlers.size === 0) return false\n\n      // Find handlers whose context is active\n      for (const registration of handlers) {\n        if (activeContexts.has(registration.context)) {\n          registration.handler()\n          return true\n        }\n      }\n      return false\n    }\n\n    return {\n      // Use ref for immediate access to pending chord, avoiding React state delay\n      // This is critical for chord sequences where the second key might be pressed\n      // before React re-renders with the updated pendingChord state\n      resolve: (input, key, contexts) =>\n        resolveKeyWithChordState(\n          input,\n          key,\n          contexts,\n          bindings,\n          pendingChordRef.current,\n        ),\n      setPendingChord,\n      getDisplayText: getDisplay,\n      bindings,\n      pendingChord,\n      activeContexts,\n      registerActiveContext,\n      unregisterActiveContext,\n      registerHandler,\n      invokeAction,\n    }\n  }, [\n    bindings,\n    pendingChordRef,\n    pendingChord,\n    setPendingChord,\n    activeContexts,\n    registerActiveContext,\n    unregisterActiveContext,\n    handlerRegistryRef,\n  ])\n\n  return (\n    <KeybindingContext.Provider value={value}>\n      {children}\n    </KeybindingContext.Provider>\n  )\n}\n\nexport function useKeybindingContext(): KeybindingContextValue {\n  const ctx = useContext(KeybindingContext)\n  if (!ctx) {\n    throw new Error(\n      'useKeybindingContext must be used within KeybindingProvider',\n    )\n  }\n  return ctx\n}\n\n/**\n * Optional hook that returns undefined outside of KeybindingProvider.\n * Useful for components that may render before provider is available.\n */\nexport function useOptionalKeybindingContext(): KeybindingContextValue | null {\n  return useContext(KeybindingContext)\n}\n\n/**\n * Hook to register a keybinding context as active while the component is mounted.\n *\n * When a context is registered, its keybindings take precedence over Global bindings.\n * This allows context-specific bindings (like ThemePicker's ctrl+t) to override\n * global bindings (like the todo toggle) when the context is active.\n *\n * @example\n * ```tsx\n * function ThemePicker() {\n *   useRegisterKeybindingContext('ThemePicker')\n *   // Now ThemePicker's ctrl+t binding takes precedence over Global\n * }\n * ```\n */\nexport function useRegisterKeybindingContext(\n  context: KeybindingContextName,\n  isActive: boolean = true,\n): void {\n  const keybindingContext = useOptionalKeybindingContext()\n\n  useLayoutEffect(() => {\n    if (!keybindingContext || !isActive) return\n\n    keybindingContext.registerActiveContext(context)\n    return () => {\n      keybindingContext.unregisterActiveContext(context)\n    }\n  }, [context, keybindingContext, isActive])\n}\n"],"mappings":"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","ignoreList":[]}

src/keybindings/KeybindingProviderSetup.tsx

@@ -0,0 +1,308 @@
+import { c as _c } from "react/compiler-runtime";
+/**
+ * Setup utilities for integrating KeybindingProvider into the app.
+ *
+ * This file provides the bindings and a composed provider that can be
+ * added to the app's component tree. It loads both default bindings and
+ * user-defined bindings from ~/.claude/keybindings.json, with hot-reload
+ * support when the file changes.
+ */
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { useNotifications } from '../context/notifications.js';
+import type { InputEvent } from '../ink/events/input-event.js';
+// ChordInterceptor intentionally uses useInput to intercept all keystrokes before
+// other handlers process them - this is required for chord sequence support
+// eslint-disable-next-line custom-rules/prefer-use-keybindings
+import { type Key, useInput } from '../ink.js';
+import { count } from '../utils/array.js';
+import { logForDebugging } from '../utils/debug.js';
+import { plural } from '../utils/stringUtils.js';
+import { KeybindingProvider } from './KeybindingContext.js';
+import { initializeKeybindingWatcher, type KeybindingsLoadResult, loadKeybindingsSyncWithWarnings, subscribeToKeybindingChanges } from './loadUserBindings.js';
+import { resolveKeyWithChordState } from './resolver.js';
+import type { KeybindingContextName, ParsedBinding, ParsedKeystroke } from './types.js';
+import type { KeybindingWarning } from './validate.js';
+
+/**
+ * Timeout for chord sequences in milliseconds.
+ * If the user doesn't complete the chord within this time, it's cancelled.
+ */
+const CHORD_TIMEOUT_MS = 1000;
+type Props = {
+  children: React.ReactNode;
+};
+
+/**
+ * Keybinding provider with default + user bindings and hot-reload support.
+ *
+ * Usage: Wrap your app with this provider to enable keybinding support.
+ *
+ * ```tsx
+ * <AppStateProvider>
+ *   <KeybindingSetup>
+ *     <REPL ... />
+ *   </KeybindingSetup>
+ * </AppStateProvider>
+ * ```
+ *
+ * Features:
+ * - Loads default bindings from code
+ * - Merges with user bindings from ~/.claude/keybindings.json
+ * - Watches for file changes and reloads automatically (hot-reload)
+ * - User bindings override defaults (later entries win)
+ * - Chord support with automatic timeout
+ */
+/**
+ * Display keybinding warnings to the user via notifications.
+ * Shows a brief message pointing to /doctor for details.
+ */
+function useKeybindingWarnings(warnings, isReload) {
+  const $ = _c(9);
+  const {
+    addNotification,
+    removeNotification
+  } = useNotifications();
+  let t0;
+  if ($[0] !== addNotification || $[1] !== removeNotification || $[2] !== warnings) {
+    t0 = () => {
+      if (warnings.length === 0) {
+        removeNotification("keybinding-config-warning");
+        return;
+      }
+      const errorCount = count(warnings, _temp);
+      const warnCount = count(warnings, _temp2);
+      let message;
+      if (errorCount > 0 && warnCount > 0) {
+        message = `Found ${errorCount} keybinding ${plural(errorCount, "error")} and ${warnCount} ${plural(warnCount, "warning")}`;
+      } else {
+        if (errorCount > 0) {
+          message = `Found ${errorCount} keybinding ${plural(errorCount, "error")}`;
+        } else {
+          message = `Found ${warnCount} keybinding ${plural(warnCount, "warning")}`;
+        }
+      }
+      message = message + " \xB7 /doctor for details";
+      addNotification({
+        key: "keybinding-config-warning",
+        text: message,
+        color: errorCount > 0 ? "error" : "warning",
+        priority: errorCount > 0 ? "immediate" : "high",
+        timeoutMs: 60000
+      });
+    };
+    $[0] = addNotification;
+    $[1] = removeNotification;
+    $[2] = warnings;
+    $[3] = t0;
+  } else {
+    t0 = $[3];
+  }
+  let t1;
+  if ($[4] !== addNotification || $[5] !== isReload || $[6] !== removeNotification || $[7] !== warnings) {
+    t1 = [warnings, isReload, addNotification, removeNotification];
+    $[4] = addNotification;
+    $[5] = isReload;
+    $[6] = removeNotification;
+    $[7] = warnings;
+    $[8] = t1;
+  } else {
+    t1 = $[8];
+  }
+  useEffect(t0, t1);
+}
+function _temp2(w_0) {
+  return w_0.severity === "warning";
+}
+function _temp(w) {
+  return w.severity === "error";
+}
+export function KeybindingSetup({
+  children
+}: Props): React.ReactNode {
+  // Load bindings synchronously for initial render
+  const [{
+    bindings,
+    warnings
+  }, setLoadResult] = useState<KeybindingsLoadResult>(() => {
+    const result = loadKeybindingsSyncWithWarnings();
+    logForDebugging(`[keybindings] KeybindingSetup initialized with ${result.bindings.length} bindings, ${result.warnings.length} warnings`);
+    return result;
+  });
+
+  // Track if this is a reload (not initial load)
+  const [isReload, setIsReload] = useState(false);
+
+  // Display warnings via notifications
+  useKeybindingWarnings(warnings, isReload);
+
+  // Chord state management - use ref for immediate access, state for re-renders
+  // The ref is used by resolve() to get the current value without waiting for re-render
+  // The state is used to trigger re-renders when needed (e.g., for UI updates)
+  const pendingChordRef = useRef<ParsedKeystroke[] | null>(null);
+  const [pendingChord, setPendingChordState] = useState<ParsedKeystroke[] | null>(null);
+  const chordTimeoutRef = useRef<NodeJS.Timeout | null>(null);
+
+  // Handler registry for action callbacks (used by ChordInterceptor to invoke handlers)
+  const handlerRegistryRef = useRef(new Map<string, Set<{
+    action: string;
+    context: KeybindingContextName;
+    handler: () => void;
+  }>>());
+
+  // Active context tracking for keybinding priority resolution
+  // Using a ref instead of state for synchronous updates - input handlers need
+  // to see the current value immediately, not after a React render cycle.
+  const activeContextsRef = useRef<Set<KeybindingContextName>>(new Set());
+  const registerActiveContext = useCallback((context: KeybindingContextName) => {
+    activeContextsRef.current.add(context);
+  }, []);
+  const unregisterActiveContext = useCallback((context_0: KeybindingContextName) => {
+    activeContextsRef.current.delete(context_0);
+  }, []);
+
+  // Clear chord timeout when component unmounts or chord changes
+  const clearChordTimeout = useCallback(() => {
+    if (chordTimeoutRef.current) {
+      clearTimeout(chordTimeoutRef.current);
+      chordTimeoutRef.current = null;
+    }
+  }, []);
+
+  // Wrapper for setPendingChord that manages timeout and syncs ref+state
+  const setPendingChord = useCallback((pending: ParsedKeystroke[] | null) => {
+    clearChordTimeout();
+    if (pending !== null) {
+      // Set timeout to cancel chord if not completed
+      chordTimeoutRef.current = setTimeout((pendingChordRef_0, setPendingChordState_0) => {
+        logForDebugging('[keybindings] Chord timeout - cancelling');
+        pendingChordRef_0.current = null;
+        setPendingChordState_0(null);
+      }, CHORD_TIMEOUT_MS, pendingChordRef, setPendingChordState);
+    }
+
+    // Update ref immediately for synchronous access in resolve()
+    pendingChordRef.current = pending;
+    // Update state to trigger re-renders for UI updates
+    setPendingChordState(pending);
+  }, [clearChordTimeout]);
+  useEffect(() => {
+    // Initialize file watcher (idempotent - only runs once)
+    void initializeKeybindingWatcher();
+
+    // Subscribe to changes
+    const unsubscribe = subscribeToKeybindingChanges(result_0 => {
+      // Any callback invocation is a reload since initial load happens
+      // synchronously in useState, not via this subscription
+      setIsReload(true);
+      setLoadResult(result_0);
+      logForDebugging(`[keybindings] Reloaded: ${result_0.bindings.length} bindings, ${result_0.warnings.length} warnings`);
+    });
+    return () => {
+      unsubscribe();
+      clearChordTimeout();
+    };
+  }, [clearChordTimeout]);
+  return <KeybindingProvider bindings={bindings} pendingChordRef={pendingChordRef} pendingChord={pendingChord} setPendingChord={setPendingChord} activeContexts={activeContextsRef.current} registerActiveContext={registerActiveContext} unregisterActiveContext={unregisterActiveContext} handlerRegistryRef={handlerRegistryRef}>
+      <ChordInterceptor bindings={bindings} pendingChordRef={pendingChordRef} setPendingChord={setPendingChord} activeContexts={activeContextsRef.current} handlerRegistryRef={handlerRegistryRef} />
+      {children}
+    </KeybindingProvider>;
+}
+
+/**
+ * Global chord interceptor that registers useInput FIRST (before children).
+ *
+ * This component intercepts keystrokes that are part of chord sequences and
+ * stops propagation before other handlers (like PromptInput) can see them.
+ *
+ * Without this, the second key of a chord (e.g., 'r' in "ctrl+c r") would be
+ * captured by PromptInput and added to the input field before the keybinding
+ * system could recognize it as completing a chord.
+ */
+type HandlerRegistration = {
+  action: string;
+  context: KeybindingContextName;
+  handler: () => void;
+};
+function ChordInterceptor(t0) {
+  const $ = _c(6);
+  const {
+    bindings,
+    pendingChordRef,
+    setPendingChord,
+    activeContexts,
+    handlerRegistryRef
+  } = t0;
+  let t1;
+  if ($[0] !== activeContexts || $[1] !== bindings || $[2] !== handlerRegistryRef || $[3] !== pendingChordRef || $[4] !== setPendingChord) {
+    t1 = (input, key, event) => {
+      if ((key.wheelUp || key.wheelDown) && pendingChordRef.current === null) {
+        return;
+      }
+      const registry = handlerRegistryRef.current;
+      const handlerContexts = new Set();
+      if (registry) {
+        for (const handlers of registry.values()) {
+          for (const registration of handlers) {
+            handlerContexts.add(registration.context);
+          }
+        }
+      }
+      const contexts = [...handlerContexts, ...activeContexts, "Global"];
+      const wasInChord = pendingChordRef.current !== null;
+      const result = resolveKeyWithChordState(input, key, contexts, bindings, pendingChordRef.current);
+      bb23: switch (result.type) {
+        case "chord_started":
+          {
+            setPendingChord(result.pending);
+            event.stopImmediatePropagation();
+            break bb23;
+          }
+        case "match":
+          {
+            setPendingChord(null);
+            if (wasInChord) {
+              const contextsSet = new Set(contexts);
+              if (registry) {
+                const handlers_0 = registry.get(result.action);
+                if (handlers_0 && handlers_0.size > 0) {
+                  for (const registration_0 of handlers_0) {
+                    if (contextsSet.has(registration_0.context)) {
+                      registration_0.handler();
+                      event.stopImmediatePropagation();
+                      break;
+                    }
+                  }
+                }
+              }
+            }
+            break bb23;
+          }
+        case "chord_cancelled":
+          {
+            setPendingChord(null);
+            event.stopImmediatePropagation();
+            break bb23;
+          }
+        case "unbound":
+          {
+            setPendingChord(null);
+            event.stopImmediatePropagation();
+            break bb23;
+          }
+        case "none":
+      }
+    };
+    $[0] = activeContexts;
+    $[1] = bindings;
+    $[2] = handlerRegistryRef;
+    $[3] = pendingChordRef;
+    $[4] = setPendingChord;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  const handleInput = t1;
+  useInput(handleInput);
+  return null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useRef","useState","useNotifications","InputEvent","Key","useInput","count","logForDebugging","plural","KeybindingProvider","initializeKeybindingWatcher","KeybindingsLoadResult","loadKeybindingsSyncWithWarnings","subscribeToKeybindingChanges","resolveKeyWithChordState","KeybindingContextName","ParsedBinding","ParsedKeystroke","KeybindingWarning","CHORD_TIMEOUT_MS","Props","children","ReactNode","useKeybindingWarnings","warnings","isReload","$","_c","addNotification","removeNotification","t0","length","errorCount","_temp","warnCount","_temp2","message","key","text","color","priority","timeoutMs","t1","w_0","w","severity","KeybindingSetup","bindings","setLoadResult","result","setIsReload","pendingChordRef","pendingChord","setPendingChordState","chordTimeoutRef","NodeJS","Timeout","handlerRegistryRef","Map","Set","action","context","handler","activeContextsRef","registerActiveContext","current","add","unregisterActiveContext","delete","clearChordTimeout","clearTimeout","setPendingChord","pending","setTimeout","unsubscribe","HandlerRegistration","ChordInterceptor","activeContexts","input","event","wheelUp","wheelDown","registry","handlerContexts","handlers","values","registration","contexts","wasInChord","bb23","type","stopImmediatePropagation","contextsSet","handlers_0","get","size","registration_0","has","handleInput"],"sources":["KeybindingProviderSetup.tsx"],"sourcesContent":["/**\n * Setup utilities for integrating KeybindingProvider into the app.\n *\n * This file provides the bindings and a composed provider that can be\n * added to the app's component tree. It loads both default bindings and\n * user-defined bindings from ~/.claude/keybindings.json, with hot-reload\n * support when the file changes.\n */\nimport React, { useCallback, useEffect, useRef, useState } from 'react'\nimport { useNotifications } from '../context/notifications.js'\nimport type { InputEvent } from '../ink/events/input-event.js'\n// ChordInterceptor intentionally uses useInput to intercept all keystrokes before\n// other handlers process them - this is required for chord sequence support\n// eslint-disable-next-line custom-rules/prefer-use-keybindings\nimport { type Key, useInput } from '../ink.js'\nimport { count } from '../utils/array.js'\nimport { logForDebugging } from '../utils/debug.js'\nimport { plural } from '../utils/stringUtils.js'\nimport { KeybindingProvider } from './KeybindingContext.js'\nimport {\n  initializeKeybindingWatcher,\n  type KeybindingsLoadResult,\n  loadKeybindingsSyncWithWarnings,\n  subscribeToKeybindingChanges,\n} from './loadUserBindings.js'\nimport { resolveKeyWithChordState } from './resolver.js'\nimport type {\n  KeybindingContextName,\n  ParsedBinding,\n  ParsedKeystroke,\n} from './types.js'\nimport type { KeybindingWarning } from './validate.js'\n\n/**\n * Timeout for chord sequences in milliseconds.\n * If the user doesn't complete the chord within this time, it's cancelled.\n */\nconst CHORD_TIMEOUT_MS = 1000\n\ntype Props = {\n  children: React.ReactNode\n}\n\n/**\n * Keybinding provider with default + user bindings and hot-reload support.\n *\n * Usage: Wrap your app with this provider to enable keybinding support.\n *\n * ```tsx\n * <AppStateProvider>\n *   <KeybindingSetup>\n *     <REPL ... />\n *   </KeybindingSetup>\n * </AppStateProvider>\n * ```\n *\n * Features:\n * - Loads default bindings from code\n * - Merges with user bindings from ~/.claude/keybindings.json\n * - Watches for file changes and reloads automatically (hot-reload)\n * - User bindings override defaults (later entries win)\n * - Chord support with automatic timeout\n */\n/**\n * Display keybinding warnings to the user via notifications.\n * Shows a brief message pointing to /doctor for details.\n */\nfunction useKeybindingWarnings(\n  warnings: KeybindingWarning[],\n  isReload: boolean,\n): void {\n  const { addNotification, removeNotification } = useNotifications()\n\n  useEffect(() => {\n    const notificationKey = 'keybinding-config-warning'\n\n    if (warnings.length === 0) {\n      removeNotification(notificationKey)\n      return\n    }\n\n    const errorCount = count(warnings, w => w.severity === 'error')\n    const warnCount = count(warnings, w => w.severity === 'warning')\n\n    let message: string\n    if (errorCount > 0 && warnCount > 0) {\n      message = `Found ${errorCount} keybinding ${plural(errorCount, 'error')} and ${warnCount} ${plural(warnCount, 'warning')}`\n    } else if (errorCount > 0) {\n      message = `Found ${errorCount} keybinding ${plural(errorCount, 'error')}`\n    } else {\n      message = `Found ${warnCount} keybinding ${plural(warnCount, 'warning')}`\n    }\n    message += ' · /doctor for details'\n\n    addNotification({\n      key: notificationKey,\n      text: message,\n      color: errorCount > 0 ? 'error' : 'warning',\n      priority: errorCount > 0 ? 'immediate' : 'high',\n      // Keep visible for 60 seconds like settings errors\n      timeoutMs: 60000,\n    })\n  }, [warnings, isReload, addNotification, removeNotification])\n}\n\nexport function KeybindingSetup({ children }: Props): React.ReactNode {\n  // Load bindings synchronously for initial render\n  const [{ bindings, warnings }, setLoadResult] =\n    useState<KeybindingsLoadResult>(() => {\n      const result = loadKeybindingsSyncWithWarnings()\n      logForDebugging(\n        `[keybindings] KeybindingSetup initialized with ${result.bindings.length} bindings, ${result.warnings.length} warnings`,\n      )\n      return result\n    })\n\n  // Track if this is a reload (not initial load)\n  const [isReload, setIsReload] = useState(false)\n\n  // Display warnings via notifications\n  useKeybindingWarnings(warnings, isReload)\n\n  // Chord state management - use ref for immediate access, state for re-renders\n  // The ref is used by resolve() to get the current value without waiting for re-render\n  // The state is used to trigger re-renders when needed (e.g., for UI updates)\n  const pendingChordRef = useRef<ParsedKeystroke[] | null>(null)\n  const [pendingChord, setPendingChordState] = useState<\n    ParsedKeystroke[] | null\n  >(null)\n  const chordTimeoutRef = useRef<NodeJS.Timeout | null>(null)\n\n  // Handler registry for action callbacks (used by ChordInterceptor to invoke handlers)\n  const handlerRegistryRef = useRef(\n    new Map<\n      string,\n      Set<{\n        action: string\n        context: KeybindingContextName\n        handler: () => void\n      }>\n    >(),\n  )\n\n  // Active context tracking for keybinding priority resolution\n  // Using a ref instead of state for synchronous updates - input handlers need\n  // to see the current value immediately, not after a React render cycle.\n  const activeContextsRef = useRef<Set<KeybindingContextName>>(new Set())\n\n  const registerActiveContext = useCallback(\n    (context: KeybindingContextName) => {\n      activeContextsRef.current.add(context)\n    },\n    [],\n  )\n\n  const unregisterActiveContext = useCallback(\n    (context: KeybindingContextName) => {\n      activeContextsRef.current.delete(context)\n    },\n    [],\n  )\n\n  // Clear chord timeout when component unmounts or chord changes\n  const clearChordTimeout = useCallback(() => {\n    if (chordTimeoutRef.current) {\n      clearTimeout(chordTimeoutRef.current)\n      chordTimeoutRef.current = null\n    }\n  }, [])\n\n  // Wrapper for setPendingChord that manages timeout and syncs ref+state\n  const setPendingChord = useCallback(\n    (pending: ParsedKeystroke[] | null) => {\n      clearChordTimeout()\n\n      if (pending !== null) {\n        // Set timeout to cancel chord if not completed\n        chordTimeoutRef.current = setTimeout(\n          (pendingChordRef, setPendingChordState) => {\n            logForDebugging('[keybindings] Chord timeout - cancelling')\n            pendingChordRef.current = null\n            setPendingChordState(null)\n          },\n          CHORD_TIMEOUT_MS,\n          pendingChordRef,\n          setPendingChordState,\n        )\n      }\n\n      // Update ref immediately for synchronous access in resolve()\n      pendingChordRef.current = pending\n      // Update state to trigger re-renders for UI updates\n      setPendingChordState(pending)\n    },\n    [clearChordTimeout],\n  )\n\n  useEffect(() => {\n    // Initialize file watcher (idempotent - only runs once)\n    void initializeKeybindingWatcher()\n\n    // Subscribe to changes\n    const unsubscribe = subscribeToKeybindingChanges(result => {\n      // Any callback invocation is a reload since initial load happens\n      // synchronously in useState, not via this subscription\n      setIsReload(true)\n\n      setLoadResult(result)\n      logForDebugging(\n        `[keybindings] Reloaded: ${result.bindings.length} bindings, ${result.warnings.length} warnings`,\n      )\n    })\n\n    return () => {\n      unsubscribe()\n      clearChordTimeout()\n    }\n  }, [clearChordTimeout])\n\n  return (\n    <KeybindingProvider\n      bindings={bindings}\n      pendingChordRef={pendingChordRef}\n      pendingChord={pendingChord}\n      setPendingChord={setPendingChord}\n      activeContexts={activeContextsRef.current}\n      registerActiveContext={registerActiveContext}\n      unregisterActiveContext={unregisterActiveContext}\n      handlerRegistryRef={handlerRegistryRef}\n    >\n      <ChordInterceptor\n        bindings={bindings}\n        pendingChordRef={pendingChordRef}\n        setPendingChord={setPendingChord}\n        activeContexts={activeContextsRef.current}\n        handlerRegistryRef={handlerRegistryRef}\n      />\n      {children}\n    </KeybindingProvider>\n  )\n}\n\n/**\n * Global chord interceptor that registers useInput FIRST (before children).\n *\n * This component intercepts keystrokes that are part of chord sequences and\n * stops propagation before other handlers (like PromptInput) can see them.\n *\n * Without this, the second key of a chord (e.g., 'r' in \"ctrl+c r\") would be\n * captured by PromptInput and added to the input field before the keybinding\n * system could recognize it as completing a chord.\n */\ntype HandlerRegistration = {\n  action: string\n  context: KeybindingContextName\n  handler: () => void\n}\n\nfunction ChordInterceptor({\n  bindings,\n  pendingChordRef,\n  setPendingChord,\n  activeContexts,\n  handlerRegistryRef,\n}: {\n  bindings: ParsedBinding[]\n  pendingChordRef: React.RefObject<ParsedKeystroke[] | null>\n  setPendingChord: (pending: ParsedKeystroke[] | null) => void\n  activeContexts: Set<KeybindingContextName>\n  handlerRegistryRef: React.RefObject<Map<string, Set<HandlerRegistration>>>\n}): null {\n  const handleInput = useCallback(\n    (input: string, key: Key, event: InputEvent) => {\n      // Wheel events can never start chord sequences — scroll:lineUp/Down are\n      // single-key bindings handled by per-component useKeybindings hooks, not\n      // here. Skip the registry scan. Mid-chord wheel still falls through so\n      // scrolling cancels the pending chord like any other non-matching key.\n      if ((key.wheelUp || key.wheelDown) && pendingChordRef.current === null) {\n        return\n      }\n\n      // Build context list from registered handlers + activeContexts + Global\n      // This ensures we can resolve chords for all contexts that have handlers\n      const registry = handlerRegistryRef.current\n      const handlerContexts = new Set<KeybindingContextName>()\n      if (registry) {\n        for (const handlers of registry.values()) {\n          for (const registration of handlers) {\n            handlerContexts.add(registration.context)\n          }\n        }\n      }\n      const contexts: KeybindingContextName[] = [\n        ...handlerContexts,\n        ...activeContexts,\n        'Global',\n      ]\n\n      // Track whether we're completing a chord (pending was non-null)\n      const wasInChord = pendingChordRef.current !== null\n\n      // Check if this keystroke is part of a chord sequence\n      const result = resolveKeyWithChordState(\n        input,\n        key,\n        contexts,\n        bindings,\n        pendingChordRef.current,\n      )\n\n      switch (result.type) {\n        case 'chord_started':\n          // This key starts a chord - store pending state and stop propagation\n          setPendingChord(result.pending)\n          event.stopImmediatePropagation()\n          break\n\n        case 'match': {\n          // Clear pending state\n          setPendingChord(null)\n\n          // Only invoke handlers and stop propagation for chord completions\n          // (multi-keystroke sequences). Single-keystroke matches should propagate\n          // to per-hook handlers to avoid interfering with other input handling\n          // (e.g., Enter needs to reach useTypeahead for autocomplete acceptance\n          // before the submit handler fires).\n          if (wasInChord) {\n            // Find and invoke the handler for this action\n            // We need to check that the handler's context is in our resolved contexts\n            // (which includes handlerContexts + activeContexts + Global)\n            const contextsSet = new Set(contexts)\n            if (registry) {\n              const handlers = registry.get(result.action)\n              if (handlers && handlers.size > 0) {\n                // Find handlers whose context is in our resolved contexts\n                for (const registration of handlers) {\n                  if (contextsSet.has(registration.context)) {\n                    registration.handler()\n                    event.stopImmediatePropagation()\n                    break // Only invoke the first matching handler\n                  }\n                }\n              }\n            }\n          }\n          break\n        }\n\n        case 'chord_cancelled':\n          // Invalid key during chord - clear pending state and swallow the\n          // keystroke so it doesn't propagate as a standalone action\n          // (e.g., ctrl+x ctrl+c should not fire app:interrupt).\n          setPendingChord(null)\n          event.stopImmediatePropagation()\n          break\n\n        case 'unbound':\n          // Key is explicitly unbound - clear pending state and swallow\n          // the keystroke (it was part of a chord sequence).\n          setPendingChord(null)\n          event.stopImmediatePropagation()\n          break\n\n        case 'none':\n          // No chord involvement - let other handlers process\n          break\n      }\n    },\n    [\n      bindings,\n      pendingChordRef,\n      setPendingChord,\n      activeContexts,\n      handlerRegistryRef,\n    ],\n  )\n\n  useInput(handleInput)\n\n  return null\n}\n"],"mappings":"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","ignoreList":[]}

src/keybindings/defaultBindings.ts

@@ -0,0 +1,340 @@
+import { feature } from 'bun:bundle'
+import { satisfies } from 'src/utils/semver.js'
+import { isRunningWithBun } from '../utils/bundledMode.js'
+import { getPlatform } from '../utils/platform.js'
+import type { KeybindingBlock } from './types.js'
+
+/**
+ * Default keybindings that match current Claude Code behavior.
+ * These are loaded first, then user keybindings.json overrides them.
+ */
+
+// Platform-specific image paste shortcut:
+// - Windows: alt+v (ctrl+v is system paste)
+// - Other platforms: ctrl+v
+const IMAGE_PASTE_KEY = getPlatform() === 'windows' ? 'alt+v' : 'ctrl+v'
+
+// Modifier-only chords (like shift+tab) may fail on Windows Terminal without VT mode
+// See: https://github.com/microsoft/terminal/issues/879#issuecomment-618801651
+// Node enabled VT mode in 24.2.0 / 22.17.0: https://github.com/nodejs/node/pull/58358
+// Bun enabled VT mode in 1.2.23: https://github.com/oven-sh/bun/pull/21161
+const SUPPORTS_TERMINAL_VT_MODE =
+  getPlatform() !== 'windows' ||
+  (isRunningWithBun()
+    ? satisfies(process.versions.bun, '>=1.2.23')
+    : satisfies(process.versions.node, '>=22.17.0 <23.0.0 || >=24.2.0'))
+
+// Platform-specific mode cycle shortcut:
+// - Windows without VT mode: meta+m (shift+tab doesn't work reliably)
+// - Other platforms: shift+tab
+const MODE_CYCLE_KEY = SUPPORTS_TERMINAL_VT_MODE ? 'shift+tab' : 'meta+m'
+
+export const DEFAULT_BINDINGS: KeybindingBlock[] = [
+  {
+    context: 'Global',
+    bindings: {
+      // ctrl+c and ctrl+d use special time-based double-press handling.
+      // They ARE defined here so the resolver can find them, but they
+      // CANNOT be rebound by users - validation in reservedShortcuts.ts
+      // will show an error if users try to override these keys.
+      'ctrl+c': 'app:interrupt',
+      'ctrl+d': 'app:exit',
+      'ctrl+l': 'app:redraw',
+      'ctrl+t': 'app:toggleTodos',
+      'ctrl+o': 'app:toggleTranscript',
+      ...(feature('KAIROS') || feature('KAIROS_BRIEF')
+        ? { 'ctrl+shift+b': 'app:toggleBrief' as const }
+        : {}),
+      'ctrl+shift+o': 'app:toggleTeammatePreview',
+      'ctrl+r': 'history:search',
+      // File navigation. cmd+ bindings only fire on kitty-protocol terminals;
+      // ctrl+shift is the portable fallback.
+      ...(feature('QUICK_SEARCH')
+        ? {
+            'ctrl+shift+f': 'app:globalSearch' as const,
+            'cmd+shift+f': 'app:globalSearch' as const,
+            'ctrl+shift+p': 'app:quickOpen' as const,
+            'cmd+shift+p': 'app:quickOpen' as const,
+          }
+        : {}),
+      ...(feature('TERMINAL_PANEL') ? { 'meta+j': 'app:toggleTerminal' } : {}),
+    },
+  },
+  {
+    context: 'Chat',
+    bindings: {
+      escape: 'chat:cancel',
+      // ctrl+x chord prefix avoids shadowing readline editing keys (ctrl+a/b/e/f/...).
+      'ctrl+x ctrl+k': 'chat:killAgents',
+      [MODE_CYCLE_KEY]: 'chat:cycleMode',
+      'meta+p': 'chat:modelPicker',
+      'meta+o': 'chat:fastMode',
+      'meta+t': 'chat:thinkingToggle',
+      enter: 'chat:submit',
+      up: 'history:previous',
+      down: 'history:next',
+      // Editing shortcuts (defined here, migration in progress)
+      // Undo has two bindings to support different terminal behaviors:
+      // - ctrl+_ for legacy terminals (send \x1f control char)
+      // - ctrl+shift+- for Kitty protocol (sends physical key with modifiers)
+      'ctrl+_': 'chat:undo',
+      'ctrl+shift+-': 'chat:undo',
+      // ctrl+x ctrl+e is the readline-native edit-and-execute-command binding.
+      'ctrl+x ctrl+e': 'chat:externalEditor',
+      'ctrl+g': 'chat:externalEditor',
+      'ctrl+s': 'chat:stash',
+      // Image paste shortcut (platform-specific key defined above)
+      [IMAGE_PASTE_KEY]: 'chat:imagePaste',
+      ...(feature('MESSAGE_ACTIONS')
+        ? { 'shift+up': 'chat:messageActions' as const }
+        : {}),
+      // Voice activation (hold-to-talk). Registered so getShortcutDisplay
+      // finds it without hitting the fallback analytics log. To rebind,
+      // add a voice:pushToTalk entry (last wins); to disable, use /voice
+      // — null-unbinding space hits a pre-existing useKeybinding.ts trap
+      // where 'unbound' swallows the event (space dead for typing).
+      ...(feature('VOICE_MODE') ? { space: 'voice:pushToTalk' } : {}),
+    },
+  },
+  {
+    context: 'Autocomplete',
+    bindings: {
+      tab: 'autocomplete:accept',
+      escape: 'autocomplete:dismiss',
+      up: 'autocomplete:previous',
+      down: 'autocomplete:next',
+    },
+  },
+  {
+    context: 'Settings',
+    bindings: {
+      // Settings menu uses escape only (not 'n') to dismiss
+      escape: 'confirm:no',
+      // Config panel list navigation (reuses Select actions)
+      up: 'select:previous',
+      down: 'select:next',
+      k: 'select:previous',
+      j: 'select:next',
+      'ctrl+p': 'select:previous',
+      'ctrl+n': 'select:next',
+      // Toggle/activate the selected setting (space only — enter saves & closes)
+      space: 'select:accept',
+      // Save and close the config panel
+      enter: 'settings:close',
+      // Enter search mode
+      '/': 'settings:search',
+      // Retry loading usage data (only active on error)
+      r: 'settings:retry',
+    },
+  },
+  {
+    context: 'Confirmation',
+    bindings: {
+      y: 'confirm:yes',
+      n: 'confirm:no',
+      enter: 'confirm:yes',
+      escape: 'confirm:no',
+      // Navigation for dialogs with lists
+      up: 'confirm:previous',
+      down: 'confirm:next',
+      tab: 'confirm:nextField',
+      space: 'confirm:toggle',
+      // Cycle modes (used in file permission dialogs and teams dialog)
+      'shift+tab': 'confirm:cycleMode',
+      // Toggle permission explanation in permission dialogs
+      'ctrl+e': 'confirm:toggleExplanation',
+      // Toggle permission debug info
+      'ctrl+d': 'permission:toggleDebug',
+    },
+  },
+  {
+    context: 'Tabs',
+    bindings: {
+      // Tab cycling navigation
+      tab: 'tabs:next',
+      'shift+tab': 'tabs:previous',
+      right: 'tabs:next',
+      left: 'tabs:previous',
+    },
+  },
+  {
+    context: 'Transcript',
+    bindings: {
+      'ctrl+e': 'transcript:toggleShowAll',
+      'ctrl+c': 'transcript:exit',
+      escape: 'transcript:exit',
+      // q — pager convention (less, tmux copy-mode). Transcript is a modal
+      // reading view with no prompt, so q-as-literal-char has no owner.
+      q: 'transcript:exit',
+    },
+  },
+  {
+    context: 'HistorySearch',
+    bindings: {
+      'ctrl+r': 'historySearch:next',
+      escape: 'historySearch:accept',
+      tab: 'historySearch:accept',
+      'ctrl+c': 'historySearch:cancel',
+      enter: 'historySearch:execute',
+    },
+  },
+  {
+    context: 'Task',
+    bindings: {
+      // Background running foreground tasks (bash commands, agents)
+      // In tmux, users must press ctrl+b twice (tmux prefix escape)
+      'ctrl+b': 'task:background',
+    },
+  },
+  {
+    context: 'ThemePicker',
+    bindings: {
+      'ctrl+t': 'theme:toggleSyntaxHighlighting',
+    },
+  },
+  {
+    context: 'Scroll',
+    bindings: {
+      pageup: 'scroll:pageUp',
+      pagedown: 'scroll:pageDown',
+      wheelup: 'scroll:lineUp',
+      wheeldown: 'scroll:lineDown',
+      'ctrl+home': 'scroll:top',
+      'ctrl+end': 'scroll:bottom',
+      // Selection copy. ctrl+shift+c is standard terminal copy.
+      // cmd+c only fires on terminals using the kitty keyboard
+      // protocol (kitty/WezTerm/ghostty/iTerm2) where the super
+      // modifier actually reaches the pty — inert elsewhere.
+      // Esc-to-clear and contextual ctrl+c are handled via raw
+      // useInput so they can conditionally propagate.
+      'ctrl+shift+c': 'selection:copy',
+      'cmd+c': 'selection:copy',
+    },
+  },
+  {
+    context: 'Help',
+    bindings: {
+      escape: 'help:dismiss',
+    },
+  },
+  // Attachment navigation (select dialog image attachments)
+  {
+    context: 'Attachments',
+    bindings: {
+      right: 'attachments:next',
+      left: 'attachments:previous',
+      backspace: 'attachments:remove',
+      delete: 'attachments:remove',
+      down: 'attachments:exit',
+      escape: 'attachments:exit',
+    },
+  },
+  // Footer indicator navigation (tasks, teams, diff, loop)
+  {
+    context: 'Footer',
+    bindings: {
+      up: 'footer:up',
+      'ctrl+p': 'footer:up',
+      down: 'footer:down',
+      'ctrl+n': 'footer:down',
+      right: 'footer:next',
+      left: 'footer:previous',
+      enter: 'footer:openSelected',
+      escape: 'footer:clearSelection',
+    },
+  },
+  // Message selector (rewind dialog) navigation
+  {
+    context: 'MessageSelector',
+    bindings: {
+      up: 'messageSelector:up',
+      down: 'messageSelector:down',
+      k: 'messageSelector:up',
+      j: 'messageSelector:down',
+      'ctrl+p': 'messageSelector:up',
+      'ctrl+n': 'messageSelector:down',
+      'ctrl+up': 'messageSelector:top',
+      'shift+up': 'messageSelector:top',
+      'meta+up': 'messageSelector:top',
+      'shift+k': 'messageSelector:top',
+      'ctrl+down': 'messageSelector:bottom',
+      'shift+down': 'messageSelector:bottom',
+      'meta+down': 'messageSelector:bottom',
+      'shift+j': 'messageSelector:bottom',
+      enter: 'messageSelector:select',
+    },
+  },
+  // PromptInput unmounts while cursor active — no key conflict.
+  ...(feature('MESSAGE_ACTIONS')
+    ? [
+        {
+          context: 'MessageActions' as const,
+          bindings: {
+            up: 'messageActions:prev' as const,
+            down: 'messageActions:next' as const,
+            k: 'messageActions:prev' as const,
+            j: 'messageActions:next' as const,
+            // meta = cmd on macOS; super for kitty keyboard-protocol — bind both.
+            'meta+up': 'messageActions:top' as const,
+            'meta+down': 'messageActions:bottom' as const,
+            'super+up': 'messageActions:top' as const,
+            'super+down': 'messageActions:bottom' as const,
+            // Mouse selection extends on shift+arrow (ScrollKeybindingHandler:573) when present —
+            // correct layered UX: esc clears selection, then shift+↑ jumps.
+            'shift+up': 'messageActions:prevUser' as const,
+            'shift+down': 'messageActions:nextUser' as const,
+            escape: 'messageActions:escape' as const,
+            'ctrl+c': 'messageActions:ctrlc' as const,
+            // Mirror MESSAGE_ACTIONS. Not imported — would pull React/ink into this config module.
+            enter: 'messageActions:enter' as const,
+            c: 'messageActions:c' as const,
+            p: 'messageActions:p' as const,
+          },
+        },
+      ]
+    : []),
+  // Diff dialog navigation
+  {
+    context: 'DiffDialog',
+    bindings: {
+      escape: 'diff:dismiss',
+      left: 'diff:previousSource',
+      right: 'diff:nextSource',
+      up: 'diff:previousFile',
+      down: 'diff:nextFile',
+      enter: 'diff:viewDetails',
+      // Note: diff:back is handled by left arrow in detail mode
+    },
+  },
+  // Model picker effort cycling (ant-only)
+  {
+    context: 'ModelPicker',
+    bindings: {
+      left: 'modelPicker:decreaseEffort',
+      right: 'modelPicker:increaseEffort',
+    },
+  },
+  // Select component navigation (used by /model, /resume, permission prompts, etc.)
+  {
+    context: 'Select',
+    bindings: {
+      up: 'select:previous',
+      down: 'select:next',
+      j: 'select:next',
+      k: 'select:previous',
+      'ctrl+n': 'select:next',
+      'ctrl+p': 'select:previous',
+      enter: 'select:accept',
+      escape: 'select:cancel',
+    },
+  },
+  // Plugin dialog actions (manage, browse, discover plugins)
+  // Navigation (select:*) uses the Select context above
+  {
+    context: 'Plugin',
+    bindings: {
+      space: 'plugin:toggle',
+      i: 'plugin:install',
+    },
+  },
+]

src/keybindings/loadUserBindings.ts

@@ -0,0 +1,472 @@
+/**
+ * User keybinding configuration loader with hot-reload support.
+ *
+ * Loads keybindings from ~/.claude/keybindings.json and watches
+ * for changes to reload them automatically.
+ *
+ * NOTE: User keybinding customization is currently only available for
+ * Anthropic employees (USER_TYPE === 'ant'). External users always
+ * use the default bindings.
+ */
+
+import chokidar, { type FSWatcher } from 'chokidar'
+import { readFileSync } from 'fs'
+import { readFile, stat } from 'fs/promises'
+import { dirname, join } from 'path'
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js'
+import { logEvent } from '../services/analytics/index.js'
+import { registerCleanup } from '../utils/cleanupRegistry.js'
+import { logForDebugging } from '../utils/debug.js'
+import { getClaudeConfigHomeDir } from '../utils/envUtils.js'
+import { errorMessage, isENOENT } from '../utils/errors.js'
+import { createSignal } from '../utils/signal.js'
+import { jsonParse } from '../utils/slowOperations.js'
+import { DEFAULT_BINDINGS } from './defaultBindings.js'
+import { parseBindings } from './parser.js'
+import type { KeybindingBlock, ParsedBinding } from './types.js'
+import {
+  checkDuplicateKeysInJson,
+  type KeybindingWarning,
+  validateBindings,
+} from './validate.js'
+
+/**
+ * Check if keybinding customization is enabled.
+ *
+ * Returns true if the tengu_keybinding_customization_release GrowthBook gate is enabled.
+ *
+ * This function is exported so other parts of the codebase (e.g., /doctor)
+ * can check the same condition consistently.
+ */
+export function isKeybindingCustomizationEnabled(): boolean {
+  return getFeatureValue_CACHED_MAY_BE_STALE(
+    'tengu_keybinding_customization_release',
+    false,
+  )
+}
+
+/**
+ * Time in milliseconds to wait for file writes to stabilize.
+ */
+const FILE_STABILITY_THRESHOLD_MS = 500
+
+/**
+ * Polling interval for checking file stability.
+ */
+const FILE_STABILITY_POLL_INTERVAL_MS = 200
+
+/**
+ * Result of loading keybindings, including any validation warnings.
+ */
+export type KeybindingsLoadResult = {
+  bindings: ParsedBinding[]
+  warnings: KeybindingWarning[]
+}
+
+let watcher: FSWatcher | null = null
+let initialized = false
+let disposed = false
+let cachedBindings: ParsedBinding[] | null = null
+let cachedWarnings: KeybindingWarning[] = []
+const keybindingsChanged = createSignal<[result: KeybindingsLoadResult]>()
+
+/**
+ * Tracks the date (YYYY-MM-DD) when we last logged a custom keybindings load event.
+ * Used to ensure we fire the event at most once per day.
+ */
+let lastCustomBindingsLogDate: string | null = null
+
+/**
+ * Log a telemetry event when custom keybindings are loaded, at most once per day.
+ * This lets us estimate the percentage of users who customize their keybindings.
+ */
+function logCustomBindingsLoadedOncePerDay(userBindingCount: number): void {
+  const today = new Date().toISOString().slice(0, 10)
+  if (lastCustomBindingsLogDate === today) return
+  lastCustomBindingsLogDate = today
+  logEvent('tengu_custom_keybindings_loaded', {
+    user_binding_count: userBindingCount,
+  })
+}
+
+/**
+ * Type guard to check if an object is a valid KeybindingBlock.
+ */
+function isKeybindingBlock(obj: unknown): obj is KeybindingBlock {
+  if (typeof obj !== 'object' || obj === null) return false
+  const b = obj as Record<string, unknown>
+  return (
+    typeof b.context === 'string' &&
+    typeof b.bindings === 'object' &&
+    b.bindings !== null
+  )
+}
+
+/**
+ * Type guard to check if an array contains only valid KeybindingBlocks.
+ */
+function isKeybindingBlockArray(arr: unknown): arr is KeybindingBlock[] {
+  return Array.isArray(arr) && arr.every(isKeybindingBlock)
+}
+
+/**
+ * Get the path to the user keybindings file.
+ */
+export function getKeybindingsPath(): string {
+  return join(getClaudeConfigHomeDir(), 'keybindings.json')
+}
+
+/**
+ * Parse default bindings (cached for performance).
+ */
+function getDefaultParsedBindings(): ParsedBinding[] {
+  return parseBindings(DEFAULT_BINDINGS)
+}
+
+/**
+ * Load and parse keybindings from user config file.
+ * Returns merged default + user bindings along with validation warnings.
+ *
+ * For external users, always returns default bindings only.
+ * User customization is currently gated to Anthropic employees.
+ */
+export async function loadKeybindings(): Promise<KeybindingsLoadResult> {
+  const defaultBindings = getDefaultParsedBindings()
+
+  // Skip user config loading for external users
+  if (!isKeybindingCustomizationEnabled()) {
+    return { bindings: defaultBindings, warnings: [] }
+  }
+
+  const userPath = getKeybindingsPath()
+
+  try {
+    const content = await readFile(userPath, 'utf-8')
+    const parsed: unknown = jsonParse(content)
+
+    // Extract bindings array from object wrapper format: { "bindings": [...] }
+    let userBlocks: unknown
+    if (typeof parsed === 'object' && parsed !== null && 'bindings' in parsed) {
+      userBlocks = (parsed as { bindings: unknown }).bindings
+    } else {
+      // Invalid format - missing bindings property
+      const errorMessage = 'keybindings.json must have a "bindings" array'
+      const suggestion = 'Use format: { "bindings": [ ... ] }'
+      logForDebugging(`[keybindings] Invalid keybindings.json: ${errorMessage}`)
+      return {
+        bindings: defaultBindings,
+        warnings: [
+          {
+            type: 'parse_error',
+            severity: 'error',
+            message: errorMessage,
+            suggestion,
+          },
+        ],
+      }
+    }
+
+    // Validate structure - bindings must be an array of valid keybinding blocks
+    if (!isKeybindingBlockArray(userBlocks)) {
+      const errorMessage = !Array.isArray(userBlocks)
+        ? '"bindings" must be an array'
+        : 'keybindings.json contains invalid block structure'
+      const suggestion = !Array.isArray(userBlocks)
+        ? 'Set "bindings" to an array of keybinding blocks'
+        : 'Each block must have "context" (string) and "bindings" (object)'
+      logForDebugging(`[keybindings] Invalid keybindings.json: ${errorMessage}`)
+      return {
+        bindings: defaultBindings,
+        warnings: [
+          {
+            type: 'parse_error',
+            severity: 'error',
+            message: errorMessage,
+            suggestion,
+          },
+        ],
+      }
+    }
+
+    const userParsed = parseBindings(userBlocks)
+    logForDebugging(
+      `[keybindings] Loaded ${userParsed.length} user bindings from ${userPath}`,
+    )
+
+    // User bindings come after defaults, so they override
+    const mergedBindings = [...defaultBindings, ...userParsed]
+
+    logCustomBindingsLoadedOncePerDay(userParsed.length)
+
+    // Run validation on user config
+    // First check for duplicate keys in raw JSON (JSON.parse silently drops earlier values)
+    const duplicateKeyWarnings = checkDuplicateKeysInJson(content)
+    const warnings = [
+      ...duplicateKeyWarnings,
+      ...validateBindings(userBlocks, mergedBindings),
+    ]
+
+    if (warnings.length > 0) {
+      logForDebugging(
+        `[keybindings] Found ${warnings.length} validation issue(s)`,
+      )
+    }
+
+    return { bindings: mergedBindings, warnings }
+  } catch (error) {
+    // File doesn't exist - use defaults (user can run /keybindings to create)
+    if (isENOENT(error)) {
+      return { bindings: defaultBindings, warnings: [] }
+    }
+
+    // Other error - log and return defaults with warning
+    logForDebugging(
+      `[keybindings] Error loading ${userPath}: ${errorMessage(error)}`,
+    )
+    return {
+      bindings: defaultBindings,
+      warnings: [
+        {
+          type: 'parse_error',
+          severity: 'error',
+          message: `Failed to parse keybindings.json: ${errorMessage(error)}`,
+        },
+      ],
+    }
+  }
+}
+
+/**
+ * Load keybindings synchronously (for initial render).
+ * Uses cached value if available.
+ */
+export function loadKeybindingsSync(): ParsedBinding[] {
+  if (cachedBindings) {
+    return cachedBindings
+  }
+
+  const result = loadKeybindingsSyncWithWarnings()
+  return result.bindings
+}
+
+/**
+ * Load keybindings synchronously with validation warnings.
+ * Uses cached values if available.
+ *
+ * For external users, always returns default bindings only.
+ * User customization is currently gated to Anthropic employees.
+ */
+export function loadKeybindingsSyncWithWarnings(): KeybindingsLoadResult {
+  if (cachedBindings) {
+    return { bindings: cachedBindings, warnings: cachedWarnings }
+  }
+
+  const defaultBindings = getDefaultParsedBindings()
+
+  // Skip user config loading for external users
+  if (!isKeybindingCustomizationEnabled()) {
+    cachedBindings = defaultBindings
+    cachedWarnings = []
+    return { bindings: cachedBindings, warnings: cachedWarnings }
+  }
+
+  const userPath = getKeybindingsPath()
+
+  try {
+    // sync IO: called from sync context (React useState initializer)
+    const content = readFileSync(userPath, 'utf-8')
+    const parsed: unknown = jsonParse(content)
+
+    // Extract bindings array from object wrapper format: { "bindings": [...] }
+    let userBlocks: unknown
+    if (typeof parsed === 'object' && parsed !== null && 'bindings' in parsed) {
+      userBlocks = (parsed as { bindings: unknown }).bindings
+    } else {
+      // Invalid format - missing bindings property
+      cachedBindings = defaultBindings
+      cachedWarnings = [
+        {
+          type: 'parse_error',
+          severity: 'error',
+          message: 'keybindings.json must have a "bindings" array',
+          suggestion: 'Use format: { "bindings": [ ... ] }',
+        },
+      ]
+      return { bindings: cachedBindings, warnings: cachedWarnings }
+    }
+
+    // Validate structure - bindings must be an array of valid keybinding blocks
+    if (!isKeybindingBlockArray(userBlocks)) {
+      const errorMessage = !Array.isArray(userBlocks)
+        ? '"bindings" must be an array'
+        : 'keybindings.json contains invalid block structure'
+      const suggestion = !Array.isArray(userBlocks)
+        ? 'Set "bindings" to an array of keybinding blocks'
+        : 'Each block must have "context" (string) and "bindings" (object)'
+      cachedBindings = defaultBindings
+      cachedWarnings = [
+        {
+          type: 'parse_error',
+          severity: 'error',
+          message: errorMessage,
+          suggestion,
+        },
+      ]
+      return { bindings: cachedBindings, warnings: cachedWarnings }
+    }
+
+    const userParsed = parseBindings(userBlocks)
+    logForDebugging(
+      `[keybindings] Loaded ${userParsed.length} user bindings from ${userPath}`,
+    )
+    cachedBindings = [...defaultBindings, ...userParsed]
+
+    logCustomBindingsLoadedOncePerDay(userParsed.length)
+
+    // Run validation - check for duplicate keys in raw JSON first
+    const duplicateKeyWarnings = checkDuplicateKeysInJson(content)
+    cachedWarnings = [
+      ...duplicateKeyWarnings,
+      ...validateBindings(userBlocks, cachedBindings),
+    ]
+    if (cachedWarnings.length > 0) {
+      logForDebugging(
+        `[keybindings] Found ${cachedWarnings.length} validation issue(s)`,
+      )
+    }
+
+    return { bindings: cachedBindings, warnings: cachedWarnings }
+  } catch {
+    // File doesn't exist or error - use defaults (user can run /keybindings to create)
+    cachedBindings = defaultBindings
+    cachedWarnings = []
+    return { bindings: cachedBindings, warnings: cachedWarnings }
+  }
+}
+
+/**
+ * Initialize file watching for keybindings.json.
+ * Call this once when the app starts.
+ *
+ * For external users, this is a no-op since user customization is disabled.
+ */
+export async function initializeKeybindingWatcher(): Promise<void> {
+  if (initialized || disposed) return
+
+  // Skip file watching for external users
+  if (!isKeybindingCustomizationEnabled()) {
+    logForDebugging(
+      '[keybindings] Skipping file watcher - user customization disabled',
+    )
+    return
+  }
+
+  const userPath = getKeybindingsPath()
+  const watchDir = dirname(userPath)
+
+  // Only watch if parent directory exists
+  try {
+    const stats = await stat(watchDir)
+    if (!stats.isDirectory()) {
+      logForDebugging(
+        `[keybindings] Not watching: ${watchDir} is not a directory`,
+      )
+      return
+    }
+  } catch {
+    logForDebugging(`[keybindings] Not watching: ${watchDir} does not exist`)
+    return
+  }
+
+  // Set initialized only after we've confirmed we can watch
+  initialized = true
+
+  logForDebugging(`[keybindings] Watching for changes to ${userPath}`)
+
+  watcher = chokidar.watch(userPath, {
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: FILE_STABILITY_THRESHOLD_MS,
+      pollInterval: FILE_STABILITY_POLL_INTERVAL_MS,
+    },
+    ignorePermissionErrors: true,
+    usePolling: false,
+    atomic: true,
+  })
+
+  watcher.on('add', handleChange)
+  watcher.on('change', handleChange)
+  watcher.on('unlink', handleDelete)
+
+  // Register cleanup
+  registerCleanup(async () => disposeKeybindingWatcher())
+}
+
+/**
+ * Clean up the file watcher.
+ */
+export function disposeKeybindingWatcher(): void {
+  disposed = true
+  if (watcher) {
+    void watcher.close()
+    watcher = null
+  }
+  keybindingsChanged.clear()
+}
+
+/**
+ * Subscribe to keybinding changes.
+ * The listener receives the new parsed bindings when the file changes.
+ */
+export const subscribeToKeybindingChanges = keybindingsChanged.subscribe
+
+async function handleChange(path: string): Promise<void> {
+  logForDebugging(`[keybindings] Detected change to ${path}`)
+
+  try {
+    const result = await loadKeybindings()
+    cachedBindings = result.bindings
+    cachedWarnings = result.warnings
+
+    // Notify all listeners with the full result
+    keybindingsChanged.emit(result)
+  } catch (error) {
+    logForDebugging(`[keybindings] Error reloading: ${errorMessage(error)}`)
+  }
+}
+
+function handleDelete(path: string): void {
+  logForDebugging(`[keybindings] Detected deletion of ${path}`)
+
+  // Reset to defaults when file is deleted
+  const defaultBindings = getDefaultParsedBindings()
+  cachedBindings = defaultBindings
+  cachedWarnings = []
+
+  keybindingsChanged.emit({ bindings: defaultBindings, warnings: [] })
+}
+
+/**
+ * Get the cached keybinding warnings.
+ * Returns empty array if no warnings or bindings haven't been loaded yet.
+ */
+export function getCachedKeybindingWarnings(): KeybindingWarning[] {
+  return cachedWarnings
+}
+
+/**
+ * Reset internal state for testing.
+ */
+export function resetKeybindingLoaderForTesting(): void {
+  initialized = false
+  disposed = false
+  cachedBindings = null
+  cachedWarnings = []
+  lastCustomBindingsLogDate = null
+  if (watcher) {
+    void watcher.close()
+    watcher = null
+  }
+  keybindingsChanged.clear()
+}

src/keybindings/match.ts

@@ -0,0 +1,120 @@
+import type { Key } from '../ink.js'
+import type { ParsedBinding, ParsedKeystroke } from './types.js'
+
+/**
+ * Modifier keys from Ink's Key type that we care about for matching.
+ * Note: `fn` from Key is intentionally excluded as it's rarely used and
+ * not commonly configurable in terminal applications.
+ */
+type InkModifiers = Pick<Key, 'ctrl' | 'shift' | 'meta' | 'super'>
+
+/**
+ * Extract modifiers from an Ink Key object.
+ * This function ensures we're explicitly extracting the modifiers we care about.
+ */
+function getInkModifiers(key: Key): InkModifiers {
+  return {
+    ctrl: key.ctrl,
+    shift: key.shift,
+    meta: key.meta,
+    super: key.super,
+  }
+}
+
+/**
+ * Extract the normalized key name from Ink's Key + input.
+ * Maps Ink's boolean flags (key.escape, key.return, etc.) to string names
+ * that match our ParsedKeystroke.key format.
+ */
+export function getKeyName(input: string, key: Key): string | null {
+  if (key.escape) return 'escape'
+  if (key.return) return 'enter'
+  if (key.tab) return 'tab'
+  if (key.backspace) return 'backspace'
+  if (key.delete) return 'delete'
+  if (key.upArrow) return 'up'
+  if (key.downArrow) return 'down'
+  if (key.leftArrow) return 'left'
+  if (key.rightArrow) return 'right'
+  if (key.pageUp) return 'pageup'
+  if (key.pageDown) return 'pagedown'
+  if (key.wheelUp) return 'wheelup'
+  if (key.wheelDown) return 'wheeldown'
+  if (key.home) return 'home'
+  if (key.end) return 'end'
+  if (input.length === 1) return input.toLowerCase()
+  return null
+}
+
+/**
+ * Check if all modifiers match between Ink Key and ParsedKeystroke.
+ *
+ * Alt and Meta: Ink historically set `key.meta` for Alt/Option. A `meta`
+ * modifier in config is treated as an alias for `alt` — both match when
+ * `key.meta` is true.
+ *
+ * Super (Cmd/Win): distinct from alt/meta. Only arrives via the kitty
+ * keyboard protocol on supporting terminals. A `cmd`/`super` binding will
+ * simply never fire on terminals that don't send it.
+ */
+function modifiersMatch(
+  inkMods: InkModifiers,
+  target: ParsedKeystroke,
+): boolean {
+  // Check ctrl modifier
+  if (inkMods.ctrl !== target.ctrl) return false
+
+  // Check shift modifier
+  if (inkMods.shift !== target.shift) return false
+
+  // Alt and meta both map to key.meta in Ink (terminal limitation)
+  // So we check if EITHER alt OR meta is required in target
+  const targetNeedsMeta = target.alt || target.meta
+  if (inkMods.meta !== targetNeedsMeta) return false
+
+  // Super (cmd/win) is a distinct modifier from alt/meta
+  if (inkMods.super !== target.super) return false
+
+  return true
+}
+
+/**
+ * Check if a ParsedKeystroke matches the given Ink input + Key.
+ *
+ * The display text will show platform-appropriate names (opt on macOS, alt elsewhere).
+ */
+export function matchesKeystroke(
+  input: string,
+  key: Key,
+  target: ParsedKeystroke,
+): boolean {
+  const keyName = getKeyName(input, key)
+  if (keyName !== target.key) return false
+
+  const inkMods = getInkModifiers(key)
+
+  // QUIRK: Ink sets key.meta=true when escape is pressed (see input-event.ts).
+  // This is a legacy behavior from how escape sequences work in terminals.
+  // We need to ignore the meta modifier when matching the escape key itself,
+  // otherwise bindings like "escape" (without modifiers) would never match.
+  if (key.escape) {
+    return modifiersMatch({ ...inkMods, meta: false }, target)
+  }
+
+  return modifiersMatch(inkMods, target)
+}
+
+/**
+ * Check if Ink's Key + input matches a parsed binding's first keystroke.
+ * For single-keystroke bindings only (Phase 1).
+ */
+export function matchesBinding(
+  input: string,
+  key: Key,
+  binding: ParsedBinding,
+): boolean {
+  if (binding.chord.length !== 1) return false
+  const keystroke = binding.chord[0]
+  if (!keystroke) return false
+  return matchesKeystroke(input, key, keystroke)
+}

src/keybindings/parser.ts

@@ -0,0 +1,203 @@
+import type {
+  Chord,
+  KeybindingBlock,
+  ParsedBinding,
+  ParsedKeystroke,
+} from './types.js'
+
+/**
+ * Parse a keystroke string like "ctrl+shift+k" into a ParsedKeystroke.
+ * Supports various modifier aliases (ctrl/control, alt/opt/option/meta,
+ * cmd/command/super/win).
+ */
+export function parseKeystroke(input: string): ParsedKeystroke {
+  const parts = input.split('+')
+  const keystroke: ParsedKeystroke = {
+    key: '',
+    ctrl: false,
+    alt: false,
+    shift: false,
+    meta: false,
+    super: false,
+  }
+  for (const part of parts) {
+    const lower = part.toLowerCase()
+    switch (lower) {
+      case 'ctrl':
+      case 'control':
+        keystroke.ctrl = true
+        break
+      case 'alt':
+      case 'opt':
+      case 'option':
+        keystroke.alt = true
+        break
+      case 'shift':
+        keystroke.shift = true
+        break
+      case 'meta':
+        keystroke.meta = true
+        break
+      case 'cmd':
+      case 'command':
+      case 'super':
+      case 'win':
+        keystroke.super = true
+        break
+      case 'esc':
+        keystroke.key = 'escape'
+        break
+      case 'return':
+        keystroke.key = 'enter'
+        break
+      case 'space':
+        keystroke.key = ' '
+        break
+      case '↑':
+        keystroke.key = 'up'
+        break
+      case '↓':
+        keystroke.key = 'down'
+        break
+      case '←':
+        keystroke.key = 'left'
+        break
+      case '→':
+        keystroke.key = 'right'
+        break
+      default:
+        keystroke.key = lower
+        break
+    }
+  }
+
+  return keystroke
+}
+
+/**
+ * Parse a chord string like "ctrl+k ctrl+s" into an array of ParsedKeystrokes.
+ */
+export function parseChord(input: string): Chord {
+  // A lone space character IS the space key binding, not a separator
+  if (input === ' ') return [parseKeystroke('space')]
+  return input.trim().split(/\s+/).map(parseKeystroke)
+}
+
+/**
+ * Convert a ParsedKeystroke to its canonical string representation for display.
+ */
+export function keystrokeToString(ks: ParsedKeystroke): string {
+  const parts: string[] = []
+  if (ks.ctrl) parts.push('ctrl')
+  if (ks.alt) parts.push('alt')
+  if (ks.shift) parts.push('shift')
+  if (ks.meta) parts.push('meta')
+  if (ks.super) parts.push('cmd')
+  // Use readable names for display
+  const displayKey = keyToDisplayName(ks.key)
+  parts.push(displayKey)
+  return parts.join('+')
+}
+
+/**
+ * Map internal key names to human-readable display names.
+ */
+function keyToDisplayName(key: string): string {
+  switch (key) {
+    case 'escape':
+      return 'Esc'
+    case ' ':
+      return 'Space'
+    case 'tab':
+      return 'tab'
+    case 'enter':
+      return 'Enter'
+    case 'backspace':
+      return 'Backspace'
+    case 'delete':
+      return 'Delete'
+    case 'up':
+      return '↑'
+    case 'down':
+      return '↓'
+    case 'left':
+      return '←'
+    case 'right':
+      return '→'
+    case 'pageup':
+      return 'PageUp'
+    case 'pagedown':
+      return 'PageDown'
+    case 'home':
+      return 'Home'
+    case 'end':
+      return 'End'
+    default:
+      return key
+  }
+}
+
+/**
+ * Convert a Chord to its canonical string representation for display.
+ */
+export function chordToString(chord: Chord): string {
+  return chord.map(keystrokeToString).join(' ')
+}
+
+/**
+ * Display platform type - a subset of Platform that we care about for display.
+ * WSL and unknown are treated as linux for display purposes.
+ */
+type DisplayPlatform = 'macos' | 'windows' | 'linux' | 'wsl' | 'unknown'
+
+/**
+ * Convert a ParsedKeystroke to a platform-appropriate display string.
+ * Uses "opt" for alt on macOS, "alt" elsewhere.
+ */
+export function keystrokeToDisplayString(
+  ks: ParsedKeystroke,
+  platform: DisplayPlatform = 'linux',
+): string {
+  const parts: string[] = []
+  if (ks.ctrl) parts.push('ctrl')
+  // Alt/meta are equivalent in terminals, show platform-appropriate name
+  if (ks.alt || ks.meta) {
+    // Only macOS uses "opt", all other platforms use "alt"
+    parts.push(platform === 'macos' ? 'opt' : 'alt')
+  }
+  if (ks.shift) parts.push('shift')
+  if (ks.super) {
+    parts.push(platform === 'macos' ? 'cmd' : 'super')
+  }
+  // Use readable names for display
+  const displayKey = keyToDisplayName(ks.key)
+  parts.push(displayKey)
+  return parts.join('+')
+}
+
+/**
+ * Convert a Chord to a platform-appropriate display string.
+ */
+export function chordToDisplayString(
+  chord: Chord,
+  platform: DisplayPlatform = 'linux',
+): string {
+  return chord.map(ks => keystrokeToDisplayString(ks, platform)).join(' ')
+}
+
+/**
+ * Parse keybinding blocks (from JSON config) into a flat list of ParsedBindings.
+ */
+export function parseBindings(blocks: KeybindingBlock[]): ParsedBinding[] {
+  const bindings: ParsedBinding[] = []
+  for (const block of blocks) {
+    for (const [key, action] of Object.entries(block.bindings)) {
+      bindings.push({
+        chord: parseChord(key),
+        action,
+        context: block.context,
+      })
+    }
+  }
+  return bindings
+}

src/keybindings/reservedShortcuts.ts

@@ -0,0 +1,127 @@
+import { getPlatform } from '../utils/platform.js'
+
+/**
+ * Shortcuts that are typically intercepted by the OS, terminal, or shell
+ * and will likely never reach the application.
+ */
+export type ReservedShortcut = {
+  key: string
+  reason: string
+  severity: 'error' | 'warning'
+}
+
+/**
+ * Shortcuts that cannot be rebound - they are hardcoded in Claude Code.
+ */
+export const NON_REBINDABLE: ReservedShortcut[] = [
+  {
+    key: 'ctrl+c',
+    reason: 'Cannot be rebound - used for interrupt/exit (hardcoded)',
+    severity: 'error',
+  },
+  {
+    key: 'ctrl+d',
+    reason: 'Cannot be rebound - used for exit (hardcoded)',
+    severity: 'error',
+  },
+  {
+    key: 'ctrl+m',
+    reason:
+      'Cannot be rebound - identical to Enter in terminals (both send CR)',
+    severity: 'error',
+  },
+]
+
+/**
+ * Terminal control shortcuts that are intercepted by the terminal/OS.
+ * These will likely never reach the application.
+ *
+ * Note: ctrl+s (XOFF) and ctrl+q (XON) are NOT included here because:
+ * - Most modern terminals disable flow control by default
+ * - We use ctrl+s for the stash feature
+ */
+export const TERMINAL_RESERVED: ReservedShortcut[] = [
+  {
+    key: 'ctrl+z',
+    reason: 'Unix process suspend (SIGTSTP)',
+    severity: 'warning',
+  },
+  {
+    key: 'ctrl+\\',
+    reason: 'Terminal quit signal (SIGQUIT)',
+    severity: 'error',
+  },
+]
+
+/**
+ * macOS-specific shortcuts that the OS intercepts.
+ */
+export const MACOS_RESERVED: ReservedShortcut[] = [
+  { key: 'cmd+c', reason: 'macOS system copy', severity: 'error' },
+  { key: 'cmd+v', reason: 'macOS system paste', severity: 'error' },
+  { key: 'cmd+x', reason: 'macOS system cut', severity: 'error' },
+  { key: 'cmd+q', reason: 'macOS quit application', severity: 'error' },
+  { key: 'cmd+w', reason: 'macOS close window/tab', severity: 'error' },
+  { key: 'cmd+tab', reason: 'macOS app switcher', severity: 'error' },
+  { key: 'cmd+space', reason: 'macOS Spotlight', severity: 'error' },
+]
+
+/**
+ * Get all reserved shortcuts for the current platform.
+ * Includes non-rebindable shortcuts and terminal-reserved shortcuts.
+ */
+export function getReservedShortcuts(): ReservedShortcut[] {
+  const platform = getPlatform()
+  // Non-rebindable shortcuts first (highest priority)
+  const reserved = [...NON_REBINDABLE, ...TERMINAL_RESERVED]
+
+  if (platform === 'macos') {
+    reserved.push(...MACOS_RESERVED)
+  }
+
+  return reserved
+}
+
+/**
+ * Normalize a key string for comparison (lowercase, sorted modifiers).
+ * Chords (space-separated steps like "ctrl+x ctrl+b") are normalized
+ * per-step — splitting on '+' first would mangle "x ctrl" into a mainKey
+ * overwritten by the next step, collapsing the chord into its last key.
+ */
+export function normalizeKeyForComparison(key: string): string {
+  return key.trim().split(/\s+/).map(normalizeStep).join(' ')
+}
+
+function normalizeStep(step: string): string {
+  const parts = step.split('+')
+  const modifiers: string[] = []
+  let mainKey = ''
+
+  for (const part of parts) {
+    const lower = part.trim().toLowerCase()
+    if (
+      [
+        'ctrl',
+        'control',
+        'alt',
+        'opt',
+        'option',
+        'meta',
+        'cmd',
+        'command',
+        'shift',
+      ].includes(lower)
+    ) {
+      // Normalize modifier names
+      if (lower === 'control') modifiers.push('ctrl')
+      else if (lower === 'option' || lower === 'opt') modifiers.push('alt')
+      else if (lower === 'command' || lower === 'cmd') modifiers.push('cmd')
+      else modifiers.push(lower)
+    } else {
+      mainKey = lower
+    }
+  }
+
+  modifiers.sort()
+  return [...modifiers, mainKey].join('+')
+}

src/keybindings/resolver.ts

@@ -0,0 +1,244 @@
+import type { Key } from '../ink.js'
+import { getKeyName, matchesBinding } from './match.js'
+import { chordToString } from './parser.js'
+import type {
+  KeybindingContextName,
+  ParsedBinding,
+  ParsedKeystroke,
+} from './types.js'
+
+export type ResolveResult =
+  | { type: 'match'; action: string }
+  | { type: 'none' }
+  | { type: 'unbound' }
+
+export type ChordResolveResult =
+  | { type: 'match'; action: string }
+  | { type: 'none' }
+  | { type: 'unbound' }
+  | { type: 'chord_started'; pending: ParsedKeystroke[] }
+  | { type: 'chord_cancelled' }
+
+/**
+ * Resolve a key input to an action.
+ * Pure function - no state, no side effects, just matching logic.
+ *
+ * @param input - The character input from Ink
+ * @param key - The Key object from Ink with modifier flags
+ * @param activeContexts - Array of currently active contexts (e.g., ['Chat', 'Global'])
+ * @param bindings - All parsed bindings to search through
+ * @returns The resolution result
+ */
+export function resolveKey(
+  input: string,
+  key: Key,
+  activeContexts: KeybindingContextName[],
+  bindings: ParsedBinding[],
+): ResolveResult {
+  // Find matching bindings (last one wins for user overrides)
+  let match: ParsedBinding | undefined
+  const ctxSet = new Set(activeContexts)
+
+  for (const binding of bindings) {
+    // Phase 1: Only single-keystroke bindings
+    if (binding.chord.length !== 1) continue
+    if (!ctxSet.has(binding.context)) continue
+
+    if (matchesBinding(input, key, binding)) {
+      match = binding
+    }
+  }
+
+  if (!match) {
+    return { type: 'none' }
+  }
+
+  if (match.action === null) {
+    return { type: 'unbound' }
+  }
+
+  return { type: 'match', action: match.action }
+}
+
+/**
+ * Get display text for an action from bindings (e.g., "ctrl+t" for "app:toggleTodos").
+ * Searches in reverse order so user overrides take precedence.
+ */
+export function getBindingDisplayText(
+  action: string,
+  context: KeybindingContextName,
+  bindings: ParsedBinding[],
+): string | undefined {
+  // Find the last binding for this action in this context
+  const binding = bindings.findLast(
+    b => b.action === action && b.context === context,
+  )
+  return binding ? chordToString(binding.chord) : undefined
+}
+
+/**
+ * Build a ParsedKeystroke from Ink's input/key.
+ */
+function buildKeystroke(input: string, key: Key): ParsedKeystroke | null {
+  const keyName = getKeyName(input, key)
+  if (!keyName) return null
+
+  // QUIRK: Ink sets key.meta=true when escape is pressed (see input-event.ts).
+  // This is legacy terminal behavior - we should NOT record this as a modifier
+  // for the escape key itself, otherwise chord matching will fail.
+  const effectiveMeta = key.escape ? false : key.meta
+
+  return {
+    key: keyName,
+    ctrl: key.ctrl,
+    alt: effectiveMeta,
+    shift: key.shift,
+    meta: effectiveMeta,
+    super: key.super,
+  }
+}
+
+/**
+ * Compare two ParsedKeystrokes for equality. Collapses alt/meta into
+ * one logical modifier — legacy terminals can't distinguish them (see
+ * match.ts modifiersMatch), so "alt+k" and "meta+k" are the same key.
+ * Super (cmd/win) is distinct — only arrives via kitty keyboard protocol.
+ */
+export function keystrokesEqual(
+  a: ParsedKeystroke,
+  b: ParsedKeystroke,
+): boolean {
+  return (
+    a.key === b.key &&
+    a.ctrl === b.ctrl &&
+    a.shift === b.shift &&
+    (a.alt || a.meta) === (b.alt || b.meta) &&
+    a.super === b.super
+  )
+}
+
+/**
+ * Check if a chord prefix matches the beginning of a binding's chord.
+ */
+function chordPrefixMatches(
+  prefix: ParsedKeystroke[],
+  binding: ParsedBinding,
+): boolean {
+  if (prefix.length >= binding.chord.length) return false
+  for (let i = 0; i < prefix.length; i++) {
+    const prefixKey = prefix[i]
+    const bindingKey = binding.chord[i]
+    if (!prefixKey || !bindingKey) return false
+    if (!keystrokesEqual(prefixKey, bindingKey)) return false
+  }
+  return true
+}
+
+/**
+ * Check if a full chord matches a binding's chord.
+ */
+function chordExactlyMatches(
+  chord: ParsedKeystroke[],
+  binding: ParsedBinding,
+): boolean {
+  if (chord.length !== binding.chord.length) return false
+  for (let i = 0; i < chord.length; i++) {
+    const chordKey = chord[i]
+    const bindingKey = binding.chord[i]
+    if (!chordKey || !bindingKey) return false
+    if (!keystrokesEqual(chordKey, bindingKey)) return false
+  }
+  return true
+}
+
+/**
+ * Resolve a key with chord state support.
+ *
+ * This function handles multi-keystroke chord bindings like "ctrl+k ctrl+s".
+ *
+ * @param input - The character input from Ink
+ * @param key - The Key object from Ink with modifier flags
+ * @param activeContexts - Array of currently active contexts
+ * @param bindings - All parsed bindings
+ * @param pending - Current chord state (null if not in a chord)
+ * @returns Resolution result with chord state
+ */
+export function resolveKeyWithChordState(
+  input: string,
+  key: Key,
+  activeContexts: KeybindingContextName[],
+  bindings: ParsedBinding[],
+  pending: ParsedKeystroke[] | null,
+): ChordResolveResult {
+  // Cancel chord on escape
+  if (key.escape && pending !== null) {
+    return { type: 'chord_cancelled' }
+  }
+
+  // Build current keystroke
+  const currentKeystroke = buildKeystroke(input, key)
+  if (!currentKeystroke) {
+    if (pending !== null) {
+      return { type: 'chord_cancelled' }
+    }
+    return { type: 'none' }
+  }
+
+  // Build the full chord sequence to test
+  const testChord = pending
+    ? [...pending, currentKeystroke]
+    : [currentKeystroke]
+
+  // Filter bindings by active contexts (Set lookup: O(n) instead of O(n·m))
+  const ctxSet = new Set(activeContexts)
+  const contextBindings = bindings.filter(b => ctxSet.has(b.context))
+
+  // Check if this could be a prefix for longer chords. Group by chord
+  // string so a later null-override shadows the default it unbinds —
+  // otherwise null-unbinding `ctrl+x ctrl+k` still makes `ctrl+x` enter
+  // chord-wait and the single-key binding on the prefix never fires.
+  const chordWinners = new Map<string, string | null>()
+  for (const binding of contextBindings) {
+    if (
+      binding.chord.length > testChord.length &&
+      chordPrefixMatches(testChord, binding)
+    ) {
+      chordWinners.set(chordToString(binding.chord), binding.action)
+    }
+  }
+  let hasLongerChords = false
+  for (const action of chordWinners.values()) {
+    if (action !== null) {
+      hasLongerChords = true
+      break
+    }
+  }
+
+  // If this keystroke could start a longer chord, prefer that
+  // (even if there's an exact single-key match)
+  if (hasLongerChords) {
+    return { type: 'chord_started', pending: testChord }
+  }
+
+  // Check for exact matches (last one wins)
+  let exactMatch: ParsedBinding | undefined
+  for (const binding of contextBindings) {
+    if (chordExactlyMatches(testChord, binding)) {
+      exactMatch = binding
+    }
+  }
+
+  if (exactMatch) {
+    if (exactMatch.action === null) {
+      return { type: 'unbound' }
+    }
+    return { type: 'match', action: exactMatch.action }
+  }
+
+  // No match and no potential longer chords
+  if (pending !== null) {
+    return { type: 'chord_cancelled' }
+  }
+
+  return { type: 'none' }
+}

src/keybindings/schema.ts

@@ -0,0 +1,236 @@
+/**
+ * Zod schema for keybindings.json configuration.
+ * Used for validation and JSON schema generation.
+ */
+
+import { z } from 'zod/v4'
+import { lazySchema } from '../utils/lazySchema.js'
+
+/**
+ * Valid context names where keybindings can be applied.
+ */
+export const KEYBINDING_CONTEXTS = [
+  'Global',
+  'Chat',
+  'Autocomplete',
+  'Confirmation',
+  'Help',
+  'Transcript',
+  'HistorySearch',
+  'Task',
+  'ThemePicker',
+  'Settings',
+  'Tabs',
+  // New contexts for keybindings migration
+  'Attachments',
+  'Footer',
+  'MessageSelector',
+  'DiffDialog',
+  'ModelPicker',
+  'Select',
+  'Plugin',
+] as const
+
+/**
+ * Human-readable descriptions for each keybinding context.
+ */
+export const KEYBINDING_CONTEXT_DESCRIPTIONS: Record<
+  (typeof KEYBINDING_CONTEXTS)[number],
+  string
+> = {
+  Global: 'Active everywhere, regardless of focus',
+  Chat: 'When the chat input is focused',
+  Autocomplete: 'When autocomplete menu is visible',
+  Confirmation: 'When a confirmation/permission dialog is shown',
+  Help: 'When the help overlay is open',
+  Transcript: 'When viewing the transcript',
+  HistorySearch: 'When searching command history (ctrl+r)',
+  Task: 'When a task/agent is running in the foreground',
+  ThemePicker: 'When the theme picker is open',
+  Settings: 'When the settings menu is open',
+  Tabs: 'When tab navigation is active',
+  Attachments: 'When navigating image attachments in a select dialog',
+  Footer: 'When footer indicators are focused',
+  MessageSelector: 'When the message selector (rewind) is open',
+  DiffDialog: 'When the diff dialog is open',
+  ModelPicker: 'When the model picker is open',
+  Select: 'When a select/list component is focused',
+  Plugin: 'When the plugin dialog is open',
+}
+
+/**
+ * All valid keybinding action identifiers.
+ */
+export const KEYBINDING_ACTIONS = [
+  // App-level actions (Global context)
+  'app:interrupt',
+  'app:exit',
+  'app:toggleTodos',
+  'app:toggleTranscript',
+  'app:toggleBrief',
+  'app:toggleTeammatePreview',
+  'app:toggleTerminal',
+  'app:redraw',
+  'app:globalSearch',
+  'app:quickOpen',
+  // History navigation
+  'history:search',
+  'history:previous',
+  'history:next',
+  // Chat input actions
+  'chat:cancel',
+  'chat:killAgents',
+  'chat:cycleMode',
+  'chat:modelPicker',
+  'chat:fastMode',
+  'chat:thinkingToggle',
+  'chat:submit',
+  'chat:newline',
+  'chat:undo',
+  'chat:externalEditor',
+  'chat:stash',
+  'chat:imagePaste',
+  'chat:messageActions',
+  // Autocomplete menu actions
+  'autocomplete:accept',
+  'autocomplete:dismiss',
+  'autocomplete:previous',
+  'autocomplete:next',
+  // Confirmation dialog actions
+  'confirm:yes',
+  'confirm:no',
+  'confirm:previous',
+  'confirm:next',
+  'confirm:nextField',
+  'confirm:previousField',
+  'confirm:cycleMode',
+  'confirm:toggle',
+  'confirm:toggleExplanation',
+  // Tabs navigation actions
+  'tabs:next',
+  'tabs:previous',
+  // Transcript viewer actions
+  'transcript:toggleShowAll',
+  'transcript:exit',
+  // History search actions
+  'historySearch:next',
+  'historySearch:accept',
+  'historySearch:cancel',
+  'historySearch:execute',
+  // Task/agent actions
+  'task:background',
+  // Theme picker actions
+  'theme:toggleSyntaxHighlighting',
+  // Help menu actions
+  'help:dismiss',
+  // Attachment navigation (select dialog image attachments)
+  'attachments:next',
+  'attachments:previous',
+  'attachments:remove',
+  'attachments:exit',
+  // Footer indicator actions
+  'footer:up',
+  'footer:down',
+  'footer:next',
+  'footer:previous',
+  'footer:openSelected',
+  'footer:clearSelection',
+  'footer:close',
+  // Message selector (rewind) actions
+  'messageSelector:up',
+  'messageSelector:down',
+  'messageSelector:top',
+  'messageSelector:bottom',
+  'messageSelector:select',
+  // Diff dialog actions
+  'diff:dismiss',
+  'diff:previousSource',
+  'diff:nextSource',
+  'diff:back',
+  'diff:viewDetails',
+  'diff:previousFile',
+  'diff:nextFile',
+  // Model picker actions (ant-only)
+  'modelPicker:decreaseEffort',
+  'modelPicker:increaseEffort',
+  // Select component actions (distinct from confirm: to avoid collisions)
+  'select:next',
+  'select:previous',
+  'select:accept',
+  'select:cancel',
+  // Plugin dialog actions
+  'plugin:toggle',
+  'plugin:install',
+  // Permission dialog actions
+  'permission:toggleDebug',
+  // Settings config panel actions
+  'settings:search',
+  'settings:retry',
+  'settings:close',
+  // Voice actions
+  'voice:pushToTalk',
+] as const
+
+/**
+ * Schema for a single keybinding block.
+ */
+export const KeybindingBlockSchema = lazySchema(() =>
+  z
+    .object({
+      context: z
+        .enum(KEYBINDING_CONTEXTS)
+        .describe(
+          'UI context where these bindings apply. Global bindings work everywhere.',
+        ),
+      bindings: z
+        .record(
+          z
+            .string()
+            .describe('Keystroke pattern (e.g., "ctrl+k", "shift+tab")'),
+          z
+            .union([
+              z.enum(KEYBINDING_ACTIONS),
+              z
+                .string()
+                .regex(/^command:[a-zA-Z0-9:\-_]+$/)
+                .describe(
+                  'Command binding (e.g., "command:help", "command:compact"). Executes the slash command as if typed.',
+                ),
+              z.null().describe('Set to null to unbind a default shortcut'),
+            ])
+            .describe(
+              'Action to trigger, command to invoke, or null to unbind',
+            ),
+        )
+        .describe('Map of keystroke patterns to actions'),
+    })
+    .describe('A block of keybindings for a specific context'),
+)
+
+/**
+ * Schema for the entire keybindings.json file.
+ * Uses object wrapper format with optional $schema and $docs metadata.
+ */
+export const KeybindingsSchema = lazySchema(() =>
+  z
+    .object({
+      $schema: z
+        .string()
+        .optional()
+        .describe('JSON Schema URL for editor validation'),
+      $docs: z.string().optional().describe('Documentation URL'),
+      bindings: z
+        .array(KeybindingBlockSchema())
+        .describe('Array of keybinding blocks by context'),
+    })
+    .describe(
+      'Claude Code keybindings configuration. Customize keyboard shortcuts by context.',
+    ),
+)
+
+/**
+ * TypeScript types derived from the schema.
+ */
+export type KeybindingsSchemaType = z.infer<
+  ReturnType<typeof KeybindingsSchema>
+>

src/keybindings/shortcutFormat.ts

@@ -0,0 +1,63 @@
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../services/analytics/index.js'
+import { loadKeybindingsSync } from './loadUserBindings.js'
+import { getBindingDisplayText } from './resolver.js'
+import type { KeybindingContextName } from './types.js'
+
+// TODO(keybindings-migration): Remove fallback parameter after migration is
+// complete and we've confirmed no 'keybinding_fallback_used' events are being
+// logged. The fallback exists as a safety net during migration - if bindings
+// fail to load or an action isn't found, we fall back to hardcoded values.
+// Once stable, callers should be able to trust that getBindingDisplayText
+// always returns a value for known actions, and we can remove this defensive
+// pattern.
+
+// Track which action+context pairs have already logged a fallback event
+// to avoid duplicate events from repeated calls in non-React contexts.
+const LOGGED_FALLBACKS = new Set<string>()
+
+/**
+ * Get the display text for a configured shortcut without React hooks.
+ * Use this in non-React contexts (commands, services, etc.).
+ *
+ * This lives in its own module (not useShortcutDisplay.ts) so that
+ * non-React callers like query/stopHooks.ts don't pull React into their
+ * module graph via the sibling hook.
+ *
+ * @param action - The action name (e.g., 'app:toggleTranscript')
+ * @param context - The keybinding context (e.g., 'Global')
+ * @param fallback - Fallback text if binding not found
+ * @returns The configured shortcut display text
+ *
+ * @example
+ * const expandShortcut = getShortcutDisplay('app:toggleTranscript', 'Global', 'ctrl+o')
+ * // Returns the user's configured binding, or 'ctrl+o' as default
+ */
+export function getShortcutDisplay(
+  action: string,
+  context: KeybindingContextName,
+  fallback: string,
+): string {
+  const bindings = loadKeybindingsSync()
+  const resolved = getBindingDisplayText(action, context, bindings)
+  if (resolved === undefined) {
+    const key = `${action}:${context}`
+    if (!LOGGED_FALLBACKS.has(key)) {
+      LOGGED_FALLBACKS.add(key)
+      logEvent('tengu_keybinding_fallback_used', {
+        action:
+          action as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        context:
+          context as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        fallback:
+          fallback as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        reason:
+          'action_not_found' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      })
+    }
+    return fallback
+  }
+  return resolved
+}

src/keybindings/template.ts

@@ -0,0 +1,52 @@
+/**
+ * Keybindings template generator.
+ * Generates a well-documented template file for ~/.claude/keybindings.json
+ */
+
+import { jsonStringify } from '../utils/slowOperations.js'
+import { DEFAULT_BINDINGS } from './defaultBindings.js'
+import {
+  NON_REBINDABLE,
+  normalizeKeyForComparison,
+} from './reservedShortcuts.js'
+import type { KeybindingBlock } from './types.js'
+
+/**
+ * Filter out reserved shortcuts that cannot be rebound.
+ * These would cause /doctor to warn, so we exclude them from the template.
+ */
+function filterReservedShortcuts(blocks: KeybindingBlock[]): KeybindingBlock[] {
+  const reservedKeys = new Set(
+    NON_REBINDABLE.map(r => normalizeKeyForComparison(r.key)),
+  )
+
+  return blocks
+    .map(block => {
+      const filteredBindings: Record<string, string | null> = {}
+      for (const [key, action] of Object.entries(block.bindings)) {
+        if (!reservedKeys.has(normalizeKeyForComparison(key))) {
+          filteredBindings[key] = action
+        }
+      }
+      return { context: block.context, bindings: filteredBindings }
+    })
+    .filter(block => Object.keys(block.bindings).length > 0)
+}
+
+/**
+ * Generate a template keybindings.json file content.
+ * Creates a fully valid JSON file with all default bindings that users can customize.
+ */
+export function generateKeybindingsTemplate(): string {
+  // Filter out reserved shortcuts that cannot be rebound
+  const bindings = filterReservedShortcuts(DEFAULT_BINDINGS)
+
+  // Format as object wrapper with bindings array
+  const config = {
+    $schema: 'https://www.schemastore.org/claude-code-keybindings.json',
+    $docs: 'https://code.claude.com/docs/en/keybindings',
+    bindings,
+  }
+
+  return jsonStringify(config, null, 2) + '\n'
+}

src/keybindings/useKeybinding.ts

@@ -0,0 +1,196 @@
+import { useCallback, useEffect } from 'react'
+import type { InputEvent } from '../ink/events/input-event.js'
+import { type Key, useInput } from '../ink.js'
+import { useOptionalKeybindingContext } from './KeybindingContext.js'
+import type { KeybindingContextName } from './types.js'
+
+type Options = {
+  /** Which context this binding belongs to (default: 'Global') */
+  context?: KeybindingContextName
+  /** Only handle when active (like useInput's isActive) */
+  isActive?: boolean
+}
+
+/**
+ * Ink-native hook for handling a keybinding.
+ *
+ * The handler stays in the component (React way).
+ * The binding (keystroke → action) comes from config.
+ *
+ * Supports chord sequences (e.g., "ctrl+k ctrl+s"). When a chord is started,
+ * the hook will manage the pending state automatically.
+ *
+ * Uses stopImmediatePropagation() to prevent other handlers from firing
+ * once this binding is handled.
+ *
+ * @example
+ * ```tsx
+ * useKeybinding('app:toggleTodos', () => {
+ *   setShowTodos(prev => !prev)
+ * }, { context: 'Global' })
+ * ```
+ */
+export function useKeybinding(
+  action: string,
+  handler: () => void | false | Promise<void>,
+  options: Options = {},
+): void {
+  const { context = 'Global', isActive = true } = options
+  const keybindingContext = useOptionalKeybindingContext()
+
+  // Register handler with the context for ChordInterceptor to invoke
+  useEffect(() => {
+    if (!keybindingContext || !isActive) return
+    return keybindingContext.registerHandler({ action, context, handler })
+  }, [action, context, handler, keybindingContext, isActive])
+
+  const handleInput = useCallback(
+    (input: string, key: Key, event: InputEvent) => {
+      // If no keybinding context available, skip resolution
+      if (!keybindingContext) return
+
+      // Build context list: registered active contexts + this context + Global
+      // More specific contexts (registered ones) take precedence over Global
+      const contextsToCheck: KeybindingContextName[] = [
+        ...keybindingContext.activeContexts,
+        context,
+        'Global',
+      ]
+      // Deduplicate while preserving order (first occurrence wins for priority)
+      const uniqueContexts = [...new Set(contextsToCheck)]
+
+      const result = keybindingContext.resolve(input, key, uniqueContexts)
+
+      switch (result.type) {
+        case 'match':
+          // Chord completed (if any) - clear pending state
+          keybindingContext.setPendingChord(null)
+          if (result.action === action) {
+            if (handler() !== false) {
+              event.stopImmediatePropagation()
+            }
+          }
+          break
+        case 'chord_started':
+          // User started a chord sequence - update pending state
+          keybindingContext.setPendingChord(result.pending)
+          event.stopImmediatePropagation()
+          break
+        case 'chord_cancelled':
+          // Chord was cancelled (escape or invalid key)
+          keybindingContext.setPendingChord(null)
+          break
+        case 'unbound':
+          // Explicitly unbound - clear any pending chord
+          keybindingContext.setPendingChord(null)
+          event.stopImmediatePropagation()
+          break
+        case 'none':
+          // No match - let other handlers try
+          break
+      }
+    },
+    [action, context, handler, keybindingContext],
+  )
+
+  useInput(handleInput, { isActive })
+}
+
+/**
+ * Handle multiple keybindings in one hook (reduces useInput calls).
+ *
+ * Supports chord sequences. When a chord is started, the hook will
+ * manage the pending state automatically.
+ *
+ * @example
+ * ```tsx
+ * useKeybindings({
+ *   'chat:submit': () => handleSubmit(),
+ *   'chat:cancel': () => handleCancel(),
+ * }, { context: 'Chat' })
+ * ```
+ */
+export function useKeybindings(
+  // Handler returning `false` means "not consumed" — the event propagates
+  // to later useInput/useKeybindings handlers. Useful for fall-through:
+  // e.g. ScrollKeybindingHandler's scroll:line* returns false when the
+  // ScrollBox content fits (scroll is a no-op), letting a child component's
+  // handler take the wheel event for list navigation instead. Promise<void>
+  // is allowed for fire-and-forget async handlers (the `!== false` check
+  // only skips propagation for a sync `false`, not a pending Promise).
+  handlers: Record<string, () => void | false | Promise<void>>,
+  options: Options = {},
+): void {
+  const { context = 'Global', isActive = true } = options
+  const keybindingContext = useOptionalKeybindingContext()
+
+  // Register all handlers with the context for ChordInterceptor to invoke
+  useEffect(() => {
+    if (!keybindingContext || !isActive) return
+
+    const unregisterFns: Array<() => void> = []
+    for (const [action, handler] of Object.entries(handlers)) {
+      unregisterFns.push(
+        keybindingContext.registerHandler({ action, context, handler }),
+      )
+    }
+
+    return () => {
+      for (const unregister of unregisterFns) {
+        unregister()
+      }
+    }
+  }, [context, handlers, keybindingContext, isActive])
+
+  const handleInput = useCallback(
+    (input: string, key: Key, event: InputEvent) => {
+      // If no keybinding context available, skip resolution
+      if (!keybindingContext) return
+
+      // Build context list: registered active contexts + this context + Global
+      // More specific contexts (registered ones) take precedence over Global
+      const contextsToCheck: KeybindingContextName[] = [
+        ...keybindingContext.activeContexts,
+        context,
+        'Global',
+      ]
+      // Deduplicate while preserving order (first occurrence wins for priority)
+      const uniqueContexts = [...new Set(contextsToCheck)]
+
+      const result = keybindingContext.resolve(input, key, uniqueContexts)
+
+      switch (result.type) {
+        case 'match':
+          // Chord completed (if any) - clear pending state
+          keybindingContext.setPendingChord(null)
+          if (result.action in handlers) {
+            const handler = handlers[result.action]
+            if (handler && handler() !== false) {
+              event.stopImmediatePropagation()
+            }
+          }
+          break
+        case 'chord_started':
+          // User started a chord sequence - update pending state
+          keybindingContext.setPendingChord(result.pending)
+          event.stopImmediatePropagation()
+          break
+        case 'chord_cancelled':
+          // Chord was cancelled (escape or invalid key)
+          keybindingContext.setPendingChord(null)
+          break
+        case 'unbound':
+          // Explicitly unbound - clear any pending chord
+          keybindingContext.setPendingChord(null)
+          event.stopImmediatePropagation()
+          break
+        case 'none':
+          // No match - let other handlers try
+          break
+      }
+    },
+    [context, handlers, keybindingContext],
+  )
+
+  useInput(handleInput, { isActive })
+}

src/keybindings/useShortcutDisplay.ts

@@ -0,0 +1,59 @@
+import { useEffect, useRef } from 'react'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../services/analytics/index.js'
+import { useOptionalKeybindingContext } from './KeybindingContext.js'
+import type { KeybindingContextName } from './types.js'
+
+// TODO(keybindings-migration): Remove fallback parameter after migration is complete
+// and we've confirmed no 'keybinding_fallback_used' events are being logged.
+// The fallback exists as a safety net during migration - if bindings fail to load
+// or an action isn't found, we fall back to hardcoded values. Once stable, callers
+// should be able to trust that getBindingDisplayText always returns a value for
+// known actions, and we can remove this defensive pattern.
+
+/**
+ * Hook to get the display text for a configured shortcut.
+ * Returns the configured binding or a fallback if unavailable.
+ *
+ * @param action - The action name (e.g., 'app:toggleTranscript')
+ * @param context - The keybinding context (e.g., 'Global')
+ * @param fallback - Fallback text if keybinding context unavailable
+ * @returns The configured shortcut display text
+ *
+ * @example
+ * const expandShortcut = useShortcutDisplay('app:toggleTranscript', 'Global', 'ctrl+o')
+ * // Returns the user's configured binding, or 'ctrl+o' as default
+ */
+export function useShortcutDisplay(
+  action: string,
+  context: KeybindingContextName,
+  fallback: string,
+): string {
+  const keybindingContext = useOptionalKeybindingContext()
+  const resolved = keybindingContext?.getDisplayText(action, context)
+  const isFallback = resolved === undefined
+  const reason = keybindingContext ? 'action_not_found' : 'no_context'
+
+  // Log fallback usage once per mount (not on every render) to avoid
+  // flooding analytics with events from frequent re-renders.
+  const hasLoggedRef = useRef(false)
+  useEffect(() => {
+    if (isFallback && !hasLoggedRef.current) {
+      hasLoggedRef.current = true
+      logEvent('tengu_keybinding_fallback_used', {
+        action:
+          action as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        context:
+          context as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        fallback:
+          fallback as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        reason:
+          reason as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      })
+    }
+  }, [isFallback, action, context, fallback, reason])
+
+  return isFallback ? fallback : resolved
+}

src/keybindings/validate.ts

@@ -0,0 +1,498 @@
+import { plural } from '../utils/stringUtils.js'
+import { chordToString, parseChord, parseKeystroke } from './parser.js'
+import {
+  getReservedShortcuts,
+  normalizeKeyForComparison,
+} from './reservedShortcuts.js'
+import type {
+  KeybindingBlock,
+  KeybindingContextName,
+  ParsedBinding,
+} from './types.js'
+
+/**
+ * Types of validation issues that can occur with keybindings.
+ */
+export type KeybindingWarningType =
+  | 'parse_error'
+  | 'duplicate'
+  | 'reserved'
+  | 'invalid_context'
+  | 'invalid_action'
+
+/**
+ * A warning or error about a keybinding configuration issue.
+ */
+export type KeybindingWarning = {
+  type: KeybindingWarningType
+  severity: 'error' | 'warning'
+  message: string
+  key?: string
+  context?: string
+  action?: string
+  suggestion?: string
+}
+
+/**
+ * Type guard to check if an object is a valid KeybindingBlock.
+ */
+function isKeybindingBlock(obj: unknown): obj is KeybindingBlock {
+  if (typeof obj !== 'object' || obj === null) return false
+  const b = obj as Record<string, unknown>
+  return (
+    typeof b.context === 'string' &&
+    typeof b.bindings === 'object' &&
+    b.bindings !== null
+  )
+}
+
+/**
+ * Type guard to check if an array contains only valid KeybindingBlocks.
+ */
+function isKeybindingBlockArray(arr: unknown): arr is KeybindingBlock[] {
+  return Array.isArray(arr) && arr.every(isKeybindingBlock)
+}
+
+/**
+ * Valid context names for keybindings.
+ * Must match KeybindingContextName in types.ts
+ */
+const VALID_CONTEXTS: KeybindingContextName[] = [
+  'Global',
+  'Chat',
+  'Autocomplete',
+  'Confirmation',
+  'Help',
+  'Transcript',
+  'HistorySearch',
+  'Task',
+  'ThemePicker',
+  'Settings',
+  'Tabs',
+  'Attachments',
+  'Footer',
+  'MessageSelector',
+  'DiffDialog',
+  'ModelPicker',
+  'Select',
+  'Plugin',
+]
+
+/**
+ * Type guard to check if a string is a valid context name.
+ */
+function isValidContext(value: string): value is KeybindingContextName {
+  return (VALID_CONTEXTS as readonly string[]).includes(value)
+}
+
+/**
+ * Validate a single keystroke string and return any parse errors.
+ */
+function validateKeystroke(keystroke: string): KeybindingWarning | null {
+  const parts = keystroke.toLowerCase().split('+')
+
+  for (const part of parts) {
+    const trimmed = part.trim()
+    if (!trimmed) {
+      return {
+        type: 'parse_error',
+        severity: 'error',
+        message: `Empty key part in "${keystroke}"`,
+        key: keystroke,
+        suggestion: 'Remove extra "+" characters',
+      }
+    }
+  }
+
+  // Try to parse and see if it fails
+  const parsed = parseKeystroke(keystroke)
+  if (
+    !parsed.key &&
+    !parsed.ctrl &&
+    !parsed.alt &&
+    !parsed.shift &&
+    !parsed.meta
+  ) {
+    return {
+      type: 'parse_error',
+      severity: 'error',
+      message: `Could not parse keystroke "${keystroke}"`,
+      key: keystroke,
+    }
+  }
+
+  return null
+}
+
+/**
+ * Validate a keybinding block from user config.
+ */
+function validateBlock(
+  block: unknown,
+  blockIndex: number,
+): KeybindingWarning[] {
+  const warnings: KeybindingWarning[] = []
+
+  if (typeof block !== 'object' || block === null) {
+    warnings.push({
+      type: 'parse_error',
+      severity: 'error',
+      message: `Keybinding block ${blockIndex + 1} is not an object`,
+    })
+    return warnings
+  }
+
+  const b = block as Record<string, unknown>
+
+  // Validate context - extract to narrowed variable for type safety
+  const rawContext = b.context
+  let contextName: string | undefined
+  if (typeof rawContext !== 'string') {
+    warnings.push({
+      type: 'parse_error',
+      severity: 'error',
+      message: `Keybinding block ${blockIndex + 1} missing "context" field`,
+    })
+  } else if (!isValidContext(rawContext)) {
+    warnings.push({
+      type: 'invalid_context',
+      severity: 'error',
+      message: `Unknown context "${rawContext}"`,
+      context: rawContext,
+      suggestion: `Valid contexts: ${VALID_CONTEXTS.join(', ')}`,
+    })
+  } else {
+    contextName = rawContext
+  }
+
+  // Validate bindings
+  if (typeof b.bindings !== 'object' || b.bindings === null) {
+    warnings.push({
+      type: 'parse_error',
+      severity: 'error',
+      message: `Keybinding block ${blockIndex + 1} missing "bindings" field`,
+    })
+    return warnings
+  }
+
+  const bindings = b.bindings as Record<string, unknown>
+  for (const [key, action] of Object.entries(bindings)) {
+    // Validate key syntax
+    const keyError = validateKeystroke(key)
+    if (keyError) {
+      keyError.context = contextName
+      warnings.push(keyError)
+    }
+
+    // Validate action
+    if (action !== null && typeof action !== 'string') {
+      warnings.push({
+        type: 'invalid_action',
+        severity: 'error',
+        message: `Invalid action for "${key}": must be a string or null`,
+        key,
+        context: contextName,
+      })
+    } else if (typeof action === 'string' && action.startsWith('command:')) {
+      // Validate command binding format
+      if (!/^command:[a-zA-Z0-9:\-_]+$/.test(action)) {
+        warnings.push({
+          type: 'invalid_action',
+          severity: 'warning',
+          message: `Invalid command binding "${action}" for "${key}": command name may only contain alphanumeric characters, colons, hyphens, and underscores`,
+          key,
+          context: contextName,
+          action,
+        })
+      }
+      // Command bindings must be in Chat context
+      if (contextName && contextName !== 'Chat') {
+        warnings.push({
+          type: 'invalid_action',
+          severity: 'warning',
+          message: `Command binding "${action}" must be in "Chat" context, not "${contextName}"`,
+          key,
+          context: contextName,
+          action,
+          suggestion: 'Move this binding to a block with "context": "Chat"',
+        })
+      }
+    } else if (action === 'voice:pushToTalk') {
+      // Hold detection needs OS auto-repeat. Bare letters print into the
+      // input during warmup and the activation strip is best-effort —
+      // space (default) or a modifier combo like meta+k avoid that.
+      const ks = parseChord(key)[0]
+      if (
+        ks &&
+        !ks.ctrl &&
+        !ks.alt &&
+        !ks.shift &&
+        !ks.meta &&
+        !ks.super &&
+        /^[a-z]$/.test(ks.key)
+      ) {
+        warnings.push({
+          type: 'invalid_action',
+          severity: 'warning',
+          message: `Binding "${key}" to voice:pushToTalk prints into the input during warmup; use space or a modifier combo like meta+k`,
+          key,
+          context: contextName,
+          action,
+        })
+      }
+    }
+  }
+
+  return warnings
+}
+
+/**
+ * Detect duplicate keys within the same bindings block in a JSON string.
+ * JSON.parse silently uses the last value for duplicate keys,
+ * so we need to check the raw string to warn users.
+ *
+ * Only warns about duplicates within the same context's bindings object.
+ * Duplicates across different contexts are allowed (e.g., "enter" in Chat
+ * and "enter" in Confirmation).
+ */
+export function checkDuplicateKeysInJson(
+  jsonString: string,
+): KeybindingWarning[] {
+  const warnings: KeybindingWarning[] = []
+
+  // Find each "bindings" block and check for duplicates within it
+  // Pattern: "bindings" : { ... }
+  const bindingsBlockPattern =
+    /"bindings"\s*:\s*\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/g
+
+  let blockMatch
+  while ((blockMatch = bindingsBlockPattern.exec(jsonString)) !== null) {
+    const blockContent = blockMatch[1]
+    if (!blockContent) continue
+
+    // Find the context for this block by looking backwards
+    const textBeforeBlock = jsonString.slice(0, blockMatch.index)
+    const contextMatch = textBeforeBlock.match(
+      /"context"\s*:\s*"([^"]+)"[^{]*$/,
+    )
+    const context = contextMatch?.[1] ?? 'unknown'
+
+    // Find all keys within this bindings block
+    const keyPattern = /"([^"]+)"\s*:/g
+    const keysByName = new Map<string, number>()
+
+    let keyMatch
+    while ((keyMatch = keyPattern.exec(blockContent)) !== null) {
+      const key = keyMatch[1]
+      if (!key) continue
+
+      const count = (keysByName.get(key) ?? 0) + 1
+      keysByName.set(key, count)
+
+      if (count === 2) {
+        // Only warn on the second occurrence
+        warnings.push({
+          type: 'duplicate',
+          severity: 'warning',
+          message: `Duplicate key "${key}" in ${context} bindings`,
+          key,
+          context,
+          suggestion: `This key appears multiple times in the same context. JSON uses the last value, earlier values are ignored.`,
+        })
+      }
+    }
+  }
+
+  return warnings
+}
+
+/**
+ * Validate user keybinding config and return all warnings.
+ */
+export function validateUserConfig(userBlocks: unknown): KeybindingWarning[] {
+  const warnings: KeybindingWarning[] = []
+
+  if (!Array.isArray(userBlocks)) {
+    warnings.push({
+      type: 'parse_error',
+      severity: 'error',
+      message: 'keybindings.json must contain an array',
+      suggestion: 'Wrap your bindings in [ ]',
+    })
+    return warnings
+  }
+
+  for (let i = 0; i < userBlocks.length; i++) {
+    warnings.push(...validateBlock(userBlocks[i], i))
+  }
+
+  return warnings
+}
+
+/**
+ * Check for duplicate bindings within the same context.
+ * Only checks user bindings (not default + user merged).
+ */
+export function checkDuplicates(
+  blocks: KeybindingBlock[],
+): KeybindingWarning[] {
+  const warnings: KeybindingWarning[] = []
+  const seenByContext = new Map<string, Map<string, string>>()
+
+  for (const block of blocks) {
+    const contextMap =
+      seenByContext.get(block.context) ?? new Map<string, string>()
+    seenByContext.set(block.context, contextMap)
+
+    for (const [key, action] of Object.entries(block.bindings)) {
+      const normalizedKey = normalizeKeyForComparison(key)
+      const existingAction = contextMap.get(normalizedKey)
+
+      if (existingAction && existingAction !== action) {
+        warnings.push({
+          type: 'duplicate',
+          severity: 'warning',
+          message: `Duplicate binding "${key}" in ${block.context} context`,
+          key,
+          context: block.context,
+          action: action ?? 'null (unbind)',
+          suggestion: `Previously bound to "${existingAction}". Only the last binding will be used.`,
+        })
+      }
+
+      contextMap.set(normalizedKey, action ?? 'null')
+    }
+  }
+
+  return warnings
+}
+
+/**
+ * Check for reserved shortcuts that may not work.
+ */
+export function checkReservedShortcuts(
+  bindings: ParsedBinding[],
+): KeybindingWarning[] {
+  const warnings: KeybindingWarning[] = []
+  const reserved = getReservedShortcuts()
+
+  for (const binding of bindings) {
+    const keyDisplay = chordToString(binding.chord)
+    const normalizedKey = normalizeKeyForComparison(keyDisplay)
+
+    // Check against reserved shortcuts
+    for (const res of reserved) {
+      if (normalizeKeyForComparison(res.key) === normalizedKey) {
+        warnings.push({
+          type: 'reserved',
+          severity: res.severity,
+          message: `"${keyDisplay}" may not work: ${res.reason}`,
+          key: keyDisplay,
+          context: binding.context,
+          action: binding.action ?? undefined,
+        })
+      }
+    }
+  }
+
+  return warnings
+}
+
+/**
+ * Parse user blocks into bindings for validation.
+ * This is separate from the main parser to avoid importing it.
+ */
+function getUserBindingsForValidation(
+  userBlocks: KeybindingBlock[],
+): ParsedBinding[] {
+  const bindings: ParsedBinding[] = []
+  for (const block of userBlocks) {
+    for (const [key, action] of Object.entries(block.bindings)) {
+      const chord = key.split(' ').map(k => parseKeystroke(k))
+      bindings.push({
+        chord,
+        action,
+        context: block.context,
+      })
+    }
+  }
+  return bindings
+}
+
+/**
+ * Run all validations and return combined warnings.
+ */
+export function validateBindings(
+  userBlocks: unknown,
+  _parsedBindings: ParsedBinding[],
+): KeybindingWarning[] {
+  const warnings: KeybindingWarning[] = []
+
+  // Validate user config structure
+  warnings.push(...validateUserConfig(userBlocks))
+
+  // Check for duplicates in user config
+  if (isKeybindingBlockArray(userBlocks)) {
+    warnings.push(...checkDuplicates(userBlocks))
+
+    // Check for reserved/conflicting shortcuts - only check USER bindings
+    const userBindings = getUserBindingsForValidation(userBlocks)
+    warnings.push(...checkReservedShortcuts(userBindings))
+  }
+
+  // Deduplicate warnings (same key+context+type)
+  const seen = new Set<string>()
+  return warnings.filter(w => {
+    const key = `${w.type}:${w.key}:${w.context}`
+    if (seen.has(key)) return false
+    seen.add(key)
+    return true
+  })
+}
+
+/**
+ * Format a warning for display to the user.
+ */
+export function formatWarning(warning: KeybindingWarning): string {
+  const icon = warning.severity === 'error' ? '✗' : '⚠'
+  let msg = `${icon} Keybinding ${warning.severity}: ${warning.message}`
+
+  if (warning.suggestion) {
+    msg += `\n  ${warning.suggestion}`
+  }
+
+  return msg
+}
+
+/**
+ * Format multiple warnings for display.
+ */
+export function formatWarnings(warnings: KeybindingWarning[]): string {
+  if (warnings.length === 0) return ''
+
+  const errors = warnings.filter(w => w.severity === 'error')
+  const warns = warnings.filter(w => w.severity === 'warning')
+
+  const lines: string[] = []
+
+  if (errors.length > 0) {
+    lines.push(
+      `Found ${errors.length} keybinding ${plural(errors.length, 'error')}:`,
+    )
+    for (const e of errors) {
+      lines.push(formatWarning(e))
+    }
+  }
+
+  if (warns.length > 0) {
+    if (lines.length > 0) lines.push('')
+    lines.push(
+      `Found ${warns.length} keybinding ${plural(warns.length, 'warning')}:`,
+    )
+    for (const w of warns) {
+      lines.push(formatWarning(w))
+    }
+  }
+
+  return lines.join('\n')
+}

src/memdir/findRelevantMemories.ts

@@ -0,0 +1,141 @@
+import { feature } from 'bun:bundle'
+import { logForDebugging } from '../utils/debug.js'
+import { errorMessage } from '../utils/errors.js'
+import { getDefaultSonnetModel } from '../utils/model/model.js'
+import { sideQuery } from '../utils/sideQuery.js'
+import { jsonParse } from '../utils/slowOperations.js'
+import {
+  formatMemoryManifest,
+  type MemoryHeader,
+  scanMemoryFiles,
+} from './memoryScan.js'
+
+export type RelevantMemory = {
+  path: string
+  mtimeMs: number
+}
+
+const SELECT_MEMORIES_SYSTEM_PROMPT = `You are selecting memories that will be useful to Claude Code as it processes a user's query. You will be given the user's query and a list of available memory files with their filenames and descriptions.
+
+Return a list of filenames for the memories that will clearly be useful to Claude Code as it processes the user's query (up to 5). Only include memories that you are certain will be helpful based on their name and description.
+- If you are unsure if a memory will be useful in processing the user's query, then do not include it in your list. Be selective and discerning.
+- If there are no memories in the list that would clearly be useful, feel free to return an empty list.
+- If a list of recently-used tools is provided, do not select memories that are usage reference or API documentation for those tools (Claude Code is already exercising them). DO still select memories containing warnings, gotchas, or known issues about those tools — active use is exactly when those matter.
+`
+
+/**
+ * Find memory files relevant to a query by scanning memory file headers
+ * and asking Sonnet to select the most relevant ones.
+ *
+ * Returns absolute file paths + mtime of the most relevant memories
+ * (up to 5). Excludes MEMORY.md (already loaded in system prompt).
+ * mtime is threaded through so callers can surface freshness to the
+ * main model without a second stat.
+ *
+ * `alreadySurfaced` filters paths shown in prior turns before the
+ * Sonnet call, so the selector spends its 5-slot budget on fresh
+ * candidates instead of re-picking files the caller will discard.
+ */
+export async function findRelevantMemories(
+  query: string,
+  memoryDir: string,
+  signal: AbortSignal,
+  recentTools: readonly string[] = [],
+  alreadySurfaced: ReadonlySet<string> = new Set(),
+): Promise<RelevantMemory[]> {
+  const memories = (await scanMemoryFiles(memoryDir, signal)).filter(
+    m => !alreadySurfaced.has(m.filePath),
+  )
+  if (memories.length === 0) {
+    return []
+  }
+
+  const selectedFilenames = await selectRelevantMemories(
+    query,
+    memories,
+    signal,
+    recentTools,
+  )
+  const byFilename = new Map(memories.map(m => [m.filename, m]))
+  const selected = selectedFilenames
+    .map(filename => byFilename.get(filename))
+    .filter((m): m is MemoryHeader => m !== undefined)
+
+  // Fires even on empty selection: selection-rate needs the denominator,
+  // and -1 ages distinguish "ran, picked nothing" from "never ran".
+  if (feature('MEMORY_SHAPE_TELEMETRY')) {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const { logMemoryRecallShape } =
+      require('./memoryShapeTelemetry.js') as typeof import('./memoryShapeTelemetry.js')
+    /* eslint-enable @typescript-eslint/no-require-imports */
+    logMemoryRecallShape(memories, selected)
+  }
+
+  return selected.map(m => ({ path: m.filePath, mtimeMs: m.mtimeMs }))
+}
+
+async function selectRelevantMemories(
+  query: string,
+  memories: MemoryHeader[],
+  signal: AbortSignal,
+  recentTools: readonly string[],
+): Promise<string[]> {
+  const validFilenames = new Set(memories.map(m => m.filename))
+
+  const manifest = formatMemoryManifest(memories)
+
+  // When Claude Code is actively using a tool (e.g. mcp__X__spawn),
+  // surfacing that tool's reference docs is noise — the conversation
+  // already contains working usage.  The selector otherwise matches
+  // on keyword overlap ("spawn" in query + "spawn" in a memory
+  // description → false positive).
+  const toolsSection =
+    recentTools.length > 0
+      ? `\n\nRecently used tools: ${recentTools.join(', ')}`
+      : ''
+
+  try {
+    const result = await sideQuery({
+      model: getDefaultSonnetModel(),
+      system: SELECT_MEMORIES_SYSTEM_PROMPT,
+      skipSystemPromptPrefix: true,
+      messages: [
+        {
+          role: 'user',
+          content: `Query: ${query}\n\nAvailable memories:\n${manifest}${toolsSection}`,
+        },
+      ],
+      max_tokens: 256,
+      output_format: {
+        type: 'json_schema',
+        schema: {
+          type: 'object',
+          properties: {
+            selected_memories: { type: 'array', items: { type: 'string' } },
+          },
+          required: ['selected_memories'],
+          additionalProperties: false,
+        },
+      },
+      signal,
+      querySource: 'memdir_relevance',
+    })
+
+    const textBlock = result.content.find(block => block.type === 'text')
+    if (!textBlock || textBlock.type !== 'text') {
+      return []
+    }
+
+    const parsed: { selected_memories: string[] } = jsonParse(textBlock.text)
+    return parsed.selected_memories.filter(f => validFilenames.has(f))
+  } catch (e) {
+    if (signal.aborted) {
+      return []
+    }
+    logForDebugging(
+      `[memdir] selectRelevantMemories failed: ${errorMessage(e)}`,
+      { level: 'warn' },
+    )
+    return []
+  }
+}

src/memdir/memdir.ts

@@ -0,0 +1,507 @@
+import { feature } from 'bun:bundle'
+import { join } from 'path'
+import { getFsImplementation } from '../utils/fsOperations.js'
+import { getAutoMemPath, isAutoMemoryEnabled } from './paths.js'
+
+/* eslint-disable @typescript-eslint/no-require-imports */
+const teamMemPaths = feature('TEAMMEM')
+  ? (require('./teamMemPaths.js') as typeof import('./teamMemPaths.js'))
+  : null
+
+import { getKairosActive, getOriginalCwd } from '../bootstrap/state.js'
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js'
+/* eslint-enable @typescript-eslint/no-require-imports */
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../services/analytics/index.js'
+import { GREP_TOOL_NAME } from '../tools/GrepTool/prompt.js'
+import { isReplModeEnabled } from '../tools/REPLTool/constants.js'
+import { logForDebugging } from '../utils/debug.js'
+import { hasEmbeddedSearchTools } from '../utils/embeddedTools.js'
+import { isEnvTruthy } from '../utils/envUtils.js'
+import { formatFileSize } from '../utils/format.js'
+import { getProjectDir } from '../utils/sessionStorage.js'
+import { getInitialSettings } from '../utils/settings/settings.js'
+import {
+  MEMORY_FRONTMATTER_EXAMPLE,
+  TRUSTING_RECALL_SECTION,
+  TYPES_SECTION_INDIVIDUAL,
+  WHAT_NOT_TO_SAVE_SECTION,
+  WHEN_TO_ACCESS_SECTION,
+} from './memoryTypes.js'
+
+export const ENTRYPOINT_NAME = 'MEMORY.md'
+export const MAX_ENTRYPOINT_LINES = 200
+// ~125 chars/line at 200 lines. At p97 today; catches long-line indexes that
+// slip past the line cap (p100 observed: 197KB under 200 lines).
+export const MAX_ENTRYPOINT_BYTES = 25_000
+const AUTO_MEM_DISPLAY_NAME = 'auto memory'
+
+export type EntrypointTruncation = {
+  content: string
+  lineCount: number
+  byteCount: number
+  wasLineTruncated: boolean
+  wasByteTruncated: boolean
+}
+
+/**
+ * Truncate MEMORY.md content to the line AND byte caps, appending a warning
+ * that names which cap fired. Line-truncates first (natural boundary), then
+ * byte-truncates at the last newline before the cap so we don't cut mid-line.
+ *
+ * Shared by buildMemoryPrompt and claudemd getMemoryFiles (previously
+ * duplicated the line-only logic).
+ */
+export function truncateEntrypointContent(raw: string): EntrypointTruncation {
+  const trimmed = raw.trim()
+  const contentLines = trimmed.split('\n')
+  const lineCount = contentLines.length
+  const byteCount = trimmed.length
+
+  const wasLineTruncated = lineCount > MAX_ENTRYPOINT_LINES
+  // Check original byte count — long lines are the failure mode the byte cap
+  // targets, so post-line-truncation size would understate the warning.
+  const wasByteTruncated = byteCount > MAX_ENTRYPOINT_BYTES
+
+  if (!wasLineTruncated && !wasByteTruncated) {
+    return {
+      content: trimmed,
+      lineCount,
+      byteCount,
+      wasLineTruncated,
+      wasByteTruncated,
+    }
+  }
+
+  let truncated = wasLineTruncated
+    ? contentLines.slice(0, MAX_ENTRYPOINT_LINES).join('\n')
+    : trimmed
+
+  if (truncated.length > MAX_ENTRYPOINT_BYTES) {
+    const cutAt = truncated.lastIndexOf('\n', MAX_ENTRYPOINT_BYTES)
+    truncated = truncated.slice(0, cutAt > 0 ? cutAt : MAX_ENTRYPOINT_BYTES)
+  }
+
+  const reason =
+    wasByteTruncated && !wasLineTruncated
+      ? `${formatFileSize(byteCount)} (limit: ${formatFileSize(MAX_ENTRYPOINT_BYTES)}) — index entries are too long`
+      : wasLineTruncated && !wasByteTruncated
+        ? `${lineCount} lines (limit: ${MAX_ENTRYPOINT_LINES})`
+        : `${lineCount} lines and ${formatFileSize(byteCount)}`
+
+  return {
+    content:
+      truncated +
+      `\n\n> WARNING: ${ENTRYPOINT_NAME} is ${reason}. Only part of it was loaded. Keep index entries to one line under ~200 chars; move detail into topic files.`,
+    lineCount,
+    byteCount,
+    wasLineTruncated,
+    wasByteTruncated,
+  }
+}
+
+/* eslint-disable @typescript-eslint/no-require-imports */
+const teamMemPrompts = feature('TEAMMEM')
+  ? (require('./teamMemPrompts.js') as typeof import('./teamMemPrompts.js'))
+  : null
+/* eslint-enable @typescript-eslint/no-require-imports */
+
+/**
+ * Shared guidance text appended to each memory directory prompt line.
+ * Shipped because Claude was burning turns on `ls`/`mkdir -p` before writing.
+ * Harness guarantees the directory exists via ensureMemoryDirExists().
+ */
+export const DIR_EXISTS_GUIDANCE =
+  'This directory already exists — write to it directly with the Write tool (do not run mkdir or check for its existence).'
+export const DIRS_EXIST_GUIDANCE =
+  'Both directories already exist — write to them directly with the Write tool (do not run mkdir or check for their existence).'
+
+/**
+ * Ensure a memory directory exists. Idempotent — called from loadMemoryPrompt
+ * (once per session via systemPromptSection cache) so the model can always
+ * write without checking existence first. FsOperations.mkdir is recursive
+ * by default and already swallows EEXIST, so the full parent chain
+ * (~/.claude/projects/<slug>/memory/) is created in one call with no
+ * try/catch needed for the happy path.
+ */
+export async function ensureMemoryDirExists(memoryDir: string): Promise<void> {
+  const fs = getFsImplementation()
+  try {
+    await fs.mkdir(memoryDir)
+  } catch (e) {
+    // fs.mkdir already handles EEXIST internally. Anything reaching here is
+    // a real problem (EACCES/EPERM/EROFS) — log so --debug shows why. Prompt
+    // building continues either way; the model's Write will surface the
+    // real perm error (and FileWriteTool does its own mkdir of the parent).
+    const code =
+      e instanceof Error && 'code' in e && typeof e.code === 'string'
+        ? e.code
+        : undefined
+    logForDebugging(
+      `ensureMemoryDirExists failed for ${memoryDir}: ${code ?? String(e)}`,
+      { level: 'debug' },
+    )
+  }
+}
+
+/**
+ * Log memory directory file/subdir counts asynchronously.
+ * Fire-and-forget — doesn't block prompt building.
+ */
+function logMemoryDirCounts(
+  memoryDir: string,
+  baseMetadata: Record<
+    string,
+    | number
+    | boolean
+    | AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+  >,
+): void {
+  const fs = getFsImplementation()
+  void fs.readdir(memoryDir).then(
+    dirents => {
+      let fileCount = 0
+      let subdirCount = 0
+      for (const d of dirents) {
+        if (d.isFile()) {
+          fileCount++
+        } else if (d.isDirectory()) {
+          subdirCount++
+        }
+      }
+      logEvent('tengu_memdir_loaded', {
+        ...baseMetadata,
+        total_file_count: fileCount,
+        total_subdir_count: subdirCount,
+      })
+    },
+    () => {
+      // Directory unreadable — log without counts
+      logEvent('tengu_memdir_loaded', baseMetadata)
+    },
+  )
+}
+
+/**
+ * Build the typed-memory behavioral instructions (without MEMORY.md content).
+ * Constrains memories to a closed four-type taxonomy (user / feedback / project /
+ * reference) — content that is derivable from the current project state (code
+ * patterns, architecture, git history) is explicitly excluded.
+ *
+ * Individual-only variant: no `## Memory scope` section, no <scope> tags
+ * in type blocks, and team/private qualifiers stripped from examples.
+ *
+ * Used by both buildMemoryPrompt (agent memory, includes content) and
+ * loadMemoryPrompt (system prompt, content injected via user context instead).
+ */
+export function buildMemoryLines(
+  displayName: string,
+  memoryDir: string,
+  extraGuidelines?: string[],
+  skipIndex = false,
+): string[] {
+  const howToSave = skipIndex
+    ? [
+        '## How to save memories',
+        '',
+        'Write each memory to its own file (e.g., `user_role.md`, `feedback_testing.md`) using this frontmatter format:',
+        '',
+        ...MEMORY_FRONTMATTER_EXAMPLE,
+        '',
+        '- Keep the name, description, and type fields in memory files up-to-date with the content',
+        '- Organize memory semantically by topic, not chronologically',
+        '- Update or remove memories that turn out to be wrong or outdated',
+        '- Do not write duplicate memories. First check if there is an existing memory you can update before writing a new one.',
+      ]
+    : [
+        '## How to save memories',
+        '',
+        'Saving a memory is a two-step process:',
+        '',
+        '**Step 1** — write the memory to its own file (e.g., `user_role.md`, `feedback_testing.md`) using this frontmatter format:',
+        '',
+        ...MEMORY_FRONTMATTER_EXAMPLE,
+        '',
+        `**Step 2** — add a pointer to that file in \`${ENTRYPOINT_NAME}\`. \`${ENTRYPOINT_NAME}\` is an index, not a memory — each entry should be one line, under ~150 characters: \`- [Title](file.md) — one-line hook\`. It has no frontmatter. Never write memory content directly into \`${ENTRYPOINT_NAME}\`.`,
+        '',
+        `- \`${ENTRYPOINT_NAME}\` is always loaded into your conversation context — lines after ${MAX_ENTRYPOINT_LINES} will be truncated, so keep the index concise`,
+        '- Keep the name, description, and type fields in memory files up-to-date with the content',
+        '- Organize memory semantically by topic, not chronologically',
+        '- Update or remove memories that turn out to be wrong or outdated',
+        '- Do not write duplicate memories. First check if there is an existing memory you can update before writing a new one.',
+      ]
+
+  const lines: string[] = [
+    `# ${displayName}`,
+    '',
+    `You have a persistent, file-based memory system at \`${memoryDir}\`. ${DIR_EXISTS_GUIDANCE}`,
+    '',
+    "You should build up this memory system over time so that future conversations can have a complete picture of who the user is, how they'd like to collaborate with you, what behaviors to avoid or repeat, and the context behind the work the user gives you.",
+    '',
+    'If the user explicitly asks you to remember something, save it immediately as whichever type fits best. If they ask you to forget something, find and remove the relevant entry.',
+    '',
+    ...TYPES_SECTION_INDIVIDUAL,
+    ...WHAT_NOT_TO_SAVE_SECTION,
+    '',
+    ...howToSave,
+    '',
+    ...WHEN_TO_ACCESS_SECTION,
+    '',
+    ...TRUSTING_RECALL_SECTION,
+    '',
+    '## Memory and other forms of persistence',
+    'Memory is one of several persistence mechanisms available to you as you assist the user in a given conversation. The distinction is often that memory can be recalled in future conversations and should not be used for persisting information that is only useful within the scope of the current conversation.',
+    '- When to use or update a plan instead of memory: If you are about to start a non-trivial implementation task and would like to reach alignment with the user on your approach you should use a Plan rather than saving this information to memory. Similarly, if you already have a plan within the conversation and you have changed your approach persist that change by updating the plan rather than saving a memory.',
+    '- When to use or update tasks instead of memory: When you need to break your work in current conversation into discrete steps or keep track of your progress use tasks instead of saving to memory. Tasks are great for persisting information about the work that needs to be done in the current conversation, but memory should be reserved for information that will be useful in future conversations.',
+    '',
+    ...(extraGuidelines ?? []),
+    '',
+  ]
+
+  lines.push(...buildSearchingPastContextSection(memoryDir))
+
+  return lines
+}
+
+/**
+ * Build the typed-memory prompt with MEMORY.md content included.
+ * Used by agent memory (which has no getClaudeMds() equivalent).
+ */
+export function buildMemoryPrompt(params: {
+  displayName: string
+  memoryDir: string
+  extraGuidelines?: string[]
+}): string {
+  const { displayName, memoryDir, extraGuidelines } = params
+  const fs = getFsImplementation()
+  const entrypoint = memoryDir + ENTRYPOINT_NAME
+
+  // Directory creation is the caller's responsibility (loadMemoryPrompt /
+  // loadAgentMemoryPrompt). Builders only read, they don't mkdir.
+
+  // Read existing memory entrypoint (sync: prompt building is synchronous)
+  let entrypointContent = ''
+  try {
+    // eslint-disable-next-line custom-rules/no-sync-fs
+    entrypointContent = fs.readFileSync(entrypoint, { encoding: 'utf-8' })
+  } catch {
+    // No memory file yet
+  }
+
+  const lines = buildMemoryLines(displayName, memoryDir, extraGuidelines)
+
+  if (entrypointContent.trim()) {
+    const t = truncateEntrypointContent(entrypointContent)
+    const memoryType = displayName === AUTO_MEM_DISPLAY_NAME ? 'auto' : 'agent'
+    logMemoryDirCounts(memoryDir, {
+      content_length: t.byteCount,
+      line_count: t.lineCount,
+      was_truncated: t.wasLineTruncated,
+      was_byte_truncated: t.wasByteTruncated,
+      memory_type:
+        memoryType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    })
+    lines.push(`## ${ENTRYPOINT_NAME}`, '', t.content)
+  } else {
+    lines.push(
+      `## ${ENTRYPOINT_NAME}`,
+      '',
+      `Your ${ENTRYPOINT_NAME} is currently empty. When you save new memories, they will appear here.`,
+    )
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * Assistant-mode daily-log prompt. Gated behind feature('KAIROS').
+ *
+ * Assistant sessions are effectively perpetual, so the agent writes memories
+ * append-only to a date-named log file rather than maintaining MEMORY.md as
+ * a live index. A separate nightly /dream skill distills logs into topic
+ * files + MEMORY.md. MEMORY.md is still loaded into context (via claudemd.ts)
+ * as the distilled index — this prompt only changes where NEW memories go.
+ */
+function buildAssistantDailyLogPrompt(skipIndex = false): string {
+  const memoryDir = getAutoMemPath()
+  // Describe the path as a pattern rather than inlining today's literal path:
+  // this prompt is cached by systemPromptSection('memory', ...) and NOT
+  // invalidated on date change. The model derives the current date from the
+  // date_change attachment (appended at the tail on midnight rollover) rather
+  // than the user-context message — the latter is intentionally left stale to
+  // preserve the prompt cache prefix across midnight.
+  const logPathPattern = join(memoryDir, 'logs', 'YYYY', 'MM', 'YYYY-MM-DD.md')
+
+  const lines: string[] = [
+    '# auto memory',
+    '',
+    `You have a persistent, file-based memory system found at: \`${memoryDir}\``,
+    '',
+    "This session is long-lived. As you work, record anything worth remembering by **appending** to today's daily log file:",
+    '',
+    `\`${logPathPattern}\``,
+    '',
+    "Substitute today's date (from `currentDate` in your context) for `YYYY-MM-DD`. When the date rolls over mid-session, start appending to the new day's file.",
+    '',
+    'Write each entry as a short timestamped bullet. Create the file (and parent directories) on first write if it does not exist. Do not rewrite or reorganize the log — it is append-only. A separate nightly process distills these logs into `MEMORY.md` and topic files.',
+    '',
+    '## What to log',
+    '- User corrections and preferences ("use bun, not npm"; "stop summarizing diffs")',
+    '- Facts about the user, their role, or their goals',
+    '- Project context that is not derivable from the code (deadlines, incidents, decisions and their rationale)',
+    '- Pointers to external systems (dashboards, Linear projects, Slack channels)',
+    '- Anything the user explicitly asks you to remember',
+    '',
+    ...WHAT_NOT_TO_SAVE_SECTION,
+    '',
+    ...(skipIndex
+      ? []
+      : [
+          `## ${ENTRYPOINT_NAME}`,
+          `\`${ENTRYPOINT_NAME}\` is the distilled index (maintained nightly from your logs) and is loaded into your context automatically. Read it for orientation, but do not edit it directly — record new information in today's log instead.`,
+          '',
+        ]),
+    ...buildSearchingPastContextSection(memoryDir),
+  ]
+
+  return lines.join('\n')
+}
+
+/**
+ * Build the "Searching past context" section if the feature gate is enabled.
+ */
+export function buildSearchingPastContextSection(autoMemDir: string): string[] {
+  if (!getFeatureValue_CACHED_MAY_BE_STALE('tengu_coral_fern', false)) {
+    return []
+  }
+  const projectDir = getProjectDir(getOriginalCwd())
+  // Ant-native builds alias grep to embedded ugrep and remove the dedicated
+  // Grep tool, so give the model a real shell invocation there.
+  // In REPL mode, both Grep and Bash are hidden from direct use — the model
+  // calls them from inside REPL scripts, so the grep shell form is what it
+  // will write in the script anyway.
+  const embedded = hasEmbeddedSearchTools() || isReplModeEnabled()
+  const memSearch = embedded
+    ? `grep -rn "<search term>" ${autoMemDir} --include="*.md"`
+    : `${GREP_TOOL_NAME} with pattern="<search term>" path="${autoMemDir}" glob="*.md"`
+  const transcriptSearch = embedded
+    ? `grep -rn "<search term>" ${projectDir}/ --include="*.jsonl"`
+    : `${GREP_TOOL_NAME} with pattern="<search term>" path="${projectDir}/" glob="*.jsonl"`
+  return [
+    '## Searching past context',
+    '',
+    'When looking for past context:',
+    '1. Search topic files in your memory directory:',
+    '```',
+    memSearch,
+    '```',
+    '2. Session transcript logs (last resort — large files, slow):',
+    '```',
+    transcriptSearch,
+    '```',
+    'Use narrow search terms (error messages, file paths, function names) rather than broad keywords.',
+    '',
+  ]
+}
+
+/**
+ * Load the unified memory prompt for inclusion in the system prompt.
+ * Dispatches based on which memory systems are enabled:
+ *   - auto + team: combined prompt (both directories)
+ *   - auto only: memory lines (single directory)
+ * Team memory requires auto memory (enforced by isTeamMemoryEnabled), so
+ * there is no team-only branch.
+ *
+ * Returns null when auto memory is disabled.
+ */
+export async function loadMemoryPrompt(): Promise<string | null> {
+  const autoEnabled = isAutoMemoryEnabled()
+
+  const skipIndex = getFeatureValue_CACHED_MAY_BE_STALE(
+    'tengu_moth_copse',
+    false,
+  )
+
+  // KAIROS daily-log mode takes precedence over TEAMMEM: the append-only
+  // log paradigm does not compose with team sync (which expects a shared
+  // MEMORY.md that both sides read + write). Gating on `autoEnabled` here
+  // means the !autoEnabled case falls through to the tengu_memdir_disabled
+  // telemetry block below, matching the non-KAIROS path.
+  if (feature('KAIROS') && autoEnabled && getKairosActive()) {
+    logMemoryDirCounts(getAutoMemPath(), {
+      memory_type:
+        'auto' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    })
+    return buildAssistantDailyLogPrompt(skipIndex)
+  }
+
+  // Cowork injects memory-policy text via env var; thread into all builders.
+  const coworkExtraGuidelines =
+    process.env.CLAUDE_COWORK_MEMORY_EXTRA_GUIDELINES
+  const extraGuidelines =
+    coworkExtraGuidelines && coworkExtraGuidelines.trim().length > 0
+      ? [coworkExtraGuidelines]
+      : undefined
+
+  if (feature('TEAMMEM')) {
+    if (teamMemPaths!.isTeamMemoryEnabled()) {
+      const autoDir = getAutoMemPath()
+      const teamDir = teamMemPaths!.getTeamMemPath()
+      // Harness guarantees these directories exist so the model can write
+      // without checking. The prompt text reflects this ("already exists").
+      // Only creating teamDir is sufficient: getTeamMemPath() is defined as
+      // join(getAutoMemPath(), 'team'), so recursive mkdir of the team dir
+      // creates the auto dir as a side effect. If the team dir ever moves
+      // out from under the auto dir, add a second ensureMemoryDirExists call
+      // for autoDir here.
+      await ensureMemoryDirExists(teamDir)
+      logMemoryDirCounts(autoDir, {
+        memory_type:
+          'auto' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      })
+      logMemoryDirCounts(teamDir, {
+        memory_type:
+          'team' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      })
+      return teamMemPrompts!.buildCombinedMemoryPrompt(
+        extraGuidelines,
+        skipIndex,
+      )
+    }
+  }
+
+  if (autoEnabled) {
+    const autoDir = getAutoMemPath()
+    // Harness guarantees the directory exists so the model can write without
+    // checking. The prompt text reflects this ("already exists").
+    await ensureMemoryDirExists(autoDir)
+    logMemoryDirCounts(autoDir, {
+      memory_type:
+        'auto' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    })
+    return buildMemoryLines(
+      'auto memory',
+      autoDir,
+      extraGuidelines,
+      skipIndex,
+    ).join('\n')
+  }
+
+  logEvent('tengu_memdir_disabled', {
+    disabled_by_env_var: isEnvTruthy(
+      process.env.CLAUDE_CODE_DISABLE_AUTO_MEMORY,
+    ),
+    disabled_by_setting:
+      !isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_AUTO_MEMORY) &&
+      getInitialSettings().autoMemoryEnabled === false,
+  })
+  // Gate on the GB flag directly, not isTeamMemoryEnabled() — that function
+  // checks isAutoMemoryEnabled() first, which is definitionally false in this
+  // branch. We want "was this user in the team-memory cohort at all."
+  if (getFeatureValue_CACHED_MAY_BE_STALE('tengu_herring_clock', false)) {
+    logEvent('tengu_team_memdir_disabled', {})
+  }
+  return null
+}

src/memdir/memoryAge.ts

@@ -0,0 +1,53 @@
+/**
+ * Days elapsed since mtime.  Floor-rounded — 0 for today, 1 for
+ * yesterday, 2+ for older.  Negative inputs (future mtime, clock skew)
+ * clamp to 0.
+ */
+export function memoryAgeDays(mtimeMs: number): number {
+  return Math.max(0, Math.floor((Date.now() - mtimeMs) / 86_400_000))
+}
+
+/**
+ * Human-readable age string.  Models are poor at date arithmetic —
+ * a raw ISO timestamp doesn't trigger staleness reasoning the way
+ * "47 days ago" does.
+ */
+export function memoryAge(mtimeMs: number): string {
+  const d = memoryAgeDays(mtimeMs)
+  if (d === 0) return 'today'
+  if (d === 1) return 'yesterday'
+  return `${d} days ago`
+}
+
+/**
+ * Plain-text staleness caveat for memories >1 day old.  Returns ''
+ * for fresh (today/yesterday) memories — warning there is noise.
+ *
+ * Use this when the consumer already provides its own wrapping
+ * (e.g. messages.ts relevant_memories → wrapMessagesInSystemReminder).
+ *
+ * Motivated by user reports of stale code-state memories (file:line
+ * citations to code that has since changed) being asserted as fact —
+ * the citation makes the stale claim sound more authoritative, not less.
+ */
+export function memoryFreshnessText(mtimeMs: number): string {
+  const d = memoryAgeDays(mtimeMs)
+  if (d <= 1) return ''
+  return (
+    `This memory is ${d} days old. ` +
+    `Memories are point-in-time observations, not live state — ` +
+    `claims about code behavior or file:line citations may be outdated. ` +
+    `Verify against current code before asserting as fact.`
+  )
+}
+
+/**
+ * Per-memory staleness note wrapped in <system-reminder> tags.
+ * Returns '' for memories ≤ 1 day old.  Use this for callers that
+ * don't add their own system-reminder wrapper (e.g. FileReadTool output).
+ */
+export function memoryFreshnessNote(mtimeMs: number): string {
+  const text = memoryFreshnessText(mtimeMs)
+  if (!text) return ''
+  return `<system-reminder>${text}</system-reminder>\n`
+}

src/memdir/memoryScan.ts

@@ -0,0 +1,94 @@
+/**
+ * Memory-directory scanning primitives. Split out of findRelevantMemories.ts
+ * so extractMemories can import the scan without pulling in sideQuery and
+ * the API-client chain (which closed a cycle through memdir.ts — #25372).
+ */
+
+import { readdir } from 'fs/promises'
+import { basename, join } from 'path'
+import { parseFrontmatter } from '../utils/frontmatterParser.js'
+import { readFileInRange } from '../utils/readFileInRange.js'
+import { type MemoryType, parseMemoryType } from './memoryTypes.js'
+
+export type MemoryHeader = {
+  filename: string
+  filePath: string
+  mtimeMs: number
+  description: string | null
+  type: MemoryType | undefined
+}
+
+const MAX_MEMORY_FILES = 200
+const FRONTMATTER_MAX_LINES = 30
+
+/**
+ * Scan a memory directory for .md files, read their frontmatter, and return
+ * a header list sorted newest-first (capped at MAX_MEMORY_FILES). Shared by
+ * findRelevantMemories (query-time recall) and extractMemories (pre-injects
+ * the listing so the extraction agent doesn't spend a turn on `ls`).
+ *
+ * Single-pass: readFileInRange stats internally and returns mtimeMs, so we
+ * read-then-sort rather than stat-sort-read. For the common case (N ≤ 200)
+ * this halves syscalls vs a separate stat round; for large N we read a few
+ * extra small files but still avoid the double-stat on the surviving 200.
+ */
+export async function scanMemoryFiles(
+  memoryDir: string,
+  signal: AbortSignal,
+): Promise<MemoryHeader[]> {
+  try {
+    const entries = await readdir(memoryDir, { recursive: true })
+    const mdFiles = entries.filter(
+      f => f.endsWith('.md') && basename(f) !== 'MEMORY.md',
+    )
+
+    const headerResults = await Promise.allSettled(
+      mdFiles.map(async (relativePath): Promise<MemoryHeader> => {
+        const filePath = join(memoryDir, relativePath)
+        const { content, mtimeMs } = await readFileInRange(
+          filePath,
+          0,
+          FRONTMATTER_MAX_LINES,
+          undefined,
+          signal,
+        )
+        const { frontmatter } = parseFrontmatter(content, filePath)
+        return {
+          filename: relativePath,
+          filePath,
+          mtimeMs,
+          description: frontmatter.description || null,
+          type: parseMemoryType(frontmatter.type),
+        }
+      }),
+    )
+
+    return headerResults
+      .filter(
+        (r): r is PromiseFulfilledResult<MemoryHeader> =>
+          r.status === 'fulfilled',
+      )
+      .map(r => r.value)
+      .sort((a, b) => b.mtimeMs - a.mtimeMs)
+      .slice(0, MAX_MEMORY_FILES)
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Format memory headers as a text manifest: one line per file with
+ * [type] filename (timestamp): description. Used by both the recall
+ * selector prompt and the extraction-agent prompt.
+ */
+export function formatMemoryManifest(memories: MemoryHeader[]): string {
+  return memories
+    .map(m => {
+      const tag = m.type ? `[${m.type}] ` : ''
+      const ts = new Date(m.mtimeMs).toISOString()
+      return m.description
+        ? `- ${tag}${m.filename} (${ts}): ${m.description}`
+        : `- ${tag}${m.filename} (${ts})`
+    })
+    .join('\n')
+}

src/memdir/memoryTypes.ts

@@ -0,0 +1,271 @@
+/**
+ * Memory type taxonomy.
+ *
+ * Memories are constrained to four types capturing context NOT derivable
+ * from the current project state. Code patterns, architecture, git history,
+ * and file structure are derivable (via grep/git/CLAUDE.md) and should NOT
+ * be saved as memories.
+ *
+ * The two TYPES_SECTION_* exports below are intentionally duplicated rather
+ * than generated from a shared spec — keeping them flat makes per-mode edits
+ * trivial without reasoning through a helper's conditional rendering.
+ */
+
+export const MEMORY_TYPES = [
+  'user',
+  'feedback',
+  'project',
+  'reference',
+] as const
+
+export type MemoryType = (typeof MEMORY_TYPES)[number]
+
+/**
+ * Parse a raw frontmatter value into a MemoryType.
+ * Invalid or missing values return undefined — legacy files without a
+ * `type:` field keep working, files with unknown types degrade gracefully.
+ */
+export function parseMemoryType(raw: unknown): MemoryType | undefined {
+  if (typeof raw !== 'string') return undefined
+  return MEMORY_TYPES.find(t => t === raw)
+}
+
+/**
+ * `## Types of memory` section for COMBINED mode (private + team directories).
+ * Includes <scope> tags and team/private qualifiers in examples.
+ */
+export const TYPES_SECTION_COMBINED: readonly string[] = [
+  '## Types of memory',
+  '',
+  'There are several discrete types of memory that you can store in your memory system. Each type below declares a <scope> of `private`, `team`, or guidance for choosing between the two.',
+  '',
+  '<types>',
+  '<type>',
+  '    <name>user</name>',
+  '    <scope>always private</scope>',
+  "    <description>Contain information about the user's role, goals, responsibilities, and knowledge. Great user memories help you tailor your future behavior to the user's preferences and perspective. Your goal in reading and writing these memories is to build up an understanding of who the user is and how you can be most helpful to them specifically. For example, you should collaborate with a senior software engineer differently than a student who is coding for the very first time. Keep in mind, that the aim here is to be helpful to the user. Avoid writing memories about the user that could be viewed as a negative judgement or that are not relevant to the work you're trying to accomplish together.</description>",
+  "    <when_to_save>When you learn any details about the user's role, preferences, responsibilities, or knowledge</when_to_save>",
+  "    <how_to_use>When your work should be informed by the user's profile or perspective. For example, if the user is asking you to explain a part of the code, you should answer that question in a way that is tailored to the specific details that they will find most valuable or that helps them build their mental model in relation to domain knowledge they already have.</how_to_use>",
+  '    <examples>',
+  "    user: I'm a data scientist investigating what logging we have in place",
+  '    assistant: [saves private user memory: user is a data scientist, currently focused on observability/logging]',
+  '',
+  "    user: I've been writing Go for ten years but this is my first time touching the React side of this repo",
+  "    assistant: [saves private user memory: deep Go expertise, new to React and this project's frontend — frame frontend explanations in terms of backend analogues]",
+  '    </examples>',
+  '</type>',
+  '<type>',
+  '    <name>feedback</name>',
+  '    <scope>default to private. Save as team only when the guidance is clearly a project-wide convention that every contributor should follow (e.g., a testing policy, a build invariant), not a personal style preference.</scope>',
+  "    <description>Guidance the user has given you about how to approach work — both what to avoid and what to keep doing. These are a very important type of memory to read and write as they allow you to remain coherent and responsive to the way you should approach work in the project. Record from failure AND success: if you only save corrections, you will avoid past mistakes but drift away from approaches the user has already validated, and may grow overly cautious. Before saving a private feedback memory, check that it doesn't contradict a team feedback memory — if it does, either don't save it or note the override explicitly.</description>",
+  '    <when_to_save>Any time the user corrects your approach ("no not that", "don\'t", "stop doing X") OR confirms a non-obvious approach worked ("yes exactly", "perfect, keep doing that", accepting an unusual choice without pushback). Corrections are easy to notice; confirmations are quieter — watch for them. In both cases, save what is applicable to future conversations, especially if surprising or not obvious from the code. Include *why* so you can judge edge cases later.</when_to_save>',
+  '    <how_to_use>Let these memories guide your behavior so that the user and other users in the project do not need to offer the same guidance twice.</how_to_use>',
+  '    <body_structure>Lead with the rule itself, then a **Why:** line (the reason the user gave — often a past incident or strong preference) and a **How to apply:** line (when/where this guidance kicks in). Knowing *why* lets you judge edge cases instead of blindly following the rule.</body_structure>',
+  '    <examples>',
+  "    user: don't mock the database in these tests — we got burned last quarter when mocked tests passed but the prod migration failed",
+  '    assistant: [saves team feedback memory: integration tests must hit a real database, not mocks. Reason: prior incident where mock/prod divergence masked a broken migration. Team scope: this is a project testing policy, not a personal preference]',
+  '',
+  '    user: stop summarizing what you just did at the end of every response, I can read the diff',
+  "    assistant: [saves private feedback memory: this user wants terse responses with no trailing summaries. Private because it's a communication preference, not a project convention]",
+  '',
+  "    user: yeah the single bundled PR was the right call here, splitting this one would've just been churn",
+  '    assistant: [saves private feedback memory: for refactors in this area, user prefers one bundled PR over many small ones. Confirmed after I chose this approach — a validated judgment call, not a correction]',
+  '    </examples>',
+  '</type>',
+  '<type>',
+  '    <name>project</name>',
+  '    <scope>private or team, but strongly bias toward team</scope>',
+  '    <description>Information that you learn about ongoing work, goals, initiatives, bugs, or incidents within the project that is not otherwise derivable from the code or git history. Project memories help you understand the broader context and motivation behind the work users are working on within this working directory.</description>',
+  '    <when_to_save>When you learn who is doing what, why, or by when. These states change relatively quickly so try to keep your understanding of this up to date. Always convert relative dates in user messages to absolute dates when saving (e.g., "Thursday" → "2026-03-05"), so the memory remains interpretable after time passes.</when_to_save>',
+  "    <how_to_use>Use these memories to more fully understand the details and nuance behind the user's request, anticipate coordination issues across users, make better informed suggestions.</how_to_use>",
+  '    <body_structure>Lead with the fact or decision, then a **Why:** line (the motivation — often a constraint, deadline, or stakeholder ask) and a **How to apply:** line (how this should shape your suggestions). Project memories decay fast, so the why helps future-you judge whether the memory is still load-bearing.</body_structure>',
+  '    <examples>',
+  "    user: we're freezing all non-critical merges after Thursday — mobile team is cutting a release branch",
+  '    assistant: [saves team project memory: merge freeze begins 2026-03-05 for mobile release cut. Flag any non-critical PR work scheduled after that date]',
+  '',
+  "    user: the reason we're ripping out the old auth middleware is that legal flagged it for storing session tokens in a way that doesn't meet the new compliance requirements",
+  '    assistant: [saves team project memory: auth middleware rewrite is driven by legal/compliance requirements around session token storage, not tech-debt cleanup — scope decisions should favor compliance over ergonomics]',
+  '    </examples>',
+  '</type>',
+  '<type>',
+  '    <name>reference</name>',
+  '    <scope>usually team</scope>',
+  '    <description>Stores pointers to where information can be found in external systems. These memories allow you to remember where to look to find up-to-date information outside of the project directory.</description>',
+  '    <when_to_save>When you learn about resources in external systems and their purpose. For example, that bugs are tracked in a specific project in Linear or that feedback can be found in a specific Slack channel.</when_to_save>',
+  '    <how_to_use>When the user references an external system or information that may be in an external system.</how_to_use>',
+  '    <examples>',
+  '    user: check the Linear project "INGEST" if you want context on these tickets, that\'s where we track all pipeline bugs',
+  '    assistant: [saves team reference memory: pipeline bugs are tracked in Linear project "INGEST"]',
+  '',
+  "    user: the Grafana board at grafana.internal/d/api-latency is what oncall watches — if you're touching request handling, that's the thing that'll page someone",
+  '    assistant: [saves team reference memory: grafana.internal/d/api-latency is the oncall latency dashboard — check it when editing request-path code]',
+  '    </examples>',
+  '</type>',
+  '</types>',
+  '',
+]
+
+/**
+ * `## Types of memory` section for INDIVIDUAL-ONLY mode (single directory).
+ * No <scope> tags. Examples use plain `[saves X memory: …]`. Prose that
+ * only makes sense with a private/team split is reworded.
+ */
+export const TYPES_SECTION_INDIVIDUAL: readonly string[] = [
+  '## Types of memory',
+  '',
+  'There are several discrete types of memory that you can store in your memory system:',
+  '',
+  '<types>',
+  '<type>',
+  '    <name>user</name>',
+  "    <description>Contain information about the user's role, goals, responsibilities, and knowledge. Great user memories help you tailor your future behavior to the user's preferences and perspective. Your goal in reading and writing these memories is to build up an understanding of who the user is and how you can be most helpful to them specifically. For example, you should collaborate with a senior software engineer differently than a student who is coding for the very first time. Keep in mind, that the aim here is to be helpful to the user. Avoid writing memories about the user that could be viewed as a negative judgement or that are not relevant to the work you're trying to accomplish together.</description>",
+  "    <when_to_save>When you learn any details about the user's role, preferences, responsibilities, or knowledge</when_to_save>",
+  "    <how_to_use>When your work should be informed by the user's profile or perspective. For example, if the user is asking you to explain a part of the code, you should answer that question in a way that is tailored to the specific details that they will find most valuable or that helps them build their mental model in relation to domain knowledge they already have.</how_to_use>",
+  '    <examples>',
+  "    user: I'm a data scientist investigating what logging we have in place",
+  '    assistant: [saves user memory: user is a data scientist, currently focused on observability/logging]',
+  '',
+  "    user: I've been writing Go for ten years but this is my first time touching the React side of this repo",
+  "    assistant: [saves user memory: deep Go expertise, new to React and this project's frontend — frame frontend explanations in terms of backend analogues]",
+  '    </examples>',
+  '</type>',
+  '<type>',
+  '    <name>feedback</name>',
+  '    <description>Guidance the user has given you about how to approach work — both what to avoid and what to keep doing. These are a very important type of memory to read and write as they allow you to remain coherent and responsive to the way you should approach work in the project. Record from failure AND success: if you only save corrections, you will avoid past mistakes but drift away from approaches the user has already validated, and may grow overly cautious.</description>',
+  '    <when_to_save>Any time the user corrects your approach ("no not that", "don\'t", "stop doing X") OR confirms a non-obvious approach worked ("yes exactly", "perfect, keep doing that", accepting an unusual choice without pushback). Corrections are easy to notice; confirmations are quieter — watch for them. In both cases, save what is applicable to future conversations, especially if surprising or not obvious from the code. Include *why* so you can judge edge cases later.</when_to_save>',
+  '    <how_to_use>Let these memories guide your behavior so that the user does not need to offer the same guidance twice.</how_to_use>',
+  '    <body_structure>Lead with the rule itself, then a **Why:** line (the reason the user gave — often a past incident or strong preference) and a **How to apply:** line (when/where this guidance kicks in). Knowing *why* lets you judge edge cases instead of blindly following the rule.</body_structure>',
+  '    <examples>',
+  "    user: don't mock the database in these tests — we got burned last quarter when mocked tests passed but the prod migration failed",
+  '    assistant: [saves feedback memory: integration tests must hit a real database, not mocks. Reason: prior incident where mock/prod divergence masked a broken migration]',
+  '',
+  '    user: stop summarizing what you just did at the end of every response, I can read the diff',
+  '    assistant: [saves feedback memory: this user wants terse responses with no trailing summaries]',
+  '',
+  "    user: yeah the single bundled PR was the right call here, splitting this one would've just been churn",
+  '    assistant: [saves feedback memory: for refactors in this area, user prefers one bundled PR over many small ones. Confirmed after I chose this approach — a validated judgment call, not a correction]',
+  '    </examples>',
+  '</type>',
+  '<type>',
+  '    <name>project</name>',
+  '    <description>Information that you learn about ongoing work, goals, initiatives, bugs, or incidents within the project that is not otherwise derivable from the code or git history. Project memories help you understand the broader context and motivation behind the work the user is doing within this working directory.</description>',
+  '    <when_to_save>When you learn who is doing what, why, or by when. These states change relatively quickly so try to keep your understanding of this up to date. Always convert relative dates in user messages to absolute dates when saving (e.g., "Thursday" → "2026-03-05"), so the memory remains interpretable after time passes.</when_to_save>',
+  "    <how_to_use>Use these memories to more fully understand the details and nuance behind the user's request and make better informed suggestions.</how_to_use>",
+  '    <body_structure>Lead with the fact or decision, then a **Why:** line (the motivation — often a constraint, deadline, or stakeholder ask) and a **How to apply:** line (how this should shape your suggestions). Project memories decay fast, so the why helps future-you judge whether the memory is still load-bearing.</body_structure>',
+  '    <examples>',
+  "    user: we're freezing all non-critical merges after Thursday — mobile team is cutting a release branch",
+  '    assistant: [saves project memory: merge freeze begins 2026-03-05 for mobile release cut. Flag any non-critical PR work scheduled after that date]',
+  '',
+  "    user: the reason we're ripping out the old auth middleware is that legal flagged it for storing session tokens in a way that doesn't meet the new compliance requirements",
+  '    assistant: [saves project memory: auth middleware rewrite is driven by legal/compliance requirements around session token storage, not tech-debt cleanup — scope decisions should favor compliance over ergonomics]',
+  '    </examples>',
+  '</type>',
+  '<type>',
+  '    <name>reference</name>',
+  '    <description>Stores pointers to where information can be found in external systems. These memories allow you to remember where to look to find up-to-date information outside of the project directory.</description>',
+  '    <when_to_save>When you learn about resources in external systems and their purpose. For example, that bugs are tracked in a specific project in Linear or that feedback can be found in a specific Slack channel.</when_to_save>',
+  '    <how_to_use>When the user references an external system or information that may be in an external system.</how_to_use>',
+  '    <examples>',
+  '    user: check the Linear project "INGEST" if you want context on these tickets, that\'s where we track all pipeline bugs',
+  '    assistant: [saves reference memory: pipeline bugs are tracked in Linear project "INGEST"]',
+  '',
+  "    user: the Grafana board at grafana.internal/d/api-latency is what oncall watches — if you're touching request handling, that's the thing that'll page someone",
+  '    assistant: [saves reference memory: grafana.internal/d/api-latency is the oncall latency dashboard — check it when editing request-path code]',
+  '    </examples>',
+  '</type>',
+  '</types>',
+  '',
+]
+
+/**
+ * `## What NOT to save in memory` section. Identical across both modes.
+ */
+export const WHAT_NOT_TO_SAVE_SECTION: readonly string[] = [
+  '## What NOT to save in memory',
+  '',
+  '- Code patterns, conventions, architecture, file paths, or project structure — these can be derived by reading the current project state.',
+  '- Git history, recent changes, or who-changed-what — `git log` / `git blame` are authoritative.',
+  '- Debugging solutions or fix recipes — the fix is in the code; the commit message has the context.',
+  '- Anything already documented in CLAUDE.md files.',
+  '- Ephemeral task details: in-progress work, temporary state, current conversation context.',
+  '',
+  // H2: explicit-save gate. Eval-validated (memory-prompt-iteration case 3,
+  // 0/2 → 3/3): prevents "save this week's PR list" → activity-log noise.
+  'These exclusions apply even when the user explicitly asks you to save. If they ask you to save a PR list or activity summary, ask what was *surprising* or *non-obvious* about it — that is the part worth keeping.',
+]
+
+/**
+ * Recall-side drift caveat. Single bullet under `## When to access memories`.
+ * Proactive: verify memory against current state before answering.
+ */
+export const MEMORY_DRIFT_CAVEAT =
+  '- Memory records can become stale over time. Use memory as context for what was true at a given point in time. Before answering the user or building assumptions based solely on information in memory records, verify that the memory is still correct and up-to-date by reading the current state of the files or resources. If a recalled memory conflicts with current information, trust what you observe now — and update or remove the stale memory rather than acting on it.'
+
+/**
+ * `## When to access memories` section. Includes MEMORY_DRIFT_CAVEAT.
+ *
+ * H6 (branch-pollution evals #22856, case 5 1/3 on capy): the "ignore" bullet
+ * is the delta. Failure mode: user says "ignore memory about X" → Claude reads
+ * code correctly but adds "not Y as noted in memory" — treats "ignore" as
+ * "acknowledge then override" rather than "don't reference at all." The bullet
+ * names that anti-pattern explicitly.
+ *
+ * Token budget (H6a): merged old bullets 1+2, tightened both. Old 4 lines
+ * were ~70 tokens; new 4 lines are ~73 tokens. Net ~+3.
+ */
+export const WHEN_TO_ACCESS_SECTION: readonly string[] = [
+  '## When to access memories',
+  '- When memories seem relevant, or the user references prior-conversation work.',
+  '- You MUST access memory when the user explicitly asks you to check, recall, or remember.',
+  '- If the user says to *ignore* or *not use* memory: proceed as if MEMORY.md were empty. Do not apply remembered facts, cite, compare against, or mention memory content.',
+  MEMORY_DRIFT_CAVEAT,
+]
+
+/**
+ * `## Trusting what you recall` section. Heavier-weight guidance on HOW to
+ * treat a memory once you've recalled it — separate from WHEN to access.
+ *
+ * Eval-validated (memory-prompt-iteration.eval.ts, 2026-03-17):
+ *   H1 (verify function/file claims): 0/2 → 3/3 via appendSystemPrompt. When
+ *      buried as a bullet under "When to access", dropped to 0/3 — position
+ *      matters. The H1 cue is about what to DO with a memory, not when to
+ *      look, so it needs its own section-level trigger context.
+ *   H5 (read-side noise rejection): 0/2 → 3/3 via appendSystemPrompt, 2/3
+ *      in-place as a bullet. Partial because "snapshot" is intuitively closer
+ *      to "when to access" than H1 is.
+ *
+ * Known gap: H1 doesn't cover slash-command claims (0/3 on the /fork case —
+ * slash commands aren't files or functions in the model's ontology).
+ */
+export const TRUSTING_RECALL_SECTION: readonly string[] = [
+  // Header wording matters: "Before recommending" (action cue at the decision
+  // point) tested better than "Trusting what you recall" (abstract). The
+  // appendSystemPrompt variant with this header went 3/3; the abstract header
+  // went 0/3 in-place. Same body text — only the header differed.
+  '## Before recommending from memory',
+  '',
+  'A memory that names a specific function, file, or flag is a claim that it existed *when the memory was written*. It may have been renamed, removed, or never merged. Before recommending it:',
+  '',
+  '- If the memory names a file path: check the file exists.',
+  '- If the memory names a function or flag: grep for it.',
+  '- If the user is about to act on your recommendation (not just asking about history), verify first.',
+  '',
+  '"The memory says X exists" is not the same as "X exists now."',
+  '',
+  'A memory that summarizes repo state (activity logs, architecture snapshots) is frozen in time. If the user asks about *recent* or *current* state, prefer `git log` or reading the code over recalling the snapshot.',
+]
+
+/**
+ * Frontmatter format example with the `type` field.
+ */
+export const MEMORY_FRONTMATTER_EXAMPLE: readonly string[] = [
+  '```markdown',
+  '---',
+  'name: {{memory name}}',
+  'description: {{one-line description — used to decide relevance in future conversations, so be specific}}',
+  `type: {{${MEMORY_TYPES.join(', ')}}}`,
+  '---',
+  '',
+  '{{memory content — for feedback/project types, structure as: rule/fact, then **Why:** and **How to apply:** lines}}',
+  '```',
+]

src/memdir/paths.ts

@@ -0,0 +1,278 @@
+import memoize from 'lodash-es/memoize.js'
+import { homedir } from 'os'
+import { isAbsolute, join, normalize, sep } from 'path'
+import {
+  getIsNonInteractiveSession,
+  getProjectRoot,
+} from '../bootstrap/state.js'
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js'
+import {
+  getClaudeConfigHomeDir,
+  isEnvDefinedFalsy,
+  isEnvTruthy,
+} from '../utils/envUtils.js'
+import { findCanonicalGitRoot } from '../utils/git.js'
+import { sanitizePath } from '../utils/path.js'
+import {
+  getInitialSettings,
+  getSettingsForSource,
+} from '../utils/settings/settings.js'
+
+/**
+ * Whether auto-memory features are enabled (memdir, agent memory, past session search).
+ * Enabled by default. Priority chain (first defined wins):
+ *   1. CLAUDE_CODE_DISABLE_AUTO_MEMORY env var (1/true → OFF, 0/false → ON)
+ *   2. CLAUDE_CODE_SIMPLE (--bare) → OFF
+ *   3. CCR without persistent storage → OFF (no CLAUDE_CODE_REMOTE_MEMORY_DIR)
+ *   4. autoMemoryEnabled in settings.json (supports project-level opt-out)
+ *   5. Default: enabled
+ */
+export function isAutoMemoryEnabled(): boolean {
+  const envVal = process.env.CLAUDE_CODE_DISABLE_AUTO_MEMORY
+  if (isEnvTruthy(envVal)) {
+    return false
+  }
+  if (isEnvDefinedFalsy(envVal)) {
+    return true
+  }
+  // --bare / SIMPLE: prompts.ts already drops the memory section from the
+  // system prompt via its SIMPLE early-return; this gate stops the other half
+  // (extractMemories turn-end fork, autoDream, /remember, /dream, team sync).
+  if (isEnvTruthy(process.env.CLAUDE_CODE_SIMPLE)) {
+    return false
+  }
+  if (
+    isEnvTruthy(process.env.CLAUDE_CODE_REMOTE) &&
+    !process.env.CLAUDE_CODE_REMOTE_MEMORY_DIR
+  ) {
+    return false
+  }
+  const settings = getInitialSettings()
+  if (settings.autoMemoryEnabled !== undefined) {
+    return settings.autoMemoryEnabled
+  }
+  return true
+}
+
+/**
+ * Whether the extract-memories background agent will run this session.
+ *
+ * The main agent's prompt always has full save instructions regardless of
+ * this gate — when the main agent writes memories, the background agent
+ * skips that range (hasMemoryWritesSince in extractMemories.ts); when it
+ * doesn't, the background agent catches anything missed.
+ *
+ * Callers must also gate on feature('EXTRACT_MEMORIES') — that check cannot
+ * live inside this helper because feature() only tree-shakes when used
+ * directly in an `if` condition.
+ */
+export function isExtractModeActive(): boolean {
+  if (!getFeatureValue_CACHED_MAY_BE_STALE('tengu_passport_quail', false)) {
+    return false
+  }
+  return (
+    !getIsNonInteractiveSession() ||
+    getFeatureValue_CACHED_MAY_BE_STALE('tengu_slate_thimble', false)
+  )
+}
+
+/**
+ * Returns the base directory for persistent memory storage.
+ * Resolution order:
+ *   1. CLAUDE_CODE_REMOTE_MEMORY_DIR env var (explicit override, set in CCR)
+ *   2. ~/.claude (default config home)
+ */
+export function getMemoryBaseDir(): string {
+  if (process.env.CLAUDE_CODE_REMOTE_MEMORY_DIR) {
+    return process.env.CLAUDE_CODE_REMOTE_MEMORY_DIR
+  }
+  return getClaudeConfigHomeDir()
+}
+
+const AUTO_MEM_DIRNAME = 'memory'
+const AUTO_MEM_ENTRYPOINT_NAME = 'MEMORY.md'
+
+/**
+ * Normalize and validate a candidate auto-memory directory path.
+ *
+ * SECURITY: Rejects paths that would be dangerous as a read-allowlist root
+ * or that normalize() doesn't fully resolve:
+ * - relative (!isAbsolute): "../foo" — would be interpreted relative to CWD
+ * - root/near-root (length < 3): "/" → "" after strip; "/a" too short
+ * - Windows drive-root (C: regex): "C:\" → "C:" after strip
+ * - UNC paths (\\server\share): network paths — opaque trust boundary
+ * - null byte: survives normalize(), can truncate in syscalls
+ *
+ * Returns the normalized path with exactly one trailing separator,
+ * or undefined if the path is unset/empty/rejected.
+ */
+function validateMemoryPath(
+  raw: string | undefined,
+  expandTilde: boolean,
+): string | undefined {
+  if (!raw) {
+    return undefined
+  }
+  let candidate = raw
+  // Settings.json paths support ~/ expansion (user-friendly). The env var
+  // override does not (it's set programmatically by Cowork/SDK, which should
+  // always pass absolute paths). Bare "~", "~/", "~/.", "~/..", etc. are NOT
+  // expanded — they would make isAutoMemPath() match all of $HOME or its
+  // parent (same class of danger as "/" or "C:\").
+  if (
+    expandTilde &&
+    (candidate.startsWith('~/') || candidate.startsWith('~\\'))
+  ) {
+    const rest = candidate.slice(2)
+    // Reject trivial remainders that would expand to $HOME or an ancestor.
+    // normalize('') = '.', normalize('.') = '.', normalize('foo/..') = '.',
+    // normalize('..') = '..', normalize('foo/../..') = '..'
+    const restNorm = normalize(rest || '.')
+    if (restNorm === '.' || restNorm === '..') {
+      return undefined
+    }
+    candidate = join(homedir(), rest)
+  }
+  // normalize() may preserve a trailing separator; strip before adding
+  // exactly one to match the trailing-sep contract of getAutoMemPath()
+  const normalized = normalize(candidate).replace(/[/\\]+$/, '')
+  if (
+    !isAbsolute(normalized) ||
+    normalized.length < 3 ||
+    /^[A-Za-z]:$/.test(normalized) ||
+    normalized.startsWith('\\\\') ||
+    normalized.startsWith('//') ||
+    normalized.includes('\0')
+  ) {
+    return undefined
+  }
+  return (normalized + sep).normalize('NFC')
+}
+
+/**
+ * Direct override for the full auto-memory directory path via env var.
+ * When set, getAutoMemPath()/getAutoMemEntrypoint() return this path directly
+ * instead of computing `{base}/projects/{sanitized-cwd}/memory/`.
+ *
+ * Used by Cowork to redirect memory to a space-scoped mount where the
+ * per-session cwd (which contains the VM process name) would otherwise
+ * produce a different project-key for every session.
+ */
+function getAutoMemPathOverride(): string | undefined {
+  return validateMemoryPath(
+    process.env.CLAUDE_COWORK_MEMORY_PATH_OVERRIDE,
+    false,
+  )
+}
+
+/**
+ * Settings.json override for the full auto-memory directory path.
+ * Supports ~/ expansion for user convenience.
+ *
+ * SECURITY: projectSettings (.claude/settings.json committed to the repo) is
+ * intentionally excluded — a malicious repo could otherwise set
+ * autoMemoryDirectory: "~/.ssh" and gain silent write access to sensitive
+ * directories via the filesystem.ts write carve-out (which fires when
+ * isAutoMemPath() matches and hasAutoMemPathOverride() is false). This follows
+ * the same pattern as hasSkipDangerousModePermissionPrompt() etc.
+ */
+function getAutoMemPathSetting(): string | undefined {
+  const dir =
+    getSettingsForSource('policySettings')?.autoMemoryDirectory ??
+    getSettingsForSource('flagSettings')?.autoMemoryDirectory ??
+    getSettingsForSource('localSettings')?.autoMemoryDirectory ??
+    getSettingsForSource('userSettings')?.autoMemoryDirectory
+  return validateMemoryPath(dir, true)
+}
+
+/**
+ * Check if CLAUDE_COWORK_MEMORY_PATH_OVERRIDE is set to a valid override.
+ * Use this as a signal that the SDK caller has explicitly opted into
+ * the auto-memory mechanics — e.g. to decide whether to inject the
+ * memory prompt when a custom system prompt replaces the default.
+ */
+export function hasAutoMemPathOverride(): boolean {
+  return getAutoMemPathOverride() !== undefined
+}
+
+/**
+ * Returns the canonical git repo root if available, otherwise falls back to
+ * the stable project root. Uses findCanonicalGitRoot so all worktrees of the
+ * same repo share one auto-memory directory (anthropics/claude-code#24382).
+ */
+function getAutoMemBase(): string {
+  return findCanonicalGitRoot(getProjectRoot()) ?? getProjectRoot()
+}
+
+/**
+ * Returns the auto-memory directory path.
+ *
+ * Resolution order:
+ *   1. CLAUDE_COWORK_MEMORY_PATH_OVERRIDE env var (full-path override, used by Cowork)
+ *   2. autoMemoryDirectory in settings.json (trusted sources only: policy/local/user)
+ *   3. <memoryBase>/projects/<sanitized-git-root>/memory/
+ *      where memoryBase is resolved by getMemoryBaseDir()
+ *
+ * Memoized: render-path callers (collapseReadSearchGroups → isAutoManagedMemoryFile)
+ * fire per tool-use message per Messages re-render; each miss costs
+ * getSettingsForSource × 4 → parseSettingsFile (realpathSync + readFileSync).
+ * Keyed on projectRoot so tests that change its mock mid-block recompute;
+ * env vars / settings.json / CLAUDE_CONFIG_DIR are session-stable in
+ * production and covered by per-test cache.clear.
+ */
+export const getAutoMemPath = memoize(
+  (): string => {
+    const override = getAutoMemPathOverride() ?? getAutoMemPathSetting()
+    if (override) {
+      return override
+    }
+    const projectsDir = join(getMemoryBaseDir(), 'projects')
+    return (
+      join(projectsDir, sanitizePath(getAutoMemBase()), AUTO_MEM_DIRNAME) + sep
+    ).normalize('NFC')
+  },
+  () => getProjectRoot(),
+)
+
+/**
+ * Returns the daily log file path for the given date (defaults to today).
+ * Shape: <autoMemPath>/logs/YYYY/MM/YYYY-MM-DD.md
+ *
+ * Used by assistant mode (feature('KAIROS')): rather than maintaining
+ * MEMORY.md as a live index, the agent appends to a date-named log file
+ * as it works. A separate nightly /dream skill distills these logs into
+ * topic files + MEMORY.md.
+ */
+export function getAutoMemDailyLogPath(date: Date = new Date()): string {
+  const yyyy = date.getFullYear().toString()
+  const mm = (date.getMonth() + 1).toString().padStart(2, '0')
+  const dd = date.getDate().toString().padStart(2, '0')
+  return join(getAutoMemPath(), 'logs', yyyy, mm, `${yyyy}-${mm}-${dd}.md`)
+}
+
+/**
+ * Returns the auto-memory entrypoint (MEMORY.md inside the auto-memory dir).
+ * Follows the same resolution order as getAutoMemPath().
+ */
+export function getAutoMemEntrypoint(): string {
+  return join(getAutoMemPath(), AUTO_MEM_ENTRYPOINT_NAME)
+}
+
+/**
+ * Check if an absolute path is within the auto-memory directory.
+ *
+ * When CLAUDE_COWORK_MEMORY_PATH_OVERRIDE is set, this matches against the
+ * env-var override directory. Note that a true return here does NOT imply
+ * write permission in that case — the filesystem.ts write carve-out is gated
+ * on !hasAutoMemPathOverride() (it exists to bypass DANGEROUS_DIRECTORIES).
+ *
+ * The settings.json autoMemoryDirectory DOES get the write carve-out: it's the
+ * user's explicit choice from a trusted settings source (projectSettings is
+ * excluded — see getAutoMemPathSetting), and hasAutoMemPathOverride() remains
+ * false for it.
+ */
+export function isAutoMemPath(absolutePath: string): boolean {
+  // SECURITY: Normalize to prevent path traversal bypasses via .. segments
+  const normalizedPath = normalize(absolutePath)
+  return normalizedPath.startsWith(getAutoMemPath())
+}

src/memdir/teamMemPaths.ts

@@ -0,0 +1,292 @@
+import { lstat, realpath } from 'fs/promises'
+import { dirname, join, resolve, sep } from 'path'
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js'
+import { getErrnoCode } from '../utils/errors.js'
+import { getAutoMemPath, isAutoMemoryEnabled } from './paths.js'
+
+/**
+ * Error thrown when a path validation detects a traversal or injection attempt.
+ */
+export class PathTraversalError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'PathTraversalError'
+  }
+}
+
+/**
+ * Sanitize a file path key by rejecting dangerous patterns.
+ * Checks for null bytes, URL-encoded traversals, and other injection vectors.
+ * Returns the sanitized string or throws PathTraversalError.
+ */
+function sanitizePathKey(key: string): string {
+  // Null bytes can truncate paths in C-based syscalls
+  if (key.includes('\0')) {
+    throw new PathTraversalError(`Null byte in path key: "${key}"`)
+  }
+  // URL-encoded traversals (e.g. %2e%2e%2f = ../)
+  let decoded: string
+  try {
+    decoded = decodeURIComponent(key)
+  } catch {
+    // Malformed percent-encoding (e.g. %ZZ, lone %) — not valid URL-encoding,
+    // so no URL-encoded traversal is possible
+    decoded = key
+  }
+  if (decoded !== key && (decoded.includes('..') || decoded.includes('/'))) {
+    throw new PathTraversalError(`URL-encoded traversal in path key: "${key}"`)
+  }
+  // Unicode normalization attacks: fullwidth ．．／ (U+FF0E U+FF0F) normalize
+  // to ASCII ../ under NFKC. While path.resolve/fs.writeFile treat these as
+  // literal bytes (not separators), downstream layers or filesystems may
+  // normalize — reject for defense-in-depth (PSR M22187 vector 4).
+  const normalized = key.normalize('NFKC')
+  if (
+    normalized !== key &&
+    (normalized.includes('..') ||
+      normalized.includes('/') ||
+      normalized.includes('\\') ||
+      normalized.includes('\0'))
+  ) {
+    throw new PathTraversalError(
+      `Unicode-normalized traversal in path key: "${key}"`,
+    )
+  }
+  // Reject backslashes (Windows path separator used as traversal vector)
+  if (key.includes('\\')) {
+    throw new PathTraversalError(`Backslash in path key: "${key}"`)
+  }
+  // Reject absolute paths
+  if (key.startsWith('/')) {
+    throw new PathTraversalError(`Absolute path key: "${key}"`)
+  }
+  return key
+}
+
+/**
+ * Whether team memory features are enabled.
+ * Team memory is a subdirectory of auto memory, so it requires auto memory
+ * to be enabled. This keeps all team-memory consumers (prompt, content
+ * injection, sync watcher, file detection) consistent when auto memory is
+ * disabled via env var or settings.
+ */
+export function isTeamMemoryEnabled(): boolean {
+  if (!isAutoMemoryEnabled()) {
+    return false
+  }
+  return getFeatureValue_CACHED_MAY_BE_STALE('tengu_herring_clock', false)
+}
+
+/**
+ * Returns the team memory path: <memoryBase>/projects/<sanitized-project-root>/memory/team/
+ * Lives as a subdirectory of the auto-memory directory, scoped per-project.
+ */
+export function getTeamMemPath(): string {
+  return (join(getAutoMemPath(), 'team') + sep).normalize('NFC')
+}
+
+/**
+ * Returns the team memory entrypoint: <memoryBase>/projects/<sanitized-project-root>/memory/team/MEMORY.md
+ * Lives as a subdirectory of the auto-memory directory, scoped per-project.
+ */
+export function getTeamMemEntrypoint(): string {
+  return join(getAutoMemPath(), 'team', 'MEMORY.md')
+}
+
+/**
+ * Resolve symlinks for the deepest existing ancestor of a path.
+ * The target file may not exist yet (we may be about to create it), so we
+ * walk up the directory tree until realpath() succeeds, then rejoin the
+ * non-existing tail onto the resolved ancestor.
+ *
+ * SECURITY (PSR M22186): path.resolve() does NOT resolve symlinks. An attacker
+ * who can place a symlink inside teamDir pointing outside (e.g. to
+ * ~/.ssh/authorized_keys) would pass a resolve()-based containment check.
+ * Using realpath() on the deepest existing ancestor ensures we compare the
+ * actual filesystem location, not the symbolic path.
+ *
+ */
+async function realpathDeepestExisting(absolutePath: string): Promise<string> {
+  const tail: string[] = []
+  let current = absolutePath
+  // Walk up until realpath succeeds. ENOENT means this segment doesn't exist
+  // yet; pop it onto the tail and try the parent. ENOTDIR means a non-directory
+  // component sits in the middle of the path; pop and retry so we can realpath
+  // the ancestor to detect symlink escapes.
+  // Loop terminates when we reach the filesystem root (dirname('/') === '/').
+  for (
+    let parent = dirname(current);
+    current !== parent;
+    parent = dirname(current)
+  ) {
+    try {
+      const realCurrent = await realpath(current)
+      // Rejoin the non-existing tail in reverse order (deepest popped first)
+      return tail.length === 0
+        ? realCurrent
+        : join(realCurrent, ...tail.reverse())
+    } catch (e: unknown) {
+      const code = getErrnoCode(e)
+      if (code === 'ENOENT') {
+        // Could be truly non-existent (safe to walk up) OR a dangling symlink
+        // whose target doesn't exist. Dangling symlinks are an attack vector:
+        // writeFile would follow the link and create the target outside teamDir.
+        // lstat distinguishes: it succeeds for dangling symlinks (the link entry
+        // itself exists), fails with ENOENT for truly non-existent paths.
+        try {
+          const st = await lstat(current)
+          if (st.isSymbolicLink()) {
+            throw new PathTraversalError(
+              `Dangling symlink detected (target does not exist): "${current}"`,
+            )
+          }
+          // lstat succeeded but isn't a symlink — ENOENT from realpath was
+          // caused by a dangling symlink in an ancestor. Walk up to find it.
+        } catch (lstatErr: unknown) {
+          if (lstatErr instanceof PathTraversalError) {
+            throw lstatErr
+          }
+          // lstat also failed (truly non-existent or inaccessible) — safe to walk up.
+        }
+      } else if (code === 'ELOOP') {
+        // Symlink loop — corrupted or malicious filesystem state.
+        throw new PathTraversalError(
+          `Symlink loop detected in path: "${current}"`,
+        )
+      } else if (code !== 'ENOTDIR' && code !== 'ENAMETOOLONG') {
+        // EACCES, EIO, etc. — cannot verify containment. Fail closed by wrapping
+        // as PathTraversalError so the caller can skip this entry gracefully
+        // instead of aborting the entire batch.
+        throw new PathTraversalError(
+          `Cannot verify path containment (${code}): "${current}"`,
+        )
+      }
+      tail.push(current.slice(parent.length + sep.length))
+      current = parent
+    }
+  }
+  // Reached filesystem root without finding an existing ancestor (rare —
+  // root normally exists). Fall back to the input; containment check will reject.
+  return absolutePath
+}
+
+/**
+ * Check whether a real (symlink-resolved) path is within the real team
+ * memory directory. Both sides are realpath'd so the comparison is between
+ * canonical filesystem locations.
+ *
+ * If teamDir does not exist, returns true (skips the check). This is safe:
+ * a symlink escape requires a pre-existing symlink inside teamDir, which
+ * requires teamDir to exist. If there's no directory, there's no symlink,
+ * and the first-pass string-level containment check is sufficient.
+ */
+async function isRealPathWithinTeamDir(
+  realCandidate: string,
+): Promise<boolean> {
+  let realTeamDir: string
+  try {
+    // getTeamMemPath() includes a trailing separator; strip it because
+    // realpath() rejects trailing separators on some platforms.
+    realTeamDir = await realpath(getTeamMemPath().replace(/[/\\]+$/, ''))
+  } catch (e: unknown) {
+    const code = getErrnoCode(e)
+    if (code === 'ENOENT' || code === 'ENOTDIR') {
+      // Team dir doesn't exist — symlink escape impossible, skip check.
+      return true
+    }
+    // Unexpected error (EACCES, EIO) — fail closed.
+    return false
+  }
+  if (realCandidate === realTeamDir) {
+    return true
+  }
+  // Prefix-attack protection: require separator after the prefix so that
+  // "/foo/team-evil" doesn't match "/foo/team".
+  return realCandidate.startsWith(realTeamDir + sep)
+}
+
+/**
+ * Check if a resolved absolute path is within the team memory directory.
+ * Uses path.resolve() to convert relative paths and eliminate traversal segments.
+ * Does NOT resolve symlinks — for write validation use validateTeamMemWritePath()
+ * or validateTeamMemKey() which include symlink resolution.
+ */
+export function isTeamMemPath(filePath: string): boolean {
+  // SECURITY: resolve() converts to absolute and eliminates .. segments,
+  // preventing path traversal attacks (e.g. "team/../../etc/passwd")
+  const resolvedPath = resolve(filePath)
+  const teamDir = getTeamMemPath()
+  return resolvedPath.startsWith(teamDir)
+}
+
+/**
+ * Validate that an absolute file path is safe for writing to the team memory directory.
+ * Returns the resolved absolute path if valid.
+ * Throws PathTraversalError if the path contains injection vectors, escapes the
+ * directory via .. segments, or escapes via a symlink (PSR M22186).
+ */
+export async function validateTeamMemWritePath(
+  filePath: string,
+): Promise<string> {
+  if (filePath.includes('\0')) {
+    throw new PathTraversalError(`Null byte in path: "${filePath}"`)
+  }
+  // First pass: normalize .. segments and check string-level containment.
+  // This is a fast rejection for obvious traversal attempts before we touch
+  // the filesystem.
+  const resolvedPath = resolve(filePath)
+  const teamDir = getTeamMemPath()
+  // Prefix attack protection: teamDir already ends with sep (from getTeamMemPath),
+  // so "team-evil/" won't match "team/"
+  if (!resolvedPath.startsWith(teamDir)) {
+    throw new PathTraversalError(
+      `Path escapes team memory directory: "${filePath}"`,
+    )
+  }
+  // Second pass: resolve symlinks on the deepest existing ancestor and verify
+  // the real path is still within the real team dir. This catches symlink-based
+  // escapes that path.resolve() alone cannot detect.
+  const realPath = await realpathDeepestExisting(resolvedPath)
+  if (!(await isRealPathWithinTeamDir(realPath))) {
+    throw new PathTraversalError(
+      `Path escapes team memory directory via symlink: "${filePath}"`,
+    )
+  }
+  return resolvedPath
+}
+
+/**
+ * Validate a relative path key from the server against the team memory directory.
+ * Sanitizes the key, joins with the team dir, resolves symlinks on the deepest
+ * existing ancestor, and verifies containment against the real team dir.
+ * Returns the resolved absolute path.
+ * Throws PathTraversalError if the key is malicious (PSR M22186).
+ */
+export async function validateTeamMemKey(relativeKey: string): Promise<string> {
+  sanitizePathKey(relativeKey)
+  const teamDir = getTeamMemPath()
+  const fullPath = join(teamDir, relativeKey)
+  // First pass: normalize .. segments and check string-level containment.
+  const resolvedPath = resolve(fullPath)
+  if (!resolvedPath.startsWith(teamDir)) {
+    throw new PathTraversalError(
+      `Key escapes team memory directory: "${relativeKey}"`,
+    )
+  }
+  // Second pass: resolve symlinks and verify real containment.
+  const realPath = await realpathDeepestExisting(resolvedPath)
+  if (!(await isRealPathWithinTeamDir(realPath))) {
+    throw new PathTraversalError(
+      `Key escapes team memory directory via symlink: "${relativeKey}"`,
+    )
+  }
+  return resolvedPath
+}
+
+/**
+ * Check if a file path is within the team memory directory
+ * and team memory is enabled.
+ */
+export function isTeamMemFile(filePath: string): boolean {
+  return isTeamMemoryEnabled() && isTeamMemPath(filePath)
+}

src/memdir/teamMemPrompts.ts

@@ -0,0 +1,100 @@
+import {
+  buildSearchingPastContextSection,
+  DIRS_EXIST_GUIDANCE,
+  ENTRYPOINT_NAME,
+  MAX_ENTRYPOINT_LINES,
+} from './memdir.js'
+import {
+  MEMORY_DRIFT_CAVEAT,
+  MEMORY_FRONTMATTER_EXAMPLE,
+  TRUSTING_RECALL_SECTION,
+  TYPES_SECTION_COMBINED,
+  WHAT_NOT_TO_SAVE_SECTION,
+} from './memoryTypes.js'
+import { getAutoMemPath } from './paths.js'
+import { getTeamMemPath } from './teamMemPaths.js'
+
+/**
+ * Build the combined prompt when both auto memory and team memory are enabled.
+ * Closed four-type taxonomy (user / feedback / project / reference) with
+ * per-type <scope> guidance embedded in XML-style <type> blocks.
+ */
+export function buildCombinedMemoryPrompt(
+  extraGuidelines?: string[],
+  skipIndex = false,
+): string {
+  const autoDir = getAutoMemPath()
+  const teamDir = getTeamMemPath()
+
+  const howToSave = skipIndex
+    ? [
+        '## How to save memories',
+        '',
+        "Write each memory to its own file in the chosen directory (private or team, per the type's scope guidance) using this frontmatter format:",
+        '',
+        ...MEMORY_FRONTMATTER_EXAMPLE,
+        '',
+        '- Keep the name, description, and type fields in memory files up-to-date with the content',
+        '- Organize memory semantically by topic, not chronologically',
+        '- Update or remove memories that turn out to be wrong or outdated',
+        '- Do not write duplicate memories. First check if there is an existing memory you can update before writing a new one.',
+      ]
+    : [
+        '## How to save memories',
+        '',
+        'Saving a memory is a two-step process:',
+        '',
+        "**Step 1** — write the memory to its own file in the chosen directory (private or team, per the type's scope guidance) using this frontmatter format:",
+        '',
+        ...MEMORY_FRONTMATTER_EXAMPLE,
+        '',
+        `**Step 2** — add a pointer to that file in the same directory's \`${ENTRYPOINT_NAME}\`. Each directory (private and team) has its own \`${ENTRYPOINT_NAME}\` index — each entry should be one line, under ~150 characters: \`- [Title](file.md) — one-line hook\`. They have no frontmatter. Never write memory content directly into a \`${ENTRYPOINT_NAME}\`.`,
+        '',
+        `- Both \`${ENTRYPOINT_NAME}\` indexes are loaded into your conversation context — lines after ${MAX_ENTRYPOINT_LINES} will be truncated, so keep them concise`,
+        '- Keep the name, description, and type fields in memory files up-to-date with the content',
+        '- Organize memory semantically by topic, not chronologically',
+        '- Update or remove memories that turn out to be wrong or outdated',
+        '- Do not write duplicate memories. First check if there is an existing memory you can update before writing a new one.',
+      ]
+
+  const lines = [
+    '# Memory',
+    '',
+    `You have a persistent, file-based memory system with two directories: a private directory at \`${autoDir}\` and a shared team directory at \`${teamDir}\`. ${DIRS_EXIST_GUIDANCE}`,
+    '',
+    "You should build up this memory system over time so that future conversations can have a complete picture of who the user is, how they'd like to collaborate with you, what behaviors to avoid or repeat, and the context behind the work the user gives you.",
+    '',
+    'If the user explicitly asks you to remember something, save it immediately as whichever type fits best. If they ask you to forget something, find and remove the relevant entry.',
+    '',
+    '## Memory scope',
+    '',
+    'There are two scope levels:',
+    '',
+    `- private: memories that are private between you and the current user. They persist across conversations with only this specific user and are stored at the root \`${autoDir}\`.`,
+    `- team: memories that are shared with and contributed by all of the users who work within this project directory. Team memories are synced at the beginning of every session and they are stored at \`${teamDir}\`.`,
+    '',
+    ...TYPES_SECTION_COMBINED,
+    ...WHAT_NOT_TO_SAVE_SECTION,
+    '- You MUST avoid saving sensitive data within shared team memories. For example, never save API keys or user credentials.',
+    '',
+    ...howToSave,
+    '',
+    '## When to access memories',
+    '- When memories (personal or team) seem relevant, or the user references prior work with them or others in their organization.',
+    '- You MUST access memory when the user explicitly asks you to check, recall, or remember.',
+    '- If the user says to *ignore* or *not use* memory: proceed as if MEMORY.md were empty. Do not apply remembered facts, cite, compare against, or mention memory content.',
+    MEMORY_DRIFT_CAVEAT,
+    '',
+    ...TRUSTING_RECALL_SECTION,
+    '',
+    '## Memory and other forms of persistence',
+    'Memory is one of several persistence mechanisms available to you as you assist the user in a given conversation. The distinction is often that memory can be recalled in future conversations and should not be used for persisting information that is only useful within the scope of the current conversation.',
+    '- When to use or update a plan instead of memory: If you are about to start a non-trivial implementation task and would like to reach alignment with the user on your approach you should use a Plan rather than saving this information to memory. Similarly, if you already have a plan within the conversation and you have changed your approach persist that change by updating the plan rather than saving a memory.',
+    '- When to use or update tasks instead of memory: When you need to break your work in current conversation into discrete steps or keep track of your progress use tasks instead of saving to memory. Tasks are great for persisting information about the work that needs to be done in the current conversation, but memory should be reserved for information that will be useful in future conversations.',
+    ...(extraGuidelines ?? []),
+    '',
+    ...buildSearchingPastContextSection(autoDir),
+  ]
+
+  return lines.join('\n')
+}

src/migrations/migrateBypassPermissionsAcceptedToSettings.ts

@@ -0,0 +1,40 @@
+import { logEvent } from 'src/services/analytics/index.js'
+import { getGlobalConfig, saveGlobalConfig } from '../utils/config.js'
+import { logError } from '../utils/log.js'
+import {
+  hasSkipDangerousModePermissionPrompt,
+  updateSettingsForSource,
+} from '../utils/settings/settings.js'
+
+/**
+ * Migration: Move bypassPermissionsModeAccepted from global config to settings.json
+ * as skipDangerousModePermissionPrompt. This is a better home since settings.json
+ * is the user-configurable settings file.
+ */
+export function migrateBypassPermissionsAcceptedToSettings(): void {
+  const globalConfig = getGlobalConfig()
+
+  if (!globalConfig.bypassPermissionsModeAccepted) {
+    return
+  }
+
+  try {
+    if (!hasSkipDangerousModePermissionPrompt()) {
+      updateSettingsForSource('userSettings', {
+        skipDangerousModePermissionPrompt: true,
+      })
+    }
+
+    logEvent('tengu_migrate_bypass_permissions_accepted', {})
+
+    saveGlobalConfig(current => {
+      if (!('bypassPermissionsModeAccepted' in current)) return current
+      const { bypassPermissionsModeAccepted: _, ...updatedConfig } = current
+      return updatedConfig
+    })
+  } catch (error) {
+    logError(
+      new Error(`Failed to migrate bypass permissions accepted: ${error}`),
+    )
+  }
+}

src/migrations/migrateEnableAllProjectMcpServersToSettings.ts

@@ -0,0 +1,118 @@
+import { logEvent } from 'src/services/analytics/index.js'
+import {
+  getCurrentProjectConfig,
+  saveCurrentProjectConfig,
+} from '../utils/config.js'
+import { logError } from '../utils/log.js'
+import {
+  getSettingsForSource,
+  updateSettingsForSource,
+} from '../utils/settings/settings.js'
+
+/**
+ * Migration: Move MCP server approval fields from project config to local settings
+ * This migrates both enableAllProjectMcpServers and enabledMcpjsonServers to the
+ * settings system for better management and consistency.
+ */
+export function migrateEnableAllProjectMcpServersToSettings(): void {
+  const projectConfig = getCurrentProjectConfig()
+
+  // Check if any field exists in project config
+  const hasEnableAll = projectConfig.enableAllProjectMcpServers !== undefined
+  const hasEnabledServers =
+    projectConfig.enabledMcpjsonServers &&
+    projectConfig.enabledMcpjsonServers.length > 0
+  const hasDisabledServers =
+    projectConfig.disabledMcpjsonServers &&
+    projectConfig.disabledMcpjsonServers.length > 0
+
+  if (!hasEnableAll && !hasEnabledServers && !hasDisabledServers) {
+    return
+  }
+
+  try {
+    const existingSettings = getSettingsForSource('localSettings') || {}
+    const updates: Partial<{
+      enableAllProjectMcpServers: boolean
+      enabledMcpjsonServers: string[]
+      disabledMcpjsonServers: string[]
+    }> = {}
+    const fieldsToRemove: Array<
+      | 'enableAllProjectMcpServers'
+      | 'enabledMcpjsonServers'
+      | 'disabledMcpjsonServers'
+    > = []
+
+    // Migrate enableAllProjectMcpServers if it exists and hasn't been migrated
+    if (
+      hasEnableAll &&
+      existingSettings.enableAllProjectMcpServers === undefined
+    ) {
+      updates.enableAllProjectMcpServers =
+        projectConfig.enableAllProjectMcpServers
+      fieldsToRemove.push('enableAllProjectMcpServers')
+    } else if (hasEnableAll) {
+      // Already migrated, just mark for removal
+      fieldsToRemove.push('enableAllProjectMcpServers')
+    }
+
+    // Migrate enabledMcpjsonServers if it exists
+    if (hasEnabledServers && projectConfig.enabledMcpjsonServers) {
+      const existingEnabledServers =
+        existingSettings.enabledMcpjsonServers || []
+      // Merge the servers (avoiding duplicates)
+      updates.enabledMcpjsonServers = [
+        ...new Set([
+          ...existingEnabledServers,
+          ...projectConfig.enabledMcpjsonServers,
+        ]),
+      ]
+      fieldsToRemove.push('enabledMcpjsonServers')
+    }
+
+    // Migrate disabledMcpjsonServers if it exists
+    if (hasDisabledServers && projectConfig.disabledMcpjsonServers) {
+      const existingDisabledServers =
+        existingSettings.disabledMcpjsonServers || []
+      // Merge the servers (avoiding duplicates)
+      updates.disabledMcpjsonServers = [
+        ...new Set([
+          ...existingDisabledServers,
+          ...projectConfig.disabledMcpjsonServers,
+        ]),
+      ]
+      fieldsToRemove.push('disabledMcpjsonServers')
+    }
+
+    // Update settings if there are any updates
+    if (Object.keys(updates).length > 0) {
+      updateSettingsForSource('localSettings', updates)
+    }
+
+    // Remove migrated fields from project config
+    if (
+      fieldsToRemove.includes('enableAllProjectMcpServers') ||
+      fieldsToRemove.includes('enabledMcpjsonServers') ||
+      fieldsToRemove.includes('disabledMcpjsonServers')
+    ) {
+      saveCurrentProjectConfig(current => {
+        const {
+          enableAllProjectMcpServers: _enableAll,
+          enabledMcpjsonServers: _enabledServers,
+          disabledMcpjsonServers: _disabledServers,
+          ...configWithoutFields
+        } = current
+        return configWithoutFields
+      })
+    }
+
+    // Log the migration event
+    logEvent('tengu_migrate_mcp_approval_fields_success', {
+      migratedCount: fieldsToRemove.length,
+    })
+  } catch (e: unknown) {
+    // Log migration failure but don't throw to avoid breaking startup
+    logError(e)
+    logEvent('tengu_migrate_mcp_approval_fields_error', {})
+  }
+}

src/migrations/migrateFennecToOpus.ts

@@ -0,0 +1,45 @@
+import {
+  getSettingsForSource,
+  updateSettingsForSource,
+} from '../utils/settings/settings.js'
+
+/**
+ * Migrate users on removed fennec model aliases to their new Opus 4.6 aliases.
+ * - fennec-latest → opus
+ * - fennec-latest[1m] → opus[1m]
+ * - fennec-fast-latest → opus[1m] + fast mode
+ * - opus-4-5-fast → opus + fast mode
+ *
+ * Only touches userSettings. Reading and writing the same source keeps this
+ * idempotent without a completion flag. Fennec aliases in project/local/policy
+ * settings are left alone — we can't rewrite those, and reading merged
+ * settings here would cause infinite re-runs + silent global promotion.
+ */
+export function migrateFennecToOpus(): void {
+  if (process.env.USER_TYPE !== 'ant') {
+    return
+  }
+
+  const settings = getSettingsForSource('userSettings')
+
+  const model = settings?.model
+  if (typeof model === 'string') {
+    if (model.startsWith('fennec-latest[1m]')) {
+      updateSettingsForSource('userSettings', {
+        model: 'opus[1m]',
+      })
+    } else if (model.startsWith('fennec-latest')) {
+      updateSettingsForSource('userSettings', {
+        model: 'opus',
+      })
+    } else if (
+      model.startsWith('fennec-fast-latest') ||
+      model.startsWith('opus-4-5-fast')
+    ) {
+      updateSettingsForSource('userSettings', {
+        model: 'opus[1m]',
+        fastMode: true,
+      })
+    }
+  }
+}

src/migrations/migrateLegacyOpusToCurrent.ts

@@ -0,0 +1,57 @@
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../services/analytics/index.js'
+import { saveGlobalConfig } from '../utils/config.js'
+import { isLegacyModelRemapEnabled } from '../utils/model/model.js'
+import { getAPIProvider } from '../utils/model/providers.js'
+import {
+  getSettingsForSource,
+  updateSettingsForSource,
+} from '../utils/settings/settings.js'
+
+/**
+ * Migrate first-party users off explicit Opus 4.0/4.1 model strings.
+ *
+ * The 'opus' alias already resolves to Opus 4.6 for 1P, so anyone still
+ * on an explicit 4.0/4.1 string pinned it in settings before 4.5 launched.
+ * parseUserSpecifiedModel now silently remaps these at runtime anyway —
+ * this migration cleans up the settings file so /model shows the right
+ * thing, and sets a timestamp so the REPL can show a one-time notification.
+ *
+ * Only touches userSettings. Legacy strings in project/local/policy settings
+ * are left alone (we can't/shouldn't rewrite those) and are still remapped at
+ * runtime by parseUserSpecifiedModel. Reading and writing the same source
+ * keeps this idempotent without a completion flag, and avoids silently
+ * promoting 'opus' to the global default for users who only pinned it in one
+ * project.
+ */
+export function migrateLegacyOpusToCurrent(): void {
+  if (getAPIProvider() !== 'firstParty') {
+    return
+  }
+
+  if (!isLegacyModelRemapEnabled()) {
+    return
+  }
+
+  const model = getSettingsForSource('userSettings')?.model
+  if (
+    model !== 'claude-opus-4-20250514' &&
+    model !== 'claude-opus-4-1-20250805' &&
+    model !== 'claude-opus-4-0' &&
+    model !== 'claude-opus-4-1'
+  ) {
+    return
+  }
+
+  updateSettingsForSource('userSettings', { model: 'opus' })
+  saveGlobalConfig(current => ({
+    ...current,
+    legacyOpusMigrationTimestamp: Date.now(),
+  }))
+  logEvent('tengu_legacy_opus_migration', {
+    from_model:
+      model as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  })
+}

src/migrations/migrateOpusToOpus1m.ts

@@ -0,0 +1,43 @@
+import { logEvent } from '../services/analytics/index.js'
+import {
+  getDefaultMainLoopModelSetting,
+  isOpus1mMergeEnabled,
+  parseUserSpecifiedModel,
+} from '../utils/model/model.js'
+import {
+  getSettingsForSource,
+  updateSettingsForSource,
+} from '../utils/settings/settings.js'
+
+/**
+ * Migrate users with 'opus' pinned in their settings to 'opus[1m]' when they
+ * are eligible for the merged Opus 1M experience (Max/Team Premium on 1P).
+ *
+ * CLI invocations with --model opus are unaffected: that flag is a runtime
+ * override and does not touch userSettings, so it continues to use plain Opus.
+ *
+ * Pro subscribers are skipped — they retain separate Opus and Opus 1M options.
+ * 3P users are skipped — their model strings are full model IDs, not aliases.
+ *
+ * Idempotent: only writes if userSettings.model is exactly 'opus'.
+ */
+export function migrateOpusToOpus1m(): void {
+  if (!isOpus1mMergeEnabled()) {
+    return
+  }
+
+  const model = getSettingsForSource('userSettings')?.model
+  if (model !== 'opus') {
+    return
+  }
+
+  const migrated = 'opus[1m]'
+  const modelToSet =
+    parseUserSpecifiedModel(migrated) ===
+    parseUserSpecifiedModel(getDefaultMainLoopModelSetting())
+      ? undefined
+      : migrated
+  updateSettingsForSource('userSettings', { model: modelToSet })
+
+  logEvent('tengu_opus_to_opus1m_migration', {})
+}

src/migrations/migrateReplBridgeEnabledToRemoteControlAtStartup.ts

@@ -0,0 +1,22 @@
+import { saveGlobalConfig } from '../utils/config.js'
+
+/**
+ * Migrate the `replBridgeEnabled` config key to `remoteControlAtStartup`.
+ *
+ * The old key was an implementation detail that leaked into user-facing config.
+ * This migration copies the value to the new key and removes the old one.
+ * Idempotent — only acts when the old key exists and the new one doesn't.
+ */
+export function migrateReplBridgeEnabledToRemoteControlAtStartup(): void {
+  saveGlobalConfig(prev => {
+    // The old key is no longer in the GlobalConfig type, so access it via
+    // an untyped cast. Only migrate if the old key exists and the new key
+    // hasn't been set yet.
+    const oldValue = (prev as Record<string, unknown>)['replBridgeEnabled']
+    if (oldValue === undefined) return prev
+    if (prev.remoteControlAtStartup !== undefined) return prev
+    const next = { ...prev, remoteControlAtStartup: Boolean(oldValue) }
+    delete (next as Record<string, unknown>)['replBridgeEnabled']
+    return next
+  })
+}

src/migrations/migrateSonnet1mToSonnet45.ts

@@ -0,0 +1,48 @@
+import {
+  getMainLoopModelOverride,
+  setMainLoopModelOverride,
+} from '../bootstrap/state.js'
+import { getGlobalConfig, saveGlobalConfig } from '../utils/config.js'
+import {
+  getSettingsForSource,
+  updateSettingsForSource,
+} from '../utils/settings/settings.js'
+
+/**
+ * Migrate users who had "sonnet[1m]" saved to the explicit "sonnet-4-5-20250929[1m]".
+ *
+ * The "sonnet" alias now resolves to Sonnet 4.6, so users who previously set
+ * "sonnet[1m]" (targeting Sonnet 4.5 with 1M context) need to be pinned to the
+ * explicit version to preserve their intended model.
+ *
+ * This is needed because Sonnet 4.6 1M was offered to a different group of users than
+ * Sonnet 4.5 1M, so we needed to pin existing sonnet[1m] users to Sonnet 4.5 1M.
+ *
+ * Reads from userSettings specifically (not merged settings) so we don't
+ * promote a project-scoped "sonnet[1m]" to the global default. Runs once,
+ * tracked by a completion flag in global config.
+ */
+export function migrateSonnet1mToSonnet45(): void {
+  const config = getGlobalConfig()
+  if (config.sonnet1m45MigrationComplete) {
+    return
+  }
+
+  const model = getSettingsForSource('userSettings')?.model
+  if (model === 'sonnet[1m]') {
+    updateSettingsForSource('userSettings', {
+      model: 'sonnet-4-5-20250929[1m]',
+    })
+  }
+
+  // Also migrate the in-memory override if already set
+  const override = getMainLoopModelOverride()
+  if (override === 'sonnet[1m]') {
+    setMainLoopModelOverride('sonnet-4-5-20250929[1m]')
+  }
+
+  saveGlobalConfig(current => ({
+    ...current,
+    sonnet1m45MigrationComplete: true,
+  }))
+}

src/migrations/migrateSonnet45ToSonnet46.ts

@@ -0,0 +1,67 @@
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../services/analytics/index.js'
+import {
+  isMaxSubscriber,
+  isProSubscriber,
+  isTeamPremiumSubscriber,
+} from '../utils/auth.js'
+import { getGlobalConfig, saveGlobalConfig } from '../utils/config.js'
+import { getAPIProvider } from '../utils/model/providers.js'
+import {
+  getSettingsForSource,
+  updateSettingsForSource,
+} from '../utils/settings/settings.js'
+
+/**
+ * Migrate Pro/Max/Team Premium first-party users off explicit Sonnet 4.5
+ * model strings to the 'sonnet' alias (which now resolves to Sonnet 4.6).
+ *
+ * Users may have been pinned to explicit Sonnet 4.5 strings by:
+ * - The earlier migrateSonnet1mToSonnet45 migration (sonnet[1m] → explicit 4.5[1m])
+ * - Manually selecting it via /model
+ *
+ * Reads userSettings specifically (not merged) so we only migrate what /model
+ * wrote — project/local pins are left alone.
+ * Idempotent: only writes if userSettings.model matches a Sonnet 4.5 string.
+ */
+export function migrateSonnet45ToSonnet46(): void {
+  if (getAPIProvider() !== 'firstParty') {
+    return
+  }
+
+  if (!isProSubscriber() && !isMaxSubscriber() && !isTeamPremiumSubscriber()) {
+    return
+  }
+
+  const model = getSettingsForSource('userSettings')?.model
+  if (
+    model !== 'claude-sonnet-4-5-20250929' &&
+    model !== 'claude-sonnet-4-5-20250929[1m]' &&
+    model !== 'sonnet-4-5-20250929' &&
+    model !== 'sonnet-4-5-20250929[1m]'
+  ) {
+    return
+  }
+
+  const has1m = model.endsWith('[1m]')
+  updateSettingsForSource('userSettings', {
+    model: has1m ? 'sonnet[1m]' : 'sonnet',
+  })
+
+  // Skip notification for brand-new users — they never experienced the old default
+  const config = getGlobalConfig()
+  if (config.numStartups > 1) {
+    saveGlobalConfig(current => ({
+      ...current,
+      sonnet45To46MigrationTimestamp: Date.now(),
+    }))
+  }
+
+  logEvent('tengu_sonnet45_to_46_migration', {
+    from_model:
+      model as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    has_1m: has1m,
+  })
+}

src/migrations/resetAutoModeOptInForDefaultOffer.ts

@@ -0,0 +1,51 @@
+import { feature } from 'bun:bundle'
+import { logEvent } from 'src/services/analytics/index.js'
+import { getGlobalConfig, saveGlobalConfig } from '../utils/config.js'
+import { logError } from '../utils/log.js'
+import { getAutoModeEnabledState } from '../utils/permissions/permissionSetup.js'
+import {
+  getSettingsForSource,
+  updateSettingsForSource,
+} from '../utils/settings/settings.js'
+
+/**
+ * One-shot migration: clear skipAutoPermissionPrompt for users who accepted
+ * the old 2-option AutoModeOptInDialog but don't have auto as their default.
+ * Re-surfaces the dialog so they see the new "make it my default mode" option.
+ * Guard lives in GlobalConfig (~/.claude.json), not settings.json, so it
+ * survives settings resets and doesn't re-arm itself.
+ *
+ * Only runs when tengu_auto_mode_config.enabled === 'enabled'. For 'opt-in'
+ * users, clearing skipAutoPermissionPrompt would remove auto from the carousel
+ * (permissionSetup.ts:988) — the dialog would become unreachable and the
+ * migration would defeat itself. In practice the ~40 target ants are all
+ * 'enabled' (they reached the old dialog via bare Shift+Tab, which requires
+ * 'enabled'), but the guard makes it safe regardless.
+ */
+export function resetAutoModeOptInForDefaultOffer(): void {
+  if (feature('TRANSCRIPT_CLASSIFIER')) {
+    const config = getGlobalConfig()
+    if (config.hasResetAutoModeOptInForDefaultOffer) return
+    if (getAutoModeEnabledState() !== 'enabled') return
+
+    try {
+      const user = getSettingsForSource('userSettings')
+      if (
+        user?.skipAutoPermissionPrompt &&
+        user?.permissions?.defaultMode !== 'auto'
+      ) {
+        updateSettingsForSource('userSettings', {
+          skipAutoPermissionPrompt: undefined,
+        })
+        logEvent('tengu_migrate_reset_auto_opt_in_for_default_offer', {})
+      }
+
+      saveGlobalConfig(c => {
+        if (c.hasResetAutoModeOptInForDefaultOffer) return c
+        return { ...c, hasResetAutoModeOptInForDefaultOffer: true }
+      })
+    } catch (error) {
+      logError(new Error(`Failed to reset auto mode opt-in: ${error}`))
+    }
+  }
+}

src/moreright/useMoreRight.tsx

@@ -0,0 +1,26 @@
+// Stub for external builds — the real hook is internal only.
+//
+// Self-contained: no relative imports. Typecheck sees this file at
+// scripts/external-stubs/src/moreright/ before overlay, where ../types/
+// would resolve to scripts/external-stubs/src/types/ (doesn't exist).
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type M = any;
+export function useMoreRight(_args: {
+  enabled: boolean;
+  setMessages: (action: M[] | ((prev: M[]) => M[])) => void;
+  inputValue: string;
+  setInputValue: (s: string) => void;
+  setToolJSX: (args: M) => void;
+}): {
+  onBeforeQuery: (input: string, all: M[], n: number) => Promise<boolean>;
+  onTurnComplete: (all: M[], aborted: boolean) => Promise<void>;
+  render: () => null;
+} {
+  return {
+    onBeforeQuery: async () => true,
+    onTurnComplete: async () => {},
+    render: () => null
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

src/outputStyles/loadOutputStylesDir.ts

@@ -0,0 +1,98 @@
+import memoize from 'lodash-es/memoize.js'
+import { basename } from 'path'
+import type { OutputStyleConfig } from '../constants/outputStyles.js'
+import { logForDebugging } from '../utils/debug.js'
+import { coerceDescriptionToString } from '../utils/frontmatterParser.js'
+import { logError } from '../utils/log.js'
+import {
+  extractDescriptionFromMarkdown,
+  loadMarkdownFilesForSubdir,
+} from '../utils/markdownConfigLoader.js'
+import { clearPluginOutputStyleCache } from '../utils/plugins/loadPluginOutputStyles.js'
+
+/**
+ * Loads markdown files from .claude/output-styles directories throughout the project
+ * and from ~/.claude/output-styles directory and converts them to output styles.
+ *
+ * Each filename becomes a style name, and the file content becomes the style prompt.
+ * The frontmatter provides name and description.
+ *
+ * Structure:
+ * - Project .claude/output-styles/*.md -> project styles
+ * - User ~/.claude/output-styles/*.md -> user styles (overridden by project styles)
+ *
+ * @param cwd Current working directory for project directory traversal
+ */
+export const getOutputStyleDirStyles = memoize(
+  async (cwd: string): Promise<OutputStyleConfig[]> => {
+    try {
+      const markdownFiles = await loadMarkdownFilesForSubdir(
+        'output-styles',
+        cwd,
+      )
+
+      const styles = markdownFiles
+        .map(({ filePath, frontmatter, content, source }) => {
+          try {
+            const fileName = basename(filePath)
+            const styleName = fileName.replace(/\.md$/, '')
+
+            // Get style configuration from frontmatter
+            const name = (frontmatter['name'] || styleName) as string
+            const description =
+              coerceDescriptionToString(
+                frontmatter['description'],
+                styleName,
+              ) ??
+              extractDescriptionFromMarkdown(
+                content,
+                `Custom ${styleName} output style`,
+              )
+
+            // Parse keep-coding-instructions flag (supports both boolean and string values)
+            const keepCodingInstructionsRaw =
+              frontmatter['keep-coding-instructions']
+            const keepCodingInstructions =
+              keepCodingInstructionsRaw === true ||
+              keepCodingInstructionsRaw === 'true'
+                ? true
+                : keepCodingInstructionsRaw === false ||
+                    keepCodingInstructionsRaw === 'false'
+                  ? false
+                  : undefined
+
+            // Warn if force-for-plugin is set on non-plugin output style
+            if (frontmatter['force-for-plugin'] !== undefined) {
+              logForDebugging(
+                `Output style "${name}" has force-for-plugin set, but this option only applies to plugin output styles. Ignoring.`,
+                { level: 'warn' },
+              )
+            }
+
+            return {
+              name,
+              description,
+              prompt: content.trim(),
+              source,
+              keepCodingInstructions,
+            }
+          } catch (error) {
+            logError(error)
+            return null
+          }
+        })
+        .filter(style => style !== null)
+
+      return styles
+    } catch (error) {
+      logError(error)
+      return []
+    }
+  },
+)
+
+export function clearOutputStyleCaches(): void {
+  getOutputStyleDirStyles.cache?.clear?.()
+  loadMarkdownFilesForSubdir.cache?.clear?.()
+  clearPluginOutputStyleCache()
+}

src/query/deps.ts

@@ -0,0 +1,40 @@
+import { randomUUID } from 'crypto'
+import { queryModelWithStreaming } from '../services/api/claude.js'
+import { autoCompactIfNeeded } from '../services/compact/autoCompact.js'
+import { microcompactMessages } from '../services/compact/microCompact.js'
+
+// -- deps
+
+// I/O dependencies for query(). Passing a `deps` override into QueryParams
+// lets tests inject fakes directly instead of spyOn-per-module — the most
+// common mocks (callModel, autocompact) are each spied in 6-8 test files
+// today with module-import-and-spy boilerplate.
+//
+// Using `typeof fn` keeps signatures in sync with the real implementations
+// automatically. This file imports the real functions for both typing and
+// the production factory — tests that import this file for typing are
+// already importing query.ts (which imports everything), so there's no
+// new module-graph cost.
+//
+// Scope is intentionally narrow (4 deps) to prove the pattern. Followup
+// PRs can add runTools, handleStopHooks, logEvent, queue ops, etc.
+export type QueryDeps = {
+  // -- model
+  callModel: typeof queryModelWithStreaming
+
+  // -- compaction
+  microcompact: typeof microcompactMessages
+  autocompact: typeof autoCompactIfNeeded
+
+  // -- platform
+  uuid: () => string
+}
+
+export function productionDeps(): QueryDeps {
+  return {
+    callModel: queryModelWithStreaming,
+    microcompact: microcompactMessages,
+    autocompact: autoCompactIfNeeded,
+    uuid: randomUUID,
+  }
+}

src/remote/RemoteSessionManager.ts

@@ -0,0 +1,343 @@
+import type { SDKMessage } from '../entrypoints/agentSdkTypes.js'
+import type {
+  SDKControlCancelRequest,
+  SDKControlPermissionRequest,
+  SDKControlRequest,
+  SDKControlResponse,
+} from '../entrypoints/sdk/controlTypes.js'
+import { logForDebugging } from '../utils/debug.js'
+import { logError } from '../utils/log.js'
+import {
+  type RemoteMessageContent,
+  sendEventToRemoteSession,
+} from '../utils/teleport/api.js'
+import {
+  SessionsWebSocket,
+  type SessionsWebSocketCallbacks,
+} from './SessionsWebSocket.js'
+
+/**
+ * Type guard to check if a message is an SDKMessage (not a control message)
+ */
+function isSDKMessage(
+  message:
+    | SDKMessage
+    | SDKControlRequest
+    | SDKControlResponse
+    | SDKControlCancelRequest,
+): message is SDKMessage {
+  return (
+    message.type !== 'control_request' &&
+    message.type !== 'control_response' &&
+    message.type !== 'control_cancel_request'
+  )
+}
+
+/**
+ * Simple permission response for remote sessions.
+ * This is a simplified version of PermissionResult for CCR communication.
+ */
+export type RemotePermissionResponse =
+  | {
+      behavior: 'allow'
+      updatedInput: Record<string, unknown>
+    }
+  | {
+      behavior: 'deny'
+      message: string
+    }
+
+export type RemoteSessionConfig = {
+  sessionId: string
+  getAccessToken: () => string
+  orgUuid: string
+  /** True if session was created with an initial prompt that's being processed */
+  hasInitialPrompt?: boolean
+  /**
+   * When true, this client is a pure viewer. Ctrl+C/Escape do NOT send
+   * interrupt to the remote agent; 60s reconnect timeout is disabled;
+   * session title is never updated. Used by `claude assistant`.
+   */
+  viewerOnly?: boolean
+}
+
+export type RemoteSessionCallbacks = {
+  /** Called when an SDKMessage is received from the session */
+  onMessage: (message: SDKMessage) => void
+  /** Called when a permission request is received from CCR */
+  onPermissionRequest: (
+    request: SDKControlPermissionRequest,
+    requestId: string,
+  ) => void
+  /** Called when the server cancels a pending permission request */
+  onPermissionCancelled?: (
+    requestId: string,
+    toolUseId: string | undefined,
+  ) => void
+  /** Called when connection is established */
+  onConnected?: () => void
+  /** Called when connection is lost and cannot be restored */
+  onDisconnected?: () => void
+  /** Called on transient WS drop while reconnect backoff is in progress */
+  onReconnecting?: () => void
+  /** Called on error */
+  onError?: (error: Error) => void
+}
+
+/**
+ * Manages a remote CCR session.
+ *
+ * Coordinates:
+ * - WebSocket subscription for receiving messages from CCR
+ * - HTTP POST for sending user messages to CCR
+ * - Permission request/response flow
+ */
+export class RemoteSessionManager {
+  private websocket: SessionsWebSocket | null = null
+  private pendingPermissionRequests: Map<string, SDKControlPermissionRequest> =
+    new Map()
+
+  constructor(
+    private readonly config: RemoteSessionConfig,
+    private readonly callbacks: RemoteSessionCallbacks,
+  ) {}
+
+  /**
+   * Connect to the remote session via WebSocket
+   */
+  connect(): void {
+    logForDebugging(
+      `[RemoteSessionManager] Connecting to session ${this.config.sessionId}`,
+    )
+
+    const wsCallbacks: SessionsWebSocketCallbacks = {
+      onMessage: message => this.handleMessage(message),
+      onConnected: () => {
+        logForDebugging('[RemoteSessionManager] Connected')
+        this.callbacks.onConnected?.()
+      },
+      onClose: () => {
+        logForDebugging('[RemoteSessionManager] Disconnected')
+        this.callbacks.onDisconnected?.()
+      },
+      onReconnecting: () => {
+        logForDebugging('[RemoteSessionManager] Reconnecting')
+        this.callbacks.onReconnecting?.()
+      },
+      onError: error => {
+        logError(error)
+        this.callbacks.onError?.(error)
+      },
+    }
+
+    this.websocket = new SessionsWebSocket(
+      this.config.sessionId,
+      this.config.orgUuid,
+      this.config.getAccessToken,
+      wsCallbacks,
+    )
+
+    void this.websocket.connect()
+  }
+
+  /**
+   * Handle messages from WebSocket
+   */
+  private handleMessage(
+    message:
+      | SDKMessage
+      | SDKControlRequest
+      | SDKControlResponse
+      | SDKControlCancelRequest,
+  ): void {
+    // Handle control requests (permission prompts from CCR)
+    if (message.type === 'control_request') {
+      this.handleControlRequest(message)
+      return
+    }
+
+    // Handle control cancel requests (server cancelling a pending permission prompt)
+    if (message.type === 'control_cancel_request') {
+      const { request_id } = message
+      const pendingRequest = this.pendingPermissionRequests.get(request_id)
+      logForDebugging(
+        `[RemoteSessionManager] Permission request cancelled: ${request_id}`,
+      )
+      this.pendingPermissionRequests.delete(request_id)
+      this.callbacks.onPermissionCancelled?.(
+        request_id,
+        pendingRequest?.tool_use_id,
+      )
+      return
+    }
+
+    // Handle control responses (acknowledgments)
+    if (message.type === 'control_response') {
+      logForDebugging('[RemoteSessionManager] Received control response')
+      return
+    }
+
+    // Forward SDK messages to callback (type guard ensures proper narrowing)
+    if (isSDKMessage(message)) {
+      this.callbacks.onMessage(message)
+    }
+  }
+
+  /**
+   * Handle control requests from CCR (e.g., permission requests)
+   */
+  private handleControlRequest(request: SDKControlRequest): void {
+    const { request_id, request: inner } = request
+
+    if (inner.subtype === 'can_use_tool') {
+      logForDebugging(
+        `[RemoteSessionManager] Permission request for tool: ${inner.tool_name}`,
+      )
+      this.pendingPermissionRequests.set(request_id, inner)
+      this.callbacks.onPermissionRequest(inner, request_id)
+    } else {
+      // Send an error response for unrecognized subtypes so the server
+      // doesn't hang waiting for a reply that never comes.
+      logForDebugging(
+        `[RemoteSessionManager] Unsupported control request subtype: ${inner.subtype}`,
+      )
+      const response: SDKControlResponse = {
+        type: 'control_response',
+        response: {
+          subtype: 'error',
+          request_id,
+          error: `Unsupported control request subtype: ${inner.subtype}`,
+        },
+      }
+      this.websocket?.sendControlResponse(response)
+    }
+  }
+
+  /**
+   * Send a user message to the remote session via HTTP POST
+   */
+  async sendMessage(
+    content: RemoteMessageContent,
+    opts?: { uuid?: string },
+  ): Promise<boolean> {
+    logForDebugging(
+      `[RemoteSessionManager] Sending message to session ${this.config.sessionId}`,
+    )
+
+    const success = await sendEventToRemoteSession(
+      this.config.sessionId,
+      content,
+      opts,
+    )
+
+    if (!success) {
+      logError(
+        new Error(
+          `[RemoteSessionManager] Failed to send message to session ${this.config.sessionId}`,
+        ),
+      )
+    }
+
+    return success
+  }
+
+  /**
+   * Respond to a permission request from CCR
+   */
+  respondToPermissionRequest(
+    requestId: string,
+    result: RemotePermissionResponse,
+  ): void {
+    const pendingRequest = this.pendingPermissionRequests.get(requestId)
+    if (!pendingRequest) {
+      logError(
+        new Error(
+          `[RemoteSessionManager] No pending permission request with ID: ${requestId}`,
+        ),
+      )
+      return
+    }
+
+    this.pendingPermissionRequests.delete(requestId)
+
+    const response: SDKControlResponse = {
+      type: 'control_response',
+      response: {
+        subtype: 'success',
+        request_id: requestId,
+        response: {
+          behavior: result.behavior,
+          ...(result.behavior === 'allow'
+            ? { updatedInput: result.updatedInput }
+            : { message: result.message }),
+        },
+      },
+    }
+
+    logForDebugging(
+      `[RemoteSessionManager] Sending permission response: ${result.behavior}`,
+    )
+
+    this.websocket?.sendControlResponse(response)
+  }
+
+  /**
+   * Check if connected to the remote session
+   */
+  isConnected(): boolean {
+    return this.websocket?.isConnected() ?? false
+  }
+
+  /**
+   * Send an interrupt signal to cancel the current request on the remote session
+   */
+  cancelSession(): void {
+    logForDebugging('[RemoteSessionManager] Sending interrupt signal')
+    this.websocket?.sendControlRequest({ subtype: 'interrupt' })
+  }
+
+  /**
+   * Get the session ID
+   */
+  getSessionId(): string {
+    return this.config.sessionId
+  }
+
+  /**
+   * Disconnect from the remote session
+   */
+  disconnect(): void {
+    logForDebugging('[RemoteSessionManager] Disconnecting')
+    this.websocket?.close()
+    this.websocket = null
+    this.pendingPermissionRequests.clear()
+  }
+
+  /**
+   * Force reconnect the WebSocket.
+   * Useful when the subscription becomes stale after container shutdown.
+   */
+  reconnect(): void {
+    logForDebugging('[RemoteSessionManager] Reconnecting WebSocket')
+    this.websocket?.reconnect()
+  }
+}
+
+/**
+ * Create a remote session config from OAuth tokens
+ */
+export function createRemoteSessionConfig(
+  sessionId: string,
+  getAccessToken: () => string,
+  orgUuid: string,
+  hasInitialPrompt = false,
+  viewerOnly = false,
+): RemoteSessionConfig {
+  return {
+    sessionId,
+    getAccessToken,
+    orgUuid,
+    hasInitialPrompt,
+    viewerOnly,
+  }
+}

src/remote/SessionsWebSocket.ts

@@ -0,0 +1,404 @@
+import { randomUUID } from 'crypto'
+import { getOauthConfig } from '../constants/oauth.js'
+import type { SDKMessage } from '../entrypoints/agentSdkTypes.js'
+import type {
+  SDKControlCancelRequest,
+  SDKControlRequest,
+  SDKControlRequestInner,
+  SDKControlResponse,
+} from '../entrypoints/sdk/controlTypes.js'
+import { logForDebugging } from '../utils/debug.js'
+import { errorMessage } from '../utils/errors.js'
+import { logError } from '../utils/log.js'
+import { getWebSocketTLSOptions } from '../utils/mtls.js'
+import { getWebSocketProxyAgent, getWebSocketProxyUrl } from '../utils/proxy.js'
+import { jsonParse, jsonStringify } from '../utils/slowOperations.js'
+
+const RECONNECT_DELAY_MS = 2000
+const MAX_RECONNECT_ATTEMPTS = 5
+const PING_INTERVAL_MS = 30000
+
+/**
+ * Maximum retries for 4001 (session not found). During compaction the
+ * server may briefly consider the session stale; a short retry window
+ * lets the client recover without giving up permanently.
+ */
+const MAX_SESSION_NOT_FOUND_RETRIES = 3
+
+/**
+ * WebSocket close codes that indicate a permanent server-side rejection.
+ * The client stops reconnecting immediately.
+ * Note: 4001 (session not found) is handled separately with limited
+ * retries since it can be transient during compaction.
+ */
+const PERMANENT_CLOSE_CODES = new Set([
+  4003, // unauthorized
+])
+
+type WebSocketState = 'connecting' | 'connected' | 'closed'
+
+type SessionsMessage =
+  | SDKMessage
+  | SDKControlRequest
+  | SDKControlResponse
+  | SDKControlCancelRequest
+
+function isSessionsMessage(value: unknown): value is SessionsMessage {
+  if (typeof value !== 'object' || value === null || !('type' in value)) {
+    return false
+  }
+  // Accept any message with a string `type` field. Downstream handlers
+  // (sdkMessageAdapter, RemoteSessionManager) decide what to do with
+  // unknown types. A hardcoded allowlist here would silently drop new
+  // message types the backend starts sending before the client is updated.
+  return typeof value.type === 'string'
+}
+
+export type SessionsWebSocketCallbacks = {
+  onMessage: (message: SessionsMessage) => void
+  onClose?: () => void
+  onError?: (error: Error) => void
+  onConnected?: () => void
+  /** Fired when a transient close is detected and a reconnect is scheduled.
+   *  onClose fires only for permanent close (server ended / attempts exhausted). */
+  onReconnecting?: () => void
+}
+
+// Common interface between globalThis.WebSocket and ws.WebSocket
+type WebSocketLike = {
+  close(): void
+  send(data: string): void
+  ping?(): void // Bun & ws both support this
+}
+
+/**
+ * WebSocket client for connecting to CCR sessions via /v1/sessions/ws/{id}/subscribe
+ *
+ * Protocol:
+ * 1. Connect to wss://api.anthropic.com/v1/sessions/ws/{sessionId}/subscribe?organization_uuid=...
+ * 2. Send auth message: { type: 'auth', credential: { type: 'oauth', token: '...' } }
+ * 3. Receive SDKMessage stream from the session
+ */
+export class SessionsWebSocket {
+  private ws: WebSocketLike | null = null
+  private state: WebSocketState = 'closed'
+  private reconnectAttempts = 0
+  private sessionNotFoundRetries = 0
+  private pingInterval: NodeJS.Timeout | null = null
+  private reconnectTimer: NodeJS.Timeout | null = null
+
+  constructor(
+    private readonly sessionId: string,
+    private readonly orgUuid: string,
+    private readonly getAccessToken: () => string,
+    private readonly callbacks: SessionsWebSocketCallbacks,
+  ) {}
+
+  /**
+   * Connect to the sessions WebSocket endpoint
+   */
+  async connect(): Promise<void> {
+    if (this.state === 'connecting') {
+      logForDebugging('[SessionsWebSocket] Already connecting')
+      return
+    }
+
+    this.state = 'connecting'
+
+    const baseUrl = getOauthConfig().BASE_API_URL.replace('https://', 'wss://')
+    const url = `${baseUrl}/v1/sessions/ws/${this.sessionId}/subscribe?organization_uuid=${this.orgUuid}`
+
+    logForDebugging(`[SessionsWebSocket] Connecting to ${url}`)
+
+    // Get fresh token for each connection attempt
+    const accessToken = this.getAccessToken()
+    const headers = {
+      Authorization: `Bearer ${accessToken}`,
+      'anthropic-version': '2023-06-01',
+    }
+
+    if (typeof Bun !== 'undefined') {
+      // Bun's WebSocket supports headers/proxy options but the DOM typings don't
+      // eslint-disable-next-line eslint-plugin-n/no-unsupported-features/node-builtins
+      const ws = new globalThis.WebSocket(url, {
+        headers,
+        proxy: getWebSocketProxyUrl(url),
+        tls: getWebSocketTLSOptions() || undefined,
+      } as unknown as string[])
+      this.ws = ws
+
+      ws.addEventListener('open', () => {
+        logForDebugging(
+          '[SessionsWebSocket] Connection opened, authenticated via headers',
+        )
+        this.state = 'connected'
+        this.reconnectAttempts = 0
+        this.sessionNotFoundRetries = 0
+        this.startPingInterval()
+        this.callbacks.onConnected?.()
+      })
+
+      ws.addEventListener('message', (event: MessageEvent) => {
+        const data =
+          typeof event.data === 'string' ? event.data : String(event.data)
+        this.handleMessage(data)
+      })
+
+      ws.addEventListener('error', () => {
+        const err = new Error('[SessionsWebSocket] WebSocket error')
+        logError(err)
+        this.callbacks.onError?.(err)
+      })
+
+      // eslint-disable-next-line eslint-plugin-n/no-unsupported-features/node-builtins
+      ws.addEventListener('close', (event: CloseEvent) => {
+        logForDebugging(
+          `[SessionsWebSocket] Closed: code=${event.code} reason=${event.reason}`,
+        )
+        this.handleClose(event.code)
+      })
+
+      ws.addEventListener('pong', () => {
+        logForDebugging('[SessionsWebSocket] Pong received')
+      })
+    } else {
+      const { default: WS } = await import('ws')
+      const ws = new WS(url, {
+        headers,
+        agent: getWebSocketProxyAgent(url),
+        ...getWebSocketTLSOptions(),
+      })
+      this.ws = ws
+
+      ws.on('open', () => {
+        logForDebugging(
+          '[SessionsWebSocket] Connection opened, authenticated via headers',
+        )
+        // Auth is handled via headers, so we're immediately connected
+        this.state = 'connected'
+        this.reconnectAttempts = 0
+        this.sessionNotFoundRetries = 0
+        this.startPingInterval()
+        this.callbacks.onConnected?.()
+      })
+
+      ws.on('message', (data: Buffer) => {
+        this.handleMessage(data.toString())
+      })
+
+      ws.on('error', (err: Error) => {
+        logError(new Error(`[SessionsWebSocket] Error: ${err.message}`))
+        this.callbacks.onError?.(err)
+      })
+
+      ws.on('close', (code: number, reason: Buffer) => {
+        logForDebugging(
+          `[SessionsWebSocket] Closed: code=${code} reason=${reason.toString()}`,
+        )
+        this.handleClose(code)
+      })
+
+      ws.on('pong', () => {
+        logForDebugging('[SessionsWebSocket] Pong received')
+      })
+    }
+  }
+
+  /**
+   * Handle incoming WebSocket message
+   */
+  private handleMessage(data: string): void {
+    try {
+      const message: unknown = jsonParse(data)
+
+      // Forward SDK messages to callback
+      if (isSessionsMessage(message)) {
+        this.callbacks.onMessage(message)
+      } else {
+        logForDebugging(
+          `[SessionsWebSocket] Ignoring message type: ${typeof message === 'object' && message !== null && 'type' in message ? String(message.type) : 'unknown'}`,
+        )
+      }
+    } catch (error) {
+      logError(
+        new Error(
+          `[SessionsWebSocket] Failed to parse message: ${errorMessage(error)}`,
+        ),
+      )
+    }
+  }
+
+  /**
+   * Handle WebSocket close
+   */
+  private handleClose(closeCode: number): void {
+    this.stopPingInterval()
+
+    if (this.state === 'closed') {
+      return
+    }
+
+    this.ws = null
+
+    const previousState = this.state
+    this.state = 'closed'
+
+    // Permanent codes: stop reconnecting — server has definitively ended the session
+    if (PERMANENT_CLOSE_CODES.has(closeCode)) {
+      logForDebugging(
+        `[SessionsWebSocket] Permanent close code ${closeCode}, not reconnecting`,
+      )
+      this.callbacks.onClose?.()
+      return
+    }
+
+    // 4001 (session not found) can be transient during compaction: the
+    // server may briefly consider the session stale while the CLI worker
+    // is busy with the compaction API call and not emitting events.
+    if (closeCode === 4001) {
+      this.sessionNotFoundRetries++
+      if (this.sessionNotFoundRetries > MAX_SESSION_NOT_FOUND_RETRIES) {
+        logForDebugging(
+          `[SessionsWebSocket] 4001 retry budget exhausted (${MAX_SESSION_NOT_FOUND_RETRIES}), not reconnecting`,
+        )
+        this.callbacks.onClose?.()
+        return
+      }
+      this.scheduleReconnect(
+        RECONNECT_DELAY_MS * this.sessionNotFoundRetries,
+        `4001 attempt ${this.sessionNotFoundRetries}/${MAX_SESSION_NOT_FOUND_RETRIES}`,
+      )
+      return
+    }
+
+    // Attempt reconnection if we were connected
+    if (
+      previousState === 'connected' &&
+      this.reconnectAttempts < MAX_RECONNECT_ATTEMPTS
+    ) {
+      this.reconnectAttempts++
+      this.scheduleReconnect(
+        RECONNECT_DELAY_MS,
+        `attempt ${this.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS}`,
+      )
+    } else {
+      logForDebugging('[SessionsWebSocket] Not reconnecting')
+      this.callbacks.onClose?.()
+    }
+  }
+
+  private scheduleReconnect(delay: number, label: string): void {
+    this.callbacks.onReconnecting?.()
+    logForDebugging(
+      `[SessionsWebSocket] Scheduling reconnect (${label}) in ${delay}ms`,
+    )
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null
+      void this.connect()
+    }, delay)
+  }
+
+  private startPingInterval(): void {
+    this.stopPingInterval()
+
+    this.pingInterval = setInterval(() => {
+      if (this.ws && this.state === 'connected') {
+        try {
+          this.ws.ping?.()
+        } catch {
+          // Ignore ping errors, close handler will deal with connection issues
+        }
+      }
+    }, PING_INTERVAL_MS)
+  }
+
+  /**
+   * Stop ping interval
+   */
+  private stopPingInterval(): void {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval)
+      this.pingInterval = null
+    }
+  }
+
+  /**
+   * Send a control response back to the session
+   */
+  sendControlResponse(response: SDKControlResponse): void {
+    if (!this.ws || this.state !== 'connected') {
+      logError(new Error('[SessionsWebSocket] Cannot send: not connected'))
+      return
+    }
+
+    logForDebugging('[SessionsWebSocket] Sending control response')
+    this.ws.send(jsonStringify(response))
+  }
+
+  /**
+   * Send a control request to the session (e.g., interrupt)
+   */
+  sendControlRequest(request: SDKControlRequestInner): void {
+    if (!this.ws || this.state !== 'connected') {
+      logError(new Error('[SessionsWebSocket] Cannot send: not connected'))
+      return
+    }
+
+    const controlRequest: SDKControlRequest = {
+      type: 'control_request',
+      request_id: randomUUID(),
+      request,
+    }
+
+    logForDebugging(
+      `[SessionsWebSocket] Sending control request: ${request.subtype}`,
+    )
+    this.ws.send(jsonStringify(controlRequest))
+  }
+
+  /**
+   * Check if connected
+   */
+  isConnected(): boolean {
+    return this.state === 'connected'
+  }
+
+  /**
+   * Close the WebSocket connection
+   */
+  close(): void {
+    logForDebugging('[SessionsWebSocket] Closing connection')
+    this.state = 'closed'
+    this.stopPingInterval()
+
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer)
+      this.reconnectTimer = null
+    }
+
+    if (this.ws) {
+      // Null out event handlers to prevent race conditions during reconnect.
+      // Under Bun (native WebSocket), onX handlers are the clean way to detach.
+      // Under Node (ws package), the listeners were attached with .on() in connect(),
+      // but since we're about to close and null out this.ws, no cleanup is needed.
+      this.ws.close()
+      this.ws = null
+    }
+  }
+
+  /**
+   * Force reconnect - closes existing connection and establishes a new one.
+   * Useful when the subscription becomes stale (e.g., after container shutdown).
+   */
+  reconnect(): void {
+    logForDebugging('[SessionsWebSocket] Force reconnecting')
+    this.reconnectAttempts = 0
+    this.sessionNotFoundRetries = 0
+    this.close()
+    // Small delay before reconnecting (stored in reconnectTimer so it can be cancelled)
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null
+      void this.connect()
+    }, 500)
+  }
+}

src/remote/sdkMessageAdapter.ts

@@ -0,0 +1,302 @@
+import type {
+  SDKAssistantMessage,
+  SDKCompactBoundaryMessage,
+  SDKMessage,
+  SDKPartialAssistantMessage,
+  SDKResultMessage,
+  SDKStatusMessage,
+  SDKSystemMessage,
+  SDKToolProgressMessage,
+} from '../entrypoints/agentSdkTypes.js'
+import type {
+  AssistantMessage,
+  Message,
+  StreamEvent,
+  SystemMessage,
+} from '../types/message.js'
+import { logForDebugging } from '../utils/debug.js'
+import { fromSDKCompactMetadata } from '../utils/messages/mappers.js'
+import { createUserMessage } from '../utils/messages.js'
+
+/**
+ * Converts SDKMessage from CCR to REPL Message types.
+ *
+ * The CCR backend sends SDK-format messages via WebSocket. The REPL expects
+ * internal Message types for rendering. This adapter bridges the two.
+ */
+
+/**
+ * Convert an SDKAssistantMessage to an AssistantMessage
+ */
+function convertAssistantMessage(msg: SDKAssistantMessage): AssistantMessage {
+  return {
+    type: 'assistant',
+    message: msg.message,
+    uuid: msg.uuid,
+    requestId: undefined,
+    timestamp: new Date().toISOString(),
+    error: msg.error,
+  }
+}
+
+/**
+ * Convert an SDKPartialAssistantMessage (streaming) to a StreamEvent
+ */
+function convertStreamEvent(msg: SDKPartialAssistantMessage): StreamEvent {
+  return {
+    type: 'stream_event',
+    event: msg.event,
+  }
+}
+
+/**
+ * Convert an SDKResultMessage to a SystemMessage
+ */
+function convertResultMessage(msg: SDKResultMessage): SystemMessage {
+  const isError = msg.subtype !== 'success'
+  const content = isError
+    ? msg.errors?.join(', ') || 'Unknown error'
+    : 'Session completed successfully'
+
+  return {
+    type: 'system',
+    subtype: 'informational',
+    content,
+    level: isError ? 'warning' : 'info',
+    uuid: msg.uuid,
+    timestamp: new Date().toISOString(),
+  }
+}
+
+/**
+ * Convert an SDKSystemMessage (init) to a SystemMessage
+ */
+function convertInitMessage(msg: SDKSystemMessage): SystemMessage {
+  return {
+    type: 'system',
+    subtype: 'informational',
+    content: `Remote session initialized (model: ${msg.model})`,
+    level: 'info',
+    uuid: msg.uuid,
+    timestamp: new Date().toISOString(),
+  }
+}
+
+/**
+ * Convert an SDKStatusMessage to a SystemMessage
+ */
+function convertStatusMessage(msg: SDKStatusMessage): SystemMessage | null {
+  if (!msg.status) {
+    return null
+  }
+
+  return {
+    type: 'system',
+    subtype: 'informational',
+    content:
+      msg.status === 'compacting'
+        ? 'Compacting conversation…'
+        : `Status: ${msg.status}`,
+    level: 'info',
+    uuid: msg.uuid,
+    timestamp: new Date().toISOString(),
+  }
+}
+
+/**
+ * Convert an SDKToolProgressMessage to a SystemMessage.
+ * We use a system message instead of ProgressMessage since the Progress type
+ * is a complex union that requires tool-specific data we don't have from CCR.
+ */
+function convertToolProgressMessage(
+  msg: SDKToolProgressMessage,
+): SystemMessage {
+  return {
+    type: 'system',
+    subtype: 'informational',
+    content: `Tool ${msg.tool_name} running for ${msg.elapsed_time_seconds}s…`,
+    level: 'info',
+    uuid: msg.uuid,
+    timestamp: new Date().toISOString(),
+    toolUseID: msg.tool_use_id,
+  }
+}
+
+/**
+ * Convert an SDKCompactBoundaryMessage to a SystemMessage
+ */
+function convertCompactBoundaryMessage(
+  msg: SDKCompactBoundaryMessage,
+): SystemMessage {
+  return {
+    type: 'system',
+    subtype: 'compact_boundary',
+    content: 'Conversation compacted',
+    level: 'info',
+    uuid: msg.uuid,
+    timestamp: new Date().toISOString(),
+    compactMetadata: fromSDKCompactMetadata(msg.compact_metadata),
+  }
+}
+
+/**
+ * Result of converting an SDKMessage
+ */
+export type ConvertedMessage =
+  | { type: 'message'; message: Message }
+  | { type: 'stream_event'; event: StreamEvent }
+  | { type: 'ignored' }
+
+type ConvertOptions = {
+  /** Convert user messages containing tool_result content blocks into UserMessages.
+   * Used by direct connect mode where tool results come from the remote server
+   * and need to be rendered locally. CCR mode ignores user messages since they
+   * are handled differently. */
+  convertToolResults?: boolean
+  /**
+   * Convert user text messages into UserMessages for display. Used when
+   * converting historical events where user-typed messages need to be shown.
+   * In live WS mode these are already added locally by the REPL so they're
+   * ignored by default.
+   */
+  convertUserTextMessages?: boolean
+}
+
+/**
+ * Convert an SDKMessage to REPL message format
+ */
+export function convertSDKMessage(
+  msg: SDKMessage,
+  opts?: ConvertOptions,
+): ConvertedMessage {
+  switch (msg.type) {
+    case 'assistant':
+      return { type: 'message', message: convertAssistantMessage(msg) }
+
+    case 'user': {
+      const content = msg.message?.content
+      // Tool result messages from the remote server need to be converted so
+      // they render and collapse like local tool results. Detect via content
+      // shape (tool_result blocks) — parent_tool_use_id is NOT reliable: the
+      // agent-side normalizeMessage() hardcodes it to null for top-level
+      // tool results, so it can't distinguish tool results from prompt echoes.
+      const isToolResult =
+        Array.isArray(content) && content.some(b => b.type === 'tool_result')
+      if (opts?.convertToolResults && isToolResult) {
+        return {
+          type: 'message',
+          message: createUserMessage({
+            content,
+            toolUseResult: msg.tool_use_result,
+            uuid: msg.uuid,
+            timestamp: msg.timestamp,
+          }),
+        }
+      }
+      // When converting historical events, user-typed messages need to be
+      // rendered (they weren't added locally by the REPL). Skip tool_results
+      // here — already handled above.
+      if (opts?.convertUserTextMessages && !isToolResult) {
+        if (typeof content === 'string' || Array.isArray(content)) {
+          return {
+            type: 'message',
+            message: createUserMessage({
+              content,
+              toolUseResult: msg.tool_use_result,
+              uuid: msg.uuid,
+              timestamp: msg.timestamp,
+            }),
+          }
+        }
+      }
+      // User-typed messages (string content) are already added locally by REPL.
+      // In CCR mode, all user messages are ignored (tool results handled differently).
+      return { type: 'ignored' }
+    }
+
+    case 'stream_event':
+      return { type: 'stream_event', event: convertStreamEvent(msg) }
+
+    case 'result':
+      // Only show result messages for errors. Success results are noise
+      // in multi-turn sessions (isLoading=false is sufficient signal).
+      if (msg.subtype !== 'success') {
+        return { type: 'message', message: convertResultMessage(msg) }
+      }
+      return { type: 'ignored' }
+
+    case 'system':
+      if (msg.subtype === 'init') {
+        return { type: 'message', message: convertInitMessage(msg) }
+      }
+      if (msg.subtype === 'status') {
+        const statusMsg = convertStatusMessage(msg)
+        return statusMsg
+          ? { type: 'message', message: statusMsg }
+          : { type: 'ignored' }
+      }
+      if (msg.subtype === 'compact_boundary') {
+        return {
+          type: 'message',
+          message: convertCompactBoundaryMessage(msg),
+        }
+      }
+      // hook_response and other subtypes
+      logForDebugging(
+        `[sdkMessageAdapter] Ignoring system message subtype: ${msg.subtype}`,
+      )
+      return { type: 'ignored' }
+
+    case 'tool_progress':
+      return { type: 'message', message: convertToolProgressMessage(msg) }
+
+    case 'auth_status':
+      // Auth status is handled separately, not converted to a display message
+      logForDebugging('[sdkMessageAdapter] Ignoring auth_status message')
+      return { type: 'ignored' }
+
+    case 'tool_use_summary':
+      // Tool use summaries are SDK-only events, not displayed in REPL
+      logForDebugging('[sdkMessageAdapter] Ignoring tool_use_summary message')
+      return { type: 'ignored' }
+
+    case 'rate_limit_event':
+      // Rate limit events are SDK-only events, not displayed in REPL
+      logForDebugging('[sdkMessageAdapter] Ignoring rate_limit_event message')
+      return { type: 'ignored' }
+
+    default: {
+      // Gracefully ignore unknown message types. The backend may send new
+      // types before the client is updated; logging helps with debugging
+      // without crashing or losing the session.
+      logForDebugging(
+        `[sdkMessageAdapter] Unknown message type: ${(msg as { type: string }).type}`,
+      )
+      return { type: 'ignored' }
+    }
+  }
+}
+
+/**
+ * Check if an SDKMessage indicates the session has ended
+ */
+export function isSessionEndMessage(msg: SDKMessage): boolean {
+  return msg.type === 'result'
+}
+
+/**
+ * Check if an SDKResultMessage indicates success
+ */
+export function isSuccessResult(msg: SDKResultMessage): boolean {
+  return msg.subtype === 'success'
+}
+
+/**
+ * Extract the result text from a successful SDKResultMessage
+ */
+export function getResultText(msg: SDKResultMessage): string | null {
+  if (msg.subtype === 'success') {
+    return msg.result
+  }
+  return null
+}