ei-tui 1.7.0 → 1.7.1

package/package.json

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

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

@@ -14,6 +14,9 @@ import { BUILT_IN_FACT_NAMES } from "../constants/built-in-facts.js";
 import { getEmbeddingService, getItemEmbeddingText, cosineSimilarity, getPersonEmbeddingText } from "../embedding-service.js";
 import { levenshtein, normalizeForMatch } from "../utils/levenshtein.js";
 
+export type PersonMatchStrength = 'strong' | 'weak';
+export interface PersonMatch { person: Person; strength: PersonMatchStrength; }
+
 const MULTI_MATCH_SIMILARITY_THRESHOLD = 0.75;
 const ZERO_MATCH_COSINE_THRESHOLD = 0.80;
 
@@ -27,13 +30,25 @@ const SINGLETON_RELATIONSHIPS = new Set([
   'father', 'mother',
 ]);
 
+function sharesNameToken(normalizedCandidateName: string, person: Person): boolean {
+  const candidateTokens = new Set(normalizedCandidateName.split(/\s+/).filter(t => t.length >= 3));
+  if (candidateTokens.size === 0) return false;
+  const personStrings = [normalizeForMatch(person.name), ...(person.identifiers ?? []).map(i => normalizeForMatch(i.value))];
+  for (const s of personStrings) {
+    for (const tok of s.split(/\s+/)) {
+      if (tok.length >= 3 && candidateTokens.has(tok)) return true;
+    }
+  }
+  return false;
+}
+
 function matchPersonCandidate(
   candidateName: string,
   candidateIdentifiers: PersonIdentifier[],
   people: Person[]
-): Person[] {
+): PersonMatch[] {
   const normName = normalizeForMatch(candidateName);
-  const matched = new Set<Person>();
+  const matched = new Map<Person, PersonMatchStrength>();
 
   // Step 1: Exact match on any identifier value (type-agnostic)
   for (const person of people) {
@@ -41,19 +56,24 @@ function matchPersonCandidate(
       ...(person.identifiers ?? []).map(i => normalizeForMatch(i.value)),
       normalizeForMatch(person.name),
     ];
-    if (allValues.includes(normName)) matched.add(person);
+    if (allValues.includes(normName)) matched.set(person, 'strong');
   }
   // 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);
+        // Corroboration gate (#78 C1): a scan-extracted identifier only STRONG-binds when the
+        // candidate's name shares a token with the match. A bare identifier hit with zero name
+        // overlap is the cross-attribution signature (one person's handle on another's record),
+        // so it drops to WEAK and must clear the cosine gate — or become a new record.
+        const strength: PersonMatchStrength = sharesNameToken(normName, person) ? 'strong' : 'weak';
+        if (matched.get(person) !== 'strong') matched.set(person, strength);
       }
     }
   }
 
-  if (matched.size > 0) return [...matched];
+  if (matched.size > 0) return [...matched].map(([person, strength]) => ({ person, strength }));
 
   // Step 2: Fuzzy match — skip for short names (< 6 chars): "mike"↔"jake" = 2 edits, false positive.
   if (normName.length >= 6) {
@@ -63,11 +83,11 @@ function matchPersonCandidate(
         ...(person.identifiers ?? []).map(i => normalizeForMatch(i.value)),
         normalizeForMatch(person.name),
       ];
-      if (allValues.some(v => levenshtein(normName, v) <= threshold)) matched.add(person);
+      if (allValues.some(v => levenshtein(normName, v) <= threshold)) matched.set(person, 'weak');
     }
   }
 
-  if (matched.size > 0) return [...matched];
+  if (matched.size > 0) return [...matched].map(([person, strength]) => ({ person, strength }));
 
   // 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.
@@ -78,11 +98,11 @@ function matchPersonCandidate(
         normalizeForMatch(person.name),
         ...(person.identifiers ?? []).map(i => normalizeForMatch(i.value)),
       ];
