ei-tui 1.0.1 → 1.2.0

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

@@ -0,0 +1,92 @@
+import type { ToolExecutor } from "../types.js";
+import type { Fact, Topic, Person, Quote, HumanEntity } from "../../types.js";
+
+type GetHuman = () => HumanEntity;
+
+function cleanFact(f: Fact): Record<string, unknown> {
+  const { embedding, persona_groups, ...rest } = f;
+  void embedding; void persona_groups;
+  return rest;
+}
+
+function cleanTopic(t: Topic): Record<string, unknown> {
+  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_length_floor, persona_groups, last_ei_asked, ...rest } = p;
+  void embedding; void rewrite_length_floor; void persona_groups; void last_ei_asked;
+  return rest;
+}
+
+function cleanQuote(
+  q: Quote,
+  facts: Fact[],
+  topics: Topic[],
+  people: Person[]
+): Record<string, unknown> {
+  const { embedding, persona_groups, data_item_ids, ...rest } = q;
+  void embedding; void persona_groups;
+
+  const linked_items: Array<{ id: string; name: string; type: string }> = [];
+  for (const id of data_item_ids) {
+    const fact = facts.find(f => f.id === id);
+    if (fact) { linked_items.push({ id: fact.id, name: fact.name, type: "fact" }); continue; }
+    const topic = topics.find(t => t.id === id);
+    if (topic) { linked_items.push({ id: topic.id, name: topic.name, type: "topic" }); continue; }
+    const person = people.find(p => p.id === id);
+    if (person) { linked_items.push({ id: person.id, name: person.name, type: "person" }); continue; }
+  }
+
+  return { ...rest, linked_items };
+}
+
+export function createFetchMemoryExecutor(getHuman: GetHuman): ToolExecutor {
+  return {
+    name: "fetch_memory",
+
+    async execute(args: Record<string, unknown>): Promise<string> {
+      const id = typeof args.id === "string" ? args.id.trim() : "";
+      console.log(`[fetch_memory] called with id="${id}"`);
+
+      if (!id) {
+        console.warn("[fetch_memory] missing id argument");
+        return JSON.stringify({ error: "Missing required argument: id" });
+      }
+
+      const human = getHuman();
+
+      const fact = human.facts.find(f => f.id === id);
+      if (fact) {
+        console.log(`[fetch_memory] found fact id="${id}" name="${fact.name}"`);
+        return JSON.stringify({ type: "fact", ...cleanFact(fact) });
+      }
+
+      const topic = human.topics.find(t => t.id === id);
+      if (topic) {
+        console.log(`[fetch_memory] found topic id="${id}" name="${topic.name}"`);
+        return JSON.stringify({ type: "topic", ...cleanTopic(topic) });
+      }
+
+      const person = human.people.find(p => p.id === id);
+      if (person) {
+        console.log(`[fetch_memory] found person id="${id}" name="${person.name}"`);
+        return JSON.stringify({ type: "person", ...cleanPerson(person) });
+      }
+
+      const quote = human.quotes.find(q => q.id === id);
+      if (quote) {
+        console.log(`[fetch_memory] found quote id="${id}"`);
+        return JSON.stringify({
+          type: "quote",
+          ...cleanQuote(quote, human.facts, human.topics, human.people),
+        });
+      }
+
+      console.log(`[fetch_memory] no entity found for id="${id}"`);
+      return JSON.stringify({ error: "No accessible record found for this ID" });
+    },
+  };
+}

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

