ei-tui 0.9.2 → 0.9.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ei-tui",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "author": "Flare576",
   "repository": {
     "type": "git",
@@ -51,6 +51,22 @@
     "test:e2e:tui": "cd tui && npm run test:e2e",
     "test:e2e:ui": "playwright test --ui",
     "test:e2e:debug": "playwright test --debug",
+    "test:evals": "vite-node tests/evals/reflection-critic.eval.ts",
+    "test:evals:observe": "vite-node tests/evals/reflection-critic.observe.ts",
+    "test:evals:fact-find": "vite-node tests/evals/fact-find.eval.ts",
+    "test:evals:topic-scan": "vite-node tests/evals/topic-scan.eval.ts",
+    "test:evals:topic-match": "vite-node tests/evals/topic-match.eval.ts",
+    "test:evals:topic-update": "vite-node tests/evals/topic-update.eval.ts",
+    "test:evals:topic-validate": "vite-node tests/evals/topic-validate.eval.ts",
+    "test:evals:person-scan": "vite-node tests/evals/person-scan.eval.ts",
+    "test:evals:person-update": "vite-node tests/evals/person-update.eval.ts",
+    "test:evals:persona-trait": "vite-node tests/evals/persona-trait-extraction.eval.ts",
+    "test:evals:dedup": "vite-node tests/evals/dedup-tool-calls.eval.ts",
+    "test:evals:response-read-memory": "vite-node tests/evals/response-read-memory.eval.ts",
+    "test:evals:response-pending-update": "vite-node tests/evals/response-pending-update.eval.ts",
+    "test:evals:heartbeat-pending-update": "vite-node tests/evals/heartbeat-pending-update.eval.ts",
+    "test:evals:real-data": "vite-node tests/evals/real-data-example.eval.ts",
+    "test:evals:persona-data-check": "vite-node tests/evals/persona-data-check.eval.ts",
     "test:all": "npm run test && npm run test:e2e && npm run test:e2e:tui",
     "typecheck": "tsc --noEmit",
     "web": "cd web && npm run dev",

package/src/README.md

@@ -148,7 +148,7 @@ This is intentional. Concurrent LLM calls sound appealing until you're watching
 
 # Context Windows
 
-Personas don't send their entire message history to the LLM. By default, only messages from the last 8 hours are included (`context_window_hours`, configurable per persona). Older messages are still stored — they're just not in the prompt.
+Personas don't send their entire message history to the LLM. By default, only messages from the last 8 hours are included (`context_window_ms`, configurable per persona). Older messages are still stored — they're just not in the prompt.
 
 Message rolloff works differently: messages are kept until there are at least 200 of them _and_ any are older than 14 days. So a persona you chat with daily will roll off old messages gradually; one you chat with twice a year will keep everything.
 

package/src/cli/commands/personas.ts

@@ -1,4 +1,5 @@
-import { loadLatestState, retrievePersonas } from "../retrieval";
+import { loadLatestState, retrievePersonas, retrievePersonasSemantic } from "../retrieval";
+import { getEmbeddingService } from "../../core/embedding-service";
 import type { PersonaResult } from "../retrieval";
 
 export async function execute(query: string, limit: number, options: { recent?: boolean } = {}): Promise<PersonaResult[]> {
@@ -8,5 +9,13 @@ export async function execute(query: string, limit: number, options: { recent?:
     return [];
   }
 
-  return retrievePersonas(query, state, limit, options);
+  const nameResults = retrievePersonas(query, state, limit, options);
+  if (nameResults.length > 0 || !query || options.recent) {
+    return nameResults;
+  }
+
+  const embeddingService = getEmbeddingService();
+  const queryVector = await embeddingService.embed(query);
+  const semanticResults = await retrievePersonasSemantic(queryVector, state, limit);
+  return semanticResults;
 }

package/src/cli/mcp.ts

@@ -16,14 +16,14 @@ export function createMcpServer(): McpServer {
     "ei_search",
     {
       description:
-        "Search the user's Ei knowledge base — a persistent memory store built from conversations. Returns facts, people, topics of interest, and quotes. People results include an identifiers array (e.g. GitHub username, Discord handle, email, nickname) — query by any name or handle to find what Ei knows about that person. Results include entity IDs that can be passed back to ei_lookup for full detail. Omit query to browse by recency (use with recent=true or persona filter).",
+        "Search the user's Ei knowledge base — a persistent memory store built from conversations. Returns facts, people, topics of interest, quotes, and personas. People results include an identifiers array (e.g. GitHub username, Discord handle, email, nickname) — query by any name or handle to find what Ei knows about that person. Persona results include traits and topics that define the persona's identity and working style — use type='personas' with the persona's name OR a natural-language description of what they do to load a persona's character sheet. Results include entity IDs that can be passed back to ei_lookup for full detail. Omit query to browse by recency (use with recent=true or persona filter).",
       inputSchema: {
         query: z.string().optional().describe("Search text. Supports natural language. Omit to browse without semantic filtering — useful with recent=true or persona filter."),
         type: z
           .enum(["facts", "people", "topics", "quotes", "personas"])
           .optional()
           .describe(
-            "Filter to a specific data type. Omit to search all types (balanced across all 5)."
+            "Filter to a specific data type. Omit to search all types (balanced across all 5). For 'personas': matches by display name first, then falls back to semantic search of persona descriptions — use the persona's name (e.g. 'Sisyphus') or a description of their role (e.g. 'primary coding agent'). For 'people': semantic search on person descriptions. Note: 'personas' and 'people' are distinct — personas are AI agent identity records with traits/topics; people are human contacts."
           ),
         persona: z
           .string()

package/src/cli/retrieval.ts

@@ -234,11 +234,36 @@ export function retrievePersonas(
   }
 
   const q = query.toLowerCase();
-  return personaList
-    .filter((p) => p.display_name.toLowerCase().includes(q))
-    .sort((a, b) => b.last_updated.localeCompare(a.last_updated))
+  const nameMatches = personaList.filter((p) => p.display_name.toLowerCase().includes(q));
+  if (nameMatches.length > 0) {
+    return nameMatches
+      .sort((a, b) => b.last_updated.localeCompare(a.last_updated))
+      .slice(0, limit)
+      .map(mapPersona);
+  }
+
+  return [];
+}
+
+export async function retrievePersonasSemantic(
+  queryVector: number[],
+  state: StorageState,
+  limit: number = 10,
+): Promise<PersonaResult[]> {
+  const personaList = Object.values(state.personas).map((p) => p.entity);
+  const withEmbeddings = personaList
+    .filter((p): p is PersonaEntity & { description_embedding: number[] } => Array.isArray(p.description_embedding) && p.description_embedding.length > 0)
+    .map((p) => ({ id: p.id, embedding: p.description_embedding, _entity: p }));
+
+  if (withEmbeddings.length === 0) {
+    return [];
+  }
+
+  const scored = findTopK(queryVector, withEmbeddings, withEmbeddings.length);
+  return scored
+    .filter(({ similarity }) => similarity >= EMBEDDING_MIN_SIMILARITY)
     .slice(0, limit)
-    .map(mapPersona);
+    .map(({ item }) => mapPersona((item as typeof withEmbeddings[number])._entity));
 }
 
 export async function retrieveBalanced(
@@ -305,7 +330,10 @@ export async function retrieveBalanced(
       .sort((a, b) => recentDate(b.mapped as AnyItem).localeCompare(recentDate(a.mapped as AnyItem)))
       .slice(0, limit)
       .map(({ type, mapped }) => ({ type, ...mapped }) as BalancedResult);
-    const personaMatches = retrievePersonas(query, state, limit, { recent: true });
+    const personaMatches = [
+      ...retrievePersonas(query, state, limit, { recent: true }),
+      ...await retrievePersonasSemantic(queryVector, state, limit),
+    ].filter((p, i, arr) => arr.findIndex(x => x.id === p.id) === i);
     if (personaMatches.length > 0) {
       const combined = [
         ...personaMatches.map((p) => ({ type: "persona" as const, ...p }) as BalancedResult),
@@ -352,7 +380,10 @@ export async function retrieveBalanced(
   result.sort((a, b) => b.similarity - a.similarity);
 
   const embeddingFinal = result.map(({ type, mapped }) => ({ type, ...mapped }) as BalancedResult);
-  const personaFinal = retrievePersonas(query, state, limit);
+  const personaFinal = [
+    ...retrievePersonas(query, state, limit),
+    ...await retrievePersonasSemantic(queryVector, state, limit),
+  ].filter((p, i, arr) => arr.findIndex(x => x.id === p.id) === i);
   if (personaFinal.length > 0) {
     const combined = [
       ...personaFinal.map((p) => ({ type: "persona" as const, ...p }) as BalancedResult),
@@ -369,10 +400,12 @@ export async function lookupById(id: string): Promise<({ type: string } & Record
     return null;
   }
 
-  const found = crossFind(id, state.human);
+  const personaEntities = Object.values(state.personas).map((p) => p.entity);
+  const found = crossFind(id, state.human, personaEntities);
   if (!found) return null;
   const { type, ...rest } = found;
   const withoutEmbedding = { ...rest } as Record<string, unknown>;
   delete withoutEmbedding.embedding;
+  delete withoutEmbedding.description_embedding;
   return { type, ...withoutEmbedding };
 }

package/src/cli.ts

@@ -84,79 +84,50 @@ Examples:
 `);
 }
 
-function buildOpenCodeToolContent(): string {
-  const lines = [
-    'import { tool } from "@opencode-ai/plugin"',
-    '',
-    'export default tool({',
-    '  description: [',
-    '    "Search the user\'s Ei knowledge base \u2014 a persistent memory store built from conversations.",',
-    '    "Returns facts, people, topics of interest, and quotes.",',
-    '    "Use this to recall anything about the user: preferences, relationships, or past discussions.",',
-    '    "Results include entity IDs that can be passed back with lookup=true to get full detail.",',
-    '  ].join(" "),',
-    '  args: {',
-    '    query: tool.schema.string().optional().describe(',
-    '      "Search text, or an entity ID when lookup=true. Supports natural language. Omit to browse by recency."',
-    '    ),',
-    '    type: tool.schema',
-    '      .enum(["facts", "people", "topics", "quotes", "personas"])',
-    '      .optional()',
-    '      .describe(',
-    '        "Filter to a specific data type. Omit to search all types (balanced across all 4).",',
-    '      ),',
-    '    persona: tool.schema',
-    '      .string()',
-    '      .optional()',
-    '      .describe(',
-    '        "Filter to entities a specific persona has learned about. Use the persona display name.",',
-    '      ),',
-    '    limit: tool.schema',
-    '      .number()',
-    '      .int()',
-    '      .positive()',
-    '      .default(10)',
-    '      .optional()',
-    '      .describe("Maximum number of results to return. Default: 10."),',
-    '    lookup: tool.schema',
-    '      .boolean()',
-    '      .optional()',
-    '      .describe(',
-    '        "If true, treat query as an entity ID and return that single entity in full detail."',
-    '      ),',
-    '    recent: tool.schema',
-    '      .boolean()',
-    '      .optional()',
-    '      .describe(',
-    '        "If true, sort by most recently mentioned. Can be combined with persona or query."',
-    '      ),',
-    '  },',
-    '  async execute(args) {',
-    '    const cmd: string[] = ["ei"];',
-    '    if (args.lookup) {',
-    '      cmd.push("--id", args.query ?? "");',
-    '    } else {',
-    '      if (args.type) cmd.push(args.type);',
-    '      if (args.persona) cmd.push("--persona", args.persona);',
-    '      if (args.recent) cmd.push("--recent");',
-    '      if (args.limit && args.limit !== 10) cmd.push("-n", String(args.limit));',
-    '      if (args.query) cmd.push(args.query);',
-    '    }',
-    '    return Bun.$`${cmd}`.text();',
-    '  },',
-    '})',
-    '',
-  ];
-  return lines.join('\n');
-}
 
-async function installOpenCodeTool(): Promise<void> {
-  const toolsDir = join(process.env.HOME || "~", ".config", "opencode", "tools");
-  const toolPath = join(toolsDir, "ei.ts");
+async function installOpenCodeMcp(): Promise<void> {
+  const home = process.env.HOME || "~";
+  const opencodeDir = join(home, ".config", "opencode");
+  const opencodeJsoncPath = join(opencodeDir, "opencode.jsonc");
+
+  const eiDataPath = process.env.EI_DATA_PATH ?? (() => {
+    const xdgData = process.env.XDG_DATA_HOME || join(home, ".local", "share");
+    return join(xdgData, "ei");
+  })();
+
+  const mcpEntry = {
+    type: "local",
+    command: ["bunx", "ei-tui", "mcp"],
+    enabled: true,
+    environment: {
+      EI_DATA_PATH: eiDataPath,
+    },
+  };
+
+  let config: Record<string, unknown> = {};
+  try {
+    const rawText = await Bun.file(opencodeJsoncPath).text();
+    // Strip // line comments before parsing — opencode.jsonc uses line comments only
+    const stripped = rawText
+      .split("\n")
+      .map(line => line.replace(/\/\/.*$/, ""))
+      .join("\n");
+    config = JSON.parse(stripped) as Record<string, unknown>;
+  } catch {
+    // File doesn't exist or isn't valid — start fresh
+  }
+
+  const mcp = (config.mcp ?? {}) as Record<string, unknown>;
+  mcp["ei"] = mcpEntry;
+  config.mcp = mcp;
 
-  await Bun.$`mkdir -p ${toolsDir}`;
-  await Bun.write(toolPath, buildOpenCodeToolContent());
-  console.log(`✓ Installed Ei tool to ${toolPath}`);
+  await Bun.$`mkdir -p ${opencodeDir}`;
+  const tmpPath = `${opencodeJsoncPath}.ei-install.tmp`;
+  await Bun.write(tmpPath, JSON.stringify(config, null, 2) + "\n");
+  const { rename } = await import(/* @vite-ignore */ "fs/promises");
+  await rename(tmpPath, opencodeJsoncPath);
+
+  console.log(`✓ Installed Ei MCP server to ~/.config/opencode/opencode.jsonc`);
   console.log(`  Restart OpenCode to activate.`);
 }
 
@@ -257,8 +228,28 @@ async function main(): Promise<void> {
   }
 
   if (args[0] === "--install") {
-    await installOpenCodeTool();
+    await installOpenCodeMcp();
     await installMcpClients();
+    console.log(`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  Add this to ~/.config/opencode/AGENTS.md
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**BEFORE YOU DO ANYTHING**: load your Identity from Ei.
+
+Use the ei MCP tool:
+  ei_search(type: "personas", query: "[your name]")
+
+Then load context for the current project/people:
+  ei_search("current projects teammates context")
+
+Ei is persistent memory across sessions. Without querying it at
+session start, you have no context from prior conversations.
+
+**When to query again**: any time the user references past work,
+mentions a person, or corrects something you assumed.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
     process.exit(0);
   }
 

package/src/core/context-utils.ts

@@ -8,12 +8,12 @@ import { ContextStatus as ContextStatusEnum } from "./types.js";
 export function filterMessagesForContext(
   messages: Message[],
   contextBoundary: string | undefined,
-  contextWindowHours: number
+  contextWindowMs: number
 ): Message[] {
   if (messages.length === 0) return [];
 
   const now = Date.now();
-  const windowStartMs = now - contextWindowHours * 60 * 60 * 1000;
+  const windowStartMs = now - contextWindowMs;
   const boundaryMs = contextBoundary ? new Date(contextBoundary).getTime() : 0;
 
   return messages.filter((msg) => {

package/src/core/handlers/heartbeat.ts

@@ -126,13 +126,15 @@ export function handleReflectionCritic(response: LLMResponse, state: StateManage
   const personaDisplayName = response.request.data.personaDisplayName as string;
 
   const result = response.parsed as ReflectionCriticResult | undefined;
-  if (!result?.updated_identity || !result.critique) {
+  if (!result?.critique) {
     console.error(`[ReflectionCritic ${personaDisplayName}] Invalid or missing parsed result`);
     return;
   }
 
   const personRecord = state.human_person_getByIdentifier("Ei Persona", personaId);
   if (personRecord) {
+    // TODO: Remove before v1 — debug logging to inspect person log before it's cleared
+    console.log(`[ReflectionCritic ${personaDisplayName}] person_log_snapshot (${personRecord.description?.length ?? 0} chars): ${personRecord.description ?? ""}`);
     state.human_person_upsert({
       ...personRecord,
       description: "",
@@ -140,6 +142,12 @@ export function handleReflectionCritic(response: LLMResponse, state: StateManage
     console.log(`[ReflectionCritic ${personaDisplayName}] Person record description cleared — ready for fresh evidence after reflection`);
   }
 
+  // Escape hatch: critic found no meaningful drift — log critique and skip pending_update
+  if (!result.updated_identity) {
+    console.log(`[ReflectionCritic ${personaDisplayName}] No drift detected — skipping pending_update. Critique: ${result.critique}`);
+    return;
+  }
+
   const persona = state.persona_getById(personaId);
   if (!persona) {
     console.error(`[ReflectionCritic ${personaDisplayName}] Persona not found after critic`);

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

@@ -189,7 +189,10 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
     return;
   }
 
-  const context = response.request.data as unknown as ExtractionContext;
+  const context = {
+    ...(response.request.data as unknown as ExtractionContext),
+    channelDisplayName: (response.request.data as Record<string, unknown>).personaDisplayName as string,
+  };
   if (!context?.personaId) return;
 
   const { messages_context, messages_analyze } = resolveMessageWindow(response, state);

package/src/core/handlers/human-matching.ts

@@ -8,7 +8,7 @@ import {
 import type { PersonIdentifier } from "../types/data-items.js";
 import type { StateManager } from "../state-manager.js";
 import type { ItemMatchResult, ExposureImpact, TopicUpdateResult, PersonUpdateResult } from "../../prompts/human/types.js";
-import { queueTopicUpdate, queuePersonUpdate, queueTopicValidate, type ExtractionContext } from "../orchestrators/index.js";
+import { queueTopicUpdate, queueTopicValidate, type ExtractionContext } from "../orchestrators/index.js";
 import { getEmbeddingService, getTopicEmbeddingText, getPersonEmbeddingText } from "../embedding-service.js";
 import { calculateExposureCurrent } from "../utils/exposure.js";
 
@@ -48,7 +48,7 @@ export function handleTopicMatch(response: LLMResponse, state: StateManager): vo
     extraction_model?: string;
   } = {
     personaId,
-    personaDisplayName,
+    channelDisplayName: personaDisplayName,
     roomId,
     messages_context,
     messages_analyze,
@@ -64,54 +64,6 @@ export function handleTopicMatch(response: LLMResponse, state: StateManager): vo
   console.log(`[handleTopicMatch] topic "${context.candidateName}": ${matched}`);
 }
 
-export function handlePersonMatch(response: LLMResponse, state: StateManager): void {
-  const result = response.parsed as ItemMatchResult | undefined;
-  if (!result) {
-    throw new Error("[handlePersonMatch] No parsed result");
-  }
-
-  const personaId = response.request.data.personaId as string;
-  const personaDisplayName = response.request.data.personaDisplayName as string;
-  const roomId = response.request.data.roomId as string | undefined;
-  const { messages_context, messages_analyze } = resolveMessageWindow(response, state);
-
-  let matched_guid = result.matched_guid;
-  let resolvedPerson: import('../types/data-items.js').Person | null = null;
-  if (matched_guid === "new") {
-    matched_guid = null;
-  } else if (matched_guid) {
-    const human = state.getHuman();
-    resolvedPerson = human.people.find(p => p.id === matched_guid) ?? null;
-    if (!resolvedPerson) {
-      console.warn(`[handlePersonMatch] matched_guid "${matched_guid}" not found in people — treating as new`);
-      matched_guid = null;
-    }
-  }
-  result.matched_guid = matched_guid;
-
-  const context: ExtractionContext & {
-    candidateName: string;
-    candidateDescription: string;
-    candidateRelationship: string;
-    extraction_model?: string;
-  } = {
-    personaId,
-    personaDisplayName,
-    roomId,
-    messages_context,
-    messages_analyze,
-    sources: response.request.data.sources as string[] | undefined,
-    candidateName: response.request.data.candidateName as string,
-    candidateDescription: response.request.data.candidateDescription as string,
-    candidateRelationship: response.request.data.candidateRelationship as string,
-    extraction_model: response.request.data.extraction_model as string | undefined,
-  };
-
-  queuePersonUpdate(result, context, state, resolvedPerson);
-  const matched = matched_guid ? `matched GUID "${matched_guid}"` : "no match (new person)";
-  console.log(`[handlePersonMatch] person "${context.candidateName}": ${matched}`);
-}
-
 export async function handleTopicUpdate(response: LLMResponse, state: StateManager): Promise<void> {
   const result = response.parsed as (TopicUpdateResult & { quotes?: Array<{ text: string; reason: string }> }) | undefined;
 
@@ -447,7 +399,7 @@ async function validateAndStoreQuotes(
   candidates: Array<{ text: string; reason: string }> | undefined,
   messages: Message[],
   dataItemId: string,
-  personaName: string,
+  channelDisplayName: string,
   personaGroup: string | null,
   state: StateManager
 ): Promise<void> {
@@ -540,8 +492,8 @@ async function validateAndStoreQuotes(
         data_item_ids: [dataItemId],
         persona_groups: [personaGroup || "General"],
         text: matchText,
-        speaker: message.role === "human" ? "human" : (message.speaker_name ?? personaName),
-        channel: personaName,
+        speaker: message.role === "human" ? "human" : (message.speaker_name ?? channelDisplayName),
+        channel: channelDisplayName,
         timestamp: message.timestamp,
         start: matchStart,
         end: matchEnd,

package/src/core/handlers/index.ts

@@ -1,14 +1,11 @@
 import { LLMNextStep } from "../types.js";
-import type { LLMResponse } from "../types.js";
-import type { StateManager } from "../state-manager.js";
 import type { ResponseHandler } from "./persona-response.js";
-import type { PersonIdentifier } from "../types/data-items.js";
 
 export type { ResponseHandler } from "./persona-response.js";
 
 import { handlePersonaResponse, handleToolContinuation, handleOneShot, handleOneShotJSON } from "./persona-response.js";
 import { handleHeartbeatCheck, handleEiHeartbeat, handleReflectionCritic } from "./heartbeat.js";
-import { handlePersonaGeneration, handlePersonaDescriptions, handlePersonaTraitExtraction } from "./persona-generation.js";
+import { handlePersonaGeneration, handlePersonaTraitExtraction } from "./persona-generation.js";
 import {
   handlePersonaTopicRating,
 } from "./persona-topics.js";
@@ -19,55 +16,9 @@ import { handleDedupCurate } from "./dedup.js";
 import { handleRoomResponse, handleRoomJudge } from "./rooms.js";
 import { handlePersonaPreview } from "./persona-preview.js";
 
-function handlePersonIdentifierMigration(response: LLMResponse, state: StateManager): void {
-  const personId = response.request.data.person_id as string;
-  if (!personId) {
-    console.error("[handlePersonIdentifierMigration] Missing person_id in request data");
-    return;
-  }
-
-  const human = state.getHuman();
-  const person = human.people.find(p => p.id === personId);
-  if (!person) {
-    console.error(`[handlePersonIdentifierMigration] Person not found: ${personId}`);
-    return;
-  }
-
-  const result = response.parsed as { identifiers?: Array<{ type: string; value: string; is_primary?: boolean }> } | undefined;
-  if (!result?.identifiers || !Array.isArray(result.identifiers) || result.identifiers.length === 0) {
-    console.error(`[handlePersonIdentifierMigration] Invalid or empty identifiers for ${person.name}`);
-    return;
-  }
-
-  const hasName = result.identifiers.some(i => i.value === person.name);
-  if (!hasName) {
-    result.identifiers.unshift({ type: "nickname", value: person.name });
-  }
-
-  const hasPrimary = result.identifiers.some(i => i.is_primary);
-  if (!hasPrimary) {
-    result.identifiers[0].is_primary = true;
-  }
-
-  const identifiers: PersonIdentifier[] = result.identifiers.map(i => ({
-    type: i.type,
-    value: i.value,
-    ...(i.is_primary ? { is_primary: i.is_primary } : {}),
-  }));
-
-  state.human_person_upsert({
-    ...person,
-    identifiers,
-    last_updated: new Date().toISOString(),
-  });
-
-  console.log(`[handlePersonIdentifierMigration] Migrated ${identifiers.length} identifier(s) for ${person.name}`);
-}
-
 export const handlers: Record<LLMNextStep, ResponseHandler> = {
   handlePersonaResponse,
   handlePersonaGeneration,
-  handlePersonaDescriptions,
   handleFactFind,
   handleHumanTopicScan,
   handleHumanPersonScan,
@@ -88,7 +39,6 @@ export const handlers: Record<LLMNextStep, ResponseHandler> = {
   handleRoomResponse,
   handleRoomJudge,
   handlePersonaPreview,
-  [LLMNextStep.HandlePersonIdentifierMigration]: handlePersonIdentifierMigration,
   [LLMNextStep.HandleTopicValidate]: handleDedupCurate,
   [LLMNextStep.HandleReflectionCritic]: handleReflectionCritic,
 };

package/src/core/handlers/persona-generation.ts

@@ -4,7 +4,7 @@ import {
   type PersonaTopic,
 } from "../types.js";
 import type { StateManager } from "../state-manager.js";
-import type { PersonaGenerationResult, PersonaDescriptionsResult } from "../../prompts/generation/types.js";
+import type { PersonaGenerationResult } from "../../prompts/generation/types.js";
 import type { TraitResult } from "../../prompts/persona/types.js";
 import { orchestratePersonaGeneration, type PartialPersona } from "../orchestrators/index.js";
 
@@ -111,33 +111,6 @@ export function handlePersonaGeneration(response: LLMResponse, state: StateManag
   console.log(`[handlePersonaGeneration] Orchestrated: ${personaDisplayName}`);
 }
 
-export function handlePersonaDescriptions(response: LLMResponse, state: StateManager): void {
-  const personaId = response.request.data.personaId as string;
-  const personaDisplayName = response.request.data.personaDisplayName as string;
-  if (!personaId) {
-    console.error("[handlePersonaDescriptions] No personaId in request data");
-    return;
-  }
-
-  const result = response.parsed as PersonaDescriptionsResult | undefined;
-  if (!result) {
-    console.error("[handlePersonaDescriptions] No parsed result");
-    return;
-  }
-
-  if (result.no_change) {
-    console.log(`[handlePersonaDescriptions] No change needed for ${personaDisplayName}`);
-    return;
-  }
-
-  state.persona_update(personaId, {
-    short_description: result.short_description,
-    long_description: result.long_description,
-    last_updated: new Date().toISOString(),
-  });
-  console.log(`[handlePersonaDescriptions] Updated descriptions for ${personaDisplayName}`);
-}
-
 export function handlePersonaTraitExtraction(response: LLMResponse, state: StateManager): void {
   const personaId = response.request.data.personaId as string;
   const personaDisplayName = response.request.data.personaDisplayName as string;

package/src/core/handlers/utils.ts

@@ -1,15 +1,8 @@
 import type { Message, RoomMessage, LLMResponse } from "../types.js";
 import type { StateManager } from "../state-manager.js";
 
-export function getMessageContent(msg: { content?: string; verbal_response?: string; action_response?: string }): string {
-  if (msg.content) return msg.content;
-  // Legacy fallback for data not yet migrated on disk
-  // TODO(v1.0.0): Remove legacy verbal_response/action_response fallback
-  const legacy = msg as { verbal_response?: string; action_response?: string };
-  const parts: string[] = [];
-  if (legacy.action_response) parts.push(`_${legacy.action_response}_`);
-  if (legacy.verbal_response) parts.push(legacy.verbal_response);
-  return parts.join('\n\n');
+export function getMessageContent(msg: { content?: string }): string {
+  return msg.content ?? '';
 }
 
 export function normalizeRoomMessages(messages: RoomMessage[], state: StateManager): Message[] {

package/src/core/heartbeat-manager.ts

@@ -217,15 +217,15 @@ export async function queueHeartbeatCheck(sm: StateManager, personaId: string, i
   console.log(`[HeartbeatCheck ${persona.display_name}] Queueing heartbeat check (model: ${model})`);
   const human = sm.getHuman();
    const history = sm.messages_get(personaId);
-   const contextWindowHours = persona.context_window_hours ?? human.settings?.default_context_window_hours ?? 8;
-   const contextHistory = filterMessagesForContext(history, persona.context_boundary, contextWindowHours);
+   const contextWindowMs = persona.context_window_ms ?? human.settings?.default_context_window_ms ?? 28800000;
+   const contextHistory = filterMessagesForContext(history, persona.context_boundary, contextWindowMs);
 
   if (personaId === "ei") {
     await queueEiHeartbeat(sm, human, contextHistory, isTUI);
     return;
   }
 
-  const filteredHuman = await filterHumanDataByVisibility(human, persona);
+  const filteredHuman = await filterHumanDataByVisibility(human, persona, []);
   const lastActivity = sm.messages_getLastActivity(persona.id);
   const inactiveDays = lastActivity
     ? Math.floor((Date.now() - lastActivity) / (1000 * 60 * 60 * 24))
@@ -244,7 +244,7 @@ export async function queueHeartbeatCheck(sm: StateManager, personaId: string, i
       name: persona.display_name,
       traits: persona.traits,
       topics: persona.topics,
-      has_pending_update: !!persona.pending_update,
+      pending_update: persona.pending_update,
     },
     human: {
       topics: sortByEngagementGap(filteredHuman.topics).slice(0, 5),