-      if (allNames.some(n => n.split(/\s+/)[0] === candidateFirstWord)) matched.add(person);
+      if (allNames.some(n => n.split(/\s+/)[0] === candidateFirstWord)) matched.set(person, 'weak');
     }
   }
 
-  return [...matched];
+  return [...matched].map(([person, strength]) => ({ person, strength }));
 }
 
 export async function handleFactFind(response: LLMResponse, state: StateManager): Promise<void> {
@@ -182,6 +202,27 @@ export async function handleHumanTopicScan(response: LLMResponse, state: StateMa
   console.log(`[handleHumanTopicScan] Queued ${result.topics.length} topic(s) for matching`);
 }
 
+async function confirmMatchByCosine(
+  person: Person,
+  candidate: { name: string; relationship?: string; description?: string },
+  threshold: number
+): Promise<Person | null> {
+  if (!person.embedding || person.embedding.length === 0) return null;
+  try {
+    const embeddingService = getEmbeddingService();
+    const candidateVector = await embeddingService.embed(getPersonEmbeddingText({
+      name: candidate.name, relationship: candidate.relationship, description: candidate.description,
+    }));
+    const sim = cosineSimilarity(person.embedding, candidateVector);
+    if (sim >= threshold) return person;
+    console.debug(`[handleHumanPersonScan] Weak single-match "${candidate.name}" → "${person.name}" rejected (cosine ${sim.toFixed(3)} < ${threshold}) — new record`);
+    return null;
+  } catch (err) {
+    console.warn(`[handleHumanPersonScan] Weak-match cosine failed for "${candidate.name}":`, err);
+    return null;
+  }
+}
+
 export async function handleHumanPersonScan(response: LLMResponse, state: StateManager): Promise<void> {
   const result = response.parsed as PersonScanResult | undefined;
   
@@ -213,7 +254,12 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
     let matchedPerson: Person | null = null;
 
     if (matches.length === 1) {
-      matchedPerson = matches[0];
+      const { person, strength } = matches[0];
+      if (strength === 'strong') {
+        matchedPerson = person;
+      } else {
+        matchedPerson = await confirmMatchByCosine(person, candidate, MULTI_MATCH_SIMILARITY_THRESHOLD);
+      }
     } else if (matches.length > 1) {
       try {
         const embeddingService = getEmbeddingService();
@@ -224,7 +270,7 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
         });
         const candidateVector = await embeddingService.embed(candidateText);
         let bestSimilarity = MULTI_MATCH_SIMILARITY_THRESHOLD;
-        for (const person of matches) {
+        for (const { person } of matches) {
           if (person.embedding) {
             const sim = cosineSimilarity(person.embedding, candidateVector);
             if (sim > bestSimilarity) {
@@ -238,7 +284,7 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
         }
       } catch (err) {
         console.warn(`[handleHumanPersonScan] Multi-match embedding failed for "${candidate.name}", using first match:`, err);
-        matchedPerson = matches[0];
+        matchedPerson = matches[0].person;
       }
     } else {
       // Step 3: relationship filter → uniqueness match or cosine on the relevant subset.
@@ -253,10 +299,13 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
         const normExistingName = normalizeForMatch(existing.name);
         const isUnknownPlaceholder = normExistingName === 'unknown' || normExistingName === normRel;
         const isSingleton = SINGLETON_RELATIONSHIPS.has(normRel!);
-        if (isUnknownPlaceholder || isSingleton) {
+        if (isSingleton) {
           matchedPerson = existing;
-          const reason = isUnknownPlaceholder ? 'unnamed placeholder' : 'singleton relationship';
-          console.debug(`[handleHumanPersonScan] Relationship unique match: "${candidate.name}" → "${existing.name}" (sole ${candidate.relationship}, ${reason})`);
+          console.debug(`[handleHumanPersonScan] Relationship unique match: "${candidate.name}" → "${existing.name}" (sole ${candidate.relationship}, singleton relationship)`);
+        } else if (isUnknownPlaceholder) {
+          // M1 (deferred, #78): a placeholder with no embedding cannot be confirmed here and will fork a new record instead of promoting. Acceptable under the dupe-tolerant policy; revisit with embedding backfill.
+          matchedPerson = await confirmMatchByCosine(existing, candidate, ZERO_MATCH_COSINE_THRESHOLD);
+          console.debug(`[handleHumanPersonScan] Relationship unique match gated by cosine: "${candidate.name}" → "${existing.name}" (sole ${candidate.relationship}, unnamed placeholder) — ${matchedPerson ? 'confirmed' : 'rejected, new record'}`);
         }
       } else {
         // N>1 same relationship → cosine within that subset.

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

@@ -607,17 +607,6 @@ export function queuePersonUpdate(
 
   const candidateIdentifiers = context.candidateIdentifiers ?? [];
 
-  if (!isNewItem && existingItem && candidateIdentifiers.length > 0) {
-    const merged = [...(existingItem.identifiers ?? [])];
-    for (const ci of candidateIdentifiers) {
-      if (!merged.some(ei => ei.value === ci.value)) {
-        merged.push(ci);
-      }
-    }
-    existingItem = { ...existingItem, identifiers: merged };
-    state.human_person_upsert(existingItem);
-  }
-
   const userIdentifierTypes = [...new Set(
     state.getHuman().people
       .flatMap(p => (p.identifiers ?? []).map(i => i.type))
@@ -642,6 +631,7 @@ export function queuePersonUpdate(
       persona_name: chunk.channelDisplayName,
       participant_context: buildParticipantContext(primaryPersonaIdForUpdate, state),
       known_identifier_types: userIdentifierTypes,
+      suggested_identifiers: !isNewItem ? candidateIdentifiers : undefined,
     });
 
     state.queue_enqueue({

package/src/core/persona-manager.ts

@@ -128,15 +128,26 @@ export async function updatePersona(
   const persona = sm.persona_getById(personaId);
   if (!persona) return false;
 
-  if ('long_description' in updates) {
-    const merged = { ...persona, ...updates };
-    const embedding = await computePersonaDescriptionEmbedding(merged);
-    if (embedding) {
-      updates = { ...updates, description_embedding: embedding };
-    }
-  }
+  const shouldRefreshDescriptionEmbedding = 'long_description' in updates;
+  const mergedForEmbedding = shouldRefreshDescriptionEmbedding
+    ? { ...persona, ...updates }
+    : null;
 
   sm.persona_update(personaId, updates);
+
+  if (shouldRefreshDescriptionEmbedding && mergedForEmbedding) {
+    void computePersonaDescriptionEmbedding(mergedForEmbedding).then((embedding) => {
+      if (!embedding) return;
+      const current = sm.persona_getById(personaId);
+      if (!current) return;
+      if (
+        current.long_description !== mergedForEmbedding.long_description ||
+        current.short_description !== mergedForEmbedding.short_description
+      ) return;
+      sm.persona_update(personaId, { description_embedding: embedding });
+    });
+  }
+
   return true;
 }
 

package/src/prompts/human/person-scan.ts

@@ -107,6 +107,8 @@ If you are unsure of the type, use \`Nickname\` as a fallback. Do NOT invent typ
 
 Only include \`identifiers\` when explicitly mentioned in the conversation — omit it entirely if nothing qualifies.
 
+Do NOT attribute one person's handle or identifier to another person discussed in the same window. If "Marcus's GitHub is @mcodes" appears alongside a mention of Priya, @mcodes belongs to Marcus's record only — never Priya's.
+
 ## Confidence & Relationship Type
 
 For each person, rate how important they are to the human user's life:

package/src/prompts/human/person-update.ts

@@ -1,5 +1,6 @@
 import type { PromptOutput, ParticipantContext } from "./types.js";
 import type { Person, Message } from "../../core/types.js";
+import type { PersonIdentifier } from "../../core/types/data-items.js";
 import { formatMessagesAsPlaceholders } from "../message-utils.js";
 
 export interface PersonUpdatePromptData {
@@ -12,6 +13,7 @@ export interface PersonUpdatePromptData {
   persona_name: string;
   participant_context?: ParticipantContext;
   known_identifier_types?: string[];
+  suggested_identifiers?: PersonIdentifier[];
 }
 
 function participantContextSection(ctx: ParticipantContext | undefined): string {
@@ -171,20 +173,29 @@ The description should NOT:
     ? `CRITICAL: The HUMAN USER is ${humanName}. They wrote these messages. Do NOT assign their names, nicknames, or handles as identifiers for this person's record — UNLESS this IS the user's own Self record (relationship: "Self").`
     : `CRITICAL: The HUMAN USER wrote these messages. Do NOT assign their own names or handles as identifiers for this person's record — UNLESS this IS the user's own Self record (relationship: "Self"). Do NOT return \`relationship: "Self"\` unless you are certain this record is about the human user themselves.`;
 
+  const attributionGuard = `\nONLY add an identifier if it is explicitly stated about THIS SPECIFIC PERSON — not inferred from proximity in the conversation. If two different people are discussed near each other, do NOT attribute one person's handle, email, or name to the other.`;
   const isUnknownNewPerson = isNewItem && personName === 'Unknown';
   const unknownIdentifierGuard = isUnknownNewPerson
-    ? `\nThis person's name is not yet known. ONLY add \`identifiers\` if their name, handle, or email is explicitly stated in the conversation about THEM specifically — not inferred, not guessed.`
+    ? `\nThis person's name is not yet known — be especially careful: only record an identifier the conversation names for THEM specifically.`
     : '';
 
-  const identifierSection = `${identityGuard}${unknownIdentifierGuard}
+  const suggestedIdentifiers = data.suggested_identifiers ?? [];
+  const suggestedIdentifiersBlock = !isNewItem && suggestedIdentifiers.length > 0
+    ? `\n\nThe scan flagged these identifiers as POSSIBLY belonging to this person: ${suggestedIdentifiers.map(i => `\`${i.type}=${i.value}\``).join(', ')}.
+For EACH, add it to \`identifiers_to_add\` ONLY if the Most Recent Messages confirm it belongs to THIS SPECIFIC PERSON. If any actually belongs to someone else mentioned in the conversation, omit it. Do not add any you cannot confirm from the conversation.`
+    : '';
+
+  const identifierSection = `${identityGuard}${attributionGuard}${unknownIdentifierGuard}
 
 If you spot a platform handle, username, email, nickname, or full name explicitly mentioned in the conversation that isn't already in the person's identifiers, include it in \`identifiers_to_add\` (updates) or \`identifiers\` (new records). Always mark exactly one identifier as \`"is_primary": true\` — prefer the most formal or complete name.
 
+Example of what NOT to do: if the conversation says "I talked to Priya and Marcus — Marcus's GitHub is @mcodes", do NOT add @mcodes to Priya's record; it belongs to Marcus only.
+
 For persons with a known relationship (Father, Mother, Sibling, etc.), also look for informal terms the HUMAN USER uses to address or refer to THAT SPECIFIC PERSON (\`Dad\`, \`Pop\`, \`Mom\`, \`Sis\`, etc.) and add them as \`{ "type": "Relationship", "value": "..." }\` identifiers.
 
 NEVER add dates, ages, birthdays, or anniversaries as identifiers. These are not identifying labels — if known, include them in the description instead.
 
-Known identifier types: ${allTypes}. If unsure of type, use \`Nickname\`.`;
+Known identifier types: ${allTypes}. If unsure of type, use \`Nickname\`.${suggestedIdentifiersBlock}`;
 
   // ── OUTPUT FORMAT ─────────────────────────────────────────────────────────