ei-tui 0.5.4 → 0.6.1

package/package.json

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

package/src/core/constants/built-in-identifier-types.ts

@@ -0,0 +1,24 @@
+/**
+ * Built-in identifier types shipped with Ei.
+ *
+ * Title Case — these are display labels in UI dropdowns, not database columns.
+ * Matching is always case-insensitive, so existing lowercase records still work
+ * until the user edits them.
+ *
+ * Any string is valid as an identifier type — users can define their own
+ * (e.g. "Slack RNP", "sehimu_thinara"). This list is purely for discoverability.
+ */
+export const BUILT_IN_IDENTIFIER_TYPES: readonly string[] = [
+  'Full Name',
+  'First Name',
+  'Nickname',
+  'Email',
+  'GitHub',
+  'Discord',
+  'Roblox',
+  'Reddit',
+  'Twitter',
+  'FF14',
+  'Relationship',
+  'Ei Persona',
+] as const;

package/src/core/embedding-service.ts

@@ -101,6 +101,29 @@ export async function computeQuoteEmbedding(text: string): Promise<number[] | un
   }
 }
 
+export function getPersonaDescriptionText(persona: {
+  display_name: string;
+  long_description?: string;
+  short_description?: string;
+}): string {
+  const desc = persona.long_description ?? persona.short_description;
+  return [persona.display_name, desc].filter(Boolean).join(' - ');
+}
+
+export async function computePersonaDescriptionEmbedding(persona: {
+  display_name: string;
+  long_description?: string;
+  short_description?: string;
+}): Promise<number[] | undefined> {
+  try {
+    const service = getEmbeddingService();
+    return await service.embed(getPersonaDescriptionText(persona));
+  } catch (err) {
+    console.warn(`[computePersonaDescriptionEmbedding] Failed for "${persona.display_name}":`, err);
+    return undefined;
+  }
+}
+
 // =============================================================================
 // FACTORY - Lazy loading based on environment
 // =============================================================================
@@ -219,7 +242,7 @@ function createBunService(): EmbeddingService {
       const cacheDir = process.env.EI_DATA_PATH
         ? path.join(process.env.EI_DATA_PATH, 'embeddings')
         : path.join(os.homedir(), '.local', 'share', 'ei', 'embeddings');
-      embedder = await mod.FlagEmbedding.init({ model: mod.EmbeddingModel.AllMiniLML6V2, cacheDir });
+      embedder = await mod.FlagEmbedding.init({ model: mod.EmbeddingModel.AllMiniLML6V2, cacheDir, showDownloadProgress: false });
       return embedder;
     })();
     

package/src/core/handlers/dedup.ts

@@ -1,7 +1,7 @@
 import { StateManager } from "../state-manager.js";
 import { LLMResponse } from "../types.js";
 import type { DedupResult } from "../../prompts/ceremony/types.js";
