ei-tui 0.1.24 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ei-tui",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "author": "Flare576",
   "repository": {
     "type": "git",

package/src/core/handlers/dedup.ts

@@ -23,6 +23,12 @@ export async function handleDedupCurate(
   const entity_ids = response.request.data.entity_ids as string[];
   const state = stateManager.getHuman();
   
+  // Validate entity_type
+  if (!entity_type || !['fact', 'trait', 'topic', 'person'].includes(entity_type)) {
+    console.error(`[Dedup] Invalid entity_type: "${entity_type}" (from request data)`, response.request.data);
+    return;
+  }
+  
   // Parse Opus response
   let decisions: DedupResult;
   try {
@@ -43,8 +49,28 @@ export async function handleDedupCurate(
   
   console.log(`[Dedup] Processing cluster: ${decisions.update.length} updates, ${decisions.remove.length} removals, ${decisions.add.length} additions`);
   
-  // HYDRATION: Fetch entities by ID (graceful degradation for missing)
-  const entityList = state[`${entity_type}s` as 'facts' | 'traits' | 'topics' | 'people'];
+  // Map entity_type to pluralized state property name
+  const pluralMap: Record<DataItemType, 'facts' | 'traits' | 'topics' | 'people'> = {
+    fact: 'facts',
+    trait: 'traits',
+    topic: 'topics',
+    person: 'people'
+  };
+  const entityList = state[pluralMap[entity_type]];
+  
+  // Validate entityList exists
+  if (!entityList || !Array.isArray(entityList)) {
+    console.error(`[Dedup] entityList is ${entityList === undefined ? 'undefined' : 'not an array'} for entity_type="${entity_type}" (looking for state.${entity_type}s)`, {
+      entity_type,
+      entity_ids,
+      stateKeys: Object.keys(state),
+      factsExists: !!state.facts,
+      traitsExists: !!state.traits,
+      topicsExists: !!state.topics,
+      peopleExists: !!state.people
+    });
+    return;
+  }
   const entities = entity_ids
     .map((id: string) => entityList.find((e: Fact | Trait | Topic | Person) => e.id === id))
     .filter((e: Fact | Trait | Topic | Person | undefined): e is (Fact | Trait | Topic | Person) => e !== undefined);

package/src/core/orchestrators/ceremony.ts

@@ -182,7 +182,6 @@ export function handleCeremonyProgress(state: StateManager, lastPhase: number):
     // Dedup phase complete → start Expose phase
     console.log("[ceremony:progress] Dedup complete, starting Expose phase");
     
-    const human = state.getHuman();
     const personas = state.persona_getAll();
     const activePersonas = personas.filter(p => 
       !p.is_paused && 
@@ -190,17 +189,21 @@ export function handleCeremonyProgress(state: StateManager, lastPhase: number):
       !p.is_static
     );
     
-    const lastCeremony = human.settings?.ceremony?.last_ceremony 
-      ? new Date(human.settings.ceremony.last_ceremony).getTime() 
-      : 0;
-    
-    const personasWithActivity = activePersonas.filter(p => {
-      const lastActivity = p.last_activity ? new Date(p.last_activity).getTime() : 0;
-      return lastActivity > lastCeremony;
+    // Find personas with unprocessed messages (any message with p/r/o/f = false)
+    const personasWithUnprocessed = activePersonas.filter(p => {
+      const messages = state.messages_get(p.id);
+      return messages.some(msg => 
+        !msg.p || 
+        !msg.r || 
+        !msg.o || 
+        !msg.f
+      );
     });
     
+    console.log(`[ceremony:expose] Found ${activePersonas.length} active personas, ${personasWithUnprocessed.length} with unprocessed messages`);
+    
     const options: ExtractionOptions = { ceremony_progress: 2 };
-    for (const persona of personasWithActivity) {
+    for (const persona of personasWithUnprocessed) {
       queueExposurePhase(persona.id, state, options);
     }
     return;

package/src/core/orchestrators/dedup-phase.ts

@@ -20,7 +20,7 @@ interface Cluster {
 // DEDUP CANDIDATE FINDING (copied from ceremony.ts)
 // =============================================================================
 
-const DEDUP_DEFAULT_THRESHOLD = 0.95;
+const DEDUP_DEFAULT_THRESHOLD = 0.85;  // Lowered from 0.95 based on experimental analysis: 0.95 only catches 3.9% of duplicate name groups, 0.85 catches 46.7%
 
 function findDedupCandidates<T extends DedupableItem>(
   items: T[],
@@ -127,6 +127,13 @@ function filterClusters(clusters: Cluster[]): Cluster[] {
 
 export function queueDedupPhase(state: StateManager): void {
   const human = state.getHuman();
+  const rewriteModel = human.settings?.rewrite_model;
+  
+  if (!rewriteModel) {
+    console.log("[Dedup] rewrite_model not set — skipping dedup phase");
+    return;
+  }
+  
   const threshold = human.settings?.ceremony?.dedup_threshold ?? DEDUP_DEFAULT_THRESHOLD;
   
   console.log(`[Dedup] Starting deduplication phase (threshold: ${threshold})`);
@@ -183,13 +190,13 @@ export function queueDedupPhase(state: StateManager): void {
         system: prompt.system,
         user: prompt.user,
         next_step: LLMNextStep.HandleDedupCurate,
+        model: rewriteModel,
         data: {
           entity_type: type,
-          entity_ids: cluster.ids,  // Lightweight stub (IDs only)
-          ceremony_progress: 1  // Phase 1 (Dedup)
+          entity_ids: cluster.ids,
+          ceremony_progress: 1
         }
       });
-      
       totalClusters++;
     }
   }

package/src/core/processor.ts

@@ -291,7 +291,7 @@ export class Processor {
         builtin: true,
         enabled: true,
         created_at: now,
-        max_calls_per_interaction: 3,
+        max_calls_per_interaction: 6,  // Dedup needs to verify relationships before irreversible merges. Typical cluster (3-8 items) requires: parent concept lookup + 2 relationship verifications + context validation. Still under HARD_TOOL_CALL_LIMIT (10).
       });
     }
 
@@ -715,14 +715,23 @@ const toolNextSteps = new Set([
   LLMNextStep.HandleHeartbeatCheck,
   LLMNextStep.HandleEiHeartbeat,
   LLMNextStep.HandleToolContinuation,
+  LLMNextStep.HandleDedupCurate,
 ]);
             const toolPersonaId =
               personaId ??
               (request.next_step === LLMNextStep.HandleEiHeartbeat ? "ei" : undefined);
-            const tools =
-              toolNextSteps.has(request.next_step) && toolPersonaId
-                ? this.stateManager.tools_getForPersona(toolPersonaId, this.isTUI)
-                : [];
+            
+            // Dedup operates on Human data, not persona data - provide read_memory directly
+            let tools: ToolDefinition[] = [];
+            if (request.next_step === LLMNextStep.HandleDedupCurate) {
+              const readMemory = this.stateManager.tools_getByName("read_memory");
+              if (readMemory?.enabled) {
+                tools = [readMemory];
+              }
+            } else if (toolNextSteps.has(request.next_step) && toolPersonaId) {
+              tools = this.stateManager.tools_getForPersona(toolPersonaId, this.isTUI);
+            }
+            
             console.log(
               `[Tools] Dispatch for ${request.next_step} persona=${toolPersonaId ?? "none"}: ${tools.length} tool(s) attached`
             );

package/src/prompts/ceremony/dedup.ts

@@ -15,22 +15,56 @@ import type { DedupPromptData } from "./types.js";
 export function buildDedupPrompt(data: DedupPromptData): { system: string; user: string } {
   const typeLabel = data.itemType.charAt(0).toUpperCase() + data.itemType.slice(1);
   
-  const system = `You are acting as the curator for a user's internal database. You have been given a cluster of ${typeLabel} records that our system believes may be duplicates (based on semantic similarity >= 0.90).
+  const system = `## HARD RULES (Non-Negotiable — Override All Other Instructions)
+
+You are working with Opus 4.6 constraints. These rules prevent overthinking and ensure decisive action:
+
+### 1. TOOL BUDGET
+- You have **6 \`read_memory\` calls** for this cluster
+- Prioritize: verify ambiguous relationships > check parent concepts > validate new entities
+- After 6 calls, make decisions with available information
+- Do NOT waste calls re-checking pairs you already examined
+
+### 2. SATISFICING MODE (Good Enough > Perfect)
+- If two items share **85%+ semantic similarity** on core meaning → merge them
+- Do NOT re-examine after deciding to merge
+- Do NOT explore alternative groupings
+- First valid match wins — stop searching for "better" options
+
+### 3. FORBIDDEN PATTERNS (Signs of Overthinking)
+If you find yourself writing these phrases, **STOP IMMEDIATELY**:
+- ❌ "On the other hand..." / "However, there's another angle..."
+- ❌ "Let me reconsider..." / "But what if..."
+- ❌ "This could be interpreted as..."
+- ❌ Re-analyzing the same pair after making a decision
+
+Output format when you catch overthinking:
+\`\`\`
+[OVERTHINKING DETECTED]
+Decision: [Yes/No to merge]
+Reason: [1 sentence]
+\`\`\`
+
+---
+
+## YOUR TASK
+
+You are acting as the curator for a user's internal database. You have been given a cluster of ${typeLabel} records that our system believes may be duplicates (based on semantic similarity >= 0.90).
 
 **YOUR PRIME DIRECTIVE IS TO LOSE _NO_ DATA.**
 
 Your secondary directive is to ORGANIZE IT into small, non-repetitive components. The user NEEDS the data, but the data is used by AI agents, so duplication limits usefulness—agents waste tokens re-reading the same information under different names.
 
-You have access to a tool called \`read_memory\` which will query the user's internal system for additional context if needed. Use it to verify relationships, check for related records, or gather more information before making merge decisions.
+You have access to a tool called \`read_memory\` (6 calls max — see HARD RULES above). Use it strategically to verify relationships, check for related records, or gather context before making merge decisions.
 
-Your task:
-1. **Identify true duplicates**: Examine each record. Are these genuinely the same thing with different wording, or are they distinct but related concepts?
+### Decision Process:
+1. **Identify true duplicates**: Examine each record. Are these genuinely the same thing with different wording (85%+ core meaning overlap), or are they distinct but related concepts?
 2. **Merge where appropriate**: For TRUE duplicates, consolidate all unique information into ONE canonical record. Pick the best "name" (most descriptive, most commonly used). Merge all descriptions—every unique detail must be preserved.
 3. **Keep distinct concepts separate**: Similar ≠ duplicate. "Software Engineering" and "Software Architecture" may be related but are NOT the same. "Job at Company X" and "Profession: Software Engineer" are related but distinct. Do NOT merge these.
 4. **Track what was merged**: For removed records, indicate which record absorbed their data (via "replaced_by" field).
 5. **Add new records if needed**: If consolidating reveals a MISSING intermediate concept (e.g., merging "Python Developer" and "Backend Engineer" reveals we're missing "Software Engineering" as a parent topic), create it.
 
-The format of your final output should be:
+### Output Format:
 {
   "update": [
     /* Full ${typeLabel} record payloads with all fields preserved */
@@ -53,14 +87,14 @@ Record format for "${typeLabel}" (based on type):
 
 ${buildRecordFormatExamples(data.itemType)}
 
-Rules:
+### Rules:
 - Do NOT invent information. Only redistribute what exists in the cluster.
 - Descriptions should be concise—ideally under 300 characters, never over 500.
 - Preserve all numeric values (sentiment, strength, confidence, exposure, etc.) from source records. When merging, take the HIGHER value for strength/confidence, AVERAGE for sentiment.
 - Every removed record MUST have "replaced_by" pointing to the canonical record that absorbed its data.
 - The "update" array should contain AT LEAST ONE record (the canonical/merged one), even if all others are removed.
 - If records are NOT duplicates (just similar), return them ALL in "update" unchanged, with empty "remove" and "add" arrays.
-- Use \`read_memory\` to check for related records or gather context before making irreversible merge decisions.`;
+- Use \`read_memory\` strategically (6 calls max) to check for related records or gather context before making irreversible merge decisions.`;
 
   const user = JSON.stringify({
     cluster: data.cluster.map(stripEmbedding),

package/tui/src/app.tsx

@@ -10,23 +10,25 @@ import { StatusBar } from "./components/StatusBar";
 import { Show } from "solid-js";
 import { useEi } from "./context/ei";
 import { WelcomeOverlay } from "./components/WelcomeOverlay";
+import { useRenderer } from "@opentui/solid";
 
 function AppContent() {
-  const { overlayRenderer, hideOverlay, showOverlay } = useOverlay();
+  const { overlayRenderer, showOverlay } = useOverlay();
   const { showWelcomeOverlay, dismissWelcomeOverlay } = useEi();
-
+  const renderer = useRenderer();
   // Show welcome overlay when LLM detection determines no provider is configured
   createEffect(() => {
     if (showWelcomeOverlay()) {
-      showOverlay((onDismiss) => (
+      showOverlay((onDismiss, _hideForEditor) => (
         <WelcomeOverlay onDismiss={() => {
           dismissWelcomeOverlay();
           onDismiss();
         }} />
-      ));
+      ), renderer);
     }
   });
 
+  
   return (
     <box flexDirection="column" width="100%" height="100%">
       <Layout
@@ -36,7 +38,7 @@ function AppContent() {
       />
       <StatusBar />
       <Show when={overlayRenderer()}>
-        {overlayRenderer()!(hideOverlay)}
+        {overlayRenderer()!()}
       </Show>
     </box>
   );

package/tui/src/commands/archive.tsx

@@ -16,7 +16,7 @@ export const archiveCommand: Command = {
         ctx.showNotification("No archived personas", "info");
         return;
       }
-      ctx.showOverlay((hideOverlay) => (
+      ctx.showOverlay((hideOverlay, _hideForEditor) => (
         <PersonaListOverlay
           personas={archived}
           activePersonaId={null}
@@ -30,7 +30,7 @@ export const archiveCommand: Command = {
           }}
           onDismiss={hideOverlay}
         />
-      ));
+      ), ctx.renderer);
       return;
     }
     

package/tui/src/commands/context.tsx

@@ -90,12 +90,12 @@ export const contextCommand: Command = {
         });
 
         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("[context] user confirmed re-edit");
-                hideOverlay();
+                hideForEditor();
                 resolve(true);
               }}
               onCancel={() => {
@@ -104,7 +104,7 @@ export const contextCommand: Command = {
                 resolve(false);
               }}
             />
-          ));
+          ), ctx.renderer);
         });
 
         logger.debug("[context] shouldReEdit", { shouldReEdit, iteration: editorIteration });
@@ -112,7 +112,6 @@ export const contextCommand: Command = {
         if (shouldReEdit) {
           yamlContent = result.content;
           logger.debug("[context] continuing to next iteration");
-          await new Promise((r) => setTimeout(r, 50));
           continue;
         } else {
           ctx.showNotification("Changes discarded", "info");

package/tui/src/commands/delete.tsx

@@ -14,13 +14,13 @@ export const deleteCommand: Command = {
     
     const confirmAndDelete = async (personaId: string, displayName: string) => {
       const confirmed = await new Promise<boolean>((resolve) => {
-        ctx.showOverlay((hideOverlay) => (
+        ctx.showOverlay((hideOverlay, _hideForEditor) => (
           <ConfirmOverlay
             message={`Delete "${displayName}"?\nThis cannot be undone.`}
             onConfirm={() => { hideOverlay(); resolve(true); }}
             onCancel={() => { hideOverlay(); resolve(false); }}
           />
-        ));
+        ), ctx.renderer);
       });
       
       if (confirmed) {
@@ -36,7 +36,7 @@ export const deleteCommand: Command = {
         ctx.showNotification("No personas available to delete", "info");
         return;
       }
-      ctx.showOverlay((hideOverlay) => (
+      ctx.showOverlay((hideOverlay, _hideForEditor) => (
         <PersonaListOverlay
           personas={deletable}
           activePersonaId={null}
@@ -48,7 +48,7 @@ export const deleteCommand: Command = {
           }}
           onDismiss={hideOverlay}
         />
-      ));
+      ), ctx.renderer);
       return;
     }
     

package/tui/src/commands/dlq.ts

@@ -52,18 +52,17 @@ export const dlqCommand: 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/help.tsx

@@ -7,6 +7,6 @@ export const helpCommand: Command = {
   description: "Show help screen",
   usage: "/help or /h",
   execute: async (_args, ctx) => {
-    ctx.showOverlay((hideOverlay) => <HelpOverlay onDismiss={hideOverlay} />);
+    ctx.showOverlay((_hideOverlay, _hideForEditor) => <HelpOverlay onDismiss={_hideOverlay} />, ctx.renderer);
   },
 };

package/tui/src/commands/me.tsx

@@ -112,12 +112,12 @@ export const meCommand: Command = {
         logger.debug("[me] 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={() => {
                 logger.debug("[me] user confirmed re-edit");
-                hideOverlay();
+                hideForEditor();
                 resolve(true);
               }}
               onCancel={() => {
@@ -126,7 +126,7 @@ export const meCommand: Command = {
                 resolve(false);
               }}
             />
-          ));
+          ), ctx.renderer);
         });
         
         logger.debug("[me] shouldReEdit", { shouldReEdit, iteration: editorIteration });
@@ -134,7 +134,6 @@ export const meCommand: Command = {
         if (shouldReEdit) {
           yamlContent = result.content;
           logger.debug("[me] continuing to next iteration");
-          await new Promise(r => setTimeout(r, 50));
           continue;
         } else {
           ctx.showNotification("Changes discarded", "info");

package/tui/src/commands/persona.tsx

@@ -13,7 +13,7 @@ export const personaCommand: Command = {
     const unarchived = ctx.ei.personas().filter(p => !p.is_archived);
     
     if (args.length === 0) {
-      ctx.showOverlay((hideOverlay) => (
+      ctx.showOverlay((hideOverlay, _hideForEditor) => (
         <PersonaListOverlay
           personas={unarchived}
           activePersonaId={ctx.ei.activePersonaId()}
@@ -25,7 +25,7 @@ export const personaCommand: Command = {
           }}
           onDismiss={hideOverlay}
         />
-      ));
+      ), ctx.renderer);
       return;
     }
     

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

@@ -54,11 +54,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 +66,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/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");