ei-tui 0.1.25 → 0.2.0

package/src/core/orchestrators/index.ts

@@ -1,12 +1,14 @@
 export { orchestratePersonaGeneration, type PartialPersona } from "./persona-generation.js";
 export {
-  queueFactScan,
-  queueTraitScan,
+  queueFactFind,
   queueTopicScan,
   queuePersonScan,
   queueAllScans,
-  queueItemMatch,
-  queueItemUpdate,
+  queueTopicMatch,
+  queueTopicUpdate,
+  queuePersonMatch,
+  queuePersonUpdate,
+  queueEventSummary,
   type ExtractionContext,
   type ExtractionOptions,
 } from "./human-extraction.js";

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

@@ -1,4 +1,4 @@
-import { LLMRequestType, LLMPriority, LLMNextStep, type Trait, type PersonaTopic } from "../types.js";
+import { LLMRequestType, LLMPriority, LLMNextStep, type PersonaTrait, type PersonaTopic } from "../types.js";
 import type { StateManager } from "../state-manager.js";
 import { buildPersonaGenerationPrompt } from "../../prompts/index.js";
 
@@ -11,7 +11,7 @@ export interface PartialPersona {
   description?: string;
   short_description?: string;
   long_description?: string;
-  traits?: Partial<Trait>[];
+  traits?: Partial<PersonaTrait>[];
   topics?: Partial<PersonaTopic>[];
   model?: string;
   group_primary?: string;
@@ -66,7 +66,7 @@ export function orchestratePersonaGeneration(
   stateManager.persona_update(partial.id, {
     short_description: partial.short_description,
     long_description: partial.long_description,
-    traits: partial.traits as Trait[],
+    traits: partial.traits as PersonaTrait[],
     topics: partial.topics as PersonaTopic[],
     last_updated: now,
   });

package/src/core/processor.ts

@@ -9,7 +9,6 @@ import {
   type MessageQueryOptions,
   type HumanEntity,
   type Fact,
-  type Trait,
   type Topic,
   type Person,
   type Quote,
@@ -33,6 +32,7 @@ import { registerReadMemoryExecutor, registerFileReadExecutor } from "./tools/in
 import { createReadMemoryExecutor } from "./tools/builtin/read-memory.js";
 import { EI_WELCOME_MESSAGE, EI_PERSONA_DEFINITION } from "../templates/welcome.js";
 import { shouldStartCeremony, startCeremony, handleCeremonyProgress } from "./orchestrators/index.js";
+import { BUILT_IN_FACTS } from "./constants/built-in-facts.js";
 
 // Static module imports
 import {
@@ -70,7 +70,6 @@ import {
   getHuman,
   updateHuman,
   upsertFact,
-  upsertTrait,
   upsertTopic,
   upsertPerson,
   removeDataItem,
@@ -191,10 +190,16 @@ export class Processor {
       }
     }
 
+    await this.completeInitialization();
+  }
+
+  private async completeInitialization(): Promise<void> {
     if (!this.stateManager.hasExistingData() || this.stateManager.persona_getAll().length === 0) {
       await this.bootstrapFirstRun();
     }
     this.bootstrapTools();
+    this.seedBuiltinFacts();
+    this.seedSettings();
     registerReadMemoryExecutor(createReadMemoryExecutor(this.searchHumanData.bind(this)));
     if (this.isTUI) {
       await registerFileReadExecutor();
@@ -571,6 +576,87 @@ export class Processor {
     }
   }
 
+  /**
+   * Seed 25 built-in facts if they don't exist yet.
+   * Called on every startup — safe to call repeatedly.
+   * New facts are created with empty descriptions and validated_date.
+   */
+  private seedBuiltinFacts(): void {
+    const human = this.stateManager.getHuman();
+    const existingFactNames = new Set(human.facts.map(f => f.name));
+    
+    // BUILT_IN_FACTS imported at top of file
+    const now = new Date().toISOString();
+    let seededCount = 0;
+
+    for (const builtInFact of BUILT_IN_FACTS) {
+      if (existingFactNames.has(builtInFact.name)) continue;
+
+      const newFact: Fact = {
+        id: crypto.randomUUID(),
+        name: builtInFact.name,
+        description: '',
+        sentiment: 0,
+        validated_date: '',
+        last_updated: now,
+      };
+      human.facts.push(newFact);
+      seededCount++;
+    }
+
+    if (seededCount > 0) {
+      this.stateManager.setHuman(human);
+      console.log(`[Processor] Seeded ${seededCount} built-in facts`);
+    }
+  }
+
+  private seedSettings(): void {
+    const human = this.stateManager.getHuman();
+    let modified = false;
+
+    if (!human.settings) {
+      human.settings = {};
+      modified = true;
+    }
+
+    if (!human.settings.opencode) {
+      human.settings.opencode = {
+        integration: false,
+        polling_interval_ms: 1800000,
+      };
+      modified = true;
+    }
+
+    if (!human.settings.claudeCode) {
+      human.settings.claudeCode = {
+        integration: false,
+        polling_interval_ms: 1800000,
+      };
+      modified = true;
+    }
+
+    if (!human.settings.ceremony) {
+      human.settings.ceremony = {
+        time: "09:00",
+      };
+      modified = true;
+    }
+
+    if (!human.settings.backup) {
+      human.settings.backup = {
+        enabled: false,
+        max_backups: 24,
+        interval_ms: 3600000,
+      };
+      modified = true;
+    }
+
+    if (modified) {
+      this.stateManager.setHuman(human);
+      console.log(`[Processor] Seeded missing settings`);
+    }
+  }
+
   async stop(): Promise<void> {
     console.log(
       `[Processor ${this.instanceId}] stop() called, running=${this.running}, stopped=${this.stopped}`
@@ -676,13 +762,7 @@ export class Processor {
 
     this.pendingConflict = null;
     this.importAbortController = new AbortController();
-    this.bootstrapTools();
-    registerReadMemoryExecutor(createReadMemoryExecutor(this.searchHumanData.bind(this)));
-    if (this.isTUI) {
-      await registerFileReadExecutor();
-    }
-    this.running = true;
-    this.runLoop();
+    await this.completeInitialization();
     this.interface.onStateImported?.();
   }
 
@@ -1093,7 +1173,10 @@ const toolNextSteps = new Set([
         }
       }
 
-      if (response.request.next_step === LLMNextStep.HandleHumanItemUpdate) {
+      if (
+        response.request.next_step === LLMNextStep.HandleTopicUpdate ||
+        response.request.next_step === LLMNextStep.HandlePersonUpdate
+      ) {
         this.interface.onHumanUpdated?.();
         this.interface.onQuoteAdded?.();
       }
@@ -1102,6 +1185,10 @@ const toolNextSteps = new Set([
         this.interface.onHumanUpdated?.();
       }
 
+      if (response.request.next_step === LLMNextStep.HandleFactFind) {
+        this.interface.onHumanUpdated?.();
+      }
+
       if (typeof response.request.data.ceremony_progress === "number") {
         handleCeremonyProgress(this.stateManager, response.request.data.ceremony_progress);
       }
@@ -1265,10 +1352,6 @@ const toolNextSteps = new Set([
     this.interface.onHumanUpdated?.();
   }
 
-  async upsertTrait(trait: Trait): Promise<void> {
-    await upsertTrait(this.stateManager, trait);
-    this.interface.onHumanUpdated?.();
-  }
 
   async upsertTopic(topic: Topic): Promise<void> {
     await upsertTopic(this.stateManager, topic);
@@ -1281,7 +1364,7 @@ const toolNextSteps = new Set([
   }
 
   async removeDataItem(
-    type: "fact" | "trait" | "topic" | "person",
+    type: "fact" | "topic" | "person",
     id: string
   ): Promise<void> {
     await removeDataItem(this.stateManager, type, id);
@@ -1313,10 +1396,9 @@ const toolNextSteps = new Set([
 
   async searchHumanData(
     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[];

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

@@ -80,14 +80,13 @@ export async function filterHumanDataByVisibility(
   const DEFAULT_GROUP = "General";
 
   if (persona.id === "ei") {
-    const [facts, traits, topics, people, quotes] = await Promise.all([
+    const [facts, topics, people, quotes] = await Promise.all([
       selectRelevantItems(human.facts, DATA_ITEM_LIMIT, currentMessage),
-      selectRelevantItems(human.traits, DATA_ITEM_LIMIT, currentMessage),
       selectRelevantItems(human.topics, DATA_ITEM_LIMIT, currentMessage),
       selectRelevantItems(human.people, DATA_ITEM_LIMIT, currentMessage),
       selectRelevantQuotes(human.quotes ?? [], currentMessage),
     ]);
-    return { facts, traits, topics, people, quotes };
+    return { facts, topics, people, quotes };
   }
 
   const visibleGroups = new Set<string>();
@@ -109,15 +108,14 @@ export async function filterHumanDataByVisibility(
     return effectiveGroups.some((g) => visibleGroups.has(g));
   });
 
-  const [facts, traits, topics, people, quotes] = await Promise.all([
+  const [facts, topics, people, quotes] = await Promise.all([
     selectRelevantItems(filterByGroup(human.facts), DATA_ITEM_LIMIT, currentMessage),
-    selectRelevantItems(filterByGroup(human.traits), DATA_ITEM_LIMIT, currentMessage),
     selectRelevantItems(filterByGroup(human.topics), DATA_ITEM_LIMIT, currentMessage),
     selectRelevantItems(filterByGroup(human.people), DATA_ITEM_LIMIT, currentMessage),
     selectRelevantQuotes(groupFilteredQuotes, currentMessage),
   ]);
 
-  return { facts, traits, topics, people, quotes };
+  return { facts, topics, people, quotes };
 }
 
 // =============================================================================

package/src/core/state/human.ts

@@ -1,10 +1,9 @@
-import type { HumanEntity, Fact, Trait, Topic, Person, Quote } from "../types.js";
+import type { HumanEntity, Fact, Topic, Person, Quote } from "../types.js";
 
 export function createDefaultHumanEntity(): HumanEntity {
   return {
     entity: "human",
     facts: [],
-    traits: [],
     topics: [],
     people: [],
     quotes: [],
@@ -63,30 +62,6 @@ export class HumanState {
     return false;
   }
 
-  trait_upsert(trait: Trait): void {
-    const idx = this.human.traits.findIndex((t) => t.id === trait.id);
-    trait.last_updated = new Date().toISOString();
-    if (idx >= 0) {
-      this.human.traits[idx] = trait;
-    } else {
-      this.human.traits.push(trait);
-    }
-    this.human.last_updated = new Date().toISOString();
-  }
-
-  trait_remove(id: string): boolean {
-    const idx = this.human.traits.findIndex((t) => t.id === id);
-    if (idx >= 0) {
-      this.human.traits.splice(idx, 1);
-      // Clean up quote references
-      this.human.quotes.forEach((q) => {
-        q.data_item_ids = q.data_item_ids.filter((itemId) => itemId !== id);
-      });
-      this.human.last_updated = new Date().toISOString();
-      return true;
-    }
-    return false;
-  }
 
   topic_upsert(topic: Topic): void {
     const idx = this.human.topics.findIndex((t) => t.id === topic.id);

package/src/core/state/personas.ts

@@ -213,7 +213,7 @@ export class PersonaState {
     return removed;
   }
 
-  messages_getUnextracted(personaId: string, flag: "f" | "r" | "p" | "o", limit?: number): Message[] {
+  messages_getUnextracted(personaId: string, flag: "f" | "t" | "p" | "e", limit?: number): Message[] {
     const data = this.personas.get(personaId);
     if (!data) return [];
     const unextracted = data.messages.filter(m => m[flag] !== true);
@@ -223,7 +223,7 @@ export class PersonaState {
     return unextracted.map(m => ({ ...m }));
   }
 
-  messages_markExtracted(personaId: string, messageIds: string[], flag: "f" | "r" | "p" | "o"): number {
+  messages_markExtracted(personaId: string, messageIds: string[], flag: "f" | "t" | "p" | "e"): number {
     const data = this.personas.get(personaId);
     if (!data) return 0;
     const idsSet = new Set(messageIds);

package/src/core/state-manager.ts

@@ -3,7 +3,6 @@ import type {
   PersonaEntity,
   Message,
   Fact,
-  Trait,
   Topic,
   Person,
   Quote,
@@ -14,6 +13,7 @@ import type {
   ToolDefinition,
   ToolProvider,
 } from "./types.js";
+import { BUILT_IN_FACT_NAMES } from './constants/built-in-facts.js';
 import type { Storage } from "../storage/interface.js";
 import {
   HumanState,
@@ -43,6 +43,8 @@ export class StateManager {
       this.tools = state.tools ?? [];
       this.providers = state.providers ?? [];
       this.migrateLearnedByToIds();
+      this.migrateFactValidation();
+      this.migrateMessageFlags();
     } else {
       this.humanState.load(createDefaultHumanEntity());
     }
@@ -80,13 +82,114 @@ export class StateManager {
         dirty = true;
       }
     };
-    [...human.facts, ...human.traits, ...human.topics, ...human.people].forEach(migrateItem);
+    [...human.facts, ...human.topics, ...human.people].forEach(migrateItem);
     if (dirty) {
       this.humanState.set(human);
       console.log("[StateManager] Migrated learned_by fields from display names to persona IDs");
     }
   }
 
+  /**
+   * Migration: Facts used to have a 'validated' field (now removed).
+   * Now, only 25 built-in facts remain; others are converted to Topics with category='Fact'.
+   * - Facts with 'validated' field whose name is NOT in BUILT_IN_FACT_NAMES → move to Topics
+   * - Facts with 'validated' field whose name IS in BUILT_IN_FACT_NAMES → strip 'validated'
+   * No-op for already-migrated data (no 'validated' field present).
+   */
+  private migrateFactValidation(): void {
+    const human = this.humanState.get();
+    
+    // Check if any fact has 'validated' property (old format detection)
+    const hasOldFormat = human.facts.some((f) => 'validated' in f);
+    if (!hasOldFormat) return;
+
+    let dirty = false;
+    const newFacts: Fact[] = [];
+    let movedCount = 0;
+    let strippedCount = 0;
+    // Define legacy fact interface for type-safe migration
+    interface LegacyFact extends Fact {
+      validated?: boolean;
+    }
+
+    for (const fact of human.facts) {
+      if (!('validated' in fact)) {
+        // Already migrated fact, keep as-is
+        newFacts.push(fact);
+        continue;
+      }
+      
+      if (BUILT_IN_FACT_NAMES.has(fact.name)) {
+        // Matching built-in: strip 'validated' field, preserve description
+        const { validated, ...cleanedFact } = fact as LegacyFact;
+        newFacts.push(cleanedFact);
+        strippedCount++;
+        dirty = true;
+      } else {
+        // Non-matching: move to Topics
+        const newTopic: Topic = {
+          id: crypto.randomUUID(),
+          name: fact.name,
+          description: fact.description,
+          category: 'Fact',
+          sentiment: fact.sentiment,
+          exposure_current: 0.3,
+          exposure_desired: 0.3,
+          last_updated: fact.last_updated,
+          learned_by: fact.learned_by,
+          last_changed_by: fact.last_changed_by,
+          persona_groups: fact.persona_groups,
+          embedding: fact.embedding,
+        };
+        human.topics.push(newTopic);
+        movedCount++;
+        dirty = true;
+      }
+    }
+
+    if (dirty) {
+      human.facts = newFacts;
+      this.humanState.set(human);
+      console.log(
+        `[StateManager] Migrated fact validation: moved ${movedCount} non-matching facts to Topics, stripped 'validated' from ${strippedCount} built-in facts`
+      );
+    }
+  }
+
+  /**
+   * Migration: Message extraction flags were incorrectly named.
+   * Old: p=Topics, o=People, r=Traits (dead)
+   * New: t=Topics, p=People (r and o removed)
+   * Detects old format by presence of 'o' flag on any message.
+   */
+  private migrateMessageFlags(): void {
+    const personas = this.personaState.getAll();
+    let migratedCount = 0;
+
+    for (const persona of personas) {
+      // Access raw message objects to detect and remap old flags
+      const rawMessages = (this.personaState as unknown as { personas: Map<string, { messages: Array<Record<string, unknown>> }> }).personas.get(persona.id)?.messages ?? [];
+      const hasOldFormat = rawMessages.some(m => 'o' in m || 'r' in m);
+      if (!hasOldFormat) continue;
+
+      for (const msg of rawMessages) {
+        // Remap: old p (topics) → new t; old o (people) → new p
+        const oldP = msg['p'];  // was topics
+        const oldO = msg['o'];  // was people
+        msg['t'] = oldP;        // topics: old p → new t
+        msg['p'] = oldO;        // people: old o → new p
+        delete msg['r'];        // trait flag dead
+        delete msg['o'];        // old people flag dead
+        migratedCount++;
+      }
+    }
+
+    if (migratedCount > 0) {
+      this.scheduleSave();
+      console.log(`[StateManager] Migrated message flags (p→t, o→p, removed r/o) for ${migratedCount} messages`);
+    }
+  }
+
   /**
    * Returns true if value looks like a persona ID (UUID or the special "ei" id).
    * Display names are free-form strings that won't match UUID format.
@@ -132,16 +235,6 @@ export class StateManager {
     return result;
   }
 
-  human_trait_upsert(trait: Trait): void {
-    this.humanState.trait_upsert(trait);
-    this.scheduleSave();
-  }
-
-  human_trait_remove(id: string): boolean {
-    const result = this.humanState.trait_remove(id);
-    this.scheduleSave();
-    return result;
-  }
 
   human_topic_upsert(topic: Topic): void {
     this.humanState.topic_upsert(topic);
@@ -303,11 +396,11 @@ export class StateManager {
     return result;
   }
 
-  messages_getUnextracted(personaId: string, flag: "f" | "r" | "p" | "o", limit?: number): Message[] {
+  messages_getUnextracted(personaId: string, flag: "f" | "t" | "p" | "e", limit?: number): Message[] {
     return this.personaState.messages_getUnextracted(personaId, flag, limit);
   }
 
-  messages_markExtracted(personaId: string, messageIds: string[], flag: "f" | "r" | "p" | "o"): number {
+  messages_markExtracted(personaId: string, messageIds: string[], flag: "f" | "t" | "p" | "e"): number {
     const result = this.personaState.messages_markExtracted(personaId, messageIds, flag);
     this.scheduleSave();
     return result;

package/src/core/tools/builtin/read-memory.ts

@@ -5,12 +5,12 @@
  * The searchHumanData function is injected at construction to avoid circular deps.
  */
 import type { ToolExecutor } from "../types.js";
-import type { Fact, Trait, Topic, Person, Quote } from "../../types.js";
+import type { Fact, Topic, Person, Quote } from "../../types.js";
 
 type SearchHumanData = (
   query: string,
-  options?: { types?: Array<"fact" | "trait" | "topic" | "person" | "quote">; limit?: number }
-) => Promise<{ facts: Fact[]; traits: Trait[]; topics: Topic[]; people: Person[]; quotes: Quote[] }>;
+  options?: { types?: Array<"fact" | "topic" | "person" | "quote">; limit?: number }
+) => Promise<{ facts: Fact[]; topics: Topic[]; people: Person[]; quotes: Quote[] }>;
 
 export function createReadMemoryExecutor(searchHumanData: SearchHumanData): ToolExecutor {
   return {
@@ -26,20 +26,19 @@ export function createReadMemoryExecutor(searchHumanData: SearchHumanData): Tool
 
       const types = Array.isArray(args.types)
         ? (args.types.filter(
-            t => typeof t === "string" && ["fact", "trait", "topic", "person", "quote"].includes(t)
-          ) as Array<"fact" | "trait" | "topic" | "person" | "quote">)
+            t => typeof t === "string" && ["fact", "topic", "person", "quote"].includes(t)
+          ) as Array<"fact" | "topic" | "person" | "quote">)
         : undefined;
 
       const limit = typeof args.limit === "number" && args.limit > 0 ? Math.min(args.limit, 20) : 10;
 
       const results = await searchHumanData(query, { types, limit });
 
-      const total = results.facts.length + results.traits.length + results.topics.length + results.people.length + results.quotes.length;
-      console.log(`[read_memory] query="${query}" => ${total} results (facts=${results.facts.length}, traits=${results.traits.length}, topics=${results.topics.length}, people=${results.people.length}, quotes=${results.quotes.length})`);
+      const total = results.facts.length + results.topics.length + results.people.length + results.quotes.length;
+      console.log(`[read_memory] query="${query}" => ${total} results (facts=${results.facts.length}, topics=${results.topics.length}, people=${results.people.length}, quotes=${results.quotes.length})`);
 
       const output: Record<string, unknown[]> = {};
       if (results.facts.length > 0) output.facts = results.facts.map(f => ({ name: f.name, description: f.description }));
-      if (results.traits.length > 0) output.traits = results.traits.map(t => ({ name: t.name, description: t.description }));
       if (results.topics.length > 0) output.topics = results.topics.map(t => ({ name: t.name, description: t.description }));
       if (results.people.length > 0) output.people = results.people.map(p => ({ name: p.name, relationship: p.relationship, description: p.description }));
       if (results.quotes.length > 0) output.quotes = results.quotes.map(q => ({ text: q.text, speaker: q.speaker }));

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

@@ -3,7 +3,6 @@
  * Source of truth: CONTRACTS.md
  */
 
-import type { ValidationLevel } from "./enums.js";
 
 export interface DataItemBase {
   id: string;
@@ -18,11 +17,10 @@ export interface DataItemBase {
 }
 
 export interface Fact extends DataItemBase {
-  validated: ValidationLevel;
   validated_date: string;
 }
 
-export interface Trait extends DataItemBase {
+export interface PersonaTrait extends DataItemBase {
   strength?: number;
 }
 
@@ -77,4 +75,4 @@ export interface Quote {
 
 export type DataItemType = "fact" | "trait" | "topic" | "person";
 
-export type DataItem = Fact | Trait | Topic | Person;
+export type DataItem = Fact | PersonaTrait | Topic | Person;

package/src/core/types/entities.ts

@@ -3,7 +3,7 @@
  * Source of truth: CONTRACTS.md
  */
 
-import type { Fact, Trait, Topic, Person, Quote, PersonaTopic } from "./data-items.js";
+import type { Fact, PersonaTrait, Topic, Person, Quote, PersonaTopic } from "./data-items.js";
 import type { ProviderType } from "./enums.js";
 
 export interface SyncCredentials {
@@ -14,6 +14,8 @@ export interface SyncCredentials {
 export interface OpenCodeSettings {
   integration?: boolean;
   polling_interval_ms?: number;  // Default: 1800000 (30 min)
+  extraction_model?: string;         // "Provider:model" for extraction. Unset = uses default_model.
+  extraction_token_limit?: number;   // Token budget for extraction chunking. Unset = resolved from model.
   last_sync?: string;  // ISO timestamp
   extraction_point?: string;  // ISO timestamp - cursor for single-session archive scan
   processed_sessions?: Record<string, string>;  // sessionId → ISO timestamp of last import
@@ -25,6 +27,7 @@ export interface CeremonyConfig {
   decay_rate?: number;  // Default: 0.1
   explore_threshold?: number;  // Default: 3
   dedup_threshold?: number;  // Cosine similarity threshold for dedup candidates. Default: 0.85
+  event_window_hours?: number;  // Gap threshold for conversation window detection. Default: 8
 }
 
 export interface BackupConfig {
@@ -88,7 +91,6 @@ export interface HumanSettings {
 export interface HumanEntity {
   entity: "human";
   facts: Fact[];
-  traits: Trait[];
   topics: Topic[];
   people: Person[];
   quotes: Quote[];
@@ -107,7 +109,7 @@ export interface PersonaEntity {
   model?: string;
   group_primary?: string | null;
   groups_visible?: string[];
-  traits: Trait[];
+  traits: PersonaTrait[];
   topics: PersonaTopic[];
   is_paused: boolean;
   pause_until?: string;
@@ -129,7 +131,7 @@ export interface PersonaCreationInput {
   aliases?: string[];
   long_description?: string;
   short_description?: string;
-  traits?: Partial<Trait>[];
+  traits?: Partial<PersonaTrait>[];
   topics?: Partial<PersonaTopic>[];
   model?: string;
   group_primary?: string;

package/src/core/types/enums.ts

@@ -9,11 +9,6 @@ export enum ContextStatus {
   Never = "never",
 }
 
-export enum ValidationLevel {
-  None = "none",     // Fresh data, never acknowledged
-  Ei = "ei",         // Ei mentioned it to user (don't mention again)
-  Human = "human",   // User explicitly confirmed (locked)
-}
 export enum LLMRequestType {
   Response = "response",
   JSON = "json",
@@ -30,12 +25,13 @@ export enum LLMNextStep {
   HandlePersonaResponse = "handlePersonaResponse",
   HandlePersonaGeneration = "handlePersonaGeneration",
   HandlePersonaDescriptions = "handlePersonaDescriptions",
-  HandleHumanFactScan = "handleHumanFactScan",
-  HandleHumanTraitScan = "handleHumanTraitScan",
+  HandleFactFind = "handleFactFind",
   HandleHumanTopicScan = "handleHumanTopicScan",
   HandleHumanPersonScan = "handleHumanPersonScan",
-  HandleHumanItemMatch = "handleHumanItemMatch",
-  HandleHumanItemUpdate = "handleHumanItemUpdate",
+  HandleTopicMatch = "handleTopicMatch",
+  HandleTopicUpdate = "handleTopicUpdate",
+  HandlePersonMatch = "handlePersonMatch",
+  HandlePersonUpdate = "handlePersonUpdate",
   HandlePersonaTraitExtraction = "handlePersonaTraitExtraction",
   HandlePersonaTopicScan = "handlePersonaTopicScan",
   HandlePersonaTopicMatch = "handlePersonaTopicMatch",
@@ -54,6 +50,7 @@ export enum LLMNextStep {
   HandleRewriteScan = "handleRewriteScan",
   HandleRewriteRewrite = "handleRewriteRewrite",
   HandleDedupCurate = "handleDedupCurate",
+  HandleEventScan = "handleEventScan",
 }
 
 export enum ProviderType {

package/src/core/types/llm.ts

@@ -18,9 +18,9 @@ export interface Message {
   // Extraction completion flags (omit when false to save space)
   // Single-letter names minimize storage overhead for large message histories
   f?: boolean;                 // Fact extraction completed
-  r?: boolean;                 // tRait extraction completed
+  t?: boolean;                 // Topic extraction completed
   p?: boolean;                 // Person extraction completed
-  o?: boolean;                 // tOpic extraction completed
+  e?: boolean;                 // Event (epic) extraction completed
   // Image generation fields (web-only, ephemeral)
   _synthesis?: boolean;         // True if message was created by multi-message synthesis