ei-tui 0.5.4 → 0.6.1

package/src/core/processor.ts

@@ -33,8 +33,9 @@ import { yoloMerge } from "../storage/merge.js";
 import { StateManager } from "./state-manager.js";
 import { QueueProcessor } from "./queue-processor.js";
 import { handlers } from "./handlers/index.js";
-import { normalizeRoomMessages } from "./handlers/utils.js";
-import { ContextStatus as ContextStatusEnum } from "./types.js";
+import { normalizeRoomMessages, getMessageContent } from "./handlers/utils.js";
+import { sanitizeEiPersonaIdentifiers } from "./utils/identifier-utils.js";
+import { ContextStatus as ContextStatusEnum, RoomMode } from "./types.js";
 import { registerReadMemoryExecutor, registerFileReadExecutor } from "./tools/index.js";
 import { createReadMemoryExecutor } from "./tools/builtin/read-memory.js";
 import { EI_WELCOME_MESSAGE, EI_PERSONA_DEFINITION } from "../templates/welcome.js";
@@ -167,6 +168,9 @@ export class Processor {
     this.instanceId = ++processorInstanceCount;
     console.log(`[Processor ${this.instanceId}] CREATED`);
     this.detectEnvironment();
+    this.stateManager.setQueueChangeListener(() => {
+      this.interface.onQueueStateChanged?.("busy");
+    });
   }
 
   private detectEnvironment(): void {
@@ -229,6 +233,7 @@ export class Processor {
     }
     this.bootstrapTools();
     this.seedBuiltinFacts();
+    this.migrateLearnedOn();
     this.seedSettings();
     registerReadMemoryExecutor(createReadMemoryExecutor(this.searchHumanData.bind(this), this.getPersonaList.bind(this)));
     if (this.isTUI) {
@@ -606,7 +611,8 @@ export class Processor {
         max_calls_per_interaction: 1,
     });
 
-    // submit_response tool — auto-injected for HandlePersonaResponse and HandleRoomResponse.
+    // submit_response tool — auto-injected for Heartbeat steps only (HandleHeartbeatCheck).
+    // PersonaResponse and RoomResponse agents now use natural Markdown output instead.
     // Not user-configurable; invisible in the tools UI. Terminates the tool loop immediately
     // when called; its arguments become response.parsed.
     this.stateManager.tools_upsertBuiltin({
@@ -796,6 +802,7 @@ export class Processor {
         sentiment: 0,
         validated_date: '',
         last_updated: now,
+        learned_on: now,
       };
       human.facts.push(newFact);
       seededCount++;
@@ -807,6 +814,27 @@ export class Processor {
     }
   }
 
+  private migrateLearnedOn(): void {
+    const human = this.stateManager.getHuman();
+
+    const backfill = <T extends { learned_on?: string; last_updated: string }>(items: T[]): T[] =>
+      items.map(item => item.learned_on ? item : { ...item, learned_on: item.last_updated });
+
+    const facts = backfill(human.facts);
+    const topics = backfill(human.topics);
+    const people = backfill(human.people);
+
+    const changed =
+      facts.some((f, i) => f !== human.facts[i]) ||
+      topics.some((t, i) => t !== human.topics[i]) ||
+      people.some((p, i) => p !== human.people[i]);
+
+    if (changed) {
+      this.stateManager.setHuman({ ...human, facts, topics, people });
+      console.log("[Processor] Backfilled learned_on for existing data items");
+    }
+  }
+
   private seedSettings(): void {
     const human = this.stateManager.getHuman();
     let modified = false;
@@ -1020,6 +1048,7 @@ const toolNextSteps = new Set([
   LLMNextStep.HandleEiHeartbeat,
   LLMNextStep.HandleToolContinuation,
   LLMNextStep.HandleDedupCurate,
+  LLMNextStep.HandlePersonIdentifierMigration,
 ]);
             const toolPersonaId =
               personaId ??
@@ -1034,8 +1063,13 @@ const toolNextSteps = new Set([
               (request.next_step === LLMNextStep.HandleToolContinuation &&
                 request.data.originalNextStep === LLMNextStep.HandleDedupCurate);
 
+            const isPersonMigrationRequest =
+              request.next_step === LLMNextStep.HandlePersonIdentifierMigration ||
+              (request.next_step === LLMNextStep.HandleToolContinuation &&
+                request.data.originalNextStep === LLMNextStep.HandlePersonIdentifierMigration);
+
             let tools: ToolDefinition[] = [];
-            if (isDedupRequest) {
+            if (isDedupRequest || isPersonMigrationRequest) {
               const readMemory = this.stateManager.tools_getByName("read_memory");
               if (readMemory?.enabled) {
                 tools = [readMemory];
@@ -1046,8 +1080,6 @@ const toolNextSteps = new Set([
 
             // Auto-inject each handler's dedicated submit tool — infrastructure, not user-visible.
             const submitToolByStep: Partial<Record<string, string>> = {
-              [LLMNextStep.HandlePersonaResponse]:  "submit_response",
-              [LLMNextStep.HandleRoomResponse]:     "submit_response",
               [LLMNextStep.HandleHeartbeatCheck]:   "submit_heartbeat_check",
               [LLMNextStep.HandleEiHeartbeat]:      "submit_ei_heartbeat",
               [LLMNextStep.HandleDedupCurate]:      "submit_dedup_decisions",
@@ -1063,8 +1095,11 @@ const toolNextSteps = new Set([
               }
             }
             
+            const toolPersonaName = toolPersonaId
+              ? (this.stateManager.persona_getById(toolPersonaId)?.display_name ?? toolPersonaId)
+              : "none";
             console.log(
-              `[Tools] Dispatch for ${request.next_step} persona=${toolPersonaId ?? "none"}: ${tools.length} tool(s) attached`
+              `[Tools] Dispatch for ${request.next_step} persona=${toolPersonaName}: ${tools.length} tool(s) attached`
             );
 
             this.queueProcessor.start(
@@ -1391,16 +1426,19 @@ const toolNextSteps = new Set([
 
     if (!roomId || !parentMessageId || !personaDisplayName) return request;
 
+    const room = this.stateManager.getRoom(roomId);
+    if (room?.mode !== RoomMode.FreeForAll) return request;
+
     const siblings = this.stateManager.getRoomChildren(roomId, parentMessageId)
-      .filter((m: RoomMessage) => m.role === "persona" && m.verbal_response)
+      .filter((m: RoomMessage) => m.role === "persona" && getMessageContent(m))
       .map((m: RoomMessage) => ({
         name: this.stateManager.persona_getById(m.persona_id ?? "")?.display_name ?? "Participant",
-        verbal_response: m.verbal_response!,
+        verbal_response: getMessageContent(m),
       }));
 
     if (siblings.length === 0) return request;
 
-    const siblingSection = buildSiblingAwarenessSection(siblings, personaDisplayName);
+    const siblingSection = buildSiblingAwarenessSection(siblings);
     return { ...request, system: request.system + "\n\n" + siblingSection };
   }
 
@@ -1586,9 +1624,7 @@ const toolNextSteps = new Set([
 
       if (
         response.request.next_step === LLMNextStep.HandlePersonaTraitExtraction ||
-        response.request.next_step === LLMNextStep.HandlePersonaTopicScan ||
-        response.request.next_step === LLMNextStep.HandlePersonaTopicMatch ||
-        response.request.next_step === LLMNextStep.HandlePersonaTopicUpdate
+        response.request.next_step === LLMNextStep.HandlePersonaTopicRating
       ) {
         const personaId = response.request.data.personaId as string;
         if (personaId) {
@@ -1819,7 +1855,8 @@ const toolNextSteps = new Set([
   }
 
   async upsertPerson(person: Person): Promise<void> {
-    await upsertPerson(this.stateManager, person);
+    const sanitized = { ...person, identifiers: sanitizeEiPersonaIdentifiers(person.identifiers ?? [], this.stateManager) };
+    await upsertPerson(this.stateManager, sanitized);
     this.interface.onHumanUpdated?.();
   }
 

package/src/core/prompt-context-builder.ts

@@ -4,11 +4,43 @@ import { getEmbeddingService, findTopK } from "./embedding-service.js";
 import type { ResponsePromptData, PromptOutput } from "../prompts/index.js";
 import { buildRoomResponsePrompt } from "../prompts/room/index.js";
 import type { RoomParticipantIdentity } from "../prompts/room/types.js";
-import { normalizeRoomMessages } from "./handlers/utils.js";
+import { normalizeRoomMessages, getMessageContent } from "./handlers/utils.js";
 
 const QUOTE_LIMIT = 10;
 const DATA_ITEM_LIMIT = 15;
 const SIMILARITY_THRESHOLD = 0.3;
+const HUMAN_CONTEXT_COMBINED_LIMIT = 10;
+const HUMAN_CONTEXT_MIN_EACH = 2;
+
+// =============================================================================
+// COMBINED TOPICS + PEOPLE CAP
+// =============================================================================
+
+function capTopicsAndPeople<T extends { id: string }, P extends { id: string }>(
+  topics: T[],
+  people: P[]
+): { topics: T[]; people: P[] } {
+  const guaranteed = {
+    topics: topics.slice(0, HUMAN_CONTEXT_MIN_EACH),
+    people: people.slice(0, HUMAN_CONTEXT_MIN_EACH),
+  };
+
+  let remaining = HUMAN_CONTEXT_COMBINED_LIMIT - guaranteed.topics.length - guaranteed.people.length;
+  const extraTopics: T[] = [];
+  const extraPeople: P[] = [];
+  let ti = HUMAN_CONTEXT_MIN_EACH;
+  let pi = HUMAN_CONTEXT_MIN_EACH;
+
+  while (remaining > 0 && (ti < topics.length || pi < people.length)) {
+    if (ti < topics.length && remaining > 0) { extraTopics.push(topics[ti++]); remaining--; }
+    if (pi < people.length && remaining > 0) { extraPeople.push(people[pi++]); remaining--; }
+  }
+
+  return {
+    topics: [...guaranteed.topics, ...extraTopics],
+    people: [...guaranteed.people, ...extraPeople],
+  };
+}
 
 // =============================================================================
 // EMBEDDING-BASED RELEVANCE SELECTION
@@ -38,7 +70,6 @@ async function selectRelevantItems<T extends { id: string; embedding?: number[]
     }
   }
 
-  // Fallback: return top items by recency
   return [...items]
     .sort((a, b) => {
       const aTime = (a as { last_updated?: string }).last_updated ?? "";
@@ -83,12 +114,13 @@ export async function filterHumanDataByVisibility(
   const DEFAULT_GROUP = "General";
 
   if (persona.id === "ei") {
-    const [facts, topics, people, quotes] = await Promise.all([
+    const [facts, rawTopics, rawPeople, quotes] = await Promise.all([
       selectRelevantItems(human.facts, DATA_ITEM_LIMIT, currentMessage),
       selectRelevantItems(human.topics, DATA_ITEM_LIMIT, currentMessage),
       selectRelevantItems(human.people, DATA_ITEM_LIMIT, currentMessage),
       selectRelevantQuotes(human.quotes ?? [], currentMessage),
     ]);
+    const { topics, people } = capTopicsAndPeople(rawTopics, rawPeople);
     return {
       facts,
       topics,
@@ -118,12 +150,13 @@ export async function filterHumanDataByVisibility(
     return effectiveGroups.some((g) => visibleGroups.has(g));
   });
 
-  const [facts, topics, people, quotes] = await Promise.all([
+  const [facts, rawTopics, rawPeople, quotes] = await Promise.all([
     selectRelevantItems(filterByGroup(human.facts), DATA_ITEM_LIMIT, currentMessage),
     selectRelevantItems(filterByGroup(human.topics), DATA_ITEM_LIMIT, currentMessage),
     selectRelevantItems(filterByGroup(human.people), DATA_ITEM_LIMIT, currentMessage),
     selectRelevantQuotes(groupFilteredQuotes, currentMessage),
   ]);
+  const { topics, people } = capTopicsAndPeople(rawTopics, rawPeople);
 
   return {
     facts,
@@ -241,7 +274,7 @@ export async function buildRoomResponsePromptData(
   const sourceMessages = byTime.length >= byCount.length ? byTime : byCount;
 
   const lastMessage = sourceMessages[sourceMessages.length - 1];
-  const currentMessage = lastMessage?.verbal_response;
+  const currentMessage = lastMessage ? getMessageContent(lastMessage) : undefined;
 
   const filteredHuman = await filterHumanDataByVisibility(human, respondingPersona, currentMessage);
 

package/src/core/queue-processor.ts

@@ -113,10 +113,12 @@ export class QueueProcessor {
     // =========================================================================
     let messages: ChatMessage[] = [];
 
-    const isResponseType = request.type === "response" as LLMRequestType;
+    const isPersonaResponse = request.next_step === LLMNextStep.HandlePersonaResponse
+      || request.next_step === LLMNextStep.HandleRoomResponse
+      || request.type === "response" as LLMRequestType;
     const isToolContinuation = request.next_step === LLMNextStep.HandleToolContinuation;
 
-    if (isResponseType || isToolContinuation) {
+    if (isPersonaResponse || isToolContinuation) {
       const personaId = request.data.personaId as string | undefined;
       const isRoomRequest = !!(request.data.roomId as string | undefined);
       // Room conversation is embedded in the prompt via placeholders — don't inject persona history.

package/src/core/room-manager.ts

@@ -4,6 +4,7 @@ import type { StateManager } from "./state-manager.js";
 import { buildRoomResponsePromptData } from "./prompt-context-builder.js";
 import { buildRoomJudgePrompt } from "../prompts/room/index.js";
 import type { RoomHistoryMessage, RoomJudgeCandidate } from "../prompts/room/types.js";
+import { getMessageContent } from "./handlers/utils.js";
 
 export function getRoomList(sm: StateManager, includeArchived = false): RoomSummary[] {
   return sm.getRoomList(includeArchived);
@@ -45,7 +46,7 @@ async function queueRoomPersonaResponses(
     const model = persona.model ?? sm.getHuman().settings?.default_model ?? "";
 
     sm.queue_enqueue({
-      type: LLMRequestType.JSON,
+      type: LLMRequestType.Raw,
       priority: LLMPriority.Room,
       system: promptOutput.system,
       user: promptOutput.user,
@@ -201,7 +202,7 @@ export async function sendFfaMessage(
     const model = persona.model ?? sm.getHuman().settings?.default_model ?? "";
 
     sm.queue_enqueue({
-      type: LLMRequestType.JSON,
+      type: LLMRequestType.Raw,
       priority: LLMPriority.Room,
       system: promptOutput.system,
       user: promptOutput.user,
@@ -282,8 +283,7 @@ export async function activateRoom(
         ? (human.settings?.name_display ?? "Human")
         : (sm.persona_getById(m.persona_id ?? "")?.display_name ?? "Unknown"),
       speaker_id: m.role === "human" ? "human" : (m.persona_id ?? ""),
-      verbal_response: m.verbal_response,
-      action_response: m.action_response,
+      verbal_response: getMessageContent(m) || undefined,
       silence_reason: m.silence_reason,
     }));
 
@@ -293,8 +293,7 @@ export async function activateRoom(
         ? (human.settings?.name_display ?? "Human")
         : (sm.persona_getById(m.persona_id ?? "")?.display_name ?? "Unknown"),
       speaker_id: m.role === "human" ? "human" : (m.persona_id ?? ""),
-      verbal_response: m.verbal_response,
-      action_response: m.action_response,
+      verbal_response: getMessageContent(m) || undefined,
       silence_reason: m.silence_reason,
     }));
 
@@ -380,7 +379,7 @@ export async function selectCYPBranch(
     const model = persona.model ?? sm.getHuman().settings?.default_model ?? "";
 
     sm.queue_enqueue({
-      type: LLMRequestType.JSON,
+      type: LLMRequestType.Raw,
       priority: LLMPriority.Room,
       system: promptOutput.system,
       user: promptOutput.user,

package/src/core/state/human.ts

@@ -89,6 +89,12 @@ export class HumanState {
   }
 
   person_upsert(person: Person): void {
+    const identifiers = person.identifiers ?? [];
+    person = { ...person, identifiers };
+    const primary = identifiers.find(i => i.is_primary) ?? identifiers[0];
+    if (primary) {
+      person = { ...person, name: primary.value };
+    }
     const idx = this.human.people.findIndex((p) => p.id === person.id);
     person.last_updated = new Date().toISOString();
     if (idx >= 0) {

package/src/core/state/personas.ts

@@ -1,15 +1,15 @@
 import type { PersonaEntity, Message, ContextStatus } from "../types.js";
 
-/**
- * Migration: If a persisted message has the old `content` field but no `verbal_response`,
- * move content → verbal_response. Runs on every load (no-op for already-migrated data).
- */
-function migrateMessage(msg: Message & { content?: string }): Message {
-  if (msg.content !== undefined && msg.verbal_response === undefined) {
-    const { content, ...rest } = msg;
-    return { ...rest, verbal_response: content };
-  }
-  return msg;
+function migrateMessage(msg: Message): Message {
+  if (msg.content) return msg;
+  if (msg.role === 'human') return msg;
+  if (msg.silence_reason) return msg;
+  const parts: string[] = [];
+  if (msg.action_response) parts.push(`_${msg.action_response}_`);
+  if (msg.verbal_response) parts.push(msg.verbal_response);
+  if (parts.length === 0) return msg;
+  const { verbal_response: _vr, action_response: _ar, ...rest } = msg;
+  return { ...rest, content: parts.join('\n\n') };
 }
 
 export interface PersonaData {
@@ -246,4 +246,29 @@ export class PersonaState {
     }
     return count;
   }
+
+  messages_getUnextractedForPersona(personaId: string, shortId: string, sinceTimestamp?: string): Message[] {
+    const data = this.personas.get(personaId);
+    if (!data) return [];
+    return data.messages
+      .filter(m => {
+        if (sinceTimestamp && new Date(m.timestamp).getTime() < new Date(sinceTimestamp).getTime()) return false;
+        return !m.persona_extracted?.[shortId];
+      })
+      .map(m => ({ ...m }));
+  }
+
+  messages_markPersonaExtracted(personaId: string, messageIds: string[], shortId: string): number {
+    const data = this.personas.get(personaId);
+    if (!data) return 0;
+    const idsSet = new Set(messageIds);
+    let count = 0;
+    for (const msg of data.messages) {
+      if (idsSet.has(msg.id) && !msg.persona_extracted?.[shortId]) {
+        msg.persona_extracted = { ...msg.persona_extracted, [shortId]: true };
+        count++;
+      }
+    }
+    return count;
+  }
 }

package/src/core/state/rooms.ts

@@ -179,4 +179,25 @@ export class RoomState {
     }
     return count;
   }
+
+  messages_getUnextractedForPersona(roomId: string, shortId: string): RoomMessage[] {
+    const activePath = new Set(this.messages_getActivePath(roomId).map(m => m.id));
+    return (this.rooms.get(roomId)?.messages ?? [])
+      .filter(m => activePath.has(m.id) && !m.persona_extracted?.[shortId])
+      .map(m => ({ ...m }));
+  }
+
+  messages_markPersonaExtracted(roomId: string, messageIds: string[], shortId: string): number {
+    const room = this.rooms.get(roomId);
+    if (!room) return 0;
+    const ids = new Set(messageIds);
+    let count = 0;
+    for (const msg of room.messages) {
+      if (ids.has(msg.id) && !msg.persona_extracted?.[shortId]) {
+        msg.persona_extracted = { ...msg.persona_extracted, [shortId]: true };
+        count++;
+      }
+    }
+    return count;
+  }
 }

package/src/core/state-manager.ts

@@ -34,6 +34,11 @@ export class StateManager {
   private roomState = new RoomState();
   private queueState = new QueueState();
   private persistenceState = new PersistenceState();
+  private queueChangeListener?: () => void;
+
+  setQueueChangeListener(listener: () => void): void {
+    this.queueChangeListener = listener;
+  }
   private providers: ToolProvider[] = [];
   private tools: ToolDefinition[] = [];
   private embeddingWarning = false;
@@ -62,6 +67,34 @@ export class StateManager {
     this.migrateMessageFlags();
     this.migrateInterestedPersonas();
     this.migrateProviderModel();
+    this.migrateRoomMessageContent();
+  }
+
+  private migrateRoomMessageContent(): void {
+    const rooms = this.roomState.getAll(true);
+    let migratedCount = 0;
+
+    for (const room of rooms) {
+      for (const msg of room.messages) {
+        if (msg.content) continue;
+        if (msg.role === 'human') continue;
+        if (msg.silence_reason) continue;
+        const parts: string[] = [];
+        const legacy = msg as RoomMessage & { verbal_response?: string; action_response?: string };
+        if (legacy.action_response) parts.push(`_${legacy.action_response}_`);
+        if (legacy.verbal_response) parts.push(legacy.verbal_response);
+        if (parts.length === 0) continue;
+        msg.content = parts.join('\n\n');
+        delete (msg as any).verbal_response;
+        delete (msg as any).action_response;
+        migratedCount++;
+      }
+    }
+
+    if (migratedCount > 0) {
+      this.scheduleSave();
+      console.log(`[StateManager] Migrated ${migratedCount} room messages to unified content field`);
+    }
   }
 
   /**
@@ -150,6 +183,7 @@ export class StateManager {
           exposure_current: 0.3,
           exposure_desired: 0.3,
           last_updated: fact.last_updated,
+          learned_on: fact.last_updated,
           learned_by: fact.learned_by,
           last_changed_by: fact.last_changed_by,
           persona_groups: fact.persona_groups,
@@ -518,6 +552,16 @@ export class StateManager {
     return count;
   }
 
+  getRoomUnextractedMessagesForPersona(roomId: string, shortId: string): RoomMessage[] {
+    return this.roomState.messages_getUnextractedForPersona(roomId, shortId);
+  }
+
+  markRoomMessagesPersonaExtracted(roomId: string, messageIds: string[], shortId: string): number {
+    const count = this.roomState.messages_markPersonaExtracted(roomId, messageIds, shortId);
+    if (count > 0) this.scheduleSave();
+    return count;
+  }
+
   private scheduleSave(): void {
     this.persistenceState.scheduleSave(this.buildStorageState());
   }
@@ -565,6 +609,12 @@ export class StateManager {
     return result;
   }
 
+  human_person_getByIdentifier(type: string | null, value: string): Person | undefined {
+    return this.getHuman().people.find(p =>
+      p.identifiers?.some(i => (!type || i.type === type) && i.value === value)
+    );
+  }
+
   human_quote_add(quote: Quote): void {
     this.humanState.quote_add(quote);
     this.scheduleSave();
@@ -713,6 +763,16 @@ export class StateManager {
     return result;
   }
 
+  messages_getUnextractedForPersona(personaId: string, shortId: string, sinceTimestamp?: string): Message[] {
+    return this.personaState.messages_getUnextractedForPersona(personaId, shortId, sinceTimestamp);
+  }
+
+  messages_markPersonaExtracted(personaId: string, messageIds: string[], shortId: string): number {
+    const result = this.personaState.messages_markPersonaExtracted(personaId, messageIds, shortId);
+    if (result > 0) this.scheduleSave();
+    return result;
+  }
+
   queue_enqueue(request: Omit<LLMRequest, "id" | "created_at" | "attempts" | "state">): string {
     const requestWithModel = {
       ...request,
@@ -720,6 +780,7 @@ export class StateManager {
     };
     const id = this.queueState.enqueue(requestWithModel);
     this.scheduleSave();
+    this.queueChangeListener?.();
     return id;
   }
 

package/src/core/types/data-items.ts

@@ -10,6 +10,7 @@ export interface DataItemBase {
   description: string;
   sentiment: number;
   last_updated: string;
+  learned_on?: string;           // ISO timestamp when item first entered the system. Immutable after creation. Pairs with learned_by.
   last_mentioned?: string;        // Set by extraction only, never ceremony. Used for --recent sorting.
   learned_by?: string;           // Persona ID that originally learned this item (stable UUID)
   last_changed_by?: string;      // Persona ID that most recently updated this item (stable UUID)
@@ -54,7 +55,18 @@ export interface PersonaTopic {
   last_updated: string;     // ISO timestamp
 }
 
+export interface PersonIdentifier {
+  type: string;         // User-extensible. "nickname", "github", "ei_persona", etc. NOT an enum.
+  value: string;        // The identifier value. For ei_persona: the Persona UUID.
+  is_primary?: boolean; // True = this is the display name. Synced to DataItemBase.name on write.
+}
+
 export interface Person extends DataItemBase {
+  identifiers?: PersonIdentifier[];
+  // DataItemBase.name stays. Must always equal:
+  //   identifiers.find(i => i.is_primary)?.value ?? identifiers[0]?.value ?? name
+  // State manager syncs name on every write.
+  validated_date?: string;  // ISO timestamp. Empty string or absent = candidate for Ei heartbeat intro. Same contract as Fact.validated_date.
   relationship: string;
   exposure_current: number;
   exposure_desired: number;

package/src/core/types/entities.ts

@@ -93,6 +93,7 @@ export interface HumanSettings {
   default_model?: string;           // Will store ModelConfig.id GUID post-migration
   oneshot_model?: string;           // Model for AI-assist (wand) requests; falls back to default_model. Will store ModelConfig.id GUID post-migration.
   rewrite_model?: string;           // Model for rewrite ceremony step; must be capable (Sonnet/Opus class). Unset = rewrite disabled. Will store ModelConfig.id GUID post-migration.
+  people_migration_complete?: boolean; // Set to true when all Person records have identifiers. Ceremony migration step short-circuits when true.
   queue_paused?: boolean;
   skip_quote_delete_confirm?: boolean;
   name_display?: string;
@@ -147,6 +148,8 @@ export interface PersonaEntity {
   last_heartbeat?: string;
   last_extraction?: string;
   tools?: string[];              // IDs of ToolDefinitions this persona can use. Empty/absent = no tool access.
+  reflection_last_asked?: string;   // ISO timestamp. Set ONLY when Persona explicitly surfaces identity drift (mentioned_reflection: true).
+  description_embedding?: number[]; // Embedding of long_description (short_description fallback). Excludes traits. See embedding-service.ts:getPersonaDescriptionText.
 }
 
 export interface PersonaCreationInput {

package/src/core/types/enums.ts

@@ -32,18 +32,12 @@ export enum LLMNextStep {
   HandleHumanPersonScan = "handleHumanPersonScan",
   HandleTopicMatch = "handleTopicMatch",
   HandleTopicUpdate = "handleTopicUpdate",
-  HandlePersonMatch = "handlePersonMatch",
   HandlePersonUpdate = "handlePersonUpdate",
   HandlePersonaTraitExtraction = "handlePersonaTraitExtraction",
-  HandlePersonaTopicScan = "handlePersonaTopicScan",
-  HandlePersonaTopicMatch = "handlePersonaTopicMatch",
-  HandlePersonaTopicUpdate = "handlePersonaTopicUpdate",
+  HandlePersonaTopicRating = "handlePersonaTopicRating",
   HandleHeartbeatCheck = "handleHeartbeatCheck",
   HandleEiHeartbeat = "handleEiHeartbeat",
   HandleOneShot = "handleOneShot",
-  HandlePersonaExpire = "handlePersonaExpire",
-  HandlePersonaExplore = "handlePersonaExplore",
-  HandleDescriptionCheck = "handleDescriptionCheck",
   // Tool calling continuation (second LLM call after tool execution, may loop for more tool calls).
   // data.toolHistory: serialized LLMHistoryMessage[] (assistant + tool result messages)
   // data.toolCallCounts: serialized Map entries [[name, count], ...] carrying per-tool call counts
@@ -56,6 +50,7 @@ export enum LLMNextStep {
   HandleRoomResponse = "handleRoomResponse",
   HandleRoomJudge = "handleRoomJudge",
   HandlePersonaPreview = "handlePersonaPreview",
+  HandlePersonIdentifierMigration = "handlePersonIdentifierMigration",
 }
 
 export enum ProviderType {

package/src/core/types/llm.ts

@@ -8,6 +8,7 @@ import type { LLMRequestType, LLMPriority, LLMNextStep } from "./enums.js";
 export interface Message {
   id: string;
   role: "human" | "system";
+  content?: string;           // Raw Markdown response (primary path going forward)
   verbal_response?: string;   // Human text or persona's spoken reply
   action_response?: string;  // Stage direction / action the persona performs
   silence_reason?: string;   // Why the persona chose not to respond (not shown to LLM)
@@ -21,6 +22,7 @@ export interface Message {
   t?: boolean;                 // Topic extraction completed
   p?: boolean;                 // Person extraction completed
   e?: boolean;                 // Event (epic) extraction completed
+  persona_extracted?: Record<string, true>; // Per-persona topic scan tracking. Key = personaId.slice(0, 8)
   // Image generation fields (web-only, ephemeral)
   _synthesis?: boolean;         // True if message was created by multi-message synthesis
   speaker_name?: string;       // Display name of actual speaker; set on room messages for clean hydration

package/src/core/types/rooms.ts

@@ -10,6 +10,7 @@ export interface RoomMessage {
   parent_id: string | null;
   role: "human" | "persona";
   persona_id?: string;
+  content?: string;
   verbal_response?: string;
   action_response?: string;
   silence_reason?: string;
@@ -21,6 +22,7 @@ export interface RoomMessage {
   t?: boolean;
   p?: boolean;
   e?: boolean;
+  persona_extracted?: Record<string, true>; // Per-persona topic scan tracking. Key = personaId.slice(0, 8)
 }
 
 export interface RoomEntity {

package/src/core/utils/identifier-utils.ts

@@ -0,0 +1,19 @@
+import type { PersonIdentifier } from "../types/data-items.js";
+import type { StateManager } from "../state-manager.js";
+
+export const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+export function sanitizeEiPersonaIdentifiers(
+  identifiers: PersonIdentifier[],
+  state: StateManager
+): PersonIdentifier[] {
+  return identifiers.map(id => {
+    if (id.type !== 'Ei Persona' && id.type !== 'AI Persona') return id;
+    if (UUID_REGEX.test(id.value)) return { ...id, type: 'Ei Persona' };
+    const matched = state.persona_getAll().find(p =>
+      p.display_name === id.value || p.aliases?.includes(id.value)
+    );
+    if (matched) return { ...id, type: 'Ei Persona', value: matched.id };
+    return id.type === 'AI Persona' ? id : { ...id, type: 'Nickname' };
+  });
+}

package/src/core/utils/index.ts

@@ -1,4 +1,5 @@
 import { crossFind } from "./crossFind.js";
 import { applyDecayToValue } from "./decay.js";
+import { UUID_REGEX, sanitizeEiPersonaIdentifiers } from "./identifier-utils.js";
 
-export { crossFind, applyDecayToValue };
+export { crossFind, applyDecayToValue, UUID_REGEX, sanitizeEiPersonaIdentifiers };