ei-tui 1.1.0 → 1.3.0

package/src/core/processor.ts

@@ -44,6 +44,7 @@ import { EI_WELCOME_MESSAGE, EI_PERSONA_DEFINITION } from "../templates/welcome.
 import { EMMETT_PERSONA_DEFINITION } from "../templates/emmett.js";
 import { shouldStartCeremony, startCeremony, handleCeremonyProgress, queueReflectionDrain, queueUserDedupRequest, queueRoomCapture, queuePersonaCapture, checkAndQueueRoomExtraction, queueTargetedPersonUpdate, queueTargetedTopicUpdate } from "./orchestrators/index.js";
 import { finishDocumentBatch } from "./handlers/document-segmentation.js";
+import { buildSynthesisPrompt } from "../prompts/synthesis/index.js";
 import { BUILT_IN_FACTS } from "./constants/built-in-facts.js";
 import { DEFAULT_SEED_TRAITS } from "./constants/seed-traits.js";
 
@@ -138,6 +139,9 @@ import {
 import type { RoomCreationInput, RoomEntity, RoomMessage, RoomSummary } from "./types.js";
 import { previewUnsource as _previewUnsource } from "../integrations/document/unsource.js";
 import type { UnsourcePreview, UnsourceResult } from "../integrations/document/unsource.js";
+import { isQualifiedMessageId, qualifyEiMessage, qualifyOpenCodeMessage } from "./utils/message-id.js";
+
+import type { IOpenCodeReader } from "../integrations/opencode/types.js";
 
 const DEFAULT_LOOP_INTERVAL_MS = 100;
 const DEFAULT_OPENCODE_POLLING_MS = 60000;
@@ -241,18 +245,30 @@ export class Processor {
     this.bootstrapTools();
     this.seedBuiltinFacts();
     this.migrateLearnedOn();
+    await this.migrateMessageIds();
     this.seedSettings();
     registerFindMemoryExecutor(createFindMemoryExecutor(this.searchHumanData.bind(this), this.getPersonaList.bind(this), this.stateManager.getHuman.bind(this.stateManager)));
     registerFetchMemoryExecutor(createFetchMemoryExecutor(this.stateManager.getHuman.bind(this.stateManager)));
-    registerFetchMessageExecutor(createFetchMessageExecutor(
-      this.stateManager.persona_getAll.bind(this.stateManager),
-      this.stateManager.messages_get.bind(this.stateManager),
-      this.stateManager.getRoomList.bind(this.stateManager),
-      this.stateManager.getRoomMessages.bind(this.stateManager),
-      (roomId: string) => this.stateManager.getRoom(roomId)?.display_name ?? null
-    ));
     if (this.isTUI) {
       await registerFileReadExecutor();
+      const { createOpenCodeReader } = await import("../integrations/opencode/reader-factory.js");
+      const openCodeReader = await createOpenCodeReader().catch(() => null);
+      registerFetchMessageExecutor(createFetchMessageExecutor(
+        this.stateManager.persona_getAll.bind(this.stateManager),
+        this.stateManager.messages_get.bind(this.stateManager),
+        this.stateManager.getRoomList.bind(this.stateManager),
+        this.stateManager.getRoomMessages.bind(this.stateManager),
+        (roomId: string) => this.stateManager.getRoom(roomId)?.display_name ?? null,
+        openCodeReader ? (id, before, after) => openCodeReader.getMessageById(id, before, after) : undefined
+      ));
+    } else {
+      registerFetchMessageExecutor(createFetchMessageExecutor(
+        this.stateManager.persona_getAll.bind(this.stateManager),
+        this.stateManager.messages_get.bind(this.stateManager),
+        this.stateManager.getRoomList.bind(this.stateManager),
+        this.stateManager.getRoomMessages.bind(this.stateManager),
+        (roomId: string) => this.stateManager.getRoom(roomId)?.display_name ?? null
+      ));
     }
     this.running = true;
     console.log(`[Processor ${this.instanceId}] initialized, starting loop`);
@@ -335,6 +351,140 @@ export class Processor {
     return executeUnsource(preview, this.stateManager);
   }
 
+  async generateDocument(subject: string): Promise<{ slug: string }> {
+    this.bootstrapEmmett();
+    const slugBase = subject
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .slice(0, 40);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const slug = `${slugBase}_${timestamp}`;
+
+    const primary = await this.searchHumanData(subject, { limit: 20 });
+    if (
+      primary.facts.length === 0 &&
+      primary.topics.length === 0 &&
+      primary.people.length === 0 &&
+      primary.quotes.length === 0
+    ) {
+      throw new Error(`No knowledge found about '${subject}'`);
+    }
+
+    const seenQuoteIds = new Set<string>();
+    const seenItemIds = new Set<string>(
+      [...primary.topics, ...primary.people, ...primary.facts].map(i => i.id)
+    );
+
+    const MAX_QUOTES_PER_ENTITY = 3;
+
+    const enrichTopic = (topic: import("../prompts/synthesis/types.js").EnrichedTopic["topic"]) => {
+      const linked = this.stateManager.human_quote_getForDataItem(topic.id)
+        .sort((a, b) => b.timestamp.localeCompare(a.timestamp))
+        .slice(0, MAX_QUOTES_PER_ENTITY);
+      linked.forEach(q => seenQuoteIds.add(q.id));
+      return { topic, quotes: linked };
+    };
+
+    const enrichPerson = (person: import("../prompts/synthesis/types.js").EnrichedPerson["person"]) => {
+      const linked = this.stateManager.human_quote_getForDataItem(person.id)
+        .sort((a, b) => b.timestamp.localeCompare(a.timestamp))
+        .slice(0, MAX_QUOTES_PER_ENTITY);
+      linked.forEach(q => seenQuoteIds.add(q.id));
+      return { person, quotes: linked };
+    };
+
+    const enrichedTopics = primary.topics.map(enrichTopic);
+    const enrichedPeople = primary.people.map(enrichPerson);
+
+    const human = this.stateManager.getHuman();
+    const allItems = [...human.facts, ...human.topics, ...human.people];
+
+    const MAX_SECONDARY_ENTITIES = 10;
+
+    const secondaryTopics: typeof enrichedTopics = [];
+    const secondaryPeople: typeof enrichedPeople = [];
+    const secondaryFacts: typeof primary.facts = [];
+
+    outer: for (const quote of [...enrichedTopics.flatMap(e => e.quotes), ...enrichedPeople.flatMap(e => e.quotes)]) {
+      for (const itemId of quote.data_item_ids) {
+        if (secondaryTopics.length + secondaryPeople.length + secondaryFacts.length >= MAX_SECONDARY_ENTITIES) break outer;
+        if (seenItemIds.has(itemId)) continue;
+        seenItemIds.add(itemId);
+        const item = allItems.find(i => i.id === itemId);
+        if (!item) continue;
+        if (human.topics.find(t => t.id === itemId)) {
+          secondaryTopics.push(enrichTopic(item as typeof primary.topics[0]));
+        } else if (human.people.find(p => p.id === itemId)) {
+          secondaryPeople.push(enrichPerson(item as typeof primary.people[0]));
+        } else if (human.facts.find(f => f.id === itemId)) {
+          secondaryFacts.push(item as typeof primary.facts[0]);
+        }
+      }
+    }
+
+    const standaloneQuotes = primary.quotes.filter(q => !seenQuoteIds.has(q.id));
+
+    const allLoadedFacts = [...primary.facts, ...secondaryFacts];
+    const allLoadedTopics = [...enrichedTopics, ...secondaryTopics];
+    const allLoadedPeople = [...enrichedPeople, ...secondaryPeople];
+
+    const loadedEntityNames = new Map<string, string>();
+    for (const f of allLoadedFacts) loadedEntityNames.set(f.id, f.name);
+    for (const { topic } of allLoadedTopics) loadedEntityNames.set(topic.id, topic.name);
+    for (const { person } of allLoadedPeople) loadedEntityNames.set(person.id, person.name);
+
+    const prompt = buildSynthesisPrompt({
+      subject,
+      facts: allLoadedFacts,
+      topics: allLoadedTopics,
+      people: allLoadedPeople,
+      standaloneQuotes,
+      loadedEntityNames,
+    });
+
+    const model = this.stateManager.getHuman().settings?.rewrite_model
+      ?? this.stateManager.getHuman().settings?.default_model;
+
+    this.stateManager.queue_enqueue({
+      type: LLMRequestType.Raw,
+      priority: LLMPriority.Normal,
+      system: prompt.system,
+      user: prompt.user,
+      next_step: LLMNextStep.HandleKnowledgeSynthesis,
+      model,
+      data: { slug, subject },
+    });
+
+    return { slug };
+  }
+
+  checkGenerationModel(): { model: string; isRewriteModel: boolean } {
+    const settings = this.stateManager.getHuman().settings;
+    if (settings?.rewrite_model) {
+      return { model: settings.rewrite_model, isRewriteModel: true };
+    }
+    return { model: settings?.default_model ?? "unknown", isRewriteModel: false };
+  }
+
+  async getGeneratedDocumentContent(slug: string): Promise<string | null> {
+    const messages = this.stateManager.messages_get("emmet");
+    const target = `generate:document:${slug}`;
+    const message = messages.find(m => m.id.startsWith(`${target}:`));
+    return message?.content ?? null;
+  }
+
+  async reRunDocument(slug: string): Promise<{ slug: string }> {
+    const docs = this.stateManager.getHuman().settings?.document?.processed_documents ?? {};
+    const entry = docs[slug];
+    if (!entry || entry.type !== "generated" || !entry.subject) {
+      throw new Error(`No generated document found for slug "${slug}"`);
+    }
+    const subject = entry.subject;
+    const preview = this.getUnsourcePreview(`generate:document:${slug}`);
+    await this.executeUnsource(preview);
+    return this.generateDocument(subject);
+  }
+
   /**
    * Seed built-in tool providers and tools if they don't exist yet.
    * Called on every startup (after state load/restore) — safe to call repeatedly.
@@ -874,6 +1024,104 @@ export class Processor {
     }
   }
 
+  private async migrateMessageIds(): Promise<void> {
+    try {
+      let msgRewrites = 0;
+      let quoteRewrites = 0;
+
+      const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+      const personas = this.stateManager.persona_getAll();
+      for (const persona of personas) {
+        for (const msg of this.stateManager.messages_get(persona.id)) {
+          if (!msg.external && UUID_PATTERN.test(msg.id)) {
+            this.stateManager.messages_update(persona.id, msg.id, { id: qualifyEiMessage(msg.id) });
+            msgRewrites++;
+          }
+        }
+      }
+
+      const rooms = this.stateManager.getRoomList();
+      for (const room of rooms) {
+        for (const msg of this.stateManager.getRoomMessages(room.id).slice()) {
+          if (UUID_PATTERN.test(msg.id)) {
+            this.stateManager.updateRoomMessage(room.id, msg.id, { id: qualifyEiMessage(msg.id) });
+            msgRewrites++;
+          }
+        }
+      }
+
+      const human = this.stateManager.getHuman();
+      const quotes = human.quotes ?? [];
+
+      const eiUuidMap = new Map<string, string>();
+      for (const persona of personas) {
+        for (const msg of this.stateManager.messages_get(persona.id)) {
+          if (msg.id.startsWith("ei:")) eiUuidMap.set(msg.id.slice(3), msg.id);
+        }
+      }
+      for (const room of rooms) {
+        for (const msg of this.stateManager.getRoomMessages(room.id)) {
+          if (msg.id.startsWith("ei:")) eiUuidMap.set(msg.id.slice(3), msg.id);
+        }
+      }
+
+      const MSG_PATTERN = /^msg_[a-zA-Z0-9]+$/;
+
+      let openCodeReader: IOpenCodeReader | null = null;
+      if (this.isTUI) {
+        const { createOpenCodeReader } = await import("../integrations/opencode/reader-factory.js");
+        openCodeReader = await createOpenCodeReader().catch(() => null);
+      }
+
+      const updatedQuotes: typeof quotes = [];
+      for (const quote of quotes) {
+        const mid = quote.message_id;
+        if (!mid || isQualifiedMessageId(mid)) {
+          updatedQuotes.push(quote);
+          continue;
+        }
+
+        if (MSG_PATTERN.test(mid)) {
+          if (openCodeReader) {
+            const ocWindow = await openCodeReader.getMessageById(mid).catch(() => null);
+            if (ocWindow) {
+              const { getMachineId } = await import("../integrations/machine-id.js");
+              updatedQuotes.push({ ...quote, message_id: qualifyOpenCodeMessage(getMachineId(), ocWindow.session.id, mid) });
+              quoteRewrites++;
+              continue;
+            }
+          }
+          updatedQuotes.push(quote);
+          continue;
+        }
+
+        if (UUID_PATTERN.test(mid)) {
+          const fqId = eiUuidMap.get(mid);
+          if (fqId) {
+            updatedQuotes.push({ ...quote, message_id: fqId });
+            quoteRewrites++;
+            continue;
+          }
+          updatedQuotes.push(quote);
+          continue;
+        }
+
+        updatedQuotes.push(quote);
+      }
+
+      if (quoteRewrites > 0) {
+        this.stateManager.setHuman({ ...human, quotes: updatedQuotes });
+      }
+
+      if (msgRewrites > 0 || quoteRewrites > 0) {
+        console.log(`[Processor] migrateMessageIds: rewrote ${msgRewrites} message IDs, ${quoteRewrites} quote message_ids`);
+      }
+    } catch (err) {
+      console.error("[Processor] migrateMessageIds failed, continuing:", err);
+    }
+  }
+
   private seedSettings(): void {
     const human = this.stateManager.getHuman();
     let modified = false;
@@ -1087,6 +1335,7 @@ const toolNextSteps = new Set([
   LLMNextStep.HandleEiHeartbeat,
   LLMNextStep.HandleToolContinuation,
   LLMNextStep.HandleDedupCurate,
+  LLMNextStep.HandleKnowledgeSynthesis,
 ]);
             const toolPersonaId =
               personaId ??
@@ -1101,9 +1350,17 @@ const toolNextSteps = new Set([
               (request.next_step === LLMNextStep.HandleToolContinuation &&
                 request.data.originalNextStep === LLMNextStep.HandleDedupCurate);
 
+            const isSynthesisRequest = request.next_step === LLMNextStep.HandleKnowledgeSynthesis ||
+              (request.next_step === LLMNextStep.HandleToolContinuation &&
+                request.data.originalNextStep === LLMNextStep.HandleKnowledgeSynthesis);
+
             let tools: ToolDefinition[] = [];
             if (isDedupRequest) {
               tools = SYSTEM_TOOLS.filter(t => t.name === "find_memory");
+            } else if (isSynthesisRequest) {
+              tools = SYSTEM_TOOLS.filter(t =>
+                t.name === "find_memory" || t.name === "fetch_memory" || t.name === "fetch_message"
+              );
             } else if (toolNextSteps.has(request.next_step) && toolPersonaId) {
               tools = [...SYSTEM_TOOLS, ...this.stateManager.tools_getForPersona(toolPersonaId, this.isTUI)];
             }
@@ -1760,6 +2017,17 @@ const toolNextSteps = new Set([
           this.interface.onHumanUpdated?.();
         }
       }
+
+      const isSynthesisCompletion =
+        response.request.next_step === LLMNextStep.HandleKnowledgeSynthesis ||
+        (response.request.next_step === LLMNextStep.HandleToolContinuation &&
+          response.request.data.originalNextStep === LLMNextStep.HandleKnowledgeSynthesis);
+      if (isSynthesisCompletion) {
+        const slug = response.request.data.slug as string;
+        const hasContent = slug && this.stateManager.messages_get("emmet")
+          .some(m => m.id.startsWith(`generate:document:${slug}:`));
+        if (hasContent) this.interface.onDocumentGenerated?.(slug);
+      }
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : String(err);
       const result = this.stateManager.queue_fail(response.request.id, errorMsg);

package/src/core/queue-manager.ts

@@ -51,6 +51,15 @@ export async function getQueueStatus(sm: StateManager): Promise<QueueStatus> {
   }
   const extracting_documents = extractingSet.size > 0 ? Array.from(extractingSet) : undefined;
 
+  const generatingSet: string[] = [];
+  for (const item of activeItems) {
+    if (item.next_step === LLMNextStep.HandleKnowledgeSynthesis) {
+      const slug = (item.data as { slug?: string }).slug;
+      if (slug) generatingSet.push(slug);
+    }
+  }
+  const generating_documents = generatingSet.length > 0 ? generatingSet : undefined;
+
   return {
     state: sm.queue_isPaused()
       ? "paused"
@@ -62,6 +71,7 @@ export async function getQueueStatus(sm: StateManager): Promise<QueueStatus> {
     embedding_warning: sm.embedding_getWarning() || undefined,
     pending_documents,
     extracting_documents,
+    generating_documents,
   };
 }
 

package/src/core/state-manager.ts

@@ -71,6 +71,7 @@ export class StateManager {
     this.migrateProviderModel();
     this.migrateThemes();
     this.migrateFfaParentIds();
+    this.migrateDocumentSettings();
   }
 
   /**
@@ -586,6 +587,40 @@ export class StateManager {
     }
   }
 
+  private migrateDocumentSettings(): void {
+    const human = this.humanState.get();
+    const doc = human.settings?.document;
+    if (!doc) return;
+
+    let migrated = false;
+
+    const existing = doc.processed_documents ?? {};
+    for (const [key, value] of Object.entries(existing)) {
+      if (typeof value === "string") {
+        (existing as Record<string, unknown>)[key] = { created_at: value, type: "imported" };
+        migrated = true;
+      }
+    }
+
+    const legacy = (doc as Record<string, unknown>).generated_documents as
+      | Record<string, { subject: string; created_at: string }>
+      | undefined;
+    if (legacy) {
+      for (const [slug, record] of Object.entries(legacy)) {
+        existing[slug] = { created_at: record.created_at, type: "generated", subject: record.subject };
+      }
+      delete (doc as Record<string, unknown>).generated_documents;
+      migrated = true;
+    }
+
+    if (migrated) {
+      doc.processed_documents = existing as import("./types/entities.js").DocumentSettings["processed_documents"];
+      this.humanState.set(human);
+      this.scheduleSave();
+      console.log("[StateManager] Migrated document settings to unified processed_documents schema");
+    }
+  }
+
   getHuman(): HumanEntity {
     return this.humanState.get();
   }

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

@@ -4,20 +4,20 @@ import type { Fact, Topic, Person, Quote, HumanEntity } from "../../types.js";
 type GetHuman = () => HumanEntity;
 
 function cleanFact(f: Fact): Record<string, unknown> {
-  const { embedding, rewrite_checked, persona_groups, ...rest } = f;
-  void embedding; void rewrite_checked; void persona_groups;
+  const { embedding, persona_groups, ...rest } = f;
+  void embedding; void persona_groups;
   return rest;
 }
 
 function cleanTopic(t: Topic): Record<string, unknown> {
-  const { embedding, rewrite_checked, persona_groups, last_ei_asked, ...rest } = t;
-  void embedding; void rewrite_checked; void persona_groups; void last_ei_asked;
+  const { embedding, rewrite_length_floor, persona_groups, last_ei_asked, ...rest } = t;
+  void embedding; void rewrite_length_floor; void persona_groups; void last_ei_asked;
   return rest;
 }
 
 function cleanPerson(p: Person): Record<string, unknown> {
-  const { embedding, rewrite_checked, persona_groups, last_ei_asked, ...rest } = p;
-  void embedding; void rewrite_checked; void persona_groups; void last_ei_asked;
+  const { embedding, rewrite_length_floor, persona_groups, last_ei_asked, ...rest } = p;
+  void embedding; void rewrite_length_floor; void persona_groups; void last_ei_asked;
   return rest;
 }
 

package/src/core/tools/builtin/fetch-message.ts

@@ -2,6 +2,7 @@ import type { ToolExecutor } from "../types.js";
 import type { Message } from "../../types.js";
 import type { RoomMessage, RoomSummary } from "../../types/rooms.js";
 import type { PersonaEntity } from "../../types/entities.js";
+import type { OpenCodeMessageWindow } from "../../../integrations/opencode/types.js";
 
 interface CleanMessage {
   id: string;
@@ -17,6 +18,9 @@ type GetPersonaMessages = (personaId: string) => Message[];
 type GetRoomList = () => RoomSummary[];
 type GetRoomMessages = (roomId: string) => RoomMessage[];
 type GetRoomDisplayName = (roomId: string) => string | null;
+type GetOpenCodeMessage = (id: string, before: number, after: number) => Promise<OpenCodeMessageWindow | null>;
+
+const OPENCODE_MESSAGE_ID = /^msg_[a-zA-Z0-9]+$/;
 
 function stripMessage(m: Message): CleanMessage {
   return {
@@ -45,7 +49,8 @@ export function createFetchMessageExecutor(
   getPersonaMessages: GetPersonaMessages,
   getRoomList: GetRoomList,
   getRoomMessages: GetRoomMessages,
-  getRoomDisplayName: GetRoomDisplayName
+  getRoomDisplayName: GetRoomDisplayName,
+  getOpenCodeMessage?: GetOpenCodeMessage
 ): ToolExecutor {
   return {
     name: "fetch_message",
@@ -62,6 +67,27 @@ export function createFetchMessageExecutor(
         return JSON.stringify({ error: "Missing required argument: id" });
       }
 
+      if (OPENCODE_MESSAGE_ID.test(id)) {
+        if (!getOpenCodeMessage) {
+          return JSON.stringify({ error: "OpenCode message lookup not available in this runtime", id });
+        }
+        const window = await getOpenCodeMessage(id, before, after);
+        if (!window) {
+          return JSON.stringify({
+            error: "OpenCode message not found on this machine. It may exist on another device.",
+            id,
+            hint: "Check the linked topic's sources for the originating machine and session.",
+          });
+        }
+        return JSON.stringify({
+          message: { id: window.message.id, role: window.message.role, content: window.message.content, timestamp: window.message.timestamp, agent: window.message.agent },
+          before: window.before.map(m => ({ id: m.id, role: m.role, content: m.content, timestamp: m.timestamp, agent: m.agent })),
+          after: window.after.map(m => ({ id: m.id, role: m.role, content: m.content, timestamp: m.timestamp, agent: m.agent })),
+          session: { id: window.session.id, title: window.session.title, directory: window.session.directory },
+          source: "opencode",
+        });
+      }
+
       const personas = getAllPersonas();
 
       // TODO: add persona access gate when calling context is available —

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

@@ -15,6 +15,14 @@ type GetPersonaList = () => Promise<PersonaSummary[]>;
 
 type GetHuman = () => HumanEntity;
 
+function formatSentiment(s: number): string {
+  const pct = Math.round(Math.abs(s) * 100);
+  const direction = s > 0.2 ? "positive" : s < -0.2 ? "negative" : "neutral";
+  if (direction === "neutral") return "neutral";
+  const intensity = pct >= 80 ? "strongly " : pct >= 50 ? "" : "slightly ";
+  return `${pct}% ${intensity}${direction}`;
+}
+
 export function createFindMemoryExecutor(searchHumanData: SearchHumanData, getPersonaList?: GetPersonaList, getHuman?: GetHuman): ToolExecutor {
   return {
     name: "find_memory",
@@ -68,8 +76,8 @@ export function createFindMemoryExecutor(searchHumanData: SearchHumanData, getPe
 
       const output: Record<string, unknown[]> = {};
       if (results.facts.length > 0) output.facts = results.facts.map(f => ({ id: f.id, name: f.name, description: f.description }));
-      if (results.topics.length > 0) output.topics = results.topics.map(t => ({ id: t.id, name: t.name, description: t.description }));
-      if (results.people.length > 0) output.people = results.people.map(p => ({ id: p.id, name: p.name, relationship: p.relationship, description: p.description, identifiers: p.identifiers ?? [] }));
+      if (results.topics.length > 0) output.topics = results.topics.map(t => ({ id: t.id, name: t.name, description: t.description, sentiment: formatSentiment(t.sentiment) }));
+      if (results.people.length > 0) output.people = results.people.map(p => ({ id: p.id, name: p.name, relationship: p.relationship, description: p.description, identifiers: p.identifiers ?? [], sentiment: formatSentiment(p.sentiment) }));
 
       if (results.quotes.length > 0) {
         const human = getHuman ? getHuman() : null;
@@ -85,7 +93,7 @@ export function createFindMemoryExecutor(searchHumanData: SearchHumanData, getPe
               if (person) { linked_items.push({ id: person.id, name: person.name, type: "person" }); }
             }
           }
-          return { id: q.id, text: q.text, speaker: q.speaker, linked_items };
+          return { id: q.id, text: q.text, speaker: q.speaker, message_id: q.message_id, linked_items };
         });
       }
 

package/src/core/tools/index.ts

@@ -29,7 +29,7 @@ export const SYSTEM_TOOLS: ToolDefinition[] = [
     provider_id: "ei",
     name: "find_memory",
     display_name: "Find Memory",
-    description: "Semantic search of your personal memory — facts, topics, people, and quotes learned across ALL conversations over time, not just this one. Use when the human references something from the past, mentions a person, or asks about a topic you might have learned about. Supports optional filters: types (array of 'facts', 'topics', 'people', 'quotes'), limit (1-20, default 10), recent (true = sort by recency), persona (filter to what a specific persona has learned — use display name).",
+    description: "Semantic search of your personal memory — facts, topics, people, and quotes learned across ALL conversations over time, not just this one. Use when the human references something from the past, mentions a person, or asks about a topic you might have learned about. People and topic results include a sentiment field (e.g. '72% positive', 'neutral', '45% slightly negative') indicating how the human generally feels about that person or subject. Supports optional filters: types (array of 'facts', 'topics', 'people', 'quotes'), limit (1-20, default 10), recent (true = sort by recency), persona (filter to what a specific persona has learned — use display name).",
     input_schema: {
       type: "object",
       properties: {
@@ -52,7 +52,7 @@ export const SYSTEM_TOOLS: ToolDefinition[] = [
     provider_id: "ei",
     name: "fetch_memory",
     display_name: "Fetch Memory",
-    description: "Retrieve the full record for a specific memory by its ID. Use when find_memory returns an item and you need its complete details, or when a system prompt references a memory ID. Returns the full Fact, Topic, Person, or Quote record.",
+    description: "Retrieve the full record for a specific memory by its ID. For most conversational use, find_memory results are sufficient. Use fetch_memory when you need provenance details (which sessions or documents the memory came from) or the raw sentiment score. Returns the complete Fact, Topic, Person, or Quote record including all fields.",
     input_schema: {
       type: "object",
       properties: {
@@ -64,7 +64,7 @@ export const SYSTEM_TOOLS: ToolDefinition[] = [
     builtin: true,
     enabled: true,
     created_at: new Date(0).toISOString(),
-    max_calls_per_interaction: 3,
+    max_calls_per_interaction: 10,
   },
   {
     id: "builtin-fetch-message",

package/src/core/tools/types.ts

@@ -6,7 +6,7 @@
 /** A single tool call the LLM wants to make (from the API response). */
 export interface ToolCall {
   id: string;           // call_abc123 — must be echoed back in tool result message
-  name: string;         // snake_case tool name ("web_search", "read_memory")
+  name: string;         // snake_case tool name ("web_search", "find_memory")
   arguments: Record<string, unknown>;  // Parsed from JSON string in the API response
 }
 

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

@@ -18,7 +18,7 @@ export interface DataItemBase {
   sources?: string[];            // Namespaced source identifiers — where items were learned from. Format: "provider:id" (e.g., "opencode:ses_abc123", "cursor:composerId"). Grow-only union.
   persona_groups?: string[];
   embedding?: number[];
-  rewrite_checked?: boolean;     // True after rewrite scan finds no changes. Cleared automatically when extraction upserts a fresh item.
+  rewrite_length_floor?: number; // Set after every rewrite scan: ceil(description.length * 1.1). Item is skipped by ceremony until description grows past this floor. Preserved across extraction upserts — only cleared when description exceeds it.
 }
 
 export interface Fact extends DataItemBase {

package/src/core/types/entities.ts

@@ -20,9 +20,15 @@ export interface OpenCodeSettings {
   processed_sessions?: Record<string, string>;  // sessionId → ISO timestamp of last import
 }
 
+export interface DocumentRecord {
+  created_at: string;
+  type: "imported" | "generated";
+  subject?: string;
+}
+
 export interface DocumentSettings {
   extraction_model?: string;
-  processed_documents?: Record<string, string>;
+  processed_documents?: Record<string, DocumentRecord>;
 }
 
 export interface CeremonyConfig {

package/src/core/types/enums.ts

@@ -53,6 +53,7 @@ export enum LLMNextStep {
   HandleTopicValidate = "handleTopicValidate",
   HandleReflectionCritic = "handleReflectionCritic",
   HandleDocumentSegmentation = "handleDocumentSegmentation",
+  HandleKnowledgeSynthesis = "handleKnowledgeSynthesis",
 }
 
 export enum ProviderType {

package/src/core/types/integrations.ts

@@ -29,7 +29,7 @@ export interface ToolProvider {
 export interface ToolDefinition {
   id: string;                          // UUID
   provider_id: string;                 // FK → ToolProvider.id (required)
-  name: string;                        // Snake_case machine name ("web_search", "read_memory")
+  name: string;                        // Snake_case machine name ("web_search", "find_memory")
   display_name: string;                // Human label
   description: string;                 // What the LLM reads to decide whether to call this tool
   input_schema: Record<string, unknown>; // JSON Schema for parameters the LLM can pass
@@ -77,6 +77,7 @@ export interface QueueStatus {
   embedding_warning?: boolean;
   pending_documents?: Array<{ batchId: string; filename: string; count: number }>;
   extracting_documents?: string[];
+  generating_documents?: string[];
 }
 
 export interface EiError {
@@ -121,6 +122,7 @@ export interface Ei_Interface {
   onRoomMessageAdded?: (roomId: string) => void;
   onRoomMessageQueued?: (roomId: string) => void;
   onRoomMessageProcessing?: (roomId: string) => void;
+  onDocumentGenerated?: (slug: string) => void;
 }
 
 // =============================================================================

package/src/core/types/llm.ts

@@ -27,15 +27,6 @@ export interface Message {
 
   external?: boolean;          // Set by integration importers (OpenCode, Cursor, Claude Code); invisible to LLM context
 
-  /**
-   * Integration source tag. Set ONLY on external: true messages by importers (document, Slack, etc.)
-   * to identify which external source this synthetic message came from.
-   * Format: "import:document:filename" | "slack:channelId" | etc.
-   * Enables quote provenance tracing: quote.message_id → message.source_tag → original source.
-   * Never set on conversational messages.
-   */
-  source_tag?: string;
-
 }
 
 export interface ChatMessage {