@@ -0,0 +1,123 @@
+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";
+
+interface CleanMessage {
+  id: string;
+  role: string;
+  content?: string;
+  silence_reason?: string;
+  timestamp: string;
+  speaker_name?: string;
+}
+
+type GetAllPersonas = () => PersonaEntity[];
+type GetPersonaMessages = (personaId: string) => Message[];
+type GetRoomList = () => RoomSummary[];
+type GetRoomMessages = (roomId: string) => RoomMessage[];
+type GetRoomDisplayName = (roomId: string) => string | null;
+
+function stripMessage(m: Message): CleanMessage {
+  return {
+    id: m.id,
+    role: m.role,
+    ...(m.content !== undefined ? { content: m.content } : {}),
+    ...(m.silence_reason !== undefined ? { silence_reason: m.silence_reason } : {}),
+    timestamp: m.timestamp,
+    ...(m.speaker_name !== undefined ? { speaker_name: m.speaker_name } : {}),
+  };
+}
+
+function stripRoomMessage(m: RoomMessage, personaDisplayName?: string): CleanMessage {
+  return {
+    id: m.id,
+    role: m.role,
+    ...(m.content !== undefined ? { content: m.content } : {}),
+    ...(m.silence_reason !== undefined ? { silence_reason: m.silence_reason } : {}),
+    timestamp: m.timestamp,
+    ...(personaDisplayName !== undefined ? { speaker_name: personaDisplayName } : {}),
+  };
+}
+
+export function createFetchMessageExecutor(
+  getAllPersonas: GetAllPersonas,
+  getPersonaMessages: GetPersonaMessages,
+  getRoomList: GetRoomList,
+  getRoomMessages: GetRoomMessages,
+  getRoomDisplayName: GetRoomDisplayName
+): ToolExecutor {
+  return {
+    name: "fetch_message",
+
+    async execute(args: Record<string, unknown>): Promise<string> {
+      const id = typeof args.id === "string" ? args.id.trim() : "";
+      const before = typeof args.before === "number" && args.before > 0 ? Math.floor(args.before) : 0;
+      const after = typeof args.after === "number" && args.after > 0 ? Math.floor(args.after) : 0;
+
+      console.log(`[fetch_message] called with id="${id}", before=${before}, after=${after}`);
+
+      if (!id) {
+        console.warn("[fetch_message] missing id argument");
+        return JSON.stringify({ error: "Missing required argument: id" });
+      }
+
+      const personas = getAllPersonas();
+
+      // TODO: add persona access gate when calling context is available —
+      // the execute() signature has no requestingPersonaId, so we search all personas.
+      for (const persona of personas) {
+        const messages = getPersonaMessages(persona.id);
+        const idx = messages.findIndex(m => m.id === id);
+        if (idx === -1) continue;
+
+        const msg = messages[idx];
+        const beforeMsgs = messages.slice(Math.max(0, idx - before), idx).map(stripMessage);
+        const afterMsgs = messages.slice(idx + 1, idx + 1 + after).map(stripMessage);
+
+        console.log(`[fetch_message] found in persona "${persona.display_name}" at idx=${idx}`);
+        return JSON.stringify({
+          message: stripMessage(msg),
+          before: beforeMsgs,
+          after: afterMsgs,
+          persona: persona.display_name,
+        });
+      }
+
+      // TODO: add persona access gate when calling context is available.
+      const rooms = getRoomList();
+      for (const roomSummary of rooms) {
+        const messages = getRoomMessages(roomSummary.id);
+        const idx = messages.findIndex(m => m.id === id);
+        if (idx === -1) continue;
+
+        const msg = messages[idx];
+        const roomDisplayName = getRoomDisplayName(roomSummary.id) ?? roomSummary.display_name;
+
+        const resolvePersonaName = (m: RoomMessage): string | undefined => {
+          if (m.role !== "persona" || !m.persona_id) return undefined;
+          const p = personas.find(pe => pe.id === m.persona_id);
+          return p?.display_name;
+        };
+
+        const beforeMsgs = messages
+          .slice(Math.max(0, idx - before), idx)
+          .map(m => stripRoomMessage(m, resolvePersonaName(m)));
+        const afterMsgs = messages
+          .slice(idx + 1, idx + 1 + after)
+          .map(m => stripRoomMessage(m, resolvePersonaName(m)));
+
+        console.log(`[fetch_message] found in room "${roomDisplayName}" at idx=${idx}`);
+        return JSON.stringify({
+          message: stripRoomMessage(msg, resolvePersonaName(msg)),
+          before: beforeMsgs,
+          after: afterMsgs,
+          persona: roomDisplayName,
+        });
+      }
+
+      console.log(`[fetch_message] message not found for id="${id}"`);
+      return JSON.stringify({ error: "Message not found" });
+    },
+  };
+}

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

