ei-tui 0.1.24 → 0.2.0

package/src/core/handlers/index.ts

@@ -14,8 +14,8 @@ import {
   handlePersonaTopicMatch,
   handlePersonaTopicUpdate,
 } from "./persona-topics.js";
-import { handleHumanFactScan, handleHumanTraitScan, handleHumanTopicScan, handleHumanPersonScan } from "./human-extraction.js";
-import { handleHumanItemMatch, handleHumanItemUpdate } from "./human-matching.js";
+import { handleFactFind, handleHumanTopicScan, handleHumanPersonScan, handleEventScan } from "./human-extraction.js";
+import { handleTopicMatch, handleTopicUpdate, handlePersonMatch, handlePersonUpdate } from "./human-matching.js";
 import { handleRewriteScan, handleRewriteRewrite } from "./rewrite.js";
 import { handleDedupCurate } from "./dedup.js";
 
@@ -23,12 +23,13 @@ export const handlers: Record<LLMNextStep, ResponseHandler> = {
   handlePersonaResponse,
   handlePersonaGeneration,
   handlePersonaDescriptions,
-  handleHumanFactScan,
-  handleHumanTraitScan,
+  handleFactFind,
   handleHumanTopicScan,
   handleHumanPersonScan,
-  handleHumanItemMatch,
-  handleHumanItemUpdate,
+  handleTopicMatch,
+  handleTopicUpdate,
+  handlePersonMatch,
+  handlePersonUpdate,
   handlePersonaTraitExtraction,
   handlePersonaTopicScan,
   handlePersonaTopicMatch,
@@ -43,4 +44,5 @@ export const handlers: Record<LLMNextStep, ResponseHandler> = {
   handleRewriteScan,
   handleRewriteRewrite,
   handleDedupCurate,
+  handleEventScan,
 };

package/src/core/handlers/persona-generation.ts

@@ -1,6 +1,6 @@
 import {
   type LLMResponse,
-  type Trait,
+  type PersonaTrait,
   type PersonaTopic,
 } from "../types.js";
 import type { StateManager } from "../state-manager.js";
@@ -27,10 +27,10 @@ export function handlePersonaGeneration(response: LLMResponse, state: StateManag
     (existingPartial.traits ?? []).filter(t => t.name?.trim()).map(t => [t.name!.toLowerCase().trim(), t])
   );
 
-  const mergedLlmTraits: Trait[] = (result?.traits || []).map(t => {
+  const mergedLlmTraits: PersonaTrait[] = (result?.traits || []).map(t => {
     const userTrait = userTraitsByName.get(t.name?.toLowerCase().trim() ?? '');
     return {
-      id: (userTrait as Trait | undefined)?.id ?? crypto.randomUUID(),
+      id: (userTrait as PersonaTrait | undefined)?.id ?? crypto.randomUUID(),
       name: t.name,
       description: userTrait?.description?.trim() || t.description,
       sentiment: userTrait?.sentiment ?? t.sentiment ?? 0,
@@ -41,10 +41,10 @@ export function handlePersonaGeneration(response: LLMResponse, state: StateManag
 
   // Keep user-provided traits the LLM didn't return
   const llmTraitNames = new Set(mergedLlmTraits.map(t => t.name?.toLowerCase().trim()));
-  const preservedUserTraits: Trait[] = (existingPartial.traits ?? [])
+  const preservedUserTraits: PersonaTrait[] = (existingPartial.traits ?? [])
     .filter(t => t.name?.trim() && !llmTraitNames.has(t.name.toLowerCase().trim()))
     .map(t => ({
-      id: (t as Trait).id ?? crypto.randomUUID(),
+      id: (t as PersonaTrait).id ?? crypto.randomUUID(),
       name: t.name!,
       description: t.description || '',
       sentiment: t.sentiment ?? 0,
@@ -52,9 +52,9 @@ export function handlePersonaGeneration(response: LLMResponse, state: StateManag
       last_updated: now,
     }));
 
-  const mergedTraits: Trait[] = mergedLlmTraits.length > 0
+  const mergedTraits: PersonaTrait[] = mergedLlmTraits.length > 0
     ? [...mergedLlmTraits, ...preservedUserTraits]
-    : (existingPartial.traits as Trait[] | undefined) ?? [];
+    : (existingPartial.traits as PersonaTrait[] | undefined) ?? [];
 
   // Merge LLM topics into user-provided topics by name.
   // User-provided fields win; LLM fills in what the user left blank.
@@ -151,7 +151,7 @@ export function handlePersonaTraitExtraction(response: LLMResponse, state: State
   }
 
   const now = new Date().toISOString();
-  const traits: Trait[] = result.map(t => ({
+  const traits: PersonaTrait[] = result.map(t => ({
     id: crypto.randomUUID(),
     name: t.name,
     description: t.description,

package/src/core/handlers/rewrite.ts

@@ -2,10 +2,8 @@ import {
   LLMRequestType,
   LLMPriority,
   LLMNextStep,
-  ValidationLevel,
   type LLMResponse,
   type Fact,
-  type Trait,
   type Topic,
   type Person,
   type DataItemBase,
@@ -48,7 +46,7 @@ export async function handleRewriteScan(response: LLMResponse, state: StateManag
   // Re-read the item from current state (it may have changed since scan was queued)
   const human = state.getHuman();
   const allItems: DataItemBase[] = [
-    ...human.facts, ...human.traits, ...human.topics, ...human.people,
+    ...human.facts, ...human.topics, ...human.people,
   ];
   const currentItem = allItems.find(i => i.id === itemId);
   if (!currentItem) {
@@ -61,11 +59,11 @@ export async function handleRewriteScan(response: LLMResponse, state: StateManag
   for (const searchTerm of subjects) {
     try {
       const results = await searchHumanData(state, searchTerm, {
-        types: ["fact", "trait", "topic", "person"],
+        types: ["fact", "topic", "person"],
         limit: 4,  // fetch 4 so we can exclude original and still have 3
       });
       const allMatches: DataItemBase[] = [
-        ...results.facts, ...results.traits, ...results.topics, ...results.people,
+        ...results.facts, ...results.topics, ...results.people,
       ].filter(m => m.id !== itemId);  // exclude original
       subjectMatches.push({ searchTerm, matches: allMatches.slice(0, 3) });
     } catch (err) {
@@ -122,7 +120,7 @@ export async function handleRewriteRewrite(response: LLMResponse, state: StateMa
 
   // Look up the original item to inherit persona_groups
   const allItems: DataItemBase[] = [
-    ...human.facts, ...human.traits, ...human.topics, ...human.people,
+    ...human.facts, ...human.topics, ...human.people,
   ];
   const originalItem = allItems.find(i => i.id === itemId);
   const inheritedGroups = originalItem?.persona_groups;
@@ -130,7 +128,6 @@ export async function handleRewriteRewrite(response: LLMResponse, state: StateMa
   // Helper: resolve actual type from existing records (don't trust LLM's type field)
   const resolveExistingType = (id: string): RewriteItemType | null => {
     if (human.facts.find(f => f.id === id)) return "fact";
-    if (human.traits.find(t => t.id === id)) return "trait";
     if (human.topics.find(t => t.id === id)) return "topic";
     if (human.people.find(p => p.id === id)) return "person";
     return null;
@@ -175,19 +172,6 @@ export async function handleRewriteRewrite(response: LLMResponse, state: StateMa
         });
         break;
       }
-      case "trait": {
-        const existing = human.traits.find(t => t.id === item.id)!;
-        state.human_trait_upsert({
-          ...existing,
-          name: item.name,
-          description: item.description,
-          sentiment: item.sentiment ?? existing.sentiment,
-          strength: item.strength ?? existing.strength,
-          last_updated: now,
-          embedding,
-        });
-        break;
-      }
       case "topic": {
         const existing = human.topics.find(t => t.id === item.id)!;
         state.human_topic_upsert({
@@ -247,20 +231,11 @@ export async function handleRewriteRewrite(response: LLMResponse, state: StateMa
       case "fact": {
         const fact: Fact = {
           ...baseFields,
-          validated: ValidationLevel.None,
           validated_date: now,
         };
         state.human_fact_upsert(fact);
         break;
       }
-      case "trait": {
-        const trait: Trait = {
-          ...baseFields,
-          strength: item.strength ?? 0.5,
-        };
-        state.human_trait_upsert(trait);
-        break;
-      }
       case "topic": {
         if (!item.category) {
           console.warn(`[handleRewriteRewrite] New topic "${item.name}" missing category — defaulting to "Interest"`);

package/src/core/handlers/utils.ts

@@ -1,7 +1,29 @@
 import type { Message, LLMResponse } from "../types.js";
 import type { StateManager } from "../state-manager.js";
 
-export type ExtractionFlag = "f" | "r" | "p" | "o";
+export function resolveMessageWindow(
+  response: LLMResponse,
+  state: StateManager
+): { messages_context: Message[]; messages_analyze: Message[] } {
+  const personaId = response.request.data.personaId as string;
+  const messageIdsToMark = response.request.data.message_ids_to_mark as string[] | undefined;
+  const allMessages = state.messages_get(personaId);
+
+  if (messageIdsToMark && messageIdsToMark.length > 0) {
+    const messageIdSet = new Set(messageIdsToMark);
+    const messages_analyze = allMessages.filter(m => messageIdSet.has(m.id));
+    const analyzeStartTime = messages_analyze[0]?.timestamp ?? '9999';
+    const messages_context = allMessages.filter(m =>
+      !messageIdSet.has(m.id) && new Date(m.timestamp).getTime() < new Date(analyzeStartTime).getTime()
+    );
+    return { messages_context, messages_analyze };
+  }
+
+  const analyzeFrom = response.request.data.analyze_from_timestamp as string | null;
+  return splitMessagesByTimestamp(allMessages, analyzeFrom);
+}
+
+export type ExtractionFlag = "f" | "t" | "p" | "e";
 
 export function splitMessagesByTimestamp(
   messages: Message[], 

package/src/core/heartbeat-manager.ts

@@ -2,7 +2,6 @@ import {
   LLMRequestType,
   LLMPriority,
   LLMNextStep,
-  ValidationLevel,
   type HumanEntity,
   type Message,
 } from "./types.js";
@@ -72,9 +71,8 @@ export async function queueEiHeartbeat(
   const unverifiedFacts = human.facts
     .filter(
       (f) =>
-        f.validated === ValidationLevel.None &&
-        f.learned_by !== "ei" &&
-        (f.last_changed_by === undefined || f.last_changed_by !== "ei")
+        f.description !== '' &&
+        f.validated_date === ''
     )
     .slice(0, 5);
   for (const fact of unverifiedFacts) {

package/src/core/human-data-manager.ts

@@ -1,4 +1,4 @@
-import type { HumanEntity, Fact, Trait, Topic, Person, Quote } from "./types.js";
+import type { HumanEntity, Fact, Topic, Person, Quote } from "./types.js";
 import { StateManager } from "./state-manager.js";
 import {
   getEmbeddingService,
@@ -24,7 +24,7 @@ export async function updateHuman(sm: StateManager, updates: Partial<HumanEntity
 }
 
 // =============================================================================
-// FACTS / TRAITS / TOPICS / PEOPLE UPSERT
+// FACTS / TOPICS / PEOPLE UPSERT
 // =============================================================================
 
 export async function upsertFact(sm: StateManager, fact: Fact): Promise<void> {
@@ -40,18 +40,6 @@ export async function upsertFact(sm: StateManager, fact: Fact): Promise<void> {
   sm.human_fact_upsert(fact);
 }
 
-export async function upsertTrait(sm: StateManager, trait: Trait): Promise<void> {
-  const human = sm.getHuman();
-  const existing = human.traits.find((t) => t.id === trait.id);
-
-  if (needsEmbeddingUpdate(existing, trait)) {
-    trait.embedding = await computeDataItemEmbedding(trait);
-  } else if (existing?.embedding) {
-    trait.embedding = existing.embedding;
-  }
-
-  sm.human_trait_upsert(trait);
-}
 
 export async function upsertTopic(sm: StateManager, topic: Topic): Promise<void> {
   const human = sm.getHuman();
@@ -81,16 +69,13 @@ export async function upsertPerson(sm: StateManager, person: Person): Promise<vo
 
 export async function removeDataItem(
   sm: StateManager,
-  type: "fact" | "trait" | "topic" | "person",
+  type: "fact" | "topic" | "person",
   id: string
 ): Promise<void> {
   switch (type) {
     case "fact":
       sm.human_fact_remove(id);
       break;
-    case "trait":
-      sm.human_trait_remove(id);
-      break;
     case "topic":
       sm.human_topic_remove(id);
       break;
@@ -160,21 +145,19 @@ export async function getQuotesForMessage(sm: StateManager, messageId: string):
 export async function searchHumanData(
   sm: StateManager,
   query: string,
-  options: { types?: Array<"fact" | "trait" | "topic" | "person" | "quote">; limit?: number } = {}
+  options: { types?: Array<"fact" | "topic" | "person" | "quote">; limit?: number } = {}
 ): Promise<{
   facts: Fact[];
-  traits: Trait[];
   topics: Topic[];
   people: Person[];
   quotes: Quote[];
 }> {
-  const { types = ["fact", "trait", "topic", "person", "quote"], limit = 10 } = options;
+  const { types = ["fact", "topic", "person", "quote"], limit = 10 } = options;
   const human = sm.getHuman();
   const SIMILARITY_THRESHOLD = 0.3;
 
   const result = {
     facts: [] as Fact[],
-    traits: [] as Trait[],
     topics: [] as Topic[],
     people: [] as Person[],
     quotes: [] as Quote[],
@@ -211,11 +194,6 @@ export async function searchHumanData(
       stripDataItemEmbedding
     );
   }
-  if (types.includes("trait")) {
-    result.traits = searchItems(human.traits, (t) => `${t.name} ${t.description || ""}`).map(
-      stripDataItemEmbedding
-    );
-  }
   if (types.includes("topic")) {
     result.topics = searchItems(human.topics, (t) => `${t.name} ${t.description || ""}`).map(
       stripDataItemEmbedding

package/src/core/message-manager.ts

@@ -16,7 +16,7 @@ import {
 } from "../prompts/index.js";
 import { buildResponsePromptData } from "./prompt-context-builder.js";
 import {
-  queueFactScan,
+  queueFactFind,
   queueTopicScan,
   queuePersonScan,
   type ExtractionContext,
@@ -178,7 +178,7 @@ export async function sendMessage(
   const traitExtractionData: PersonaTraitExtractionPromptData = {
     persona_name: persona.display_name,
     current_traits: persona.traits,
-    messages_context: history.slice(0, -1),
+    messages_context: history.slice(-11, -1),
     messages_analyze: [message],
   };
   const traitPrompt = buildPersonaTraitExtractionPrompt(traitExtractionData);
@@ -217,7 +217,7 @@ export function checkAndQueueHumanExtraction(
   const human = sm.getHuman();
 
   const unextractedFacts = sm.messages_getUnextracted(personaId, "f");
-  const factsThreshold = Math.min(EXTRACTION_TAPER_CAP, human.facts.length);
+  const factsThreshold = Math.min(EXTRACTION_TAPER_CAP, human.facts.filter(f => f.description && f.description !== "").length);
   if (unextractedFacts.length > 0 && unextractedFacts.length >= factsThreshold) {
     const context: ExtractionContext = {
       personaId,
@@ -226,21 +226,21 @@ export function checkAndQueueHumanExtraction(
       messages_analyze: unextractedFacts,
       extraction_flag: "f",
     };
-    queueFactScan(context, sm);
+    queueFactFind(context, sm);
     console.log(
       `[Processor] Human Seed extraction: facts (threshold: ${factsThreshold}, unextracted: ${unextractedFacts.length})`
     );
   }
 
-  const unextractedTopics = sm.messages_getUnextracted(personaId, "p");
+  const unextractedTopics = sm.messages_getUnextracted(personaId, "t");
   const topicsThreshold = Math.min(EXTRACTION_TAPER_CAP, human.topics.length);
   if (unextractedTopics.length > 0 && unextractedTopics.length >= topicsThreshold) {
     const context: ExtractionContext = {
       personaId,
       personaDisplayName,
-      messages_context: history.filter((m) => m.p === true),
+      messages_context: history.filter((m) => m.t === true),
       messages_analyze: unextractedTopics,
-      extraction_flag: "p",
+      extraction_flag: "t",
     };
     queueTopicScan(context, sm);
     console.log(
@@ -248,15 +248,15 @@ export function checkAndQueueHumanExtraction(
     );
   }
 
-  const unextractedPeople = sm.messages_getUnextracted(personaId, "o");
+  const unextractedPeople = sm.messages_getUnextracted(personaId, "p");
   const peopleThreshold = Math.min(EXTRACTION_TAPER_CAP, human.people.length);
   if (unextractedPeople.length > 0 && unextractedPeople.length >= peopleThreshold) {
     const context: ExtractionContext = {
       personaId,
       personaDisplayName,
-      messages_context: history.filter((m) => m.o === true),
+      messages_context: history.filter((m) => m.p === true),
       messages_analyze: unextractedPeople,
-      extraction_flag: "o",
+      extraction_flag: "p",
     };
     queuePersonScan(context, sm);
     console.log(

package/src/core/orchestrators/ceremony.ts

@@ -2,10 +2,10 @@ import { LLMRequestType, LLMPriority, LLMNextStep, MESSAGE_MIN_COUNT, MESSAGE_MA
 import type { StateManager } from "../state-manager.js";
 import { applyDecayToValue } from "../utils/index.js";
 import {
-  queueFactScan,
-  queueTraitScan,
+  queueFactFind,
   queueTopicScan,
   queuePersonScan,
+  queueEventSummary,
   type ExtractionContext,
   type ExtractionOptions,
 } from "./human-extraction.js";
@@ -109,56 +109,45 @@ function queueExposurePhase(personaId: string, state: StateManager, options?: Ex
       messages_analyze: unextractedFacts,
       extraction_flag: "f",
     };
-    queueFactScan(context, state, options);
+    queueFactFind(context, state, options);
   }
   
-  const unextractedTraits = state.messages_getUnextracted(personaId, "r");
-  if (unextractedTraits.length > 0) {
-    const context: ExtractionContext = {
-      personaId,
-      personaDisplayName: persona.display_name,
-      messages_context: allMessages.filter(m => m.r === true),
-      messages_analyze: unextractedTraits,
-      extraction_flag: "r",
-    };
-    queueTraitScan(context, state, options);
-  }
   
-  const unextractedTopics = state.messages_getUnextracted(personaId, "p");
+  const unextractedTopics = state.messages_getUnextracted(personaId, "t");
   if (unextractedTopics.length > 0) {
     const context: ExtractionContext = {
       personaId,
       personaDisplayName: persona.display_name,
-      messages_context: allMessages.filter(m => m.p === true),
+      messages_context: allMessages.filter(m => m.t === true),
       messages_analyze: unextractedTopics,
-      extraction_flag: "p",
+      extraction_flag: "t",
     };
     queueTopicScan(context, state, options);
   }
   
-  const unextractedPeople = state.messages_getUnextracted(personaId, "o");
+  const unextractedPeople = state.messages_getUnextracted(personaId, "p");
   if (unextractedPeople.length > 0) {
     const context: ExtractionContext = {
       personaId,
       personaDisplayName: persona.display_name,
-      messages_context: allMessages.filter(m => m.o === true),
+      messages_context: allMessages.filter(m => m.p === true),
       messages_analyze: unextractedPeople,
-      extraction_flag: "o",
+      extraction_flag: "p",
     };
     queuePersonScan(context, state, options);
   }
   
-  const totalUnextracted = unextractedFacts.length + unextractedTraits.length + unextractedTopics.length + unextractedPeople.length;
+  const totalUnextracted = unextractedFacts.length + unextractedTopics.length + unextractedPeople.length;
   if (totalUnextracted > 0) {
-    console.log(`[ceremony:exposure] Queued human extraction scans (f:${unextractedFacts.length}, r:${unextractedTraits.length}, p:${unextractedTopics.length}, o:${unextractedPeople.length})`);
+    console.log(`[ceremony:exposure] Queued human extraction scans (f:${unextractedFacts.length}, t:${unextractedTopics.length}, p:${unextractedPeople.length})`);
   }
 
-  const unextractedForPersonaTopics = state.messages_getUnextracted(personaId, "p");
+  const unextractedForPersonaTopics = state.messages_getUnextracted(personaId, "t");
   if (unextractedForPersonaTopics.length > 0) {
     const personaTopicContext: PersonaTopicContext = {
       personaId,
       personaDisplayName: persona.display_name,
-      messages_context: allMessages.filter(m => m.p === true),
+      messages_context: allMessages.filter(m => m.t === true),
       messages_analyze: unextractedForPersonaTopics,
     };
     queuePersonaTopicScan(personaTopicContext, state);
@@ -171,7 +160,7 @@ function queueExposurePhase(personaId: string, state: StateManager, options?: Ex
  * AND at the end of startCeremony (for the zero-messages edge case).
  * 
  * If any ceremony_progress items remain in the queue, does nothing — more work pending.
- * If the queue is clear of ceremony items, advances to Decay → Prune → Expire.
+ * Phase 1: Dedup → Phase 2: Expose → Phase 3: EventSummary → Decay → Expire
  */
 export function handleCeremonyProgress(state: StateManager, lastPhase: number): void {
   if (state.queue_hasPendingCeremonies()) {
@@ -182,7 +171,6 @@ export function handleCeremonyProgress(state: StateManager, lastPhase: number):
     // Dedup phase complete → start Expose phase
     console.log("[ceremony:progress] Dedup complete, starting Expose phase");
     
-    const human = state.getHuman();
     const personas = state.persona_getAll();
     const activePersonas = personas.filter(p => 
       !p.is_paused && 
@@ -190,24 +178,40 @@ export function handleCeremonyProgress(state: StateManager, lastPhase: number):
       !p.is_static
     );
     
-    const lastCeremony = human.settings?.ceremony?.last_ceremony 
-      ? new Date(human.settings.ceremony.last_ceremony).getTime() 
-      : 0;
-    
-    const personasWithActivity = activePersonas.filter(p => {
-      const lastActivity = p.last_activity ? new Date(p.last_activity).getTime() : 0;
-      return lastActivity > lastCeremony;
+    // Find personas with unprocessed messages (any message with p/r/o/f = false)
+    const personasWithUnprocessed = activePersonas.filter(p => {
+      const messages = state.messages_get(p.id);
+      return messages.some(msg => 
+        !msg.t || 
+        !msg.p || 
+        !msg.f
+      );
     });
     
+    console.log(`[ceremony:expose] Found ${activePersonas.length} active personas, ${personasWithUnprocessed.length} with unprocessed messages`);
+    
     const options: ExtractionOptions = { ceremony_progress: 2 };
-    for (const persona of personasWithActivity) {
+    for (const persona of personasWithUnprocessed) {
       queueExposurePhase(persona.id, state, options);
     }
     return;
   }
+
+  if (lastPhase === 2) {
+    console.log("[ceremony:progress] Expose complete, starting EventSummary phase");
+    const options: ExtractionOptions = { ceremony_progress: 3 };
+    queueEventSummaryForAll(state, options);
+
+    // Zero-work guard: same pattern as DeDupe phase
+    if (!state.queue_hasPendingCeremonies()) {
+      console.log("[ceremony:progress] No event summary work, advancing to Decay");
+      handleCeremonyProgress(state, 3);
+    }
+    return;
+  }
   
-  // Phase 2 (Expose) complete → advance to Decay/Prune/Expire/Explore
-  console.log("[ceremony:progress] All exposure scans complete, advancing to Decay");
+  // Phase 3 (EventSummary) complete → advance to Decay/Prune/Expire/Explore
+  console.log("[ceremony:progress] EventSummary complete, advancing to Decay");
   
   const personas = state.persona_getAll();
   const activePersonas = personas.filter(p => 
@@ -233,7 +237,7 @@ export function handleCeremonyProgress(state: StateManager, lastPhase: number):
   // Human ceremony: decay topics + people
   runHumanCeremony(state);
 
-  // Dedup phase: log near-duplicate human entities (dry-run only, no mutations)
+  // Dedup phase: log near-duplicate human entity candidates for visibility
   runDedupPhase(state);
 
   // Rewrite phase: fire-and-forget scans for bloated human data items
@@ -317,7 +321,7 @@ export function prunePersonaMessages(personaId: string, state: StateManager): vo
     const msgMs = new Date(m.timestamp).getTime();
     if (msgMs >= cutoffMs) break; // Sorted by time, no more old ones
     
-    const fullyExtracted = m.p && m.r && m.o && m.f;
+    const fullyExtracted = m.t && m.p && m.f; // r intentionally excluded — trait extraction deprecated
     if (fullyExtracted) {
       toRemove.push(m.id);
     }
@@ -515,7 +519,7 @@ export function runHumanCeremony(state: StateManager): void {
 }
 
 // =============================================================================
-// DEDUP PHASE (synchronous, dry-run — logs candidates, no mutations)
+// DEDUP PHASE (synchronous, logging only — candidates are queued for curation by dedup-phase.ts)
 // =============================================================================
 
 const DEDUP_DEFAULT_THRESHOLD = 0.85;
@@ -555,11 +559,10 @@ export function runDedupPhase(state: StateManager): void {
   const human = state.getHuman();
   const threshold = human.settings?.ceremony?.dedup_threshold ?? DEDUP_DEFAULT_THRESHOLD;
 
-  console.log(`[ceremony:dedup] Running dry-run dedup (threshold: ${threshold})`);
+  console.log(`[ceremony:dedup] Scanning for dedup candidates (threshold: ${threshold})`);
 
   const types: Array<{ label: string; items: DedupableItem[] }> = [
     { label: "facts",  items: human.facts },
-    { label: "traits", items: human.traits },
     { label: "topics", items: human.topics },
     { label: "people", items: human.people },
   ];
@@ -618,11 +621,7 @@ export function queueRewritePhase(state: StateManager): void {
       itemsToScan.push({ item: fact, type: "fact" });
     }
   }
-  for (const trait of human.traits) {
-    if ((trait.description?.length ?? 0) > REWRITE_DESCRIPTION_THRESHOLD) {
-      itemsToScan.push({ item: trait, type: "trait" });
-    }
-  }
+
   for (const topic of human.topics) {
     if ((topic.description?.length ?? 0) > REWRITE_DESCRIPTION_THRESHOLD) {
       itemsToScan.push({ item: topic, type: "topic" });
@@ -661,3 +660,18 @@ export function queueRewritePhase(state: StateManager): void {
 
   console.log(`[ceremony:rewrite] Queued ${itemsToScan.length} Phase 1 scan(s) at Low priority`);
 }
+
+function queueEventSummaryForAll(state: StateManager, options?: ExtractionOptions): void {
+  const personas = state.persona_getAll();
+  const activePersonas = personas.filter(p =>
+    !p.is_paused &&
+    !p.is_archived &&
+    !p.is_static
+  );
+
+  let totalQueued = 0;
+  for (const persona of activePersonas) {
+    totalQueued += queueEventSummary(persona.id, state, options);
+  }
+  console.log(`[ceremony:event] Queued event summary scans for ${activePersonas.length} personas (${totalQueued} total chunks)`);
+}

package/src/core/orchestrators/dedup-phase.ts

@@ -20,7 +20,7 @@ interface Cluster {
 // DEDUP CANDIDATE FINDING (copied from ceremony.ts)
 // =============================================================================
 
-const DEDUP_DEFAULT_THRESHOLD = 0.95;
+const DEDUP_DEFAULT_THRESHOLD = 0.85;  // Lowered from 0.95 based on experimental analysis: 0.95 only catches 3.9% of duplicate name groups, 0.85 catches 46.7%
 
 function findDedupCandidates<T extends DedupableItem>(
   items: T[],
@@ -127,13 +127,19 @@ function filterClusters(clusters: Cluster[]): Cluster[] {
 
 export function queueDedupPhase(state: StateManager): void {
   const human = state.getHuman();
+  const rewriteModel = human.settings?.rewrite_model;
+  
+  if (!rewriteModel) {
+    console.log("[Dedup] rewrite_model not set — skipping dedup phase");
+    return;
+  }
+  
   const threshold = human.settings?.ceremony?.dedup_threshold ?? DEDUP_DEFAULT_THRESHOLD;
   
   console.log(`[Dedup] Starting deduplication phase (threshold: ${threshold})`);
   
   const entityTypes: Array<{ type: DataItemType; items: DedupableItem[] }> = [
     { type: "fact", items: human.facts },
-    { type: "trait", items: human.traits },
     { type: "topic", items: human.topics },
     { type: "person", items: human.people },
   ];
@@ -183,13 +189,13 @@ export function queueDedupPhase(state: StateManager): void {
         system: prompt.system,
         user: prompt.user,
         next_step: LLMNextStep.HandleDedupCurate,
+        model: rewriteModel,
         data: {
           entity_type: type,
-          entity_ids: cluster.ids,  // Lightweight stub (IDs only)
-          ceremony_progress: 1  // Phase 1 (Dedup)
+          entity_ids: cluster.ids,
+          ceremony_progress: 1
         }
       });
-      
       totalClusters++;
     }
   }