ei-tui 0.1.25 → 0.3.1

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,
@@ -109,6 +108,7 @@ const DEFAULT_LOOP_INTERVAL_MS = 100;
 const DEFAULT_CONTEXT_WINDOW_HOURS = 8;
 const DEFAULT_OPENCODE_POLLING_MS = 1800000;
 const DEFAULT_CLAUDE_CODE_POLLING_MS = 1800000;
+const DEFAULT_CURSOR_POLLING_MS = 1800000;
 
 let processorInstanceCount = 0;
 
@@ -129,6 +129,8 @@ export class Processor {
   private openCodeImportInProgress = false;
   private lastClaudeCodeSync = 0;
   private claudeCodeImportInProgress = false;
+  private lastCursorSync = 0;
+  private cursorImportInProgress = false;
   private pendingConflict: StateConflictData | null = null;
   private storage: Storage | null = null;
   private importAbortController = new AbortController();
@@ -191,10 +193,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();
@@ -273,19 +281,20 @@ export class Processor {
         name: "read_memory",
         display_name: "Read Memory",
         description:
-          "Search your personal memory for relevant facts, traits, topics, people, or quotes. Use this when you need information about the user that may not be in the current conversation.",
+          "Search your personal memory for relevant facts, topics, people, or quotes. Use this when you need information about the user that may not be in the current conversation. Use `recent: true` to retrieve what's been discussed recently.",
         input_schema: {
           type: "object",
           properties: {
             query: { type: "string", description: "What to search for in memory" },
             types: {
               type: "array",
-              items: { type: "string", enum: ["fact", "trait", "topic", "person", "quote"] },
+              items: { type: "string", enum: ["fact", "topic", "person", "quote"] },
               description: "Limit search to specific memory types (default: all types)",
             },
             limit: { type: "number", description: "Max results to return (default: 10, max: 20)" },
+            recent: { type: "boolean", description: "If true, return recently-mentioned results sorted by last_mentioned date instead of relevance. Combine with a query to filter recent results by topic." },
           },
-          required: ["query"],
+          required: [],
         },
         runtime: "any",
         builtin: true,
@@ -571,6 +580,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 +766,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?.();
   }
 
@@ -796,6 +880,14 @@ const toolNextSteps = new Set([
       await this.checkAndSyncClaudeCode(human, now);
     }
 
+    if (
+      this.isTUI &&
+      human.settings?.cursor?.integration &&
+      this.stateManager.queue_length() === 0
+    ) {
+      await this.checkAndSyncCursor(human, now);
+    }
+
     if (human.settings?.ceremony && shouldStartCeremony(human.settings.ceremony, this.stateManager)) {
       if (human.settings?.sync && remoteSync.isConfigured()) {
         const state = this.stateManager.getStorageState();
@@ -982,6 +1074,59 @@ const toolNextSteps = new Set([
       });
   }
 
+  private async checkAndSyncCursor(human: HumanEntity, now: number): Promise<void> {
+    if (this.cursorImportInProgress) {
+      return;
+    }
+
+    const cursor = human.settings?.cursor;
+    const pollingInterval = cursor?.polling_interval_ms ?? DEFAULT_CURSOR_POLLING_MS;
+    const lastSync = cursor?.last_sync ? new Date(cursor.last_sync).getTime() : 0;
+    const timeSinceSync = now - lastSync;
+
+    if (timeSinceSync < pollingInterval && this.lastCursorSync > 0) {
+      return;
+    }
+
+    this.lastCursorSync = now;
+    const syncTimestamp = new Date().toISOString();
+    this.stateManager.setHuman({
+      ...this.stateManager.getHuman(),
+      settings: {
+        ...this.stateManager.getHuman().settings,
+        cursor: {
+          ...cursor,
+          last_sync: syncTimestamp,
+        },
+      },
+    });
+
+    this.cursorImportInProgress = true;
+    import("../integrations/cursor/importer.js")
+      .then(({ importCursorSessions }) =>
+        importCursorSessions({
+          stateManager: this.stateManager,
+          interface: this.interface,
+          signal: this.importAbortController.signal,
+        })
+      )
+      .then((result) => {
+        if (result.sessionsProcessed > 0) {
+          console.log(
+            `[Processor] Cursor sync complete: ${result.sessionsProcessed} sessions, ` +
+              `${result.topicsCreated} topics created, ${result.messagesImported} messages imported, ` +
+              `${result.extractionScansQueued} extraction scans queued`
+          );
+        }
+      })
+      .catch((err) => {
+        console.warn(`[Processor] Cursor sync failed:`, err);
+      })
+      .finally(() => {
+        this.cursorImportInProgress = false;
+      });
+  }
+
   private classifyLLMError(error: string): string {
     const match = error.match(/\((\d{3})\)/);
     if (match) {
@@ -1093,7 +1238,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 +1250,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 +1417,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 +1429,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 +1461,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; recent?: boolean } = {}
   ): 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

@@ -1,16 +1,10 @@
-/**
- * read_memory builtin tool
- *
- * Delegates to Processor.searchHumanData() — no external call, runtime: "any".
- * 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; recent?: boolean }
+) => Promise<{ facts: Fact[]; topics: Topic[]; people: Person[]; quotes: Quote[] }>;
 
 export function createReadMemoryExecutor(searchHumanData: SearchHumanData): ToolExecutor {
   return {
@@ -18,28 +12,29 @@ export function createReadMemoryExecutor(searchHumanData: SearchHumanData): Tool
 
     async execute(args: Record<string, unknown>): Promise<string> {
       const query = typeof args.query === "string" ? args.query.trim() : "";
-      console.log(`[read_memory] called with query="${query}", types=${JSON.stringify(args.types ?? null)}, limit=${args.limit ?? 10}`);
-      if (!query) {
+      const recent = args.recent === true;
+      console.log(`[read_memory] called with query="${query}", types=${JSON.stringify(args.types ?? null)}, limit=${args.limit ?? 10}, recent=${recent}`);
+
+      if (!query && !recent) {
         console.warn("[read_memory] missing query argument");
-        return JSON.stringify({ error: "Missing required argument: query" });
+        return JSON.stringify({ error: "Missing required argument: query (or use recent: true)" });
       }
 
       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 results = await searchHumanData(query, { types, limit, recent });
 
-      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 }));