ei-tui 0.1.24 → 0.2.0

package/tui/src/commands/provider.tsx

@@ -77,7 +77,7 @@ export const providerCommand: Command = {
         ctx.showNotification("No providers configured. Use /provider new to create one.", "info");
         return;
       }
-      ctx.showOverlay((hideOverlay) => (
+      ctx.showOverlay((hideOverlay, hideForEditor) => (
         <ProviderListOverlay
           providers={providers}
           activeProviderKey={activeKey}
@@ -86,8 +86,7 @@ export const providerCommand: Command = {
             await setProviderOnPersona(provider.key, provider.defaultModel, ctx);
           }}
           onEdit={async (provider) => {
-            hideOverlay();
-            await new Promise(r => setTimeout(r, 50));
+            hideForEditor();
             const human = await ctx.ei.getHuman();
             const account = human.settings?.accounts?.find(a => a.id === provider.id);
             if (account) {
@@ -96,12 +95,11 @@ export const providerCommand: Command = {
           }}
           onNew={async () => {
             hideOverlay();
-            await new Promise(r => setTimeout(r, 50));
             await createProviderViaEditor(ctx);
           }}
           onDismiss={hideOverlay}
         />
-      ));
+      ), ctx.renderer);
       return;
     }
     

package/tui/src/commands/queue.ts

