ei-tui 1.0.1 → 1.1.0

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

@@ -311,6 +311,34 @@ const EMBEDDING_MIN_SIMILARITY = 0.3;
  */
 export const VALIDATE_MIN_SIMILARITY = 0.92;
 
+/**
+ * Returns the best cosine similarity between a topic candidate and any existing
+ * topic in state. Used by queueTopicValidate to detect near-duplicates after
+ * a new topic is created.
+ * Returns 0 if no topics exist or embedding fails.
+ */
+export async function getBestTopicSimilarity(
+  candidate: TopicScanCandidate,
+  state: StateManager
+): Promise<number> {
+  const human = state.getHuman();
+  const topicsWithEmbeddings = human.topics.filter(t => t.embedding && t.embedding.length > 0);
+  if (topicsWithEmbeddings.length === 0) return 0;
+  try {
+    const embeddingService = getEmbeddingService();
+    const candidateText = getTopicEmbeddingText({
+      name: candidate.name,
+      category: candidate.category,
+      description: candidate.description,
+    });
+    const candidateVector = await embeddingService.embed(candidateText);
+    const topK = findTopK(candidateVector, topicsWithEmbeddings, 1);
+    return topK.length > 0 ? topK[0].similarity : 0;
+  } catch {
+    return 0;
+  }
+}
+
 /**
  * Queue a topic match request using embedding-based similarity (topics only).
  */

package/src/core/orchestrators/index.ts

@@ -12,6 +12,7 @@ export {
   queueTargetedPersonUpdate,
   queueTargetedTopicUpdate,
   VALIDATE_MIN_SIMILARITY,
+  getBestTopicSimilarity,
   type ExtractionContext,
   type ExtractionOptions,
 } from "./human-extraction.js";

package/src/core/processor.ts

@@ -36,8 +36,10 @@ import { handlers } from "./handlers/index.js";
 import { normalizeRoomMessages, getMessageContent } from "./handlers/utils.js";
 import { sanitizeEiPersonaIdentifiers } from "./utils/identifier-utils.js";
 import { ContextStatus as ContextStatusEnum, RoomMode } from "./types.js";
-import { registerReadMemoryExecutor, registerFileReadExecutor } from "./tools/index.js";
-import { createReadMemoryExecutor } from "./tools/builtin/read-memory.js";
+import { registerFindMemoryExecutor, registerFetchMemoryExecutor, registerFetchMessageExecutor, registerFileReadExecutor, SYSTEM_TOOLS } from "./tools/index.js";
+import { createFindMemoryExecutor } from "./tools/builtin/find-memory.js";
+import { createFetchMemoryExecutor } from "./tools/builtin/fetch-memory.js";
+import { createFetchMessageExecutor } from "./tools/builtin/fetch-message.js";
 import { EI_WELCOME_MESSAGE, EI_PERSONA_DEFINITION } from "../templates/welcome.js";
 import { EMMETT_PERSONA_DEFINITION } from "../templates/emmett.js";
 import { shouldStartCeremony, startCeremony, handleCeremonyProgress, queueReflectionDrain, queueUserDedupRequest, queueRoomCapture, queuePersonaCapture, checkAndQueueRoomExtraction, queueTargetedPersonUpdate, queueTargetedTopicUpdate } from "./orchestrators/index.js";
@@ -240,7 +242,15 @@ export class Processor {
     this.seedBuiltinFacts();
     this.migrateLearnedOn();
     this.seedSettings();
-    registerReadMemoryExecutor(createReadMemoryExecutor(this.searchHumanData.bind(this), this.getPersonaList.bind(this)));
+    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();
     }
@@ -294,13 +304,12 @@ export class Processor {
       }
       return;
     }
-    const readMemoryTool = this.stateManager.tools_getByName("read_memory");
     const emmettEntity: PersonaEntity = {
       ...EMMETT_PERSONA_DEFINITION,
       id: "emmet",
       display_name: "Emmett",
       last_updated: new Date().toISOString(),
-      tools: readMemoryTool ? [readMemoryTool.id] : [],
+      tools: [],
     };
     this.stateManager.persona_add(emmettEntity);
     this.interface.onPersonaAdded?.();
