ei-tui 0.9.1 → 0.9.2

package/package.json

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

package/src/core/handlers/heartbeat.ts

@@ -135,9 +135,9 @@ export function handleReflectionCritic(response: LLMResponse, state: StateManage
   if (personRecord) {
     state.human_person_upsert({
       ...personRecord,
-      description: result.updated_identity.long_description,
+      description: "",
     });
-    console.log(`[ReflectionCritic ${personaDisplayName}] Person record description replaced (was log, now distilled identity)`);
+    console.log(`[ReflectionCritic ${personaDisplayName}] Person record description cleared — ready for fresh evidence after reflection`);
   }
 
   const persona = state.persona_getById(personaId);

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

@@ -298,6 +298,15 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
       }
     }
 
+    if (matchedPerson && response.request.data.reflection_progress === 1) {
+      const linkedPersonaId = matchedPerson.identifiers
+        ?.find(i => i.type === "Ei Persona")?.value;
+      if (linkedPersonaId) {
+        console.log(`[handleHumanPersonScan] Skipping update for "${candidate.name}" — scan marked as reflection drain (reflection_progress=1)`);
+        continue;
+      }
+    }
+
     const matchResult: ItemMatchResult = { matched_guid: matchedPerson?.id ?? null };
     queuePersonUpdate(matchResult, {
       ...context,

package/src/core/message-manager.ts

@@ -253,6 +253,8 @@ export function checkAndQueueHumanExtraction(
   const unextractedPeople = sm.messages_getUnextracted(personaId, "p", undefined, "exclude");
   const peopleThreshold = Math.min(EXTRACTION_TAPER_CAP, human.people.length);
   if (unextractedPeople.length > 0 && unextractedPeople.length >= peopleThreshold) {
+    const personaForScan = sm.persona_getById(personaId);
+    const personScanOptions = personaForScan?.pending_update ? { reflection_progress: 1 } : undefined;
     const context: ExtractionContext = {
       personaId,
       personaDisplayName,
@@ -260,9 +262,9 @@ export function checkAndQueueHumanExtraction(
       messages_analyze: unextractedPeople,
       extraction_flag: "p",
     };
-    queuePersonScan(context, sm);
+    queuePersonScan(context, sm, personScanOptions);
     console.log(
-      `[Processor] Human Seed extraction: people (threshold: ${peopleThreshold}, unextracted: ${unextractedPeople.length})`
+      `[Processor] Human Seed extraction: people (threshold: ${peopleThreshold}, unextracted: ${unextractedPeople.length}${personScanOptions ? ", reflection_progress=1" : ""})`
     );
   }
 }

package/src/core/orchestrators/ceremony.ts

@@ -139,7 +139,10 @@ function queueExposurePhase(personaId: string, state: StateManager, options?: Ex
       messages_analyze: unextractedPeople,
       extraction_flag: "p",
     };
-    queuePersonScan(context, state, options);
+    const personScanOptions = persona.pending_update
+      ? { ...options, reflection_progress: 1 }
+      : options;
+    queuePersonScan(context, state, personScanOptions);
   }
   
   const totalUnextracted = unextractedFacts.length + unextractedTopics.length + unextractedPeople.length;
@@ -445,6 +448,35 @@ const REWRITE_DESCRIPTION_THRESHOLD = 750;
  * Phase 2 items enqueue at Normal priority, naturally processing before more
  * Low-priority Phase 1 scans.
  */
+/**
+ * Forces an unconditional, threshold-bypassing Person scan on Apply/Dismiss.
+ * Cannot be replaced by checkAndQueueHumanExtraction — that function gates on
+ * MIN(10, people_count) and would silently skip messages if the threshold isn't
+ * met, leaving reflection-era noise unprocessed and ungated.
+ */
+export function queueReflectionDrain(personaId: string, state: StateManager): void {
+  const persona = state.persona_getById(personaId);
+  if (!persona) return;
+
+  const allMessages = state.messages_get(personaId);
+  const unextractedPeople = state.messages_getUnextracted(personaId, "p");
+
+  if (unextractedPeople.length === 0) {
+    console.log(`[reflection:drain] No unextracted messages for ${persona.display_name} — drain complete`);
+    return;
+  }
+
+  const context: ExtractionContext = {
+    personaId,
+    personaDisplayName: persona.display_name,
+    messages_context: allMessages.filter(m => m.p === true),
+    messages_analyze: unextractedPeople,
+    extraction_flag: "p",
+  };
+  queuePersonScan(context, state, { reflection_progress: 1 });
+  console.log(`[reflection:drain] Queued Person scan for ${persona.display_name} (${unextractedPeople.length} messages) — clears on completion`);
+}
+
 export function queueRewritePhase(state: StateManager): void {
   const human = state.getHuman();
   const rewriteModel = human.settings?.rewrite_model;

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

@@ -67,6 +67,8 @@ export interface ExtractionContext {
 export interface ExtractionOptions {
   /** Ceremony phase number (1=Dedup, 2=Expose) */
   ceremony_progress?: number;
+  /** Set to 1 on scans queued while there is a Pending Reflection. */
+  reflection_progress?: number;
   /** Override model for extraction LLM calls */
   extraction_model?: string;
   /**

package/src/core/orchestrators/index.ts

@@ -19,6 +19,7 @@ export {
   shouldStartCeremony, 
   startCeremony,
   handleCeremonyProgress,
+  queueReflectionDrain,
   prunePersonaMessages,
   runHumanCeremony,
   } from "./ceremony.js";

package/src/core/processor.ts

@@ -39,7 +39,7 @@ import { ContextStatus as ContextStatusEnum, RoomMode } from "./types.js";
 import { registerReadMemoryExecutor, registerFileReadExecutor } from "./tools/index.js";
 import { createReadMemoryExecutor } from "./tools/builtin/read-memory.js";
 import { EI_WELCOME_MESSAGE, EI_PERSONA_DEFINITION } from "../templates/welcome.js";
-import { shouldStartCeremony, startCeremony, handleCeremonyProgress, queueUserDedupRequest, queueRoomCapture, queuePersonaCapture, checkAndQueueRoomExtraction, queueTargetedPersonUpdate, queueTargetedTopicUpdate } from "./orchestrators/index.js";
+import { shouldStartCeremony, startCeremony, handleCeremonyProgress, queueReflectionDrain, queueUserDedupRequest, queueRoomCapture, queuePersonaCapture, checkAndQueueRoomExtraction, queueTargetedPersonUpdate, queueTargetedTopicUpdate } from "./orchestrators/index.js";
 import { BUILT_IN_FACTS } from "./constants/built-in-facts.js";
 import { DEFAULT_SEED_TRAITS } from "./constants/seed-traits.js";
 
@@ -1755,6 +1755,43 @@ const toolNextSteps = new Set([
     if (ok) this.interface.onPersonaUpdated?.(personaId);
   }
 
+  async finalizeReflection(
+    personaId: string,
+    action: "apply" | "dismiss",
+    identity?: { short_description?: string; long_description: string; traits: NonNullable<PersonaEntity["pending_update"]>["traits"]; topics: NonNullable<PersonaEntity["pending_update"]>["topics"] }
+  ): Promise<void> {
+    const persona = this.stateManager.persona_getById(personaId);
+    if (!persona) return;
+
+    const source = identity ?? (persona.pending_update ? {
+      short_description: persona.pending_update.short_description,
+      long_description: persona.pending_update.long_description,
+      traits: persona.pending_update.traits,
+      topics: persona.pending_update.topics,
+    } : null);
+
+    const updates: Partial<PersonaEntity> = { pending_update: undefined };
+
+    if (action === "apply" && source) {
+      updates.short_description = source.short_description;
+      updates.long_description = source.long_description;
+      updates.traits = source.traits.map(t => ({
+        ...t,
+        id: t.id?.startsWith("pending-") ? crypto.randomUUID() : t.id,
+      }));
+      updates.topics = source.topics.map(t => ({
+        ...t,
+        id: t.id?.startsWith("pending-") ? crypto.randomUUID() : t.id,
+      }));
+    }
+
+    const ok = await updatePersona(this.stateManager, personaId, updates);
+    if (ok) {
+      queueReflectionDrain(personaId, this.stateManager);
+      this.interface.onPersonaUpdated?.(personaId);
+    }
+  }
+
   async updateRoom(roomId: string, updates: Partial<RoomEntity>): Promise<void> {
     const ok = this.stateManager.updateRoom(roomId, updates);
     if (ok) this.interface.onRoomUpdated?.(roomId);

package/tui/src/commands/persona.tsx

@@ -233,7 +233,7 @@ export const personaCommand: Command = {
           }
 
           if (reviewResult.content === null) {
-            await ctx.ei.updatePersona(personaId, { pending_update: undefined });
+            await ctx.ei.finalizeReflection(personaId, "dismiss");
             ctx.showNotification(`Dismissed pending changes for ${persona.display_name}`, "info");
             return;
           }
@@ -267,17 +267,16 @@ export const personaCommand: Command = {
               return;
             }
 
-            await ctx.ei.updatePersona(personaId, { pending_update: undefined });
+            await ctx.ei.finalizeReflection(personaId, "dismiss");
             ctx.showNotification(`Dismissed pending changes for ${persona.display_name}`, "info");
             return;
           }
 
-          await ctx.ei.updatePersona(personaId, {
+          await ctx.ei.finalizeReflection(personaId, "apply", {
             long_description: previewParsed.long_description,
             short_description: previewParsed.short_description,
             traits: previewParsed.traits,
             topics: previewParsed.topics,
-            pending_update: undefined,
           });
           ctx.showNotification(`Applied changes to ${persona.display_name}`, "info");
           return;

package/tui/src/commands/reflect.tsx

@@ -327,13 +327,7 @@ export const reflectCommand: Command = {
         topics: persona.pending_update!.topics,
       };
 
-      await ctx.ei.updatePersona(personaId, {
-        long_description: source.long_description,
-        short_description: source.short_description,
-        traits: source.traits,
-        topics: source.topics,
-        pending_update: undefined,
-      });
+      await ctx.ei.finalizeReflection(personaId, "apply", source);
 
       if (fs.existsSync(folderPath)) {
         fs.rmSync(folderPath, { recursive: true, force: true });
@@ -363,7 +357,7 @@ export const reflectCommand: Command = {
         return;
       }
 
-      await ctx.ei.updatePersona(personaId, { pending_update: undefined });
+      await ctx.ei.finalizeReflection(personaId, "dismiss");
       const folderPath = getReflectFolder(persona);
       if (fs.existsSync(folderPath)) {
         fs.rmSync(folderPath, { recursive: true, force: true });

package/tui/src/context/ei.tsx

@@ -80,6 +80,7 @@ export interface EiContextValue {
   deletePersona: (personaId: string) => Promise<void>;
   setContextBoundary: (personaId: string, timestamp: string | null) => Promise<void>;
   updatePersona: (personaId: string, updates: Partial<PersonaEntity>) => Promise<void>;
+  finalizeReflection: (personaId: string, action: "apply" | "dismiss", identity?: { short_description?: string; long_description: string; traits: NonNullable<PersonaEntity["pending_update"]>["traits"]; topics: NonNullable<PersonaEntity["pending_update"]>["topics"] }) => Promise<void>;
   getPersona: (personaId: string) => Promise<PersonaEntity | null>;
   resolvePersonaName: (nameOrAlias: string) => Promise<string | null>;
   getHuman: () => Promise<HumanEntity>;
@@ -360,6 +361,16 @@ export const EiProvider: ParentComponent = (props) => {
     await refreshPersonas();
   };
 
+  const finalizeReflection = async (
+    personaId: string,
+    action: "apply" | "dismiss",
+    identity?: { short_description?: string; long_description: string; traits: NonNullable<PersonaEntity["pending_update"]>["traits"]; topics: NonNullable<PersonaEntity["pending_update"]>["topics"] }
+  ) => {
+    if (!processor) return;
+    await processor.finalizeReflection(personaId, action, identity);
+    await refreshPersonas();
+  };
+
   const getPersona = async (personaId: string) => {
     if (!processor) return null;
     return processor.getPersona(personaId);
@@ -937,6 +948,7 @@ export const EiProvider: ParentComponent = (props) => {
     deletePersona,
     setContextBoundary,
     updatePersona,
+    finalizeReflection,
     getPersona,
     resolvePersonaName,
     getHuman,