ei-tui 0.1.25 → 0.2.0

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

@@ -1,35 +1,72 @@
-import { LLMRequestType, LLMPriority, LLMNextStep, type Message, type DataItemType, type Fact, type Trait, type Topic, type Person } from "../types.js";
+import { LLMRequestType, LLMPriority, LLMNextStep, type Message, type Topic, type Person } from "../types.js";
 import type { StateManager } from "../state-manager.js";
 import {
-  buildHumanFactScanPrompt,
-  buildHumanTraitScanPrompt,
+  buildFactFindPrompt,
   buildHumanTopicScanPrompt,
   buildHumanPersonScanPrompt,
-  buildHumanItemMatchPrompt,
-  buildHumanItemUpdatePrompt,
-  type FactScanCandidate,
-  type TraitScanCandidate,
+  buildTopicMatchPrompt,
+  buildTopicUpdatePrompt,
+  buildPersonMatchPrompt,
+  buildPersonUpdatePrompt,
+  buildEventScanPrompt,
   type TopicScanCandidate,
   type PersonScanCandidate,
   type ItemMatchResult,
+  type ParticipantContext,
 } from "../../prompts/human/index.js";
 import { chunkExtractionContext } from "./extraction-chunker.js";
-import { getEmbeddingService, findTopK } from "../embedding-service.js";
+import { getEmbeddingService, findTopK, getTopicEmbeddingText, getPersonEmbeddingText } from "../embedding-service.js";
 import { resolveTokenLimit } from "../llm-client.js";
+import { BUILT_IN_FACT_NAMES } from "../constants/built-in-facts.js";
+import { buildEventWindows } from "../utils/event-windows.js";
 