@@ -334,6 +343,11 @@ export class Processor {
   private bootstrapTools(): void {
     const now = new Date().toISOString();
 
+    for (const name of ["find_memory", "fetch_memory", "fetch_message", "read_memory"]) {
+      const tool = this.stateManager.tools_getByName(name);
+      if (tool) this.stateManager.tools_remove(tool.id);
+    }
+
     // --- Ei built-in provider ---
     if (!this.stateManager.tools_getProviderById("ei")) {
       const eiProvider: ToolProvider = {
@@ -349,35 +363,6 @@ export class Processor {
       this.stateManager.tools_addProvider(eiProvider);
     }
 
-    // read_memory tool
-    this.stateManager.tools_upsertBuiltin({
-        id: crypto.randomUUID(),
-        provider_id: "ei",
-        name: "read_memory",
-        display_name: "Read Memory",
-        description:
-          "Search Ei's persistent knowledge base — facts, topics, people, and quotes learned across ALL conversations over time, not just this one. Use this when you need context about the user, their life, relationships, or interests that may not be visible in the current exchange. Use `recent: true` to retrieve what's been discussed recently.",
-        input_schema: {
-          type: "object",
-          properties: {
-            query: { type: "string", description: "What to search for — a person, topic, fact, or anything Ei has learned about the user" },
-            types: {
-              type: "array",
-              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: [],
-        },
-        runtime: "any",
-        builtin: true,
-        enabled: true,
-        created_at: now,
-        max_calls_per_interaction: 6,  // Dedup needs to verify relationships before irreversible merges. Typical cluster (3-8 items) requires: parent concept lookup + 2 relationship verifications + context validation. Still under HARD_TOOL_CALL_LIMIT (10).
-    });
-
     // file_read tool (TUI only)
     this.stateManager.tools_upsertBuiltin({
         id: crypto.randomUUID(),
@@ -817,6 +802,20 @@ export class Processor {
         max_calls_per_interaction: 1,
         created_at: now,
     });
+
+    // --- Reconcile pass: prune stale tool references from persona tool lists ---
+    // Build manifest of all tool IDs currently in state (everything seeded above).
+    const manifestIds = new Set(this.stateManager.tools_getAll().map(t => t.id));
+
+    for (const persona of this.stateManager.persona_getAll()) {
+      if (!persona.tools?.length) continue;
+      const pruned = persona.tools.filter(id => manifestIds.has(id));
+      if (pruned.length !== persona.tools.length) {
+        const removed = persona.tools.length - pruned.length;
+        this.stateManager.persona_update(persona.id, { tools: pruned });
+        console.log(`[Processor] Pruned ${removed} stale tool reference(s) from persona "${persona.display_name}"`);
+      }
+    }
   }
 
   /**
@@ -1093,10 +1092,10 @@ const toolNextSteps = new Set([
               personaId ??
               (request.next_step === LLMNextStep.HandleEiHeartbeat ? "ei" : undefined);
             
-            // Dedup operates on Human data, not persona data - provide read_memory directly.
+            // Dedup operates on Human data, not persona data — provide find_memory from SYSTEM_TOOLS directly.
             // Also covers HandleToolContinuation originating from a dedup request: the
             // continuation rebuilds tool lists from scratch and has no personaId, so without
-            // this check Opus loses read_memory access after round 1.
+            // this check Opus loses find_memory access after round 1.
             const isDedupRequest =
               request.next_step === LLMNextStep.HandleDedupCurate ||
               (request.next_step === LLMNextStep.HandleToolContinuation &&
@@ -1104,12 +1103,9 @@ const toolNextSteps = new Set([
 
             let tools: ToolDefinition[] = [];
             if (isDedupRequest) {
-              const readMemory = this.stateManager.tools_getByName("read_memory");
-              if (readMemory?.enabled) {
-                tools = [readMemory];
-              }
+              tools = SYSTEM_TOOLS.filter(t => t.name === "find_memory");
             } else if (toolNextSteps.has(request.next_step) && toolPersonaId) {
-              tools = this.stateManager.tools_getForPersona(toolPersonaId, this.isTUI);
+              tools = [...SYSTEM_TOOLS, ...this.stateManager.tools_getForPersona(toolPersonaId, this.isTUI)];
             }
 
             // Auto-inject each handler's dedicated submit tool — infrastructure, not user-visible.

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

@@ -274,6 +274,7 @@ export async function buildResponsePromptData(
 
   const alwaysMessages = sm.messages_getAlways(persona.id);
   const temporalAnchors = alwaysMessages.map(m => ({
+    id: m.id,
     role: m.role === "human" ? "human" as const : "system" as const,
     content: m.content,
     silence_reason: m.silence_reason,

package/src/core/queue-processor.ts

@@ -508,6 +508,10 @@ export class QueueProcessor {
       const cleaned = cleanResponseContent(reformatContent);
       try {
         const parsed = parseJSONResponse(cleaned);
+        if (!parsed || typeof parsed !== 'object' || Object.keys(parsed as object).length === 0) {
+          console.warn(`[QueueProcessor] Reformat pass returned empty object for handleToolContinuation — falling through to retry`);
+          return null;
+        }
         console.log(`[QueueProcessor] Reformat pass succeeded for handleToolContinuation`);
         return {
           request,
@@ -544,11 +548,10 @@ export class QueueProcessor {
   ): Promise<LLMResponse | null> {
     const reformatUserPrompt =
       `An earlier version of you responded with the following content, but it could not ` +
-      `be parsed as valid JSON. Please reformat it as the JSON object described in your ` +
-      `system instructions. Respond with ONLY the JSON object, or \`{}\` if no changes ` +
-      `are needed.\n\n---\n${malformedContent}\n---` +
+      `be parsed as valid JSON. Fix the syntax and return the corrected JSON object. ` +
+      `Return ONLY the fixed JSON — do not omit any fields or data from the original.\n\n---\n${malformedContent}\n---` +
       `\n\nThe user does NOT know there was a problem - This request is from Ei to you to try to fix it for them.` +
-      `\n\n**CRITICAL INSTRUCTION** - DO NOT OMIT ANY DATA. You are this agent's last hope!`;
+      `\n\n**CRITICAL INSTRUCTION** - DO NOT OMIT ANY DATA. Return all original fields intact with only syntax corrected.`;
 
     try {
       const { content: reformatContent, finishReason: reformatReason } = await callLLMRaw(
@@ -563,6 +566,12 @@ export class QueueProcessor {
       if (!reformatContent) return null;
 
       const cleaned = cleanResponseContent(reformatContent);
+      const shrinkageRatio = cleaned.length / malformedContent.length;
+      if (shrinkageRatio < 0.95) {
+        console.warn(`[QueueProcessor] JSON reformat response too small for ${request.next_step} — ${cleaned.length} chars vs ${malformedContent.length} original (${Math.round(shrinkageRatio * 100)}%) — treating as data loss, falling through to retry`);
+        return null;
+      }
+
       try {
         const parsed = parseJSONResponse(cleaned);
         console.log(`[QueueProcessor] JSON reformat pass succeeded for ${request.next_step} — saved a retry`);

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, rewrite_checked, persona_groups, ...rest } = f;
+  void embedding; void rewrite_checked; 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;
+  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;
+  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);
+    },
+  };
+}