-import type { DataItemType, Fact, Topic, Person, Quote } from "../types/data-items.js";
+import type { DataItemType, Fact, Topic, Person, PersonIdentifier, Quote } from "../types/data-items.js";
 import { getEmbeddingService } from "../embedding-service.js";
 
 /**
@@ -51,7 +51,7 @@ export async function handleDedupCurate(
 
   // Pre-compute: for each survivor (replaced_by), union the removed entity's groups.
   // Must happen before any phase mutates state so we read the original values.
-  const groupsToMerge = new Map<string, { persona_groups: string[]; interested_personas: string[] }>();
+  const groupsToMerge = new Map<string, { persona_groups: string[]; interested_personas: string[]; learned_on?: string; identifiers?: PersonIdentifier[] }>();
 
   // Map entity_type to pluralized state property name
   const pluralMap: Record<string, 'facts' | 'topics' | 'people'> = {
@@ -86,9 +86,25 @@ export async function handleDedupCurate(
     const removed = entities.find(e => e.id === removal.to_be_removed);
     if (!removed) continue;
     const acc = groupsToMerge.get(removal.replaced_by) ?? { persona_groups: [], interested_personas: [] };
+    const candidates = [acc.learned_on, removed.learned_on].filter(Boolean) as string[];
+
+    let mergedIdentifiers: PersonIdentifier[] | undefined;
+    if (entity_type === 'person') {
+      const removedPerson = removed as Person;
+      const accIdentifiers = acc.identifiers ?? [];
+      mergedIdentifiers = [...accIdentifiers];
+      for (const id of (removedPerson.identifiers ?? [])) {
+        if (!mergedIdentifiers.some(existing => existing.value === id.value)) {
+          mergedIdentifiers.push(id);
+        }
+      }
+    }
+
     groupsToMerge.set(removal.replaced_by, {
       persona_groups: [...new Set([...acc.persona_groups, ...(removed.persona_groups ?? [])])],
       interested_personas: [...new Set([...acc.interested_personas, ...(removed.interested_personas ?? [])])],
+      learned_on: candidates.length > 0 ? candidates.sort()[0] : undefined,
+      ...(entity_type === 'person' && { identifiers: mergedIdentifiers }),
     });
   }
 
@@ -144,12 +160,16 @@ export async function handleDedupCurate(
     }
     
     const mergedFromRemoved = groupsToMerge.get(update.id);
+    const minLearned = mergedFromRemoved?.learned_on
+      ? [entity.learned_on, mergedFromRemoved.learned_on].filter(Boolean).sort()[0]
+      : entity.learned_on;
     const updatedEntity = {
       ...entity,
       name: update.name ?? entity.name,
       description: update.description ?? entity.description,
       sentiment: update.sentiment ?? entity.sentiment,
       last_updated: new Date().toISOString(),
+      ...(minLearned !== undefined && { learned_on: minLearned }),
       embedding,
       persona_groups: mergedFromRemoved
         ? [...new Set([...(entity.persona_groups ?? []), ...mergedFromRemoved.persona_groups])]
@@ -163,6 +183,14 @@ export async function handleDedupCurate(
       ...(update.exposure_desired !== undefined && { exposure_desired: update.exposure_desired }),
       ...(update.relationship !== undefined && { relationship: update.relationship }),
       ...(update.category !== undefined && { category: update.category }),
+      ...(entity_type === 'person' && mergedFromRemoved?.identifiers !== undefined && (() => {
+        const existingIds = (entity as Person).identifiers ?? [];
+        const result: PersonIdentifier[] = [...existingIds];
+        for (const id of mergedFromRemoved.identifiers!) {
+          if (!result.some(e => e.value === id.value)) result.push(id);
+        }
+        return { identifiers: result };
+      })()),
     };
     
     // Type-safe cast based on entity_type
@@ -216,13 +244,15 @@ export async function handleDedupCurate(
     // Generate ID for new entity
     const id = crypto.randomUUID();
     
+    const now = new Date().toISOString();
     const newEntity = {
       id,
       type: entity_type,
       name: addition.name,
       description: addition.description,
       sentiment: addition.sentiment ?? 0.0,
-      last_updated: new Date().toISOString(),
+      last_updated: now,
+      learned_on: now,
       learned_by: "ei",
       last_changed_by: "ei",
       embedding,
@@ -233,7 +263,7 @@ export async function handleDedupCurate(
         exposure_desired: addition.exposure_desired ?? 0.5,
         last_ei_asked: null
       }),
-      ...(entity_type === 'person' && { relationship: addition.relationship ?? 'Unknown' }),
+      ...(entity_type === 'person' && { identifiers: [], validated_date: '', relationship: addition.relationship ?? 'Unknown' }),
       ...(entity_type === 'topic' && { category: addition.category ?? 'Interest' }),
     };
     

package/src/core/handlers/heartbeat.ts

@@ -27,6 +27,11 @@ export function handleHeartbeatCheck(response: LLMResponse, state: StateManager)
   state.persona_update(personaId, { last_heartbeat: now });
   state.queue_clearPersonaResponses(personaId, LLMNextStep.HandleHeartbeatCheck);
 
+  if (result.mentioned_reflection === true) {
+    state.persona_update(personaId, { reflection_last_asked: now });
+    console.log(`[HeartbeatCheck ${personaDisplayName}] Persona surfaced identity drift - reflection_last_asked set`);
+  }
+
   if (!result.should_respond) {
     console.log(`[HeartbeatCheck ${personaDisplayName}] Chose not to reach out (should_respond=false)`);
     return;
@@ -107,4 +112,15 @@ export function handleEiHeartbeat(response: LLMResponse, state: StateManager): v
     default:
       console.warn(`[handleEiHeartbeat] Unexpected item type "${found.type}" for id "${result.id}"`);
   }
+
+  const newPersonIds = (response.request.data.newPersonIds ?? []) as string[];
+  if (newPersonIds.length > 0) {
+    const human = state.getHuman();
+    for (const personId of newPersonIds) {
+      const person = human.people.find(p => p.id === personId);
+      if (person) {
+        state.human_person_upsert({ ...person, validated_date: now });
+      }
+    }
+  }
 }

package/src/core/handlers/human-extraction.ts

@@ -1,15 +1,89 @@
-import type { LLMResponse, Fact } from "../types.js";
+import type { LLMResponse, Fact, Person } from "../types.js";
+import type { PersonIdentifier } from "../types/data-items.js";
 import type { StateManager } from "../state-manager.js";
 import type {
   FactFindResult,
   TopicScanResult,
   PersonScanResult,
   TopicScanCandidate,
+  ItemMatchResult,
 } from "../../prompts/human/types.js";
-import { queueTopicMatch, queuePersonMatch, type ExtractionContext } from "../orchestrators/index.js";
-import { markMessagesExtracted } from "./utils.js";
+import { queueTopicMatch, queuePersonUpdate, type ExtractionContext } from "../orchestrators/index.js";
+import { markMessagesExtracted, resolveMessageWindow } from "./utils.js";
 import { BUILT_IN_FACT_NAMES } from "../constants/built-in-facts.js";
-import { getEmbeddingService, getItemEmbeddingText } from "../embedding-service.js";
+import { getEmbeddingService, getItemEmbeddingText, cosineSimilarity, getPersonEmbeddingText } from "../embedding-service.js";
+import { levenshtein, normalizeForMatch } from "../utils/levenshtein.js";
+
+const MULTI_MATCH_SIMILARITY_THRESHOLD = 0.75;
+const ZERO_MATCH_COSINE_THRESHOLD = 0.80;
+
+// Relationships where a person typically has exactly one instance.
+// Only these fire the "sole relationship" uniqueness shortcut when the
+// existing record already has a real name (non-Unknown records in non-singleton
+// relationships fall through to cosine so we don't merge David into Sisyphus).
+const SINGLETON_RELATIONSHIPS = new Set([
+  'self',
+  'husband', 'wife', 'spouse',
+  'father', 'mother',
+]);
+
+function matchPersonCandidate(
+  candidateName: string,
+  candidateIdentifiers: PersonIdentifier[],
+  people: Person[]
+): Person[] {
+  const normName = normalizeForMatch(candidateName);
+  const matched = new Set<Person>();
+
+  // Step 1: Exact match on any identifier value (type-agnostic)
+  for (const person of people) {
+    const allValues = [
+      ...(person.identifiers ?? []).map(i => normalizeForMatch(i.value)),
+      normalizeForMatch(person.name),
+    ];
+    if (allValues.includes(normName)) matched.add(person);
+  }
+  // Also check scan-extracted identifiers against existing identifier values
+  for (const scanId of candidateIdentifiers) {
+    const normVal = normalizeForMatch(scanId.value);
+    for (const person of people) {
+      if ((person.identifiers ?? []).some(i => normalizeForMatch(i.value) === normVal)) {
+        matched.add(person);
+      }
+    }
+  }
+
+  if (matched.size > 0) return [...matched];
+
+  // Step 2: Fuzzy match — skip for short names (< 6 chars): "mike"↔"jake" = 2 edits, false positive.
+  if (normName.length >= 6) {
+    const threshold = normName.length < 10 ? 1 : 2;
+    for (const person of people) {
+      const allValues = [
+        ...(person.identifiers ?? []).map(i => normalizeForMatch(i.value)),
+        normalizeForMatch(person.name),
+      ];
+      if (allValues.some(v => levenshtein(normName, v) <= threshold)) matched.add(person);
+    }
+  }
+
+  if (matched.size > 0) return [...matched];
+
+  // Step 2.5: First-name match — "Lucas Jeremy Scherer" should find "Lucas".
+  // Only fires when first word is >= 4 chars to avoid short-name collisions.
+  const candidateFirstWord = normName.split(/\s+/)[0];
+  if (candidateFirstWord.length >= 4) {
+    for (const person of people) {
+      const allNames = [
+        normalizeForMatch(person.name),
+        ...(person.identifiers ?? []).map(i => normalizeForMatch(i.value)),
+      ];
+      if (allNames.some(n => n.split(/\s+/)[0] === candidateFirstWord)) matched.add(person);
+    }
+  }
+
+  return [...matched];
+}
 
 export async function handleFactFind(response: LLMResponse, state: StateManager): Promise<void> {
   const result = response.parsed as FactFindResult | undefined;
@@ -117,11 +191,131 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
   const context = response.request.data as unknown as ExtractionContext;
   if (!context?.personaId) return;
 
-  const extractionModel = (response.request.data as Record<string, unknown>).extraction_model as string | undefined;
+  const { messages_context, messages_analyze } = resolveMessageWindow(response, state);
+  const human = state.getHuman();
+
   for (const candidate of result.people) {
-    await queuePersonMatch(candidate, context, state, extractionModel);
+    const candidateIdentifiers: PersonIdentifier[] = (candidate.identifiers ?? []).map(i => ({
+      type: i.type,
+      value: i.value,
+      ...(i.is_primary ? { is_primary: i.is_primary } : {}),
+    }));
+
+    const matches = matchPersonCandidate(candidate.name, candidateIdentifiers, human.people);
+
+    let matchedPerson: Person | null = null;
+
+    if (matches.length === 1) {
+      matchedPerson = matches[0];
+    } else if (matches.length > 1) {
+      try {
+        const embeddingService = getEmbeddingService();
+        const candidateText = getPersonEmbeddingText({
+          name: candidate.name,
+          relationship: candidate.relationship,
+          description: candidate.description,
+        });
+        const candidateVector = await embeddingService.embed(candidateText);
+        let bestSimilarity = MULTI_MATCH_SIMILARITY_THRESHOLD;
+        for (const person of matches) {
+          if (person.embedding) {
+            const sim = cosineSimilarity(person.embedding, candidateVector);
+            if (sim > bestSimilarity) {
+              bestSimilarity = sim;
+              matchedPerson = person;
+            }
+          }
+        }
+        if (!matchedPerson) {
+          console.log(`[handleHumanPersonScan] Multi-match for "${candidate.name}" (${matches.length} hits) — no embedding above threshold, creating new record`);
+        }
+      } catch (err) {
+        console.warn(`[handleHumanPersonScan] Multi-match embedding failed for "${candidate.name}", using first match:`, err);
+        matchedPerson = matches[0];
+      }
+    } else {
+      // Step 3: relationship filter → uniqueness match or cosine on the relevant subset.
+      // Filter first (O(N)), then cosine only on the filtered set (O(K) where K <= N).
+      const normRel = candidate.relationship?.toLowerCase();
+      const sameRel = normRel && normRel !== 'unknown'
+        ? human.people.filter(p => p.relationship?.toLowerCase() === normRel)
+        : [];
+
+      if (sameRel.length === 1) {
+        const existing = sameRel[0];
+        const normExistingName = normalizeForMatch(existing.name);
+        const isUnknownPlaceholder = normExistingName === 'unknown' || normExistingName === normRel;
+        const isSingleton = SINGLETON_RELATIONSHIPS.has(normRel!);
+        if (isUnknownPlaceholder || isSingleton) {
+          matchedPerson = existing;
+          const reason = isUnknownPlaceholder ? 'unnamed placeholder' : 'singleton relationship';
+          console.log(`[handleHumanPersonScan] Relationship unique match: "${candidate.name}" → "${existing.name}" (sole ${candidate.relationship}, ${reason})`);
+        }
+      } else {
+        // N>1 same relationship → cosine within that subset.
+        // N=0 (unknown relationship or no stored records) → cosine against all people.
+        const searchPool = sameRel.length > 1
+          ? sameRel.filter(p => p.embedding && p.embedding.length > 0)
+          : human.people.filter(p => p.embedding && p.embedding.length > 0);
+
+        const poolLabel = sameRel.length > 1
+          ? `${sameRel.length} ${candidate.relationship} records`
+          : `all ${human.people.length} people`;
+
+        if (searchPool.length > 0) {
+          console.log(`[handleHumanPersonScan] "${candidate.name}": cosine against ${searchPool.length} embedded (${poolLabel})`);
+          try {
+            const embeddingService = getEmbeddingService();
+            const candidateText = getPersonEmbeddingText({
+              name: candidate.name,
+              relationship: candidate.relationship,
+              description: candidate.description,
+            });
+            const candidateVector = await embeddingService.embed(candidateText);
+            const scores: Array<{ name: string; sim: number }> = [];
+            let bestSimilarity = ZERO_MATCH_COSINE_THRESHOLD;
+            for (const person of searchPool) {
+              const sim = cosineSimilarity(person.embedding!, candidateVector);
+              scores.push({ name: person.name, sim });
+              if (sim > bestSimilarity) {
+                bestSimilarity = sim;
+                matchedPerson = person;
+              }
+            }
+            const top3 = scores.sort((a, b) => b.sim - a.sim).slice(0, 3).map(s => `"${s.name}"=${s.sim.toFixed(3)}`).join(', ');
+            if (matchedPerson) {
+              console.log(`[handleHumanPersonScan] Cosine matched "${candidate.name}" → "${matchedPerson.name}" (${bestSimilarity.toFixed(3)}) | top3: ${top3}`);
+            } else {
+              console.log(`[handleHumanPersonScan] Cosine: no match above ${ZERO_MATCH_COSINE_THRESHOLD} for "${candidate.name}" | top3: ${top3}`);
+            }
+          } catch (err) {
+            console.warn(`[handleHumanPersonScan] Cosine failed for "${candidate.name}":`, err);
+          }
+        } else {
+          console.log(`[handleHumanPersonScan] "${candidate.name}": no embedded people in pool (${poolLabel}) — new person`);
+        }
+      }
+    }
+
+    const matchResult: ItemMatchResult = { matched_guid: matchedPerson?.id ?? null };
+    queuePersonUpdate(matchResult, {
+      ...context,
+      messages_context,
+      messages_analyze,
+      candidateName: candidate.name,
+      candidateDescription: candidate.description,
+      candidateRelationship: candidate.relationship,
+      candidateIdentifiers,
+    }, state);
+
+    const matched = matchedPerson
+      ? `matched "${matchedPerson.name}"`
+      : matches.length > 1
+        ? `multi-match ambiguous (${matches.length} hits) — new record`
+        : "no match (new person)";
+    console.log(`[handleHumanPersonScan] person "${candidate.name}": ${matched}`);
   }
-  console.log(`[handleHumanPersonScan] Queued ${result.people.length} person(s) for matching`);
+  console.log(`[handleHumanPersonScan] Processed ${result.people.length} person(s)`);
 }
 
 export async function handleEventScan(response: LLMResponse, state: StateManager): Promise<void> {

package/src/core/handlers/human-matching.ts

@@ -5,6 +5,7 @@ import {
   type Person,
   type Quote,
 } from "../types.js";
+import type { PersonIdentifier } from "../types/data-items.js";
 import type { StateManager } from "../state-manager.js";
 import type { ItemMatchResult, ExposureImpact, TopicUpdateResult, PersonUpdateResult } from "../../prompts/human/types.js";
 import { queueTopicUpdate, queuePersonUpdate, type ExtractionContext } from "../orchestrators/index.js";
@@ -13,12 +14,12 @@ import { calculateExposureCurrent } from "../utils/exposure.js";
 
 
 import { resolveMessageWindow, getMessageText, normalizeRoomMessages } from "./utils.js";
+import { sanitizeEiPersonaIdentifiers } from "../utils/identifier-utils.js";
 
 export function handleTopicMatch(response: LLMResponse, state: StateManager): void {
   const result = response.parsed as ItemMatchResult | undefined;
   if (!result) {
-    console.error("[handleTopicMatch] No parsed result");
-    return;
+    throw new Error("[handleTopicMatch] No parsed result");
   }
 
   const personaId = response.request.data.personaId as string;
@@ -64,8 +65,7 @@ export function handleTopicMatch(response: LLMResponse, state: StateManager): vo
 export function handlePersonMatch(response: LLMResponse, state: StateManager): void {
   const result = response.parsed as ItemMatchResult | undefined;
   if (!result) {
-    console.error("[handlePersonMatch] No parsed result");
-    return;
+    throw new Error("[handlePersonMatch] No parsed result");
   }
 
   const personaId = response.request.data.personaId as string;
@@ -123,11 +123,6 @@ export async function handleTopicUpdate(response: LLMResponse, state: StateManag
   const roomId = response.request.data.roomId as string | undefined;
   const candidateCategory = response.request.data.candidateCategory as string | undefined;
 
-  if (!result.name || !result.description || result.sentiment === undefined) {
-    console.error("[handleTopicUpdate] Missing required fields in result");
-    return;
-  }
-
   const personaIds = personaId.split("|").filter(Boolean);
   const primaryId = personaIds[0] ?? personaId;
 
@@ -148,14 +143,21 @@ export async function handleTopicUpdate(response: LLMResponse, state: StateManag
 
   const existingTopic = isNewItem ? undefined : human.topics.find(t => t.id === existingItemId);
 
+  const resolvedName = result.name || existingTopic?.name;
+  const resolvedDescription = typeof result.description === 'string' ? result.description : existingTopic?.description;
+
+  if (!resolvedName || !resolvedDescription || result.sentiment === undefined) {
+    throw new Error(`[handleTopicUpdate] Missing required fields: name=${resolvedName}, description=${!!resolvedDescription}, sentiment=${result.sentiment}`);
+  }
+
   let embedding: number[] | undefined;
   try {
     const embeddingService = getEmbeddingService();
     const category = result.category ?? candidateCategory ?? existingTopic?.category;
-    const text = getTopicEmbeddingText({ name: result.name, category, description: result.description });
+    const text = getTopicEmbeddingText({ name: resolvedName, category, description: resolvedDescription });
     embedding = await embeddingService.embed(text);
   } catch (err) {
-    console.warn(`[handleTopicUpdate] Failed to compute embedding for topic "${result.name}":`, err);
+    console.warn(`[handleTopicUpdate] Failed to compute embedding for topic "${resolvedName}":`, err);
   }
 
   const exposureImpact = result.exposure_impact as ExposureImpact | undefined;
@@ -168,13 +170,14 @@ export async function handleTopicUpdate(response: LLMResponse, state: StateManag
 
   const topic: Topic = {
     id: itemId,
-    name: result.name,
-    description: result.description,
+    name: resolvedName,
+    description: resolvedDescription,
     sentiment: result.sentiment,
     category: result.category ?? candidateCategory ?? existingTopic?.category,
     exposure_current: calculateExposureCurrent(exposureImpact, existingTopic?.exposure_current ?? 0),
     exposure_desired: result.exposure_desired ?? 0.5,
     last_updated: now,
+    learned_on: isNewItem ? now : existingTopic?.learned_on,
     last_mentioned: now,
     learned_by: isNewItem ? primaryId : existingTopic?.learned_by,
     last_changed_by: primaryId,
@@ -189,11 +192,15 @@ export async function handleTopicUpdate(response: LLMResponse, state: StateManag
     : state.messages_get(personaId);
   await validateAndStoreQuotes(result.quotes, allMessages, itemId, personaDisplayName, personaGroup, state);
 
-  console.log(`[handleTopicUpdate] ${isNewItem ? "Created" : "Updated"} topic "${result.name}"`);
+  console.log(`[handleTopicUpdate] ${isNewItem ? "Created" : "Updated"} topic "${resolvedName}"`);
 }
 
 export async function handlePersonUpdate(response: LLMResponse, state: StateManager): Promise<void> {
-  const result = response.parsed as (PersonUpdateResult & { quotes?: Array<{ text: string; reason: string }> }) | undefined;
+  const result = response.parsed as (PersonUpdateResult & {
+    identifiers?: PersonIdentifier[];
+    identifiers_to_add?: PersonIdentifier[];
+    quotes?: Array<{ text: string; reason: string }>;
+  }) | undefined;
 
   if (!result || Object.keys(result).length === 0) {
     console.log("[handlePersonUpdate] No changes needed (empty result)");
@@ -206,12 +213,13 @@ export async function handlePersonUpdate(response: LLMResponse, state: StateMana
   const personaDisplayName = response.request.data.personaDisplayName as string;
   const roomId = response.request.data.roomId as string | undefined;
   const candidateRelationship = response.request.data.candidateRelationship as string | undefined;
+  const candidateIdentifiers = (response.request.data.candidateIdentifiers ?? []) as PersonIdentifier[];
 
-  if (!result.name || !result.description || result.sentiment === undefined) {
-    console.error("[handlePersonUpdate] Missing required fields in result");
-    return;
+  if (!result.description || result.sentiment === undefined) {
+    throw new Error(`[handlePersonUpdate] Missing required fields: description=${!!result.description}, sentiment=${result.sentiment}`);
   }
 
+  const candidateName = response.request.data.candidateName as string;
   const personaIds = personaId.split("|").filter(Boolean);
   const primaryId = personaIds[0] ?? personaId;
 
@@ -236,10 +244,10 @@ export async function handlePersonUpdate(response: LLMResponse, state: StateMana
   try {
     const embeddingService = getEmbeddingService();
     const relationship = result.relationship ?? candidateRelationship ?? existingPerson?.relationship;
-    const text = getPersonEmbeddingText({ name: result.name, relationship, description: result.description });
+    const text = getPersonEmbeddingText({ name: candidateName, relationship, description: result.description });
     embedding = await embeddingService.embed(text);
   } catch (err) {
-    console.warn(`[handlePersonUpdate] Failed to compute embedding for person "${result.name}":`, err);
+    console.warn(`[handlePersonUpdate] Failed to compute embedding for person "${candidateName}":`, err);
   }
 
   const exposureImpact = result.exposure_impact as ExposureImpact | undefined;
@@ -250,15 +258,51 @@ export async function handlePersonUpdate(response: LLMResponse, state: StateMana
     ? (allPersonaGroups.length > 0 ? allPersonaGroups : existingPerson?.persona_groups)
     : [...new Set([...(existingPerson?.persona_groups ?? []), ...allPersonaGroups])];
 
+  let resolvedIdentifiers: PersonIdentifier[];
+  if (isNewItem) {
+    const llmIdentifiers: PersonIdentifier[] = sanitizeEiPersonaIdentifiers(
+      (result.identifiers ?? []).map(i => ({
+        type: i.type,
+        value: i.value,
+        ...(i.is_primary ? { is_primary: i.is_primary } : {}),
+      })),
+      state
+    );
+    const allCandidateIds = [...llmIdentifiers, ...candidateIdentifiers];
+    if (allCandidateIds.length === 0) {
+      const hasSpace = candidateName.includes(' ');
+      allCandidateIds.push({ type: hasSpace ? "full_name" : "nickname", value: candidateName, is_primary: true });
+    }
+    const deduped: PersonIdentifier[] = [];
+    for (const id of allCandidateIds) {
+      if (!deduped.some(e => e.value === id.value)) {
+        deduped.push(id);
+      }
+    }
+    resolvedIdentifiers = deduped;
+  } else {
+    const base = [...(existingPerson?.identifiers ?? [])];
+    const sanitizedToAdd = sanitizeEiPersonaIdentifiers(result.identifiers_to_add ?? [], state);
+    for (const id of sanitizedToAdd) {
+      if (!base.some(e => e.value === id.value)) {
+        base.push({ type: id.type, value: id.value, ...(id.is_primary ? { is_primary: id.is_primary } : {}) });
+      }
+    }
+    resolvedIdentifiers = base;
+  }
+
   const person: Person = {
     id: itemId,
-    name: result.name,
+    name: candidateName,
     description: result.description,
     sentiment: result.sentiment,
     relationship: result.relationship ?? candidateRelationship ?? existingPerson?.relationship ?? "Unknown",
     exposure_current: calculateExposureCurrent(exposureImpact, existingPerson?.exposure_current ?? 0),
     exposure_desired: result.exposure_desired ?? 0.5,
+    identifiers: resolvedIdentifiers,
+    validated_date: isNewItem ? '' : (existingPerson?.validated_date ?? ''),
     last_updated: now,
+    learned_on: isNewItem ? now : existingPerson?.learned_on,
     last_mentioned: now,
     learned_by: isNewItem ? primaryId : existingPerson?.learned_by,
     last_changed_by: primaryId,
@@ -273,9 +317,14 @@ export async function handlePersonUpdate(response: LLMResponse, state: StateMana
     : state.messages_get(personaId);
   await validateAndStoreQuotes(result.quotes, allMessages, itemId, personaDisplayName, personaGroup, state);
 
-  console.log(`[handlePersonUpdate] ${isNewItem ? "Created" : "Updated"} person "${result.name}"`);
+  const primaryValue = resolvedIdentifiers.find(i => i.is_primary)?.value ?? candidateName;
+  const resolvedName = (!primaryValue || primaryValue.toLowerCase() === 'unknown')
+    ? (result.relationship ?? candidateRelationship ?? '(unknown)')
+    : primaryValue;
+  console.log(`[handlePersonUpdate] ${isNewItem ? "Created" : "Updated"} person "${resolvedName}"`);
 }
 
+
 function normalizeText(text: string): string {
   return text
     .replace(/[\u201C\u201D]/g, '"')              // curly double quotes