ei-tui 0.4.3 → 0.5.1

package/tui/src/components/ToolkitListOverlay.tsx

@@ -1,6 +1,7 @@
 import { useKeyboard } from "@opentui/solid";
-import { For, createSignal, createMemo } from "solid-js";
+import { For, createSignal, createMemo, onMount, onCleanup } from "solid-js";
 import type { KeyEvent } from "@opentui/core";
+import { useKeyboardNav } from "../context/keyboard.js";
 
 export interface ToolkitListItem {
   id: string;
@@ -17,6 +18,9 @@ interface ToolkitListOverlayProps {
 }
 
 export function ToolkitListOverlay(props: ToolkitListOverlayProps) {
+  const { setOverlayActive } = useKeyboardNav();
+  onMount(() => setOverlayActive(true));
+  onCleanup(() => setOverlayActive(false));
   const [selectedIndex, setSelectedIndex] = createSignal(0);
   const [filterText, setFilterText] = createSignal("");
   const [filterMode, setFilterMode] = createSignal(false);

package/tui/src/components/WelcomeOverlay.tsx

@@ -1,10 +1,16 @@
 import { useKeyboard } from "@opentui/solid";
+import { onMount, onCleanup } from "solid-js";
+import { useKeyboardNav } from "../context/keyboard.js";
 
 interface WelcomeOverlayProps {
   onDismiss: () => void;
 }
 
 export function WelcomeOverlay(props: WelcomeOverlayProps) {
+  const { setOverlayActive } = useKeyboardNav();
+  onMount(() => setOverlayActive(true));
+  onCleanup(() => setOverlayActive(false));
+
   useKeyboard((event) => {
     event.preventDefault();
     props.onDismiss();

package/tui/src/context/ei.tsx

@@ -6,6 +6,7 @@ import {
   Match,
   Switch,
   createSignal,
+  createMemo,
   type ParentComponent,
 } from "solid-js";
 import { createStore } from "solid-js/store";
@@ -34,6 +35,7 @@ import type {
   LLMRequest,
 } from "../../../src/core/types.js";
 import type { ToolProvider, ToolDefinition } from "../../../src/core/types.js";
+import type { RoomSummary, RoomEntity, RoomMessage, RoomCreationInput } from "../../../src/core/types.js";
 
 interface EiStore {
   ready: boolean;
@@ -43,6 +45,11 @@ interface EiStore {
   messages: Message[];
   queueStatus: QueueStatus;
   notification: { message: string; level: "error" | "warn" | "info" } | null;
+  rooms: RoomSummary[];
+  activeRoomId: string | null;
+  roomMessages: RoomMessage[];
+  roomActivePath: RoomMessage[];
+  isRoomProcessing: boolean;
 }
 
 export interface EiContextValue {
@@ -108,6 +115,30 @@ export interface EiContextValue {
   updateTool: (id: string, updates: Partial<Omit<ToolDefinition, 'id' | 'created_at'>>) => Promise<boolean>;
   queueUserDedup: (itemType: "topic" | "person", entityIds: string[]) => void;
   cleanupTimers: () => void;
+  rooms: () => RoomSummary[];
+  activeRoomId: () => string | null;
+  roomMessages: () => RoomMessage[];
+  roomActivePath: () => RoomMessage[];
+  isRoomProcessing: () => boolean;
+  selectRoom: (roomId: string) => void;
+  resolveRoomName: (nameOrAlias: string) => string | null;
+  getRoom: (roomId: string) => RoomEntity | null;
+  createRoom: (input: RoomCreationInput) => Promise<string>;
+  updateRoom: (roomId: string, updates: Partial<RoomEntity>) => Promise<void>;
+  archiveRoom: (roomId: string) => Promise<void>;
+  deleteRoom: (roomId: string) => Promise<void>;
+  sendFfaMessage: (content: string | null, silenceReason?: string) => Promise<void>;
+  submitHumanRoomMessage: (content: string | null, silenceReason?: string) => string | null;
+  recallHumanRoomMessage: () => boolean;
+  activateRoom: () => Promise<void>;
+  selectCYPBranch: (messageId: string) => Promise<void>;
+  markAllRoomMessagesRead: () => Promise<number>;
+  captureRoom: () => void;
+  capturePersona: () => void;
+  sendSilenceMessage: (silenceReason?: string) => Promise<void>;
+  humanRoomMessagePending: () => boolean;
+  getArchivedRooms: () => RoomSummary[];
+  generatePersonaPreview: (name: string, description: string, relationship?: string, personaId?: string) => Promise<import('../../../src/prompts/generation/types.js').PersonaGenerationResult>;
 }
 const EiContext = createContext<EiContextValue>();
 
@@ -120,6 +151,11 @@ export const EiProvider: ParentComponent = (props) => {
     messages: [],
     queueStatus: { state: "idle", pending_count: 0, dlq_count: 0 },
     notification: null,
+    rooms: [],
+    activeRoomId: null,
+    roomMessages: [],
+    roomActivePath: [],
+    isRoomProcessing: false,
   });
 
   const [contextBoundarySignal, setContextBoundarySignal] = createSignal<string | undefined>(undefined);
@@ -173,6 +209,7 @@ export const EiProvider: ParentComponent = (props) => {
   };
 
   const selectPersona = (personaId: string) => {
+    setStore("activeRoomId", null);
     // Mark previous persona as read ONLY if we dwelled there 5+ seconds
     const previousId = store.activePersonaId;
     if (previousId && previousId === dwelledPersona && processor) {
@@ -266,6 +303,11 @@ export const EiProvider: ParentComponent = (props) => {
     return await processor.createPersona(input);
   };
 
+  const generatePersonaPreview = async (name: string, description: string, relationship?: string, personaId?: string) => {
+    if (!processor) throw new Error("Processor not ready");
+    return processor.generatePersonaPreview(name, description, relationship, personaId);
+  };
+
   const archivePersona = async (personaId: string) => {
     if (!processor) return;
     await processor.archivePersona(personaId);
@@ -456,7 +498,168 @@ export const EiProvider: ParentComponent = (props) => {
     return processor.searchHumanData(query, options);
   };
 
-  // Post-start initialization: refresh UI state, select first persona, detect LLM
+  const refreshRooms = async () => {
+    if (!processor) return;
+    const list = processor.getRoomList();
+    setStore("rooms", list);
+  };
+
+  const refreshRoomMessages = async () => {
+    if (!processor) return;
+    const currentRoomId = store.activeRoomId;
+    if (!currentRoomId) return;
+    const msgs = processor.getRoomMessages(currentRoomId);
+    setStore("roomMessages", [...msgs]);
+  };
+
+  const refreshRoomActivePath = () => {
+    if (!processor) return;
+    const roomId = store.activeRoomId;
+    if (!roomId) return;
+    const path = processor.getRoomActivePath(roomId);
+    setStore("roomActivePath", [...path]);
+  };
+
+  const selectRoom = (roomId: string) => {
+    setStore("activeRoomId", roomId);
+    setStore("roomMessages", []);
+    setStore("roomActivePath", []);
+    setStore("isRoomProcessing", false);
+    if (processor) {
+      const msgs = processor.getRoomMessages(roomId);
+      setStore("roomMessages", [...msgs]);
+      refreshRoomActivePath();
+      if (readTimer) clearTimeout(readTimer);
+      readTimer = setTimeout(async () => {
+        if (store.activeRoomId === roomId && processor) {
+          await processor.markAllRoomMessagesRead(roomId);
+          await refreshRooms();
+        }
+        readTimer = null;
+      }, 5000);
+    }
+  };
+
+  const sendFfaMessage = async (content: string | null, silenceReason?: string) => {
+    const roomId = store.activeRoomId;
+    if (!roomId || !processor) return;
+    await processor.sendFfaMessage(roomId, content, silenceReason);
+    await refreshRooms();
+  };
+
+  const submitHumanRoomMessage = (content: string | null, silenceReason?: string): string | null => {
+    const roomId = store.activeRoomId;
+    if (!roomId || !processor) return null;
+    const msgId = processor.submitHumanRoomMessage(roomId, content, silenceReason);
+    void refreshRoomMessages();
+    return msgId;
+  };
+
+  const recallHumanRoomMessage = (): boolean => {
+    const roomId = store.activeRoomId;
+    if (!roomId || !processor) return false;
+    const recalled = processor.recallHumanRoomMessage(roomId);
+    void refreshRoomMessages();
+    return recalled;
+  };
+
+  const activateRoom = async () => {
+    const roomId = store.activeRoomId;
+    if (!roomId || !processor) return;
+    await processor.activateRoom(roomId);
+    await refreshRoomMessages();
+    void refreshRoomActivePath();
+    void refreshRooms();
+  };
+
+  const selectCYPBranch = async (messageId: string) => {
+    const roomId = store.activeRoomId;
+    if (!roomId || !processor) return;
+    await processor.selectCYPBranch(roomId, messageId);
+    await refreshRoomMessages();
+    await refreshRoomActivePath();
+    void refreshRooms();
+  };
+
+  const createRoom = async (input: RoomCreationInput): Promise<string> => {
+    if (!processor) return "";
+    const roomId = await processor.createRoom(input);
+    await refreshRooms();
+    selectRoom(roomId);
+    return roomId;
+  };
+
+  const updateRoom = async (roomId: string, updates: Partial<RoomEntity>) => {
+    if (!processor) return;
+    await processor.updateRoom(roomId, updates);
+    await refreshRooms();
+    if (roomId === store.activeRoomId) await refreshRoomMessages();
+  };
+
+  const archiveRoom = async (roomId: string) => {
+    if (!processor) return;
+    await processor.archiveRoom(roomId);
+    if (store.activeRoomId === roomId) setStore("activeRoomId", null);
+    await refreshRooms();
+  };
+
+  const deleteRoom = async (roomId: string) => {
+    if (!processor) return;
+    await processor.deleteRoom(roomId);
+    if (store.activeRoomId === roomId) setStore("activeRoomId", null);
+    await refreshRooms();
+  };
+
+  const markAllRoomMessagesRead = async (): Promise<number> => {
+    const roomId = store.activeRoomId;
+    if (!roomId || !processor) return 0;
+    const count = await processor.markAllRoomMessagesRead(roomId);
+    await refreshRooms();
+    return count;
+  };
+
+  const captureRoom = () => {
+    const roomId = store.activeRoomId;
+    if (!roomId || !processor) return;
+    processor.captureRoom(roomId);
+  };
+
+  const capturePersona = () => {
+    const personaId = store.activePersonaId;
+    if (!personaId || !processor) return;
+    processor.capturePersona(personaId);
+  };
+
+  const resolveRoomName = (nameOrAlias: string): string | null => {
+    if (!processor) return null;
+    return processor.resolveRoomName(nameOrAlias);
+  };
+
+  const getArchivedRooms = (): RoomSummary[] => {
+    if (!processor) return [];
+    return processor.getRoomList(true).filter(r => r.is_archived);
+  };
+
+  const getRoom = (roomId: string): RoomEntity | null => {
+    if (!processor) return null;
+    return processor.getRoom(roomId);
+  };
+
+  const humanRoomMessagePending = createMemo(() => {
+    const roomId = store.activeRoomId;
+    if (!roomId) return false;
+    const roomSummary = store.rooms.find(r => r.id === roomId);
+    if (!roomSummary?.active_node_id) return false;
+    return store.roomMessages.some(m => m.parent_id === roomSummary.active_node_id && m.role === "human");
+  });
+
+  const sendSilenceMessage = async (silenceReason?: string) => {
+    const currentId = store.activePersonaId;
+    if (!currentId || !processor) return;
+    await processor.sendMessage(currentId, null, silenceReason);
+    await refreshPersonas();
+  };
+
   async function finishBootstrap() {
     if (!processor) return;
 
@@ -474,6 +677,7 @@ export const EiProvider: ParentComponent = (props) => {
       }
     }
     await refreshPersonas();
+    await refreshRooms();
     logger.debug(`refreshPersonas done, count: ${store.personas.length}`);
     const status = await processor.getQueueStatus();
     logger.debug("Initial getQueueStatus:", status);
@@ -589,6 +793,29 @@ export const EiProvider: ParentComponent = (props) => {
           logger.info("State conflict detected, waiting for user resolution");
           setConflictData(data);
         },
+        onRoomAdded: () => void refreshRooms(),
+        onRoomRemoved: () => void refreshRooms(),
+        onRoomUpdated: (roomId) => {
+          void refreshRooms();
+          if (roomId === store.activeRoomId) {
+            void refreshRoomMessages();
+            refreshRoomActivePath();
+          }
+        },
+        onRoomMessageAdded: (roomId) => {
+          void refreshRooms();
+          if (roomId === store.activeRoomId) {
+            void refreshRoomMessages();
+            refreshRoomActivePath();
+            setStore("isRoomProcessing", false);
+          }
+        },
+        onRoomMessageQueued: () => {
+          void refreshRooms();
+        },
+        onRoomMessageProcessing: (roomId) => {
+          if (roomId === store.activeRoomId) setStore("isRoomProcessing", true);
+        },
       };
       processor = new Processor(eiInterface);
       logger.debug("Processor created, calling start()");
@@ -671,6 +898,30 @@ export const EiProvider: ParentComponent = (props) => {
     updateTool,
     queueUserDedup,
     cleanupTimers,
+    rooms: () => store.rooms,
+    activeRoomId: () => store.activeRoomId,
+    roomMessages: () => store.roomMessages,
+    roomActivePath: () => store.roomActivePath,
+    isRoomProcessing: () => store.isRoomProcessing,
+    selectRoom,
+    resolveRoomName,
+    getRoom,
+    createRoom,
+    updateRoom,
+    archiveRoom,
+    deleteRoom,
+    sendFfaMessage,
+    submitHumanRoomMessage,
+    recallHumanRoomMessage,
+    activateRoom,
+    selectCYPBranch,
+    markAllRoomMessagesRead,
+    captureRoom,
+    capturePersona,
+    sendSilenceMessage,
+    humanRoomMessagePending,
+    getArchivedRooms,
+    generatePersonaPreview,
   };
   return (
     <Switch>

package/tui/src/context/keyboard.tsx

@@ -7,7 +7,7 @@ import {
 } from "solid-js";
 import { useKeyboard, useRenderer, useSelectionHandler } from "@opentui/solid";
 import type { ScrollBoxRenderable, KeyEvent, TextareaRenderable, CliRenderer } from "@opentui/core";
-import type { PersonaSummary } from "../../../src/core/types.js";
+import type { PersonaSummary, RoomSummary } from "../../../src/core/types.js";
 import { useEi } from "./ei";
 import { logger } from "../util/logger";
 import { copyToClipboard } from "../util/clipboard";
@@ -25,6 +25,8 @@ interface KeyboardContextValue {
   exitApp: () => Promise<void>;
   renderer: CliRenderer;
   resetHistoryIndex: () => void;
+  overlayActive: () => boolean;
+  setOverlayActive: (active: boolean) => void;
 }
 
 const KeyboardContext = createContext<KeyboardContextValue>();
@@ -32,8 +34,9 @@ const KeyboardContext = createContext<KeyboardContextValue>();
 export const KeyboardProvider: ParentComponent = (props) => {
   const [focusedPanel, setFocusedPanel] = createSignal<Panel>("input");
   const [sidebarVisible, setSidebarVisible] = createSignal(true);
+  const [overlayActive, setOverlayActive] = createSignal(false);
   const renderer = useRenderer();
-  const { queueStatus, abortCurrentOperation, resumeQueue, pauseQueue, personas, activePersonaId, selectPersona, saveAndExit, showNotification, messages, recallPendingMessages, cleanupTimers } = useEi();
+  const { queueStatus, abortCurrentOperation, resumeQueue, pauseQueue, personas, activePersonaId, selectPersona, saveAndExit, showNotification, messages, recallPendingMessages, cleanupTimers, rooms, activeRoomId, selectRoom } = useEi();
   
   let messageScrollRef: ScrollBoxRenderable | null = null;
   let textareaRef: TextareaRenderable | null = null;
@@ -76,13 +79,26 @@ export const KeyboardProvider: ParentComponent = (props) => {
     if (event.name === "tab") {
       event.preventDefault();
       if (textareaRef && textareaRef.plainText.length > 0) return;
-      
+
+      if (activeRoomId()) {
+        const activeRooms = rooms().filter((r: RoomSummary) => !r.is_archived);
+        if (activeRooms.length <= 1) return;
+        const current = activeRoomId();
+        const currentIndex = activeRooms.findIndex((r: RoomSummary) => r.id === current);
+        let nextIndex: number;
+        if (event.shift) {
+          nextIndex = (currentIndex - 1 + activeRooms.length) % activeRooms.length;
+        } else {
+          nextIndex = (currentIndex + 1) % activeRooms.length;
+        }
+        selectRoom(activeRooms[nextIndex].id);
+        return;
+      }
+
       const unarchived = personas().filter((p: PersonaSummary) => !p.is_archived);
       if (unarchived.length <= 1) return;
-      
       const current = activePersonaId();
       const currentIndex = unarchived.findIndex((p: PersonaSummary) => p.id === current);
-      
       let nextIndex: number;
       if (event.shift) {
         nextIndex = (currentIndex - 1 + unarchived.length) % unarchived.length;
@@ -120,6 +136,7 @@ export const KeyboardProvider: ParentComponent = (props) => {
     }
 
     if (event.name === "escape") {
+      if (overlayActive()) return;
       event.preventDefault();
       const status = queueStatus();
       
@@ -137,7 +154,7 @@ export const KeyboardProvider: ParentComponent = (props) => {
     }
 
 
-    if (event.name === "up" && !event.ctrl && !event.shift && !event.meta) {
+    if (event.name === "up" && !overlayActive() && !activeRoomId() && !event.ctrl && !event.shift && !event.meta) {
       if (!textareaRef) return;
       const cursor = textareaRef.logicalCursor;
       // Only intercept when cursor is at the very beginning (row 0, col 0)
@@ -174,7 +191,7 @@ export const KeyboardProvider: ParentComponent = (props) => {
       return;
     }
 
-    if (event.name === "down" && !event.ctrl && !event.shift && !event.meta) {
+    if (event.name === "down" && !overlayActive() && !activeRoomId() && !event.ctrl && !event.shift && !event.meta) {
       if (!textareaRef || historyIndex === -1) return;
       // Only intercept when cursor is at the very end
       if (textareaRef.cursorOffset !== textareaRef.plainText.length) return;
@@ -199,7 +216,7 @@ export const KeyboardProvider: ParentComponent = (props) => {
 
     if (!messageScrollRef) return;
 
-    const scrollAmount = messageScrollRef.height;
+    const scrollAmount = Math.floor(messageScrollRef.height / 2);
     
     if (event.name === "pageup") {
       event.preventDefault();
@@ -243,6 +260,8 @@ export const KeyboardProvider: ParentComponent = (props) => {
     exitApp,
     renderer,
     resetHistoryIndex,
+    overlayActive,
+    setOverlayActive,
   };
 
   return (
@@ -252,10 +271,27 @@ export const KeyboardProvider: ParentComponent = (props) => {
   );
 };
 
+// No-op stub returned when useKeyboardNav is called outside KeyboardProvider.
+// ConflictOverlay is the only legitimate caller in this situation — it renders
+// before KeyboardProvider exists because the app can't boot (state conflict).
+// All keyboard operations are genuinely meaningless at that point; the stub
+// makes setOverlayActive calls harmless rather than fatal.
+const KEYBOARD_NOOP: KeyboardContextValue = {
+  focusedPanel: () => "input" as Panel,
+  setFocusedPanel: () => {},
+  registerMessageScroll: () => {},
+  registerTextarea: () => {},
+  registerEditorHandler: () => {},
+  sidebarVisible: () => true,
+  toggleSidebar: () => {},
+  exitApp: async () => {},
+  renderer: null as unknown as CliRenderer,
+  resetHistoryIndex: () => {},
+  overlayActive: () => false,
+  setOverlayActive: () => {},
+};
+
 export const useKeyboardNav = () => {
   const ctx = useContext(KeyboardContext);
-  if (!ctx) {
-    throw new Error("useKeyboardNav must be used within KeyboardProvider");
-  }
-  return ctx;
+  return ctx ?? KEYBOARD_NOOP;
 };

package/tui/src/util/cyp-editor.tsx

@@ -0,0 +1,152 @@
+import { spawnEditor } from "./editor.js";
+import type { CliRenderer } from "@opentui/core";
+import type { RoomMessage, PersonaSummary } from "../../../src/core/types.js";
+
+interface ParsedBlock {
+  id: string;
+  chosen: boolean;
+}
+
+export function buildCYPEditorYAML(
+  activeNodeId: string,
+  messages: RoomMessage[],
+  personas: PersonaSummary[]
+): string {
+  const children = messages.filter((m) => m.parent_id === activeNodeId);
+
+  const header = `# Choose Your Path
+# Mark exactly ONE response with _chosen: true to continue the story.
+# Save and exit to confirm your selection.
+
+`;
+
+  const isExplored = (msgId: string) => messages.some((x) => x.parent_id === msgId);
+
+  const blocks = children.map((m) => {
+    let speaker = "You";
+    if (m.role === "persona" && m.persona_id) {
+      speaker = personas.find((p) => p.id === m.persona_id)?.display_name ?? m.persona_id;
+    }
+
+    const contentLines: string[] = [];
+    if (m.verbal_response !== undefined) {
+      const indented = m.verbal_response.split("\n").map((l) => `    ${l}`).join("\n");
+      contentLines.push(`  verbal_response: |\n${indented}`);
+    }
+    if (m.action_response !== undefined) {
+      const indented = m.action_response.split("\n").map((l) => `    ${l}`).join("\n");
+      contentLines.push(`  action_response: |\n${indented}`);
+    }
+    if (m.silence_reason !== undefined && m.verbal_response === undefined) {
+      contentLines.push(`  silence_reason: "${m.silence_reason}"`);
+    }
+    if (contentLines.length === 0) {
+      contentLines.push(`  # (no content)`);
+    }
+
+    return `- id: "${m.id}"
+  speaker: "${speaker}"
+  explored: ${isExplored(m.id)}
+  _chosen: false
+${contentLines.join("\n")}`;
+  });
+
+  return header + blocks.join("\n\n");
+}
+
+export function parseCYPEditorYAML(content: string): ParsedBlock[] {
+  const blocks: ParsedBlock[] = [];
+  let currentId: string | null = null;
+  let currentChosen = false;
+  let inContent = false;
+
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+
+    if (trimmed.startsWith("#") || trimmed === "") continue;
+
+    // New block starts with `- id:` at column 0
+    if (line.startsWith("- id:")) {
+      if (currentId !== null) {
+        blocks.push({ id: currentId, chosen: currentChosen });
+      }
+      const val = trimmed.slice("- id:".length).trim().replace(/^["']|["']$/g, "");
+      currentId = val;
+      currentChosen = false;
+      inContent = false;
+      continue;
+    }
+
+    // Content block lines are indented with 4 spaces — skip them
+    if (inContent && line.startsWith("    ")) {
+      continue;
+    }
+    inContent = false;
+
+    if (currentId !== null) {
+      if (trimmed.startsWith("_chosen:")) {
+        const val = trimmed.slice("_chosen:".length).trim().toLowerCase();
+        currentChosen = val === "true";
+      } else if (trimmed.startsWith("content:")) {
+        inContent = true;
+      }
+    }
+  }
+
+  if (currentId !== null) {
+    blocks.push({ id: currentId, chosen: currentChosen });
+  }
+
+  return blocks;
+}
+
+export async function openCYPEditor(opts: {
+  roomId: string;
+  activeNodeId: string;
+  messages: RoomMessage[];
+  activePath: RoomMessage[];
+  personas: PersonaSummary[];
+  selectBranch: (messageId: string) => Promise<void>;
+  showNotification: (msg: string, level: "error" | "warn" | "info") => void;
+  renderer: CliRenderer;
+}): Promise<void> {
+  const { roomId, activeNodeId, messages, personas, selectBranch, showNotification, renderer } = opts;
+
+  const yamlContent = buildCYPEditorYAML(activeNodeId, messages, personas);
+
+  const result = await spawnEditor({
+    initialContent: yamlContent,
+    filename: `${roomId}-choose.yaml`,
+    renderer,
+  });
+
+  if (result.aborted) {
+    showNotification("Editor cancelled", "info");
+    return;
+  }
+
+  if (!result.success) {
+    showNotification("Editor failed to open", "error");
+    return;
+  }
+
+  if (result.content === null) {
+    showNotification("No changes made", "info");
+    return;
+  }
+
+  const blocks = parseCYPEditorYAML(result.content);
+  const chosenBlocks = blocks.filter((b) => b.chosen);
+
+  if (chosenBlocks.length === 0) {
+    showNotification("No response chosen — editor cancelled", "warn");
+    return;
+  }
+
+  if (chosenBlocks.length > 1) {
+    showNotification("Mark exactly one response — try again", "warn");
+    return;
+  }
+
+  await selectBranch(chosenBlocks[0].id);
+}

package/tui/src/util/quote-utils.ts

@@ -0,0 +1,19 @@
+import type { Quote } from "../../../src/core/types.js";
+
+export function insertQuoteMarkers(content: string, quotes: Quote[]): string {
+  const validQuotes = quotes
+    .filter(q => q.end !== null && q.end !== undefined)
+    .sort((a, b) => b.end! - a.end!);
+  
+  let result = content;
+  for (const quote of validQuotes) {
+    let insertPos = quote.end!;
+    if (insertPos >= 0 && insertPos <= result.length) {
+      while (insertPos > 0 && (result[insertPos - 1] === '\n' || result[insertPos - 1] === ' ')) {
+        insertPos--;
+      }
+      result = result.slice(0, insertPos) + "\u207a" + result.slice(insertPos);
+    }
+  }
+  return result;
+}