ei-tui 1.0.0 → 1.1.0

package/src/core/state-manager.ts

@@ -1054,7 +1054,7 @@ export class StateManager {
   tools_getForPersona(personaId: string, isTUI: boolean): ToolDefinition[] {
     const persona = this.personaState.getById(personaId);
     if (!persona?.tools?.length) {
-      console.log(`[Tools] tools_getForPersona(${personaId}): persona has no assigned tools`);
+      console.debug(`[Tools] tools_getForPersona(${personaId}): persona has no assigned tools`);
       return [];
     }
     const assignedIds = new Set(persona.tools);
@@ -1077,13 +1077,13 @@ export class StateManager {
     if (result.length < assignedIds.size) {
       for (const id of assignedIds) {
         const tool = this.tools.find(t => t.id === id);
-        if (!tool) { console.log(`[Tools] tools_getForPersona: assigned tool id=${id} not found in registry`); continue; }
-        if (!tool.enabled) { console.log(`[Tools] tools_getForPersona: tool "${tool.name}" is disabled`); continue; }
-        if (!enabledProviderIds.has(tool.provider_id)) { console.log(`[Tools] tools_getForPersona: tool "${tool.name}" provider is disabled`); continue; }
-        if (!(tool.runtime === "any" || (tool.runtime === "node" && isTUI))) { console.log(`[Tools] tools_getForPersona: tool "${tool.name}" runtime "${tool.runtime}" not available (isTUI=${isTUI})`); continue; }
+        if (!tool) { console.debug(`[Tools] tools_getForPersona: assigned tool id=${id} not found in registry`); continue; }
+        if (!tool.enabled) { console.debug(`[Tools] tools_getForPersona: tool "${tool.name}" is disabled`); continue; }
+        if (!enabledProviderIds.has(tool.provider_id)) { console.debug(`[Tools] tools_getForPersona: tool "${tool.name}" provider is disabled`); continue; }
+        if (!(tool.runtime === "any" || (tool.runtime === "node" && isTUI))) { console.debug(`[Tools] tools_getForPersona: tool "${tool.name}" runtime "${tool.runtime}" not available (isTUI=${isTUI})`); continue; }
       }
     }
-    console.log(`[Tools] tools_getForPersona(${personaId}): resolved ${result.length}/${assignedIds.size} tools: [${result.map(t => t.name).join(", ")}]`);
+    console.debug(`[Tools] tools_getForPersona(${personaId}): resolved ${result.length}/${assignedIds.size} tools: [${result.map(t => t.name).join(", ")}]`);
     return result;
   }
 

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);
+    },
+  };
+}

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: 3,
+  },
+  {
+    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/integrations/persona-history/importer.ts

@@ -3,6 +3,7 @@ import type { Message } from "../../core/types.js";
 import {
   queueTopicScan,
   queuePersonScan,
+  queueFactFind,
   type ExtractionContext,
 } from "../../core/orchestrators/human-extraction.js";
 
@@ -101,11 +102,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 ?? {})) {

package/src/prompts/ceremony/dedup.ts

@@ -20,7 +20,7 @@ export function buildDedupPrompt(data: DedupPromptData): { system: string; user:
 You are working with Opus 4.6 constraints. These rules prevent overthinking and ensure decisive action:
 
 ### 1. TOOL BUDGET
-- You have **6 \`read_memory\` calls** for this cluster
+- You have **6 \`find_memory\` calls** for this cluster
 - Prioritize: verify ambiguous relationships > check parent concepts > validate new entities
 - After 6 calls, make decisions with available information
 - Do NOT waste calls re-checking pairs you already examined
@@ -55,7 +55,7 @@ You are acting as the curator for a user's internal database. You have been give
 
 Your secondary directive is to ORGANIZE IT into small, non-repetitive components. The user NEEDS the data, but the data is used by AI agents, so duplication limits usefulness—agents waste tokens re-reading the same information under different names.
 
-You have access to a tool called \`read_memory\` (6 calls max — see HARD RULES above). Use it strategically to verify relationships, check for related records, or gather context before making merge decisions.
+You have access to a tool called \`find_memory\` (6 calls max — see HARD RULES above). Use it strategically to verify relationships, check for related records, or gather context before making merge decisions.
 
 ### Decision Process:
 1. **Identify true duplicates**: Examine each record. Are these genuinely the same thing with different wording (85%+ core meaning overlap), or are they distinct but related concepts?
@@ -94,7 +94,7 @@ ${buildRecordFormatExamples(data.itemType)}
 - Every removed record MUST have "replaced_by" pointing to the canonical record that absorbed its data.
 - The "update" array should contain AT LEAST ONE record (the canonical/merged one), even if all others are removed.
 - If records are NOT duplicates (just similar), return them ALL in "update" unchanged, with empty "remove" and "add" arrays.
-- Use \`read_memory\` strategically (6 calls max) to check for related records or gather context before making irreversible merge decisions.`;
+- Use \`find_memory\` strategically (6 calls max) to check for related records or gather context before making irreversible merge decisions.`;
 
   const payload = JSON.stringify({
     cluster: data.cluster.map(stripEmbedding),

package/src/prompts/ceremony/types.ts

@@ -15,7 +15,7 @@ export interface RewriteScanPromptData {
 /** Phase 1 output: array of subject strings (parsed from LLM JSON response). */
 export type RewriteScanResult = string[];
 
-/** A single subject and the read_memory matches found for it. */
+/** A single subject and the find_memory matches found for it. */
 export interface RewriteSubjectMatch {
   searchTerm: string;
   matches: DataItemBase[];  // Top 3 from searchHumanData, may be empty

package/src/prompts/human/person-scan.ts

@@ -93,6 +93,19 @@ If you are unsure of the type, use \`Nickname\` as a fallback. Do NOT invent typ
 
 Only include \`identifiers\` when explicitly mentioned in the conversation — omit it entirely if nothing qualifies.
 
+## Confidence & Relationship Type
+
+For each person, rate how important they are to the human user's life:
+
+- \`confidence\`: integer 1–5
+  - 1–2 = mentioned in passing, single event, no ongoing relevance
+  - 3 = unclear significance — may matter, may not
+  - 4–5 = clearly important, recurring presence, meaningful relationship
+- \`relationship_type\`: one of \`"family"\` | \`"friend"\` | \`"colleague"\` | \`"acquaintance"\` | \`"transactional"\` | \`"unknown"\`
+  - Use \`"transactional"\` when the person appeared only in the context of a single transaction (purchase, sale, support ticket, delivery)
+
+Use the full range. Most extractions should score 1–3. A confidence of 4–5 means this person genuinely matters to the user's life.
+
 ## Output Format
 
 \`\`\`json
@@ -105,6 +118,8 @@ Only include \`identifiers\` when explicitly mentioned in the conversation — o
       ],
       "description": "1-2 sentences: who this person is and their role in the user's life",
       "relationship": "Father|Mother|Brother|Son|Friend|Coworker|Self|etc.",
+      "relationship_type": "family|friend|colleague|acquaintance|transactional|unknown",
+      "confidence": 4,
       "reason": "Evidence from the conversation that justified flagging this person"
     }
   ]
@@ -143,6 +158,8 @@ Scan the "Most Recent Messages" for PEOPLE in the human user's life.
       "identifiers": [{ "type": "GitHub", "value": "handle" }],
       "description": "1-2 sentences: who this person is and their role in the user's life",
       "relationship": "Father|Mother|Brother|Son|Friend|Coworker|Self|etc.",
+      "relationship_type": "family|friend|colleague|acquaintance|transactional|unknown",
+      "confidence": 4,
       "reason": "Evidence from the conversation that justified flagging this person"
     }
   ]

package/src/prompts/human/types.ts

@@ -55,11 +55,15 @@ export interface TopicScanCandidate {
   reason: string;
 }
 
+export type PersonRelationshipType = "family" | "friend" | "colleague" | "acquaintance" | "transactional" | "unknown";
+
 export interface PersonScanCandidate {
   name: string;
   identifiers?: Array<{ type: string; value: string; is_primary?: boolean }>;
   description: string;
   relationship: string;
+  relationship_type?: PersonRelationshipType;
+  confidence?: number;
   reason: string;
 }
 

package/src/prompts/response/sections.ts

@@ -464,21 +464,28 @@ export function buildTemporalAnchorsSection(anchors: TemporalAnchor[], humanName
 
   const formatted = anchors.map(a => {
     const speaker = a.role === "human" ? humanName : "You";
-    let text: string;
-    if (a._synthesis && a.content) {
-      text = `[${humanName} used your conversation to generate an image. The full prompt was: "${a.content}"]`;
+    let preview: string;
+    if (a._synthesis) {
+      const raw = a.content ?? "";
+      const firstSentenceEnd = raw.search(/\.\s/);
+      const snippet = firstSentenceEnd > 0 && firstSentenceEnd <= 120
+        ? raw.slice(0, firstSentenceEnd + 1)
+        : raw.slice(0, 100);
+      preview = `[${humanName} generated an image: "${snippet}…"]`;
     } else if (a.silence_reason) {
       const silentParty = a.role === "human" ? humanName : "You";
-      text = `${silentParty} chose not to respond because: ${a.silence_reason}`;
+      const truncated = a.silence_reason.length > 80 ? `${a.silence_reason.slice(0, 80)}…` : a.silence_reason;
+      preview = `${silentParty} chose not to respond: "${truncated}"`;
     } else {
-      text = a.content ?? "";
+      const raw = a.content ?? "";
+      preview = raw.length > 80 ? `${raw.slice(0, 80)}…` : raw;
     }
-    return `[${formatTimestamp(a.timestamp)}] ${speaker}: ${text}`;
+    return `[${formatTimestamp(a.timestamp)}] ${speaker}: ${preview}\n  → fetch_message("${a.id}") for full content`;
   }).join("\n\n");
 
   return `## Temporal Anchors
 
-These are pinned moments from your shared history — preserved across context windows as part of who you are:
+Pinned moments from your shared history. These are snapshots — use fetch_message(id) if one feels relevant to pull the full memory:
 
 ${formatted}`;
 }

package/src/prompts/response/types.ts

@@ -8,6 +8,7 @@ import type { ToolDefinition } from "../../core/types.js";
 import type { PersonaEntity } from "../../core/types/entities.js";
 
 export interface TemporalAnchor {
+  id: string;
   role: "human" | "system";
   content?: string;
   silence_reason?: string;

package/tui/README.md

@@ -168,9 +168,10 @@ Rooms have three modes, set at creation time:
 | `XDG_DATA_HOME` | `~/.local/share` | XDG base directory. Ignored if `EI_DATA_PATH` is set. |
 | `EI_SYNC_USERNAME` | — | Username for remote sync. If set at startup, bootstraps sync credentials automatically (useful for dotfiles/scripts). |
 | `EI_SYNC_PASSPHRASE` | — | Passphrase for remote sync. Paired with `EI_SYNC_USERNAME`. |
-| `EDITOR` / `VISUAL` | `vi` | Editor opened by `/details`, `/me`, `/settings`, `/context`, `/quotes`, etc. Falls back to `VISUAL` if `EDITOR` is unset. |
+| `EI_LOG_LEVEL` | `warn` | Log verbosity written to `tui.log`: `error`, `warn`, `info`, `debug`. |
+| `EI_DEBUG_NETWORK_VERBOSE` | — | Set to `1` to dump full LLM request/response payloads as JSON files under `$EI_DATA_PATH/logs/`. One file per call, named `TIMESTAMP_callN_STEP.json`. |
 
-> **Tip**: `tail -f $EI_DATA_PATH/tui.log` to watch live debug output.
+> **Tip**: `tail -f $EI_DATA_PATH/tui.log` to watch live TUI output. Set `EI_LOG_LEVEL=info` to see LLM call summaries (model, latency, token counts). Set `EI_DEBUG_NETWORK_VERBOSE=1` to dump full request/response payloads to `$EI_DATA_PATH/logs/`.
 
 
 # Development

package/tui/src/util/logger.ts

@@ -22,7 +22,7 @@ const LOG_LEVELS: Record<LogLevel, number> = {
   error: 3,
 };
 
-const currentLevel: LogLevel = (Bun.env.EI_LOG_LEVEL as LogLevel) || "debug";
+const currentLevel: LogLevel = (Bun.env.EI_LOG_LEVEL as LogLevel) || "warn";
 
 function shouldLog(level: LogLevel): boolean {
   return LOG_LEVELS[level] >= LOG_LEVELS[currentLevel];