ei-tui 0.8.0 → 0.9.0

package/src/prompts/index.ts

@@ -81,6 +81,15 @@ export {
   buildRoomResponsePrompt,
   buildRoomJudgePrompt,
 } from "./room/index.js";
+
+export { buildReflectionCriticPrompt } from "./reflection/index.js";
+export type {
+  ReflectionCriticPromptData,
+  ReflectionCriticResult,
+  PersonaIdentitySnapshot,
+} from "./reflection/types.js";
+
+
 export type {
   RoomResponsePromptData,
   RoomJudgePromptData,

package/src/prompts/message-utils.ts

@@ -8,24 +8,27 @@ export function getMessageDisplayText(message: Message): string | null {
   const content = getMessageContent(message);
   if (content) parts.push(content);
   if (message.silence_reason) {
-    const name = message.speaker_name ?? 'Persona';
+    const name = message.role === "human"
+      ? (message.speaker_name ?? 'Human')
+      : (message.speaker_name ?? 'Persona');
     parts.push(`[${name} chose not to respond because: ${message.silence_reason}]`);
   }
   if (parts.length === 0) return null;
   return parts.join('\n\n');
 }
 
-export function buildChatMessageContent(message: Message): string {
+export function buildChatMessageContent(message: Message, humanName?: string): string {
   const parts: string[] = [];
   const content = getMessageContent(message);
 
   if (message._synthesis && content) {
-    parts.push(`[The user used your conversation to generate an image. The full prompt was: "${content}"]`);
+    parts.push(`[${humanName ?? 'The user'} used your conversation to generate an image. The full prompt was: "${content}"]`);
   } else if (content) {
     parts.push(content);
   }
   if (message.silence_reason) {
-    parts.push(`You chose not to respond because: ${message.silence_reason}`);
+    const silentParty = message.role === "human" ? (humanName ?? "The human") : "You";
+    parts.push(`${silentParty} chose not to respond because: ${message.silence_reason}`);
   }
   return parts.join('\n\n');
 }

package/src/prompts/reflection/index.ts

@@ -0,0 +1,77 @@
+import type { PromptOutput } from "../response/types.js";
+import type { ReflectionCriticPromptData } from "./types.js";
+
+export type {
+  ReflectionCriticPromptData,
+  ReflectionCriticResult,
+  PersonaIdentitySnapshot,
+} from "./types.js";
+
+export function buildReflectionCriticPrompt(data: ReflectionCriticPromptData): PromptOutput {
+  if (!data.persona_identity?.name) {
+    throw new Error("buildReflectionCriticPrompt: persona_identity.name is required");
+  }
+
+  const identityJson = JSON.stringify({
+    long_description: data.persona_identity.long_description,
+    short_description: data.persona_identity.short_description,
+    traits: data.persona_identity.traits.map(t => ({ name: t.name, description: t.description, strength: t.strength, sentiment: t.sentiment })),
+    topics: data.persona_identity.topics.map(t => ({ name: t.name, perspective: t.perspective, approach: t.approach, personal_stake: t.personal_stake, sentiment: t.sentiment, exposure_current: t.exposure_current, exposure_desired: t.exposure_desired })),
+  }, null, 2);
+
+  const system = `You are a character analyst reviewing an AI persona named ${data.persona_identity.name}.
+
+You have been given two documents:
+
+1. **The Person Log** (System Prompt — treat as ground truth): A running record of observed behaviors, statements, and patterns from real conversations. This is what actually happened.
+
+2. **The Current Identity** (User Prompt — treat as a draft to revise): The persona's self-definition: traits, topics, and descriptions. This should reflect who they actually are.
+
+Read the Person Log carefully. Then review the Current Identity. Produce a revised Identity that reflects the Person Log's observations — updating, adding, or softening any traits or topics where the log shows evidence of divergence.
+
+## Field Semantics
+
+**Traits:**
+- \`strength\` (0.0–1.0): How consistently this trait manifests. 0.0 = actively suppress this behavior, 0.5 = moderate/default, 1.0 = defining characteristic, always present.
+- \`sentiment\` (-1.0–1.0): How the persona feels about having this trait. -1.0 = resents it, 0.0 = neutral, 1.0 = embraces it fully.
+
+**Topics:**
+- \`sentiment\` (-1.0–1.0): How the persona feels about this topic. -1.0 = aversion/conflict, 0.0 = neutral, 1.0 = deep affinity.
+- \`exposure_current\` (0.0–1.0): How recently and frequently this topic has been discussed. 0.0 = hasn't come up in a long time, 1.0 = was just discussed at length.
+- \`exposure_desired\` (0.0–1.0): How much the persona wants to engage with this topic. 0.0 = avoid entirely, 0.5 = average engagement, 1.0 = core obsession.
+
+Return JSON:
+
+\`\`\`json
+{
+  "critique": "2-4 sentence prose summary of what the log reveals — what confirms, nuances, or contradicts the current identity",
+  "updated_identity": {
+    "long_description": "revised long description",
+    "short_description": "revised short description (1-2 sentences)",
+    "traits": [{ "name": "...", "description": "...", "strength": 0.8, "sentiment": 0.7 }],
+    "topics": [{ "name": "...", "perspective": "...", "approach": "...", "personal_stake": "...", "sentiment": 0.5, "exposure_current": 0.5, "exposure_desired": 0.6 }]
+  }
+}
+\`\`\`
+
+Rules:
+- Never invent observations not supported by the log
+- Preserve traits and topics the log confirms — don't remove them
+- If the log shows no evidence on a trait, leave it unchanged
+- updated_identity must be complete and self-contained — not a diff`;
+
+  const user = `## Current Identity
+
+\`\`\`json
+${identityJson}
+\`\`\`
+
+Analyze the Person Log above and return the revised identity JSON.`;
+
+  return {
+    system: `${system}\n\n## Person Log (Ground Truth)\n\n${data.person_log}`,
+    user,
+  };
+}
+
+

package/src/prompts/reflection/types.ts

@@ -0,0 +1,26 @@
+import type { PersonaTrait, PersonaTopic } from "../../core/types.js";
+
+export interface PersonaIdentitySnapshot {
+  name: string;
+  long_description: string;
+  short_description: string;
+  traits: PersonaTrait[];
+  topics: PersonaTopic[];
+}
+
+export interface ReflectionCriticPromptData {
+  persona_identity: PersonaIdentitySnapshot;
+  person_log: string;
+}
+
+export interface ReflectionCriticResult {
+  critique: string;
+  updated_identity: {
+    long_description: string;
+    short_description: string;
+    traits: PersonaTrait[];
+    topics: PersonaTopic[];
+  };
+}
+
+

package/src/prompts/response/index.ts

@@ -22,6 +22,7 @@ import {
   getConversationStateText,
   buildResponseFormatSection,
   buildToolsSection,
+  buildTemporalAnchorsSection,
 } from "./sections.js";
 
 export type { ResponsePromptData, PromptOutput, PersonaResponseResult } from "./types.js";
@@ -45,6 +46,7 @@ Your role is unique among personas:
   const guidelines = buildGuidelinesSection("ei");
   const yourTraits = buildTraitsSection(data.persona.traits, "Your Personality");
   const yourTopics = buildTopicsSection(data.persona.topics, "Your Interests");
+  const temporalAnchors = buildTemporalAnchorsSection(data.temporal_anchors, data.human.name);
   const humanSection = buildHumanSection(data.human);
   const quotesSection = buildQuotesSection(data.human.quotes, data.human);
   const associatesSection = buildAssociatesSection(data.visible_personas);
@@ -65,7 +67,7 @@ ${guidelines}
 ${yourTraits}
 
 ${yourTopics}
-
+${temporalAnchors ? `\n${temporalAnchors}` : ""}
 ${humanSection}
 ${quotesSection}
 ${associatesSection}
@@ -91,6 +93,7 @@ function buildStandardSystemPrompt(data: ResponsePromptData): string {
   const guidelines = buildGuidelinesSection(data.persona.name);
   const yourTraits = buildTraitsSection(data.persona.traits, "Your Personality");
   const yourTopics = buildTopicsSection(data.persona.topics, "Your Interests");
+  const temporalAnchors = buildTemporalAnchorsSection(data.temporal_anchors, data.human.name);
   const humanSection = buildHumanSection(data.human);
   const quotesSection = buildQuotesSection(data.human.quotes, data.human);
   const associatesSection = buildAssociatesSection(data.visible_personas);
@@ -110,7 +113,7 @@ ${guidelines}
 ${yourTraits}
 
 ${yourTopics}
-
+${temporalAnchors ? `\n${temporalAnchors}` : ""}
 ${humanSection}
 ${quotesSection}
 ${associatesSection}

package/src/prompts/response/sections.ts

@@ -4,7 +4,7 @@
  */
 
 import type { PersonaTrait, Quote, PersonaTopic } from "../../core/types.js";
-import type { ResponsePromptData } from "./types.js";
+import type { ResponsePromptData, TemporalAnchor } from "./types.js";
 import { formatTimestamp } from "../../core/format-utils.js";
 
 const DESCRIPTION_MAX_CHARS = 500;
@@ -428,3 +428,31 @@ You have tools available (listed in the API call). Use them freely:
 - Tool calls are a *pre-response step*, not a response. Do NOT produce the JSON reply until you have gathered everything you need.
 - When you are ready to speak, produce the JSON reply as specified above.`;
 }
+
+// =============================================================================
+// TEMPORAL ANCHORS SECTION
+// =============================================================================
+
+export function buildTemporalAnchorsSection(anchors: TemporalAnchor[], humanName: string): string {
+  if (anchors.length === 0) return "";
+
+  const formatted = anchors.map(a => {
+    const speaker = a.role === "human" ? humanName : "You";
+    let text: string;
+    if (a._synthesis && a.content) {
+      text = `[${humanName} used your conversation to generate an image. The full prompt was: "${a.content}"]`;
+    } else if (a.silence_reason) {
+      const silentParty = a.role === "human" ? humanName : "You";
+      text = `${silentParty} chose not to respond because: ${a.silence_reason}`;
+    } else {
+      text = a.content ?? "";
+    }
+    return `[${formatTimestamp(a.timestamp)}] ${speaker}: ${text}`;
+  }).join("\n\n");
+
+  return `## Temporal Anchors
+
+These are pinned moments from your shared history — preserved across context windows as part of who you are:
+
+${formatted}`;
+}

package/src/prompts/response/types.ts

@@ -6,6 +6,14 @@
 import type { Fact, PersonaTrait, Topic, Person, Quote, PersonaTopic } from "../../core/types.js";
 import type { ToolDefinition } from "../../core/types.js";
 
+export interface TemporalAnchor {
+  role: "human" | "system";
+  content?: string;
+  silence_reason?: string;
+  timestamp: string;
+  _synthesis?: boolean;
+}
+
 /**
  * Data contract for buildResponsePrompt (from CONTRACTS.md)
  */
@@ -34,6 +42,7 @@ export interface ResponsePromptData {
     interested_topics: Topic[];
   };
   visible_personas: Array<{ name: string; short_description?: string }>;
+  temporal_anchors: TemporalAnchor[];
   delay_ms: number;
   isTUI: boolean;
   /** Tools assigned to this persona and available in the current runtime. Used to conditionally include tool-use instructions in the system prompt. */
@@ -45,8 +54,7 @@ export interface ResponsePromptData {
  */
 export interface PersonaResponseResult {
   should_respond: boolean;
-  verbal_response?: string;
-  action_response?: string;
+  content?: string;
   reason?: string;
 }
 

package/src/prompts/room/sections.ts

@@ -40,10 +40,7 @@ export function buildRoomHistorySection(history: RoomHistoryMessage[], humanName
     if (msg.silence_reason) {
       return `**${speaker}**: *[chose not to respond: ${msg.silence_reason}]*`;
     }
-    const parts: string[] = [];
-    if (msg.verbal_response) parts.push(msg.verbal_response);
-    if (msg.action_response) parts.push(`*${msg.action_response}*`);
-    return `**${speaker}**: ${parts.join(" ")}`;
+    return `**${speaker}**: ${msg.content ?? ''}`;
   });
 
   return `## Conversation So Far\n\n${lines.join("\n\n")}`;
@@ -103,10 +100,10 @@ Silence can be the right response: stepping back when someone else was addressed
 }
 
 export function buildSiblingAwarenessSection(
-  siblings: Array<{ name: string; verbal_response: string }>
+  siblings: Array<{ name: string; content: string }>
 ): string {
   if (siblings.length === 0) return "";
-  const lines = siblings.map(s => `**${s.name}**: "${s.verbal_response}"`);
+  const lines = siblings.map(s => `**${s.name}**: "${s.content}"`);
   return `## Room context — this round
 
 You're in a shared conversation. The human will read everyone's responses together. Here's what has already been contributed this round:
@@ -121,7 +118,7 @@ export function buildJudgeCandidatesSection(candidates: RoomJudgeCandidate[], hu
     const speaker = c.speaker_id === "human" ? humanName : c.speaker_name;
     const content = c.silence_reason
       ? `*[chose not to respond: ${c.silence_reason}]*`
-      : [c.verbal_response, c.action_response ? `*${c.action_response}*` : ""].filter(Boolean).join(" ");
+      : (c.content ?? '');
     return `### Option ${i + 1} — ${speaker}\nMessage ID: \`${c.message_id}\`\n\n${content}`;
   });
   return `## The Responses\n\n${lines.join("\n\n")}`;

package/src/prompts/room/types.ts

@@ -17,8 +17,7 @@ export interface RoomParticipantIdentity {
 export interface RoomHistoryMessage {
   speaker_name: string;
   speaker_id: string;
-  verbal_response?: string;
-  action_response?: string;
+  content?: string;
   silence_reason?: string;
 }
 
@@ -58,8 +57,7 @@ export interface RoomJudgeCandidate {
   message_id: string;
   speaker_name: string;
   speaker_id: string;
-  verbal_response?: string;
-  action_response?: string;
+  content?: string;
   silence_reason?: string;
 }
 
@@ -87,8 +85,7 @@ export interface RoomJudgeResult {
 
 export interface PersonaResponseResult {
   should_respond: boolean;
-  verbal_response?: string;
-  action_response?: string;
+  content?: string;
   reason?: string;
 }
 

package/src/storage/embeddings.ts

@@ -15,8 +15,9 @@
  * decodeEmbedding returns it as-is. Mixed old/new files are handled transparently.
  *
  * IMPORTANT: encodeAllEmbeddings does NOT mutate the input state. It returns a new
- * StorageState where human item arrays are shallow-copied with encoded embedding fields.
- * This prevents the live in-memory state from being corrupted with base64 strings.
+ * StorageState where human item arrays and persona entities are shallow-copied with
+ * encoded embedding fields. This prevents the live in-memory state from being
+ * corrupted with base64 strings.
  */
 
 import type { StorageState } from "../core/types.js";
@@ -58,46 +59,80 @@ function decodeEmbedding(value: unknown): number[] | undefined {
 
 const HUMAN_ITEM_KEYS = ["facts", "topics", "people", "quotes"] as const;
 
-/**
- * Returns a new StorageState with embeddings encoded as base64 strings.
- * Does NOT mutate the input — human item arrays are shallow-copied.
- */
 export function encodeAllEmbeddings(state: StorageState): StorageState {
-  const human = (state as unknown as Record<string, unknown>)["human"] as Record<string, unknown> | undefined;
-  if (!human) return state;
-
-  const encodedHuman: Record<string, unknown> = { ...human };
-  for (const key of HUMAN_ITEM_KEYS) {
-    const items = human[key];
-    if (Array.isArray(items)) {
-      encodedHuman[key] = items.map((item: Record<string, unknown>) => {
-        if (!Array.isArray(item.embedding) || item.embedding.length === 0) return item;
-        return { ...item, embedding: encodeEmbedding(item.embedding as number[]) };
-      });
+  const raw = state as unknown as Record<string, unknown>;
+
+  const human = raw["human"] as Record<string, unknown> | undefined;
+  let encodedHuman = human;
+  if (human) {
+    encodedHuman = { ...human };
+    for (const key of HUMAN_ITEM_KEYS) {
+      const items = human[key];
+      if (Array.isArray(items)) {
+        (encodedHuman as Record<string, unknown>)[key] = items.map((item: Record<string, unknown>) => {
+          if (!Array.isArray(item.embedding) || item.embedding.length === 0) return item;
+          return { ...item, embedding: encodeEmbedding(item.embedding as number[]) };
+        });
+      }
+    }
+  }
+
+  const personas = raw["personas"] as Record<string, unknown> | undefined;
+  let encodedPersonas = personas;
+  if (personas) {
+    encodedPersonas = {};
+    for (const [id, data] of Object.entries(personas)) {
+      const d = data as Record<string, unknown>;
+      const entity = d["entity"] as Record<string, unknown> | undefined;
+      if (!entity || !Array.isArray(entity["description_embedding"]) || (entity["description_embedding"] as unknown[]).length === 0) {
+        (encodedPersonas as Record<string, unknown>)[id] = data;
+      } else {
+        (encodedPersonas as Record<string, unknown>)[id] = {
+          ...d,
+          entity: { ...entity, description_embedding: encodeEmbedding(entity["description_embedding"] as number[]) },
+        };
+      }
     }
   }
 
-  return { ...state, human: encodedHuman as unknown as StorageState["human"] };
+  return { ...state, human: encodedHuman as unknown as StorageState["human"], personas: encodedPersonas as unknown as StorageState["personas"] };
 }
 
-/**
- * Returns a new StorageState with embeddings decoded from base64 to number[].
- * Does NOT mutate the input — human item arrays are shallow-copied.
- */
 export function decodeAllEmbeddings(state: StorageState): StorageState {
-  const human = (state as unknown as Record<string, unknown>)["human"] as Record<string, unknown> | undefined;
-  if (!human) return state;
-
-  const decodedHuman: Record<string, unknown> = { ...human };
-  for (const key of HUMAN_ITEM_KEYS) {
-    const items = human[key];
-    if (Array.isArray(items)) {
-      decodedHuman[key] = items.map((item: Record<string, unknown>) => {
-        if (item.embedding === undefined || Array.isArray(item.embedding)) return item;
-        return { ...item, embedding: decodeEmbedding(item.embedding) };
-      });
+  const raw = state as unknown as Record<string, unknown>;
+
+  const human = raw["human"] as Record<string, unknown> | undefined;
+  let decodedHuman = human;
+  if (human) {
+    decodedHuman = { ...human };
+    for (const key of HUMAN_ITEM_KEYS) {
+      const items = human[key];
+      if (Array.isArray(items)) {
+        (decodedHuman as Record<string, unknown>)[key] = items.map((item: Record<string, unknown>) => {
+          if (item.embedding === undefined || Array.isArray(item.embedding)) return item;
+          return { ...item, embedding: decodeEmbedding(item.embedding) };
+        });
+      }
+    }
+  }
+
+  const personas = raw["personas"] as Record<string, unknown> | undefined;
+  let decodedPersonas = personas;
+  if (personas) {
+    decodedPersonas = {};
+    for (const [id, data] of Object.entries(personas)) {
+      const d = data as Record<string, unknown>;
+      const entity = d["entity"] as Record<string, unknown> | undefined;
+      if (!entity || entity["description_embedding"] === undefined || Array.isArray(entity["description_embedding"])) {
+        (decodedPersonas as Record<string, unknown>)[id] = data;
+      } else {
+        (decodedPersonas as Record<string, unknown>)[id] = {
+          ...d,
+          entity: { ...entity, description_embedding: decodeEmbedding(entity["description_embedding"]) },
+        };
+      }
     }
   }
 
-  return { ...state, human: decodedHuman as unknown as StorageState["human"] };
+  return { ...state, human: decodedHuman as unknown as StorageState["human"], personas: decodedPersonas as unknown as StorageState["personas"] };
 }

package/src/storage/merge.ts

@@ -150,7 +150,7 @@ export function yoloMerge(local: StorageState, remote: StorageState): StorageSta
     if (remoteSettings.queue_paused !== undefined) localSettings.queue_paused = remoteSettings.queue_paused;
     if (remoteSettings.skip_quote_delete_confirm !== undefined) localSettings.skip_quote_delete_confirm = remoteSettings.skip_quote_delete_confirm;
     if (remoteSettings.name_display !== undefined) localSettings.name_display = remoteSettings.name_display;
-    if (remoteSettings.time_mode !== undefined) localSettings.time_mode = remoteSettings.time_mode;
+
 
     if (remoteSettings.opencode) localSettings.opencode = remoteSettings.opencode;
     if (remoteSettings.ceremony) localSettings.ceremony = remoteSettings.ceremony;

package/src/templates/welcome.ts

@@ -87,5 +87,4 @@ Ei's unique role:
   is_archived: false,
   is_static: false,
   last_updated: new Date().toISOString(),
-  last_activity: new Date().toISOString(),
 };

package/tui/README.md

@@ -24,8 +24,11 @@ OpenCode also supports reading Ei's extracted knowledge back out via the [CLI to
 # Install Bun (if you don't have it)
 curl -fsSL https://bun.sh/install | bash
 
-# Install Ei
-npm install -g ei-tui
+# Run Ei — no install needed, always the latest version
+bunx ei-tui
+
+# Or, if you use it as much as I do, add this to your profile!
+alias ei='bunx ei-tui'
 ```
 
 ## TUI Commands

package/tui/src/commands/editor.tsx

@@ -38,7 +38,6 @@ export const editorCommand: Command = {
     }
     
     if (result.content === null) {
-      ctx.setInputText("");
       ctx.showNotification("No changes made", "info");
       return;
     }

package/tui/src/commands/persona.tsx

@@ -1,5 +1,7 @@
+import YAML from "yaml";
 import type { Command } from "./registry";
 import { isReservedPersonaName } from "../../../src/core/types.js";
+import { logger } from "../util/logger.js";
 import { PersonaListOverlay } from "../components/PersonaListOverlay";
 import { LoadingOverlay } from "../components/LoadingOverlay.js";
 import { PersonPickerOverlay } from "../components/PersonPickerOverlay.js";
@@ -66,6 +68,7 @@ export const personaCommand: Command = {
       try {
         parsed = descriptionFromYAML(descResult.content);
       } catch (e) {
+        logger.error("[persona:new] description parse error", e);
         ctx.showNotification(`Parse error: ${e instanceof Error ? e.message : String(e)}`, "error");
         return;
       }
@@ -104,6 +107,7 @@ export const personaCommand: Command = {
           .catch(e => {
             if (!dismissed && overlayCallbacks.hideOverlay) {
               overlayCallbacks.hideOverlay();
+              logger.error("[persona:new] generation failed", e);
               ctx.showNotification(`Generation failed: ${e instanceof Error ? e.message : String(e)}`, "error");
               resolve(null);
             }
@@ -199,11 +203,91 @@ export const personaCommand: Command = {
 
       let selectedPerson: (typeof human.people)[0];
       if (!personName) {
+        if (persona.pending_update) {
+          const previewContent = personaPreviewToYAML(
+            {
+              long_description: persona.pending_update.long_description,
+              short_description: persona.pending_update.short_description ?? '',
+              traits: persona.pending_update.traits.map(t => ({ ...t, strength: t.strength ?? 0.5, sentiment: t.sentiment ?? 0 })),
+              topics: persona.pending_update.topics,
+            },
+            persona.display_name,
+            undefined,
+            persona.long_description,
+          );
+          const applyHeader = [
+            `# Set _apply: true to apply these changes. Leave false to dismiss without applying.`,
+            `# :cq to cancel (pending changes will remain).`,
+            `_apply: false`,
+            ``,
+          ].join('\n');
+          const reviewResult = await spawnEditor({
+            initialContent: applyHeader + previewContent,
+            filename: `${personaId}-pending-update.yaml`,
+            renderer: ctx.renderer,
+          });
+
+          if (reviewResult.aborted) {
+            ctx.showNotification("Cancelled — pending changes preserved", "info");
+            return;
+          }
+
+          if (reviewResult.content === null) {
+            await ctx.ei.updatePersona(personaId, { pending_update: undefined });
+            ctx.showNotification(`Dismissed pending changes for ${persona.display_name}`, "info");
+            return;
+          }
+
+          const content = reviewResult.content;
+          let shouldApply = false;
+          let previewParsed: ReturnType<typeof personaPreviewFromYAML>;
+          try {
+            const raw = YAML.parse(content) as Record<string, unknown>;
+            shouldApply = raw._apply === true;
+            previewParsed = personaPreviewFromYAML(content);
+          } catch (e) {
+            logger.error("[persona:update] pending update parse error", e);
+            ctx.showNotification(`Parse error: ${e instanceof Error ? e.message : String(e)}`, "error");
+            return;
+          }
+
+          if (!shouldApply) {
+            const goBack = await new Promise<boolean>((resolve) => {
+              ctx.showOverlay((hideOverlay, hideForEditor) => (
+                <ConfirmOverlay
+                  message={`You made edits but _apply is still false — changes won't be applied.\n\nConfirm = go back and edit\nCancel = dismiss without applying`}
+                  onConfirm={() => { hideForEditor(); resolve(true); }}
+                  onCancel={() => { hideOverlay(); resolve(false); }}
+                />
+              ), ctx.renderer);
+            });
+
+            if (goBack) {
+              ctx.showNotification("Pending changes preserved", "info");
+              return;
+            }
+
+            await ctx.ei.updatePersona(personaId, { pending_update: undefined });
+            ctx.showNotification(`Dismissed pending changes for ${persona.display_name}`, "info");
+            return;
+          }
+
+          await ctx.ei.updatePersona(personaId, {
+            long_description: previewParsed.long_description,
+            short_description: previewParsed.short_description,
+            traits: previewParsed.traits,
+            topics: previewParsed.topics,
+            pending_update: undefined,
+          });
+          ctx.showNotification(`Applied changes to ${persona.display_name}`, "info");
+          return;
+        }
+
         const linked = (human.people ?? []).find(p =>
-          p.identifiers?.some(id => id.type === 'Ei Persona' && id.value === personaId)
+          p.identifiers?.some(id => id.type.toLowerCase() === 'ei persona' && id.value === personaId)
         );
         if (!linked) {
-          ctx.showNotification(`No person linked to "${personaName}". Try: /p update ${personaName} <personName>`, "error");
+          ctx.showNotification(`No pending update or linked person for "${personaName}". Try: /p update ${personaName} <personName>`, "error");
           return;
         }
         selectedPerson = linked;
@@ -284,6 +368,7 @@ export const personaCommand: Command = {
           .catch(e => {
             if (!dismissed && overlayCallbacks2.hideOverlay) {
               overlayCallbacks2.hideOverlay();
+              logger.error("[persona:update] generation failed", e);
               ctx.showNotification(`Generation failed: ${e instanceof Error ? e.message : String(e)}`, "error");
               resolve(null);
             }
@@ -318,6 +403,7 @@ export const personaCommand: Command = {
       try {
         previewParsed = personaPreviewFromYAML(reviewResult.content ?? updatePreviewYAML);
       } catch (e) {
+        logger.error("[persona:update] preview parse error", e);
         ctx.showNotification(`Parse error: ${e instanceof Error ? e.message : String(e)}`, "error");
         return;
       }
@@ -331,7 +417,7 @@ export const personaCommand: Command = {
       });
 
       const existingIdentifiers = selectedPerson.identifiers ?? [];
-      const alreadyLinked = existingIdentifiers.some(id => id.type === 'Ei Persona' && id.value === personaId);
+      const alreadyLinked = existingIdentifiers.some(id => id.type.toLowerCase() === 'ei persona' && id.value === personaId);
       if (!alreadyLinked) {
         const isPrimaryFirst = existingIdentifiers.length === 0;
         const updatedIdentifiers = [...existingIdentifiers, { type: 'Ei Persona', value: personaId, ...(isPrimaryFirst ? { is_primary: true } : {}) }];