@@ -0,0 +1,99 @@
+import type { ToolExecutor } from "../types.js";
+import type { Fact, Topic, Person, Quote, HumanEntity } from "../../types.js";
+
+interface PersonaSummary {
+  id: string;
+  display_name: string;
+}
+
+type SearchHumanData = (
+  query: string,
+  options?: { types?: Array<"fact" | "topic" | "person" | "quote">; limit?: number; recent?: boolean; persona_filter?: string }
+) => Promise<{ facts: Fact[]; topics: Topic[]; people: Person[]; quotes: Quote[] }>;
+
+type GetPersonaList = () => Promise<PersonaSummary[]>;
+
+type GetHuman = () => HumanEntity;
+
+export function createFindMemoryExecutor(searchHumanData: SearchHumanData, getPersonaList?: GetPersonaList, getHuman?: GetHuman): ToolExecutor {
+  return {
+    name: "find_memory",
+
+    async execute(args: Record<string, unknown>): Promise<string> {
+      const query = typeof args.query === "string" ? args.query.trim() : "";
+      const recent = args.recent === true;
+      const personaArg = typeof args.persona === "string" ? args.persona.trim() : "";
+      console.log(`[find_memory] called with query="${query}", types=${JSON.stringify(args.types ?? null)}, limit=${args.limit ?? 10}, recent=${recent}, persona="${personaArg}"`);
+
+      if (!query && !recent) {
+        console.warn("[find_memory] missing query argument");
+        return JSON.stringify({ error: "Missing required argument: query (or use recent: true)" });
+      }
+
+      const typeMap: Record<string, "fact" | "topic" | "person" | "quote"> = {
+        fact: "fact", facts: "fact",
+        topic: "topic", topics: "topic",
+        person: "person", people: "person",
+        quote: "quote", quotes: "quote",
+      };
+
+      const types = Array.isArray(args.types)
+        ? (args.types
+            .filter((t): t is string => typeof t === "string")
+            .map(t => typeMap[t])
+            .filter((t): t is "fact" | "topic" | "person" | "quote" => t !== undefined)
+            .filter((v, i, a) => a.indexOf(v) === i)
+          )
+        : undefined;
+
+      const limit = typeof args.limit === "number" && args.limit > 0 ? Math.min(args.limit, 20) : 10;
+
+      // Resolve persona display_name to ID
+      let persona_filter: string | undefined;
+      if (personaArg && getPersonaList) {
+        const personas = await getPersonaList();
+        const match = personas.find(p => p.display_name.toLowerCase() === personaArg.toLowerCase());
+        if (match) {
+          persona_filter = match.id;
+          console.log(`[find_memory] resolved persona "${personaArg}" to ID "${persona_filter}"`);
+        } else {
+          console.warn(`[find_memory] persona "${personaArg}" not found, proceeding without filter`);
+        }
+      }
+
+      const results = await searchHumanData(query, { types, limit, recent, persona_filter });
+
+      const total = results.facts.length + results.topics.length + results.people.length + results.quotes.length;
+      console.log(`[find_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 => ({ 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.quotes.length > 0) {
+        const human = getHuman ? getHuman() : null;
+        output.quotes = results.quotes.map(q => {
+          const linked_items: Array<{ id: string; name: string; type: string }> = [];
+          if (human && q.data_item_ids.length > 0) {
+            for (const itemId of q.data_item_ids) {
+              const fact = human.facts.find(f => f.id === itemId);
+              if (fact) { linked_items.push({ id: fact.id, name: fact.name, type: "fact" }); continue; }
+              const topic = human.topics.find(t => t.id === itemId);
+              if (topic) { linked_items.push({ id: topic.id, name: topic.name, type: "topic" }); continue; }
+              const person = human.people.find(p => p.id === itemId);
+              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 };
+        });
+      }
+
+      if (Object.keys(output).length === 0) {
+        return JSON.stringify({ result: "No relevant memories found for this query." });
+      }
+
+      return JSON.stringify(output);
+    },
+  };
+}

package/src/core/tools/index.ts

@@ -18,6 +18,77 @@ import { webFetchExecutor } from "./builtin/web-fetch.js";
 /** Hard upper limit on total tool calls per interaction, regardless of individual limits. */
 export const HARD_TOOL_CALL_LIMIT = 10;
 
+/**
+ * System tools — injected unconditionally into every LLM call that uses tools.
+ * NOT stored in state.json. NOT user-configurable. Do NOT count against HARD_TOOL_CALL_LIMIT.
+ * Enforce their own per-tool limits via max_calls_per_interaction.
+ */
+export const SYSTEM_TOOLS: ToolDefinition[] = [
+  {
+    id: "builtin-find-memory",
+    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).",
+    input_schema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "What to search for" },
+        types: { type: "array", items: { type: "string", enum: ["facts", "topics", "people", "quotes"] }, description: "Filter to specific types" },
+        limit: { type: "number", description: "Max results (1-20, default 10)" },
+        recent: { type: "boolean", description: "Sort by most recently mentioned instead of relevance" },
+        persona: { type: "string", description: "Filter to what a specific persona has learned. Use their display name." },
+      },
+      required: ["query"],
+    },
+    runtime: "any",
+    builtin: true,
+    enabled: true,
+    created_at: new Date(0).toISOString(),
+    max_calls_per_interaction: 3,
+  },
+  {
+    id: "builtin-fetch-memory",
+    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.",
+    input_schema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "The ID of the memory to retrieve" },
+      },
+      required: ["id"],
+    },
+    runtime: "any",
+    builtin: true,
+    enabled: true,
+    created_at: new Date(0).toISOString(),
+    max_calls_per_interaction: 10,
+  },
+  {
+    id: "builtin-fetch-message",
+    provider_id: "ei",
+    name: "fetch_message",
+    display_name: "Fetch Message",
+    description: "Retrieve a specific message by its ID, with optional surrounding context. Use when find_memory returns a quote with a message_id and you want to read the original conversation, or when a temporal anchor references a message ID. The 'before' and 'after' parameters return that many additional messages for context (default 0).",
+    input_schema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "The message ID to retrieve" },
+        before: { type: "number", description: "Number of preceding messages to include for context (default 0)" },
+        after: { type: "number", description: "Number of following messages to include for context (default 0)" },
+      },
+      required: ["id"],
+    },
+    runtime: "any",
+    builtin: true,
+    enabled: true,
+    created_at: new Date(0).toISOString(),
+    max_calls_per_interaction: 5,
+  },
+];
+
 /** Default max calls per tool if not set on the ToolDefinition. */
 const DEFAULT_MAX_CALLS = 3;
 
@@ -32,7 +103,7 @@ export function registerExecutor(executor: ToolExecutor): void {
   executorRegistry.set(executor.name, executor);
 }
 
-// Register builtins. read_memory is registered lazily via registerReadMemoryExecutor()
+// Register builtins. find_memory is registered lazily via registerFindMemoryExecutor()
 // because it requires Processor.searchHumanData injection.
 registerExecutor(tavilyWebSearchExecutor);
 registerExecutor(tavilyNewsSearchExecutor);
@@ -42,10 +113,18 @@ registerExecutor(webFetchExecutor);
 // file_read and list_directory are registered lazily via registerFileReadExecutor() — Node/TUI only.
 
 /**
- * Register the read_memory executor — called by Processor after it's initialized,
+ * Register the find_memory executor — called by Processor after it's initialized,
  * injecting its own searchHumanData method to avoid circular imports.
  */
-export function registerReadMemoryExecutor(executor: ToolExecutor): void {
+export function registerFindMemoryExecutor(executor: ToolExecutor): void {
+  executorRegistry.set(executor.name, executor);
+}
+
+export function registerFetchMemoryExecutor(executor: ToolExecutor): void {
+  executorRegistry.set(executor.name, executor);
+}
+
+export function registerFetchMessageExecutor(executor: ToolExecutor): void {
   executorRegistry.set(executor.name, executor);
 }
 
@@ -122,7 +201,9 @@ export async function executeToolCalls(
   const toolsByName = new Map(tools.map(t => [t.name, t]));
 
   for (const call of calls) {
-    if (totalCalls.count >= HARD_TOOL_CALL_LIMIT) {
+    const isSystemTool = SYSTEM_TOOLS.some(t => t.name === call.name);
+
+    if (!isSystemTool && totalCalls.count >= HARD_TOOL_CALL_LIMIT) {
       console.log(`[Tools] Hard limit (${HARD_TOOL_CALL_LIMIT}) reached — skipping remaining tool calls`);
       break;
     }
@@ -168,7 +249,9 @@ export async function executeToolCalls(
     }
 
     callCounts.set(call.name, currentCount + 1);
-    totalCalls.count++;
+    if (!isSystemTool) {
+      totalCalls.count++;
+    }
 
     const newCount = currentCount + 1;
     if (newCount >= maxCalls) {

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/integrations/claude-code/importer.ts

@@ -11,6 +11,10 @@ import {
   queueAllScans,
   type ExtractionContext,
 } from "../../core/orchestrators/human-extraction.js";
+import {
+  queuePersonRewritePhase,
+  queueTopicRewritePhase,
+} from "../../core/orchestrators/ceremony.js";
 import { isProcessRunning } from "../process-check.js";
 import { getMachineId } from "../machine-id.js";
 
@@ -268,6 +272,8 @@ export async function importClaudeCodeSessions(
       sources: [`claudecode:${getMachineId()}:${targetSession.id}`],
     };
 
+    queuePersonRewritePhase(stateManager);
+    queueTopicRewritePhase(stateManager);
     const ccSettings = stateManager.getHuman().settings?.claudeCode;
     queueAllScans(context, stateManager, {
       extraction_model: ccSettings?.extraction_model,

package/src/integrations/cursor/importer.ts

@@ -13,6 +13,10 @@ import {
   queueAllScans,
   type ExtractionContext,
 } from "../../core/orchestrators/human-extraction.js";
+import {
+  queuePersonRewritePhase,
+  queueTopicRewritePhase,
+} from "../../core/orchestrators/ceremony.js";
 
 export interface CursorImportResult {
   sessionsProcessed: number;
@@ -227,6 +231,8 @@ export async function importCursorSessions(
       sources: [`cursor:${getMachineId()}:${targetSession.id}`],
     };
 
+    queuePersonRewritePhase(stateManager);
+    queueTopicRewritePhase(stateManager);
     queueAllScans(context, stateManager, { external_filter: "only" });
     result.extractionScansQueued += 4;
   }

package/src/integrations/document/unsource.ts

@@ -150,13 +150,15 @@ export async function executeUnsource(
     stateManager.messages_remove("emmet", sourceMessageIds);
   }
 
-  const filename = preview.sourceTag.startsWith("import:document:")
+  const key = preview.sourceTag.startsWith("import:document:")
     ? preview.sourceTag.slice("import:document:".length)
-    : preview.sourceTag;
+    : preview.sourceTag.startsWith("generate:document:")
+      ? preview.sourceTag.slice("generate:document:".length)
+      : preview.sourceTag;
 
   const human = stateManager.getHuman();
   if (human.settings?.document?.processed_documents) {
-    delete human.settings.document.processed_documents[filename];
+    delete human.settings.document.processed_documents[key];
     stateManager.setHuman(human);
   }
 

package/src/integrations/opencode/importer.ts

@@ -8,6 +8,10 @@ import {
   queueAllScans,
   type ExtractionContext,
 } from "../../core/orchestrators/human-extraction.js";
+import {
+  queuePersonRewritePhase,
+  queueTopicRewritePhase,
+} from "../../core/orchestrators/ceremony.js";
 import { isProcessRunning } from "../process-check.js";
 import { getMachineId } from "../machine-id.js";
 
@@ -195,6 +199,7 @@ export async function importOpenCodeSessions(
 
   const cutoffIso = processedSessions[targetSession.id] ?? null;
   const cutoffMs = cutoffIso ? new Date(cutoffIso).getTime() : null;
+  let anyPersonaHasChanges = false;
 
   for (const [, { persona, msgs: agentMsgs, isNew, agentName }] of byPersonaId) {
     if (isNew) {
@@ -252,6 +257,7 @@ export async function importOpenCodeSessions(
       };
 
       if (!signal?.aborted) {
+        anyPersonaHasChanges = true;
         const openCodeSettings = stateManager.getHuman().settings?.opencode;
         queueAllScans(context, stateManager, {
           extraction_model: openCodeSettings?.extraction_model,
@@ -264,7 +270,13 @@ export async function importOpenCodeSessions(
 
   result.sessionsProcessed = 1;
 
-  // ─── Step 6: Advance extraction state ────────────────────────────────
+  // ─── Step 6: Queue rewrite checks if any persona had new messages ─────
+  if (anyPersonaHasChanges && !signal?.aborted) {
+    queuePersonRewritePhase(stateManager);
+    queueTopicRewritePhase(stateManager);
+  }
+
+  // ─── Step 7: Advance extraction state ────────────────────────────────
   updateExtractionState(stateManager, targetSession);
 
   console.log(

package/src/integrations/persona-history/importer.ts

@@ -3,8 +3,13 @@ import type { Message } from "../../core/types.js";
 import {
   queueTopicScan,
   queuePersonScan,
+  queueFactFind,
   type ExtractionContext,
 } from "../../core/orchestrators/human-extraction.js";
+import {
+  queuePersonRewritePhase,
+  queueTopicRewritePhase,
+} from "../../core/orchestrators/ceremony.js";
 
 export interface PersonaHistoryImportResult {
   daysQueued: number;
@@ -101,11 +106,12 @@ export async function importPersonaHistory(
     };
 
     const extractionModel = settings?.extraction_model;
+    queueFactFind(context, stateManager, { extraction_model: extractionModel });
     queueTopicScan(context, stateManager, { extraction_model: extractionModel });
     queuePersonScan(context, stateManager, { extraction_model: extractionModel });
 
     result.personasProcessed++;
-    result.scansQueued += 2;
+    result.scansQueued += 3;
   }
 
   for (const room of Object.values((stateManager.getStorageState() as any).rooms ?? {})) {
@@ -139,6 +145,11 @@ export async function importPersonaHistory(
 
   result.daysQueued = 1;
 
+  if (result.scansQueued > 0) {
+    queuePersonRewritePhase(stateManager);
+    queueTopicRewritePhase(stateManager);
+  }
+
   const isLastDay = currentDate >= today;
   advanceProgress(stateManager, currentDate, isLastDay);