-type ScanCandidate = FactScanCandidate | TraitScanCandidate | TopicScanCandidate | PersonScanCandidate;
+function buildParticipantContext(personaId: string, state: StateManager): ParticipantContext {
+  const persona = state.persona_getById(personaId);
+  const human = state.getHuman();
+
+  const persona_description = persona?.long_description || undefined;
+
+  const fullNameFact = human.facts.find(f => f.name === "Full Name");
+  const nicknameFact = human.facts.find(f => f.name === "Nickname/Preferred Name");
+  const fullName = fullNameFact?.description || "";
+  const nickname = nicknameFact?.description || "";
+  let human_name: string | undefined;
+  if (fullName && nickname) human_name = `${fullName} (${nickname})`;
+  else if (fullName) human_name = fullName;
+  else if (nickname) human_name = nickname;
+
+  let human_age: number | undefined;
+  const birthdayFact = human.facts.find(f => f.name === "Birthday");
+  if (birthdayFact?.description) {
+    const birth = new Date(birthdayFact.description);
+    if (!isNaN(birth.getTime())) {
+      human_age = Math.floor((Date.now() - birth.getTime()) / (365.25 * 24 * 60 * 60 * 1000));
+    }
+  }
+
+  return {
+    persona_name: persona?.display_name ?? personaId,
+    persona_description,
+    human_name,
+    human_age,
+  };
+}
 
 export interface ExtractionContext {
   personaId: string;
   personaDisplayName: string;
   messages_context: Message[];
   messages_analyze: Message[];
-  extraction_flag?: "f" | "r" | "p" | "o";
+  extraction_flag?: "f" | "t" | "p" | "e";
 }
 
 export interface ExtractionOptions {
   /** Ceremony phase number (1=Dedup, 2=Expose) */
   ceremony_progress?: number;
+  /** Override model for extraction LLM calls */
+  extraction_model?: string;
+  /** Override token budget for chunking */
+  extraction_token_limit?: number;
 }
 
 function getAnalyzeFromTimestamp(context: ExtractionContext): string | null {
@@ -40,16 +77,27 @@ function getAnalyzeFromTimestamp(context: ExtractionContext): string | null {
 const EXTRACTION_BUDGET_RATIO = 0.75;
 const MIN_EXTRACTION_TOKENS = 10000;
 
-function getExtractionMaxTokens(state: StateManager): number {
+function getExtractionMaxTokens(state: StateManager, options?: ExtractionOptions): number {
+  if (options?.extraction_token_limit) {
+    return Math.max(MIN_EXTRACTION_TOKENS, Math.floor(options.extraction_token_limit * EXTRACTION_BUDGET_RATIO));
+  }
   const human = state.getHuman();
-  const tokenLimit = resolveTokenLimit(human.settings?.default_model, human.settings?.accounts);
+  const modelForTokenLimit = options?.extraction_model ?? human.settings?.default_model;
+  const tokenLimit = resolveTokenLimit(modelForTokenLimit, human.settings?.accounts);
   return Math.max(MIN_EXTRACTION_TOKENS, Math.floor(tokenLimit * EXTRACTION_BUDGET_RATIO));
 }
 
-export function queueFactScan(context: ExtractionContext, state: StateManager, options?: ExtractionOptions): number {
-  const { chunks } = chunkExtractionContext(context, getExtractionMaxTokens(state));
-  
-  if (chunks.length === 0) return 0;
+export function queueFactFind(context: ExtractionContext, state: StateManager, options?: ExtractionOptions): number {
+  const human = state.getHuman();
+  const extractionModel = options?.extraction_model;
+  const missing_fact_names = human.facts
+    .filter(f => !f.description || f.description === "")
+    .map(f => f.name)
+    .filter(name => BUILT_IN_FACT_NAMES.has(name));
+
+  if (missing_fact_names.length === 0) return 0;
+
+  const { chunks } = chunkExtractionContext(context, getExtractionMaxTokens(state, options));
 
   // Pre-mark messages before enqueuing — prevents duplicate scans if the
   // queue check fires again during LLM latency (100ms loop × 5s call = 50 dupes)
@@ -58,8 +106,9 @@ export function queueFactScan(context: ExtractionContext, state: StateManager, o
   }
 
   for (const chunk of chunks) {
-    const prompt = buildHumanFactScanPrompt({
+    const prompt = buildFactFindPrompt({
       persona_name: chunk.personaDisplayName,
+      missing_fact_names,
       messages_context: chunk.messages_context,
       messages_analyze: chunk.messages_analyze,
     });
@@ -67,9 +116,10 @@ export function queueFactScan(context: ExtractionContext, state: StateManager, o
     state.queue_enqueue({
       type: LLMRequestType.JSON,
       priority: LLMPriority.Low,
+      model: extractionModel,
       system: prompt.system,
       user: prompt.user,
-      next_step: LLMNextStep.HandleHumanFactScan,
+      next_step: LLMNextStep.HandleFactFind,
       data: {
         ...options,
         personaId: chunk.personaId,
@@ -84,47 +134,16 @@ export function queueFactScan(context: ExtractionContext, state: StateManager, o
   return chunks.length;
 }
 
-export function queueTraitScan(context: ExtractionContext, state: StateManager, options?: ExtractionOptions): number {
-  const { chunks } = chunkExtractionContext(context, getExtractionMaxTokens(state));
-  
-  if (chunks.length === 0) return 0;
-  
-  for (const chunk of chunks) {
-    const prompt = buildHumanTraitScanPrompt({
-      persona_name: chunk.personaDisplayName,
-      messages_context: chunk.messages_context,
-      messages_analyze: chunk.messages_analyze,
-    });
-
-    state.queue_enqueue({
-      type: LLMRequestType.JSON,
-      priority: LLMPriority.Low,
-      system: prompt.system,
-      user: prompt.user,
-      next_step: LLMNextStep.HandleHumanTraitScan,
-      data: {
-        ...options,
-        personaId: chunk.personaId,
-        personaDisplayName: chunk.personaDisplayName,
-        analyze_from_timestamp: getAnalyzeFromTimestamp(chunk),
-        extraction_flag: context.extraction_flag,
-        message_ids_to_mark: chunk.messages_analyze.map(m => m.id),
-      },
-    });
-  }
-  
-  return chunks.length;
-}
-
 export function queueTopicScan(context: ExtractionContext, state: StateManager, options?: ExtractionOptions): number {
-  const { chunks } = chunkExtractionContext(context, getExtractionMaxTokens(state));
+  const extractionModel = options?.extraction_model;
+  const { chunks } = chunkExtractionContext(context, getExtractionMaxTokens(state, options));
   
   if (chunks.length === 0) return 0;
 
   // Pre-mark messages before enqueuing — prevents duplicate scans if the
   // queue check fires again during LLM latency (100ms loop × 5s call = 50 dupes)
   for (const chunk of chunks) {
-    state.messages_markExtracted(chunk.personaId, chunk.messages_analyze.map(m => m.id), "p");
+    state.messages_markExtracted(chunk.personaId, chunk.messages_analyze.map(m => m.id), "t");
   }
 
   for (const chunk of chunks) {
@@ -132,11 +151,13 @@ export function queueTopicScan(context: ExtractionContext, state: StateManager,
       persona_name: chunk.personaDisplayName,
       messages_context: chunk.messages_context,
       messages_analyze: chunk.messages_analyze,
+      participant_context: buildParticipantContext(context.personaId, state),
     });
 
     state.queue_enqueue({
       type: LLMRequestType.JSON,
       priority: LLMPriority.Low,
+      model: extractionModel,
       system: prompt.system,
       user: prompt.user,
       next_step: LLMNextStep.HandleHumanTopicScan,
@@ -155,14 +176,15 @@ export function queueTopicScan(context: ExtractionContext, state: StateManager,
 }
 
 export function queuePersonScan(context: ExtractionContext, state: StateManager, options?: ExtractionOptions): number {
-  const { chunks } = chunkExtractionContext(context, getExtractionMaxTokens(state));
+  const extractionModel = options?.extraction_model;
+  const { chunks } = chunkExtractionContext(context, getExtractionMaxTokens(state, options));
   
   if (chunks.length === 0) return 0;
 
   // Pre-mark messages before enqueuing — prevents duplicate scans if the
   // queue check fires again during LLM latency (100ms loop × 5s call = 50 dupes)
   for (const chunk of chunks) {
-    state.messages_markExtracted(chunk.personaId, chunk.messages_analyze.map(m => m.id), "o");
+    state.messages_markExtracted(chunk.personaId, chunk.messages_analyze.map(m => m.id), "p");
   }
 
   for (const chunk of chunks) {
@@ -175,6 +197,7 @@ export function queuePersonScan(context: ExtractionContext, state: StateManager,
     state.queue_enqueue({
       type: LLMRequestType.JSON,
       priority: LLMPriority.Low,
+      model: extractionModel,
       system: prompt.system,
       user: prompt.user,
       next_step: LLMNextStep.HandleHumanPersonScan,
@@ -193,10 +216,10 @@ export function queuePersonScan(context: ExtractionContext, state: StateManager,
 }
 
 export function queueAllScans(context: ExtractionContext, state: StateManager, options?: ExtractionOptions): void {
-  queueFactScan(context, state, options);
-  queueTraitScan(context, state, options);
+  queueFactFind(context, state, options);
   queuePersonScan(context, state, options);
   queueTopicScan(context, state, options);
+  queueEventSummary(context.personaId, state, options);
 }
 
 /**
@@ -214,32 +237,33 @@ export function queueAllScans(context: ExtractionContext, state: StateManager, o
 export function queueDirectTopicUpdate(
   topic: import("../types.js").Topic,
   context: ExtractionContext,
-  state: StateManager
+  state: StateManager,
+  options?: ExtractionOptions
 ): number {
-  const { chunks } = chunkExtractionContext(context, getExtractionMaxTokens(state));
+  const extractionModel = options?.extraction_model;
+  const { chunks } = chunkExtractionContext(context, getExtractionMaxTokens(state, options));
 
   if (chunks.length === 0) return 0;
 
   for (const chunk of chunks) {
-    const prompt = buildHumanItemUpdatePrompt({
-      data_type: "topic",
+    const prompt = buildTopicUpdatePrompt({
       existing_item: topic,
       messages_context: chunk.messages_context,
       messages_analyze: chunk.messages_analyze,
       persona_name: chunk.personaDisplayName,
+      participant_context: buildParticipantContext(context.personaId, state),
     });
 
     state.queue_enqueue({
       type: LLMRequestType.JSON,
       priority: LLMPriority.Normal,
+      model: extractionModel,
       system: prompt.system,
       user: prompt.user,
-      next_step: LLMNextStep.HandleHumanItemUpdate,
+      next_step: LLMNextStep.HandleTopicUpdate,
       data: {
         personaId: context.personaId,
         personaDisplayName: context.personaDisplayName,
-        candidateType: "topic",
-        matchedType: "topic",
         isNewItem: false,
         existingItemId: topic.id,
         analyze_from_timestamp: getAnalyzeFromTimestamp(chunk),
@@ -250,227 +274,345 @@ export function queueDirectTopicUpdate(
   return chunks.length;
 }
 
-function truncateDescription(description: string, maxLength: number = 255): string {
-  if (description.length <= maxLength) return description;
-  return description.slice(0, maxLength) + "...";
-}
-
 const EMBEDDING_TOP_K = 20;
 const EMBEDDING_MIN_SIMILARITY = 0.3;
 
 /**
- * Queue an item match request using embedding-based similarity.
- * 
- * Instead of sending ALL items to the LLM, we:
- * 1. Compute embedding for the candidate (name + value)
- * 2. Find top-K most similar existing items via cosine similarity
- * 3. Send only those candidates to the LLM for final matching decision
- * 
- * This reduces prompt size from O(all_items) to O(K) where K=20.
+ * Queue a topic match request using embedding-based similarity (topics only).
  */
-export async function queueItemMatch(
-  dataType: DataItemType,
-  candidate: ScanCandidate,
+export async function queueTopicMatch(
+  candidate: TopicScanCandidate,
   context: ExtractionContext,
-  state: StateManager
+  state: StateManager,
+  extractionModel?: string
 ): Promise<void> {
   const human = state.getHuman();
-  
-  let itemName: string;
-  let itemValue: string;
-
-  switch (dataType) {
-    case "fact":
-      itemName = (candidate as FactScanCandidate).type_of_fact;
-      itemValue = (candidate as FactScanCandidate).value_of_fact;
-      break;
-    case "trait":
-      itemName = (candidate as TraitScanCandidate).type_of_trait;
-      itemValue = (candidate as TraitScanCandidate).value_of_trait;
-      break;
-    case "topic":
-      itemName = (candidate as TopicScanCandidate).value_of_topic;
-      itemValue = (candidate as TopicScanCandidate).type_of_topic;
-      break;
-    case "person":
-      itemName = (candidate as PersonScanCandidate).name_of_person;
-      itemValue = (candidate as PersonScanCandidate).type_of_person;
-      break;
-  }
 
-  // Traits are personality patterns — they must only match against other traits.
-  // Non-trait candidates (facts, topics, people) must never absorb trait content,
-  // and trait candidates must never cross-match into facts/topics/people.
-  const allItemsWithEmbeddings = [
-    ...(dataType !== "trait" ? human.facts.map(f => ({ ...f, data_type: "fact" as DataItemType })) : []),
-    ...human.traits.map(t => ({ ...t, data_type: "trait" as DataItemType })),
-    ...(dataType !== "trait" ? human.topics.map(t => ({ ...t, data_type: "topic" as DataItemType })) : []),
-    ...(dataType !== "trait" ? human.people.map(p => ({ ...p, data_type: "person" as DataItemType })) : []),
-  ].filter(item => item.embedding && item.embedding.length > 0);
-
-  let topKItems: Array<{
-    data_type: DataItemType;
-    data_id: string;
-    data_name: string;
-    data_description: string;
-  }> = [];
-
-  if (allItemsWithEmbeddings.length > 0) {
+  const topicsWithEmbeddings = human.topics.filter(t => t.embedding && t.embedding.length > 0);
+
+  let topKItems: Array<{ id: string; name: string; description: string; category?: string }> = [];
+
+  if (topicsWithEmbeddings.length > 0) {
     try {
       const embeddingService = getEmbeddingService();
-      const candidateText = `${itemName}: ${itemValue}`;
+      const candidateText = getTopicEmbeddingText({
+        name: candidate.name,
+        category: candidate.category,
+        description: candidate.description,
+      });
       const candidateVector = await embeddingService.embed(candidateText);
 
-      const topK = findTopK(candidateVector, allItemsWithEmbeddings, EMBEDDING_TOP_K);
-      
+      const topK = findTopK(candidateVector, topicsWithEmbeddings, EMBEDDING_TOP_K);
       topKItems = topK
         .filter(({ similarity }) => similarity >= EMBEDDING_MIN_SIMILARITY)
         .map(({ item }) => ({
-          data_type: item.data_type,
-          data_id: item.id,
-          data_name: item.name,
-          data_description: item.data_type === dataType 
-            ? item.description 
-            : truncateDescription(item.description),
+          id: item.id,
+          name: item.name,
+          description: item.description,
+          category: item.category,
         }));
 
-      console.log(`[queueItemMatch] Embedding search: ${allItemsWithEmbeddings.length} items → ${topKItems.length} candidates (top-K=${EMBEDDING_TOP_K}, min_sim=${EMBEDDING_MIN_SIMILARITY})`);
+      console.log(`[queueTopicMatch] Embedding search: ${topicsWithEmbeddings.length} topics → ${topKItems.length} candidates`);
     } catch (err) {
-      console.error(`[queueItemMatch] Embedding search failed, falling back to all items:`, err);
+      console.error(`[queueTopicMatch] Embedding search failed, falling back to all topics:`, err);
     }
   }
 
   if (topKItems.length === 0) {
+    console.log(`[queueTopicMatch] No embeddings available, using all topics`);
+    topKItems = human.topics.map(t => ({
+      id: t.id,
+      name: t.name,
+      description: t.description,
+      category: t.category,
+    }));
+  }
 
-    console.log(`[queueItemMatch] No embeddings available, using filtered items (dataType=${dataType})`);
-
-    if (dataType !== "trait") {
-      for (const fact of human.facts) {
-        topKItems.push({
-          data_type: "fact",
-          data_id: fact.id,
-          data_name: fact.name,
-          data_description: dataType === "fact" ? fact.description : truncateDescription(fact.description),
-        });
-      }
-    }
+  const prompt = buildTopicMatchPrompt({
+    candidate_name: candidate.name,
+    candidate_description: candidate.description,
+    candidate_category: candidate.category,
+    existing_topics: topKItems,
+  });
+
+  state.queue_enqueue({
+    type: LLMRequestType.JSON,
+    priority: LLMPriority.Normal,
+    model: extractionModel,
+    system: prompt.system,
+    user: prompt.user,
+    next_step: LLMNextStep.HandleTopicMatch,
+    data: {
+      ...context,
+      candidateName: candidate.name,
+      candidateDescription: candidate.description,
+      candidateCategory: candidate.category,
+      extraction_model: extractionModel,
+    },
+  });
+}
+
+/**
+ * Queue a person match request using embedding-based similarity (people only).
+ */
+export async function queuePersonMatch(
+  candidate: PersonScanCandidate,
+  context: ExtractionContext,
+  state: StateManager,
+  extractionModel?: string
+): Promise<void> {
+  const human = state.getHuman();
+
+  const peopleWithEmbeddings = human.people.filter(p => p.embedding && p.embedding.length > 0);
+
+  let topKItems: Array<{ id: string; name: string; description: string; relationship?: string }> = [];
 
-    for (const trait of human.traits) {
-      topKItems.push({
-        data_type: "trait",
-        data_id: trait.id,
-        data_name: trait.name,
-        data_description: dataType === "trait" ? trait.description : truncateDescription(trait.description),
+  if (peopleWithEmbeddings.length > 0) {
+    try {
+      const embeddingService = getEmbeddingService();
+      const candidateText = getPersonEmbeddingText({
+        name: candidate.name,
+        relationship: candidate.relationship,
+        description: candidate.description,
       });
-    }
+      const candidateVector = await embeddingService.embed(candidateText);
+
+      const topK = findTopK(candidateVector, peopleWithEmbeddings, EMBEDDING_TOP_K);
+      topKItems = topK
+        .filter(({ similarity }) => similarity >= EMBEDDING_MIN_SIMILARITY)
+        .map(({ item }) => ({
+          id: item.id,
+          name: item.name,
+          description: item.description,
+          relationship: item.relationship,
+        }));
 
-    if (dataType !== "trait") {
-      for (const topic of human.topics) {
-        topKItems.push({
-          data_type: "topic",
-          data_id: topic.id,
-          data_name: topic.name,
-          data_description: dataType === "topic" ? topic.description : truncateDescription(topic.description),
-        });
-      }
-
-      for (const person of human.people) {
-        topKItems.push({
-          data_type: "person",
-          data_id: person.id,
-          data_name: person.name,
-          data_description: dataType === "person" ? person.description : truncateDescription(person.description),
-        });
-      }
+      console.log(`[queuePersonMatch] Embedding search: ${peopleWithEmbeddings.length} people → ${topKItems.length} candidates`);
+    } catch (err) {
+      console.error(`[queuePersonMatch] Embedding search failed, falling back to all people:`, err);
     }
   }
 
-  const prompt = buildHumanItemMatchPrompt({
-    candidate_type: dataType,
-    candidate_name: itemName,
-    candidate_value: itemValue,
-    all_items: topKItems,
-  });
-
+  if (topKItems.length === 0) {
+    console.log(`[queuePersonMatch] No embeddings available, using all people`);
+    topKItems = human.people.map(p => ({
+      id: p.id,
+      name: p.name,
+      description: p.description,
+      relationship: p.relationship,
+    }));
+  }
 
+  const prompt = buildPersonMatchPrompt({
+    candidate_name: candidate.name,
+    candidate_description: candidate.description,
+    candidate_relationship: candidate.relationship,
+    existing_people: topKItems,
+  });
 
   state.queue_enqueue({
     type: LLMRequestType.JSON,
     priority: LLMPriority.Normal,
+    model: extractionModel,
     system: prompt.system,
     user: prompt.user,
-    next_step: LLMNextStep.HandleHumanItemMatch,
+    next_step: LLMNextStep.HandlePersonMatch,
     data: {
       ...context,
-      candidateType: dataType,
-      itemName,
-      itemValue,
+      candidateName: candidate.name,
+      candidateDescription: candidate.description,
+      candidateRelationship: candidate.relationship,
+      extraction_model: extractionModel,
     },
   });
 }
 
-export function queueItemUpdate(
-  candidateType: DataItemType,
+export function queueTopicUpdate(
   matchResult: ItemMatchResult,
-  context: ExtractionContext & { itemName: string; itemValue: string; itemCategory?: string },
+  context: ExtractionContext & {
+    candidateName: string;
+    candidateDescription: string;
+    candidateCategory: string;
+    extraction_model?: string;
+  },
   state: StateManager
 ): number {
   const human = state.getHuman();
   const matchedGuid = matchResult.matched_guid;
   const isNewItem = matchedGuid === null;
 
-  let existingItem: Fact | Trait | Topic | Person | null = null;
-  let matchedType: DataItemType | null = null;
+  let existingItem: Topic | null = null;
+  if (!isNewItem && matchedGuid) {
+    existingItem = human.topics.find(t => t.id === matchedGuid) ?? null;
+  }
 
-  if (!isNewItem) {
-    existingItem = human.facts.find(f => f.id === matchedGuid) ?? null;
-    if (existingItem) matchedType = "fact";
+  const extractionOptions: ExtractionOptions = { extraction_model: context.extraction_model };
+  const { chunks } = chunkExtractionContext(context, getExtractionMaxTokens(state, extractionOptions));
 
-    if (!existingItem) {
-      existingItem = human.traits.find(t => t.id === matchedGuid) ?? null;
-      if (existingItem) matchedType = "trait";
-    }
+  if (chunks.length === 0) return 0;
 
-    if (!existingItem) {
-      existingItem = human.topics.find(t => t.id === matchedGuid) ?? null;
-      if (existingItem) matchedType = "topic";
-    }
+  for (const chunk of chunks) {
+    const prompt = buildTopicUpdatePrompt({
+      existing_item: existingItem,
+      new_topic_name: isNewItem ? context.candidateName : undefined,
+      new_topic_description: isNewItem ? context.candidateDescription : undefined,
+      new_topic_category: isNewItem ? context.candidateCategory : undefined,
+      messages_context: chunk.messages_context,
+      messages_analyze: chunk.messages_analyze,
+      persona_name: chunk.personaDisplayName,
+      participant_context: buildParticipantContext(context.personaId, state),
+    });
+
+    state.queue_enqueue({
+      type: LLMRequestType.JSON,
+      priority: LLMPriority.Normal,
+      model: context.extraction_model,
+      system: prompt.system,
+      user: prompt.user,
+      next_step: LLMNextStep.HandleTopicUpdate,
+      data: {
+        personaId: context.personaId,
+        personaDisplayName: context.personaDisplayName,
+        isNewItem,
+        existingItemId: existingItem?.id,
+        candidateCategory: context.candidateCategory,
+        analyze_from_timestamp: getAnalyzeFromTimestamp(chunk),
+      },
+    });
+  }
+
+  return chunks.length;
+}
+
+export function queueEventSummary(
+  personaId: string,
+  state: StateManager,
+  options?: ExtractionOptions
+): number {
+  const persona = state.persona_getById(personaId);
+  if (!persona) {
+    console.error(`[queueEventSummary] Persona not found: ${personaId}`);
+    return 0;
+  }
+
+  const unextractedMessages = state.messages_getUnextracted(personaId, "e");
+  if (unextractedMessages.length === 0) {
+    console.log(`[queueEventSummary] No unprocessed messages for ${persona.display_name}`);
+    return 0;
+  }
+
+  const human = state.getHuman();
+  const gapHours = human.settings?.ceremony?.event_window_hours ?? 8;
+
+  const sorted = [...unextractedMessages].sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+
+  const windows = buildEventWindows(sorted, gapHours);
+
+  const allMessages = state.messages_get(personaId);
+  const extractionModel = options?.extraction_model;
+  let totalChunks = 0;
+
+  state.messages_markExtracted(personaId, sorted.map(m => m.id), "e");
+
+  for (const windowMessages of windows) {
+    if (windowMessages.length === 0) continue;
+
+    const windowStartTime = new Date(windowMessages[0].timestamp).getTime();
+    const messages_context = allMessages.filter(
+      m => m.e === true && new Date(m.timestamp).getTime() < windowStartTime
+    );
 
-    if (!existingItem) {
-      existingItem = human.people.find(p => p.id === matchedGuid) ?? null;
-      if (existingItem) matchedType = "person";
+    const context: ExtractionContext = {
+      personaId,
+      personaDisplayName: persona.display_name,
+      messages_context,
+      messages_analyze: windowMessages,
+      extraction_flag: "e",
+    };
+
+    const { chunks } = chunkExtractionContext(context, getExtractionMaxTokens(state, options));
+
+    for (const chunk of chunks) {
+      const prompt = buildEventScanPrompt({
+        persona_name: chunk.personaDisplayName,
+        messages_context: chunk.messages_context,
+        messages_analyze: chunk.messages_analyze,
+        participant_context: buildParticipantContext(personaId, state),
+      });
+
+      state.queue_enqueue({
+        type: LLMRequestType.JSON,
+        priority: LLMPriority.Low,
+        model: extractionModel,
+        system: prompt.system,
+        user: prompt.user,
+        next_step: LLMNextStep.HandleEventScan,
+        data: {
+          ...options,
+          personaId: chunk.personaId,
+          personaDisplayName: chunk.personaDisplayName,
+          extraction_flag: "e",
+          message_ids_to_mark: chunk.messages_analyze.map(m => m.id),
+        },
+      });
+      totalChunks++;
     }
   }
 
-  const { chunks } = chunkExtractionContext(context, getExtractionMaxTokens(state));
+  console.log(`[queueEventSummary] Queued ${totalChunks} event scan chunk(s) for ${persona.display_name} (${windows.length} window(s))`);
+  return totalChunks;
+}
+
+export function queuePersonUpdate(
+  matchResult: ItemMatchResult,
+  context: ExtractionContext & {
+    candidateName: string;
+    candidateDescription: string;
+    candidateRelationship: string;
+    extraction_model?: string;
+  },
+  state: StateManager
+): number {
+  const human = state.getHuman();
+  const matchedGuid = matchResult.matched_guid;
+  const isNewItem = matchedGuid === null;
+
+  let existingItem: Person | null = null;
+  if (!isNewItem && matchedGuid) {
+    existingItem = human.people.find(p => p.id === matchedGuid) ?? null;
+  }
+
+  const extractionOptions: ExtractionOptions = { extraction_model: context.extraction_model };
+  const { chunks } = chunkExtractionContext(context, getExtractionMaxTokens(state, extractionOptions));
 
   if (chunks.length === 0) return 0;
 
   for (const chunk of chunks) {
-    const prompt = buildHumanItemUpdatePrompt({
-      data_type: candidateType,
+    const prompt = buildPersonUpdatePrompt({
       existing_item: existingItem,
+      new_person_name: isNewItem ? context.candidateName : undefined,
+      new_person_description: isNewItem ? context.candidateDescription : undefined,
+      new_person_relationship: isNewItem ? context.candidateRelationship : undefined,
       messages_context: chunk.messages_context,
       messages_analyze: chunk.messages_analyze,
       persona_name: chunk.personaDisplayName,
-      new_item_name: isNewItem ? context.itemName : undefined,
-      new_item_value: isNewItem ? context.itemValue : undefined,
     });
 
     state.queue_enqueue({
       type: LLMRequestType.JSON,
       priority: LLMPriority.Normal,
+      model: context.extraction_model,
       system: prompt.system,
       user: prompt.user,
-      next_step: LLMNextStep.HandleHumanItemUpdate,
+      next_step: LLMNextStep.HandlePersonUpdate,
       data: {
         personaId: context.personaId,
         personaDisplayName: context.personaDisplayName,
-        candidateType,
-        matchedType,
         isNewItem,
         existingItemId: existingItem?.id,
-        itemCategory: context.itemCategory,
+        candidateRelationship: context.candidateRelationship,
         analyze_from_timestamp: getAnalyzeFromTimestamp(chunk),
       },
     });
@@ -478,3 +620,5 @@ export function queueItemUpdate(
 
   return chunks.length;
 }
+
+