@@ -53,18 +53,17 @@ export const queueCommand: Command = {
         const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
 
         const shouldReEdit = await new Promise<boolean>((resolve) => {
-          ctx.showOverlay((hideOverlay) =>
+          ctx.showOverlay((hideOverlay, hideForEditor) =>
             ConfirmOverlay({
               message: `YAML error:\n${errorMsg}\n\nRe-edit?`,
-              onConfirm: () => { hideOverlay(); resolve(true); },
+              onConfirm: () => { hideForEditor(); resolve(true); },
               onCancel: () => { hideOverlay(); resolve(false); },
             })
-          );
+          , ctx.renderer);
         });
 
         if (shouldReEdit) {
           yamlContent = result.content;
-          await new Promise(r => setTimeout(r, 50));
           continue;
         }
 

package/tui/src/commands/quotes.tsx

@@ -75,12 +75,12 @@ async function openQuotesInEditor(
       });
 
       const shouldReEdit = await new Promise<boolean>((resolve) => {
-        ctx.showOverlay((hideOverlay) => (
+        ctx.showOverlay((hideOverlay, hideForEditor) => (
           <ConfirmOverlay
             message={`YAML parse error:\n${errorMsg}\n\nRe-edit?`}
             onConfirm={() => {
               logger.debug("[quotes] user confirmed re-edit");
-              hideOverlay();
+              hideForEditor();
               resolve(true);
             }}
             onCancel={() => {
@@ -89,7 +89,7 @@ async function openQuotesInEditor(
               resolve(false);
             }}
           />
-        ));
+        ), ctx.renderer);
       });
 
       logger.debug("[quotes] shouldReEdit", { shouldReEdit, iteration: editorIteration });
@@ -97,7 +97,6 @@ async function openQuotesInEditor(
       if (shouldReEdit) {
         yamlContent = result.content;
         logger.debug("[quotes] continuing to next iteration");
-        await new Promise((r) => setTimeout(r, 50));
         continue;
       } else {
         ctx.showNotification("Changes discarded", "info");
@@ -146,14 +145,13 @@ export const quotesCommand: Command = {
       const allQuotes = await ctx.ei.getQuotes();
       const messageQuotes = allQuotes.filter(q => q.message_id === targetMessage.id);
 
-      ctx.showOverlay((hide) => (
+      ctx.showOverlay((hide, hideForEditor) => (
         <QuotesOverlay
           quotes={messageQuotes}
           messageIndex={index}
           onClose={hide}
           onEdit={async () => {
-            hide();
-            await new Promise((r) => setTimeout(r, 50));
+            hideForEditor();
             await openQuotesInEditor(ctx, messageQuotes, `quotes from message [${index}]`);
           }}
           onDelete={async (quoteId) => {
@@ -161,7 +159,7 @@ export const quotesCommand: Command = {
             ctx.showNotification("Quote deleted", "info");
           }}
         />
-      ));
+      ), ctx.renderer);
       return;
     }
 

package/tui/src/commands/registry.ts

@@ -11,7 +11,7 @@ export interface Command {
 }
 
 export interface CommandContext {
-  showOverlay: (renderer: OverlayRenderer) => void;
+  showOverlay: (renderer: OverlayRenderer, cliRenderer?: CliRenderer) => void;
   hideOverlay: () => void;
   showNotification: (msg: string, level: "error" | "warn" | "info") => void;
   exitApp: () => Promise<void>;

package/tui/src/commands/setsync.tsx

@@ -16,7 +16,7 @@ export const setSyncCommand: Command = {
     const [username, passphrase] = args;
 
     const confirmed = await new Promise<boolean>((resolve) => {
-      ctx.showOverlay((hideOverlay) => (
+      ctx.showOverlay((hideOverlay, _hideForEditor) => (
         <ConfirmOverlay
           message={`Set sync credentials for "${username}"?\n\nThis requires a restart. Just re-run ei once it closes!`}
           onConfirm={() => {
@@ -28,7 +28,7 @@ export const setSyncCommand: Command = {
             resolve(false);
           }}
         />
-      ));
+      ), ctx.renderer);
     });
 
     if (!confirmed) {

package/tui/src/commands/settings.tsx

@@ -45,6 +45,21 @@ export const settingsCommand: Command = {
         // Validate provider name in default_model (case-insensitive match + auto-correct)
         const llmAccounts = human.settings?.accounts?.filter(a => a.type === "llm") ?? [];
         newSettings.default_model = validateModelProvider(newSettings.default_model, llmAccounts);
+
+        if (newSettings.opencode?.extraction_model) {
+          newSettings.opencode.extraction_model = validateModelProvider(
+            newSettings.opencode.extraction_model,
+            llmAccounts
+          );
+        }
+
+        if (newSettings.claudeCode?.extraction_model) {
+          newSettings.claudeCode.extraction_model = validateModelProvider(
+            newSettings.claudeCode.extraction_model,
+            llmAccounts
+          );
+        }
+
         await ctx.ei.updateSettings(newSettings);
         ctx.showNotification("Settings updated", "info");
         return;
@@ -54,11 +69,11 @@ export const settingsCommand: Command = {
         logger.debug("[settings] YAML parse error, prompting for re-edit", { iteration: editorIteration, error: errorMsg });
         
         const shouldReEdit = await new Promise<boolean>((resolve) => {
-          ctx.showOverlay((hideOverlay) => (
+          ctx.showOverlay((hideOverlay, hideForEditor) => (
             <ConfirmOverlay
               message={`YAML parse error:\n${errorMsg}\n\nRe-edit?`}
               onConfirm={() => {
-                hideOverlay();
+                hideForEditor();
                 resolve(true);
               }}
               onCancel={() => {
@@ -66,12 +81,11 @@ export const settingsCommand: Command = {
                 resolve(false);
               }}
             />
-          ));
+          ), ctx.renderer);
         });
         
         if (shouldReEdit) {
           yamlContent = result.content;
-          await new Promise(r => setTimeout(r, 50));
           continue;
         } else {
           ctx.showNotification("Changes discarded", "info");

package/tui/src/commands/spotify-auth.ts

@@ -45,7 +45,6 @@ export async function runSpotifyAuth(ctx: CommandContext): Promise<void> {
   const codePromise = waitForAuthCode(ctx);
 
   // Give the server a tick to bind its port before opening the browser
-  await new Promise<void>((r) => setTimeout(r, 50));
   logger.info("[spotify-auth] Server should be up — opening browser now");
 
   // Open the authorization URL in the user's default browser

package/tui/src/commands/tools.tsx

@@ -25,20 +25,19 @@ export const toolsCommand: Command = {
       toolCount: allTools.filter(t => t.provider_id === p.id).length,
     }));
 
-    ctx.showOverlay((hideOverlay) => (
+    ctx.showOverlay((hideOverlay, hideForEditor) => (
       <ToolkitListOverlay
         toolkits={toolkits}
         onEdit={async (toolkit) => {
-          hideOverlay();
-          await new Promise(r => setTimeout(r, 50));
+          hideForEditor();
           const provider = providers.find(p => p.id === toolkit.id);
           if (provider) {
-            const providerTools = allTools.filter(t => t.provider_id === provider.id);
+            const providerTools = allTools.filter(t => t.provider_id === toolkit.id);
             await openToolkitEditor(provider, providerTools, ctx);
           }
         }}
         onDismiss={hideOverlay}
       />
-    ));
+    ), ctx.renderer);
   },
 };

package/tui/src/context/ei.tsx

@@ -23,7 +23,6 @@ import type {
   HumanEntity,
   HumanSettings,
   Fact,
-  Trait,
   Topic,
   Person,
   Quote,
@@ -78,10 +77,9 @@ export interface EiContextValue {
   updateHuman: (updates: Partial<HumanEntity>) => Promise<void>;
   updateSettings: (updates: Partial<HumanSettings>) => Promise<void>;
   upsertFact: (fact: Fact) => Promise<void>;
-  upsertTrait: (trait: Trait) => Promise<void>;
   upsertTopic: (topic: Topic) => Promise<void>;
   upsertPerson: (person: Person) => Promise<void>;
-  removeDataItem: (type: "fact" | "trait" | "topic" | "person", id: string) => Promise<void>;
+  removeDataItem: (type: "fact" | "topic" | "person", id: string) => Promise<void>;
   syncStatus: () => { configured: boolean; envBased: boolean };
   triggerSync: () => Promise<{ success: boolean; error?: string }>;
   getGroupList: () => Promise<string[]>;
@@ -92,10 +90,9 @@ export interface EiContextValue {
   quotesVersion: () => number;
   searchHumanData: (
     query: string,
-    options?: { types?: Array<"fact" | "trait" | "topic" | "person" | "quote">; limit?: number }
+    options?: { types?: Array<"fact" | "topic" | "person" | "quote">; limit?: number }
   ) => Promise<{
     facts: Fact[];
-    traits: Trait[];
     topics: Topic[];
     people: Person[];
     quotes: Quote[];
@@ -329,11 +326,6 @@ export const EiProvider: ParentComponent = (props) => {
     await processor.upsertFact(fact);
   };
 
-  const upsertTrait = async (trait: Trait) => {
-    if (!processor) return;
-    await processor.upsertTrait(trait);
-  };
-
   const upsertTopic = async (topic: Topic) => {
     if (!processor) return;
     await processor.upsertTopic(topic);
@@ -344,7 +336,7 @@ export const EiProvider: ParentComponent = (props) => {
     await processor.upsertPerson(person);
   };
 
-  const removeDataItem = async (type: "fact" | "trait" | "topic" | "person", id: string) => {
+  const removeDataItem = async (type: "fact" | "topic" | "person", id: string) => {
     if (!processor) return;
     await processor.removeDataItem(type, id);
   };
@@ -450,9 +442,9 @@ export const EiProvider: ParentComponent = (props) => {
 
   const searchHumanData = async (
     query: string,
-    options?: { types?: Array<"fact" | "trait" | "topic" | "person" | "quote">; limit?: number }
+    options?: { types?: Array<"fact" | "topic" | "person" | "quote">; limit?: number }
   ) => {
-    if (!processor) return { facts: [], traits: [], topics: [], people: [], quotes: [] };
+    if (!processor) return { facts: [], topics: [], people: [], quotes: [] };
     return processor.searchHumanData(query, options);
   };
 
@@ -648,7 +640,6 @@ export const EiProvider: ParentComponent = (props) => {
     updateHuman,
     updateSettings,
     upsertFact,
-    upsertTrait,
     upsertTopic,
     upsertPerson,
     removeDataItem,

package/tui/src/context/overlay.tsx

@@ -6,24 +6,35 @@ import {
   type JSX,
   type Accessor,
 } from "solid-js";
+import { type CliRenderer } from "@opentui/core";
 import { logger } from "../util/logger";
 
-export type OverlayRenderer = (hideOverlay: () => void) => JSX.Element;
+export type OverlayRenderer = (hideOverlay: () => void, hideForEditor: () => void) => JSX.Element;
 
 interface OverlayContextValue {
-  overlayRenderer: Accessor<OverlayRenderer | null>;
-  showOverlay: (renderer: OverlayRenderer) => void;
+  overlayRenderer: Accessor<(() => JSX.Element) | null>;
+  showOverlay: (renderer: OverlayRenderer, cliRenderer?: CliRenderer) => void;
   hideOverlay: () => void;
 }
 
 const OverlayContext = createContext<OverlayContextValue>();
 
 export const OverlayProvider: ParentComponent = (props) => {
-  const [overlayRenderer, setOverlayRenderer] = createSignal<OverlayRenderer | null>(null);
+  const [overlayRenderer, setOverlayRenderer] = createSignal<(() => JSX.Element) | null>(null);
 
-  const showOverlay = (renderer: OverlayRenderer) => {
+  const showOverlay = (renderer: OverlayRenderer, cliRenderer?: CliRenderer) => {
     logger.debug("[overlay] showOverlay called");
-    setOverlayRenderer(() => renderer);
+    const hideForEditor = () => {
+      if (cliRenderer) {
+        cliRenderer.currentRenderBuffer.clear();
+      }
+      setOverlayRenderer(null);
+    };
+    const hideOverlay = () => {
+      logger.debug("[overlay] hideOverlay called");
+      setOverlayRenderer(null);
+    };
+    setOverlayRenderer(() => () => renderer(hideOverlay, hideForEditor));
   };
 
   const hideOverlay = () => {

package/tui/src/util/editor.ts

@@ -3,6 +3,7 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 import type { CliRenderer } from "@opentui/core";
+import { RendererControlState } from "@opentui/core";
 import { logger } from "./logger";
 
 export interface EditorOptions {
@@ -103,23 +104,30 @@ export async function spawnEditor(options: EditorOptions): Promise<EditorResult>
   const safeName = filename.replace(/\s+/g, "-");
   const tmpFile = path.join(tmpDir, `ei-${Date.now()}-${safeName}`);
   
-  logger.debug("[editor] spawnEditor called", { filename, editor });
+  logger.debug("[editor] spawnEditor called - START", { filename, editor });
+  
+  // CRITICAL: 50ms delay to let SolidJS reactive updates settle before suspending
+  // This prevents ghost frames when transitioning from overlays to editor
+  await new Promise(resolve => setTimeout(resolve, 50));
   
   fs.writeFileSync(tmpFile, initialContent, "utf-8");
   const originalContent = initialContent;
   
   return new Promise((resolve) => {
-    logger.debug("[editor] calling renderer.suspend()");
-    renderer.suspend();
-    logger.debug("[editor] calling renderer.currentRenderBuffer.clear()");
-    renderer.currentRenderBuffer.clear();
+    const wasAlreadySuspended = renderer.controlState === RendererControlState.EXPLICIT_SUSPENDED;
+    logger.debug("[editor] renderer state", { controlState: renderer.controlState, wasAlreadySuspended });
+    
+    if (!wasAlreadySuspended) {
+      renderer.suspend();
+    }
     
-    logger.debug("[editor] spawning editor process");
+    renderer.currentRenderBuffer.clear();
     const child = spawn(editor, [tmpFile], {
       stdio: "inherit",
       shell: true,
     });
     
+    
     child.on("error", () => {
       logger.error("[editor] editor process error");
       renderer.currentRenderBuffer.clear();
@@ -135,13 +143,16 @@ export async function spawnEditor(options: EditorOptions): Promise<EditorResult>
     
     child.on("exit", (code) => {
       logger.debug("[editor] editor process exited", { code });
-      logger.debug("[editor] calling renderer.currentRenderBuffer.clear()");
       renderer.currentRenderBuffer.clear();
-      logger.debug("[editor] calling renderer.resume()");
-      renderer.resume();
-      logger.debug("[editor] queueMicrotask for requestRender");
+      
+      if (!wasAlreadySuspended) {
+        logger.debug("[editor] calling renderer.resume()");
+        renderer.resume();
+      } else {
+        logger.debug("[editor] already suspended before spawn, skipping resume");
+      }
+      
       queueMicrotask(() => {
-        logger.debug("[editor] calling renderer.requestRender()");
         renderer.requestRender();
       });
       

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

@@ -80,12 +80,12 @@ export async function createPersonaViaEditor(options: NewPersonaEditorOptions):
       logger.debug("[persona-editor] YAML parse error in new persona", { error: errorMsg });
       
       const shouldReEdit = await new Promise<boolean>((resolve) => {
-        ctx.showOverlay((hideOverlay) => (
+        ctx.showOverlay((hideOverlay, hideForEditor) => (
           <ConfirmOverlay
             message={`YAML parse error:\n${errorMsg}\n\nRe-edit?`}
             onConfirm={() => {
               logger.debug("[persona-editor] user confirmed re-edit (new)");
-              hideOverlay();
+              hideForEditor();
               resolve(true);
             }}
             onCancel={() => {
@@ -94,12 +94,11 @@ export async function createPersonaViaEditor(options: NewPersonaEditorOptions):
               resolve(false);
             }}
           />
-        ));
+        ), ctx.renderer);
       });
       
       if (shouldReEdit) {
         yamlContent = result.content;
-        await new Promise(r => setTimeout(r, 50));
         continue;
       } else {
         ctx.showNotification("Creation cancelled", "info");
@@ -155,12 +154,12 @@ export async function openPersonaEditor(options: PersonaEditorOptions): Promise<
       logger.debug("[persona-editor] YAML parse error", { error: errorMsg });
       
       const shouldReEdit = await new Promise<boolean>((resolve) => {
-        ctx.showOverlay((hideOverlay) => (
+        ctx.showOverlay((hideOverlay, hideForEditor) => (
           <ConfirmOverlay
             message={`YAML parse error:\n${errorMsg}\n\nRe-edit?`}
             onConfirm={() => {
               logger.debug("[persona-editor] user confirmed re-edit");
-              hideOverlay();
+              hideForEditor();
               resolve(true);
             }}
             onCancel={() => {
@@ -169,12 +168,11 @@ export async function openPersonaEditor(options: PersonaEditorOptions): Promise<
               resolve(false);
             }}
           />
-        ));
+        ), ctx.renderer);
       });
       
       if (shouldReEdit) {
         yamlContent = result.content;
-        await new Promise(r => setTimeout(r, 50));
         continue;
       } else {
         ctx.showNotification("Changes discarded", "info");

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

@@ -66,11 +66,11 @@ export async function createProviderViaEditor(ctx: CommandContext): Promise<NewP
       logger.debug("[provider-editor] YAML parse error in new provider", { error: errorMsg });
       
       const shouldReEdit = await new Promise<boolean>((resolve) => {
-        ctx.showOverlay((hideOverlay) => (
+        ctx.showOverlay((hideOverlay, hideForEditor) => (
           <ConfirmOverlay
             message={`YAML parse error:\n${errorMsg}\n\nRe-edit?`}
             onConfirm={() => {
-              hideOverlay();
+              hideForEditor();
               resolve(true);
             }}
             onCancel={() => {
@@ -78,12 +78,11 @@ export async function createProviderViaEditor(ctx: CommandContext): Promise<NewP
               resolve(false);
             }}
           />
-        ));
+        ), ctx.renderer);
       });
       
       if (shouldReEdit) {
         yamlContent = result.content;
-        await new Promise(r => setTimeout(r, 50));
         continue;
       } else {
         ctx.showNotification("Creation cancelled", "info");
@@ -140,11 +139,11 @@ export async function openProviderEditor(account: ProviderAccount, ctx: CommandC
       logger.debug("[provider-editor] YAML parse error", { error: errorMsg });
       
       const shouldReEdit = await new Promise<boolean>((resolve) => {
-        ctx.showOverlay((hideOverlay) => (
+        ctx.showOverlay((hideOverlay, hideForEditor) => (
           <ConfirmOverlay
             message={`YAML parse error:\n${errorMsg}\n\nRe-edit?`}
             onConfirm={() => {
-              hideOverlay();
+              hideForEditor();
               resolve(true);
             }}
             onCancel={() => {
@@ -152,12 +151,11 @@ export async function openProviderEditor(account: ProviderAccount, ctx: CommandC
               resolve(false);
             }}
           />
-        ));
+        ), ctx.renderer);
       });
       
       if (shouldReEdit) {
         yamlContent = result.content;
-        await new Promise(r => setTimeout(r, 50));
         continue;
       } else {
         ctx.showNotification("Changes discarded", "info");

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

@@ -55,11 +55,11 @@ export async function openToolkitEditor(
       logger.debug("[toolkit-editor] YAML parse error", { error: errorMsg });
 
       const shouldReEdit = await new Promise<boolean>((resolve) => {
-        ctx.showOverlay((hideOverlay) => (
+        ctx.showOverlay((hideOverlay, hideForEditor) => (
           <ConfirmOverlay
             message={`YAML parse error:\n${errorMsg}\n\nRe-edit?`}
             onConfirm={() => {
-              hideOverlay();
+              hideForEditor();
               resolve(true);
             }}
             onCancel={() => {
@@ -67,12 +67,11 @@ export async function openToolkitEditor(
               resolve(false);
             }}
           />
-        ));
+        ), ctx.renderer);
       });
 
       if (shouldReEdit) {
         yamlContent = result.content;
-        await new Promise(r => setTimeout(r, 50));
         continue;
       } else {
         ctx.showNotification("Changes discarded", "info");