ei-tui 0.6.3 → 0.6.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ei-tui",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "author": "Flare576",
   "repository": {
     "type": "git",

package/src/core/handlers/dedup.ts

@@ -114,7 +114,9 @@ export async function handleDedupCurate(
   // =========================================================================
   // PHASE 1: Update Quote foreign keys FIRST (before deletions)
   // =========================================================================
-  
+
+  const liveEntityIds = new Set(entityList.map((e: Fact | Topic | Person) => e.id));
+
   for (const removal of decisions.remove) {
     const quotes = state.quotes.filter((q: Quote) =>
       q.data_item_ids.includes(removal.to_be_removed)
@@ -123,6 +125,7 @@ export async function handleDedupCurate(
     for (const quote of quotes) {
       const updatedIds = quote.data_item_ids
         .map((id: string) => id === removal.to_be_removed ? removal.replaced_by : id)
+        .filter((id: string) => liveEntityIds.has(id))         // Drop links to already-merged entities
         .filter((id: string, idx: number, arr: string[]) => arr.indexOf(id) === idx);  // Dedupe
       
       stateManager.human_quote_update(quote.id, {

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, type ExtractionContext } from "../orchestrators/index.js";
+import { queueTopicUpdate, queuePersonUpdate, queueTopicValidate, type ExtractionContext } from "../orchestrators/index.js";
 import { getEmbeddingService, getTopicEmbeddingText, getPersonEmbeddingText } from "../embedding-service.js";
 import { calculateExposureCurrent } from "../utils/exposure.js";
 
@@ -28,12 +28,13 @@ export function handleTopicMatch(response: LLMResponse, state: StateManager): vo
   const { messages_context, messages_analyze } = resolveMessageWindow(response, state);
 
   let matched_guid = result.matched_guid;
+  let resolvedTopic: import('../types/data-items.js').Topic | null = null;
   if (matched_guid === "new") {
     matched_guid = null;
   } else if (matched_guid) {
     const human = state.getHuman();
-    const found = human.topics.find(t => t.id === matched_guid);
-    if (!found) {
+    resolvedTopic = human.topics.find(t => t.id === matched_guid) ?? null;
+    if (!resolvedTopic) {
       console.warn(`[handleTopicMatch] matched_guid "${matched_guid}" not found in topics — treating as new`);
       matched_guid = null;
     }
@@ -57,7 +58,7 @@ export function handleTopicMatch(response: LLMResponse, state: StateManager): vo
     extraction_model: response.request.data.extraction_model as string | undefined,
   };
 
-  queueTopicUpdate(result, context, state);
+  queueTopicUpdate(result, context, state, resolvedTopic);
   const matched = matched_guid ? `matched GUID "${matched_guid}"` : "no match (new topic)";
   console.log(`[handleTopicMatch] topic "${context.candidateName}": ${matched}`);
 }
@@ -74,12 +75,13 @@ export function handlePersonMatch(response: LLMResponse, state: StateManager): v
   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();
-    const found = human.people.find(p => p.id === matched_guid);
-    if (!found) {
+    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;
     }
@@ -103,7 +105,7 @@ export function handlePersonMatch(response: LLMResponse, state: StateManager): v
     extraction_model: response.request.data.extraction_model as string | undefined,
   };
 
-  queuePersonUpdate(result, context, state);
+  queuePersonUpdate(result, context, state, resolvedPerson);
   const matched = matched_guid ? `matched GUID "${matched_guid}"` : "no match (new person)";
   console.log(`[handlePersonMatch] person "${context.candidateName}": ${matched}`);
 }
@@ -123,6 +125,7 @@ export async function handleTopicUpdate(response: LLMResponse, state: StateManag
   const roomId = response.request.data.roomId as string | undefined;
   const candidateCategory = response.request.data.candidateCategory as string | undefined;
   const candidateName = response.request.data.candidateName as string | undefined;
+  const candidateDescription = response.request.data.candidateDescription as string | undefined;
 
   const personaIds = personaId.split("|").filter(Boolean);
   const primaryId = personaIds[0] ?? personaId;
@@ -145,10 +148,15 @@ export async function handleTopicUpdate(response: LLMResponse, state: StateManag
   const existingTopic = isNewItem ? undefined : human.topics.find(t => t.id === existingItemId);
 
   const resolvedName = result.name || existingTopic?.name || candidateName;
-  const resolvedDescription = typeof result.description === 'string' ? result.description : existingTopic?.description;
+  const resolvedDescription = typeof result.description === 'string' ? result.description : existingTopic?.description ?? candidateDescription;
+  const resolvedSentiment = result.sentiment !== undefined ? result.sentiment : existingTopic?.sentiment ?? 0;
 
-  if (!resolvedName || !resolvedDescription || result.sentiment === undefined) {
-    throw new Error(`[handleTopicUpdate] Missing required fields: name=${resolvedName}, description=${!!resolvedDescription}, sentiment=${result.sentiment}`);
+  if (!resolvedName || !resolvedDescription) {
+    if (isNewItem) {
+      throw new Error(`[handleTopicUpdate] Cannot create new topic — missing required fields: name=${resolvedName}, description=${!!resolvedDescription}`);
+    }
+    console.log(`[handleTopicUpdate] Skipping update for "${resolvedName ?? existingItemId}" — no description available and existing record preserved`);
+    return;
   }
 
   let embedding: number[] | undefined;
@@ -173,7 +181,7 @@ export async function handleTopicUpdate(response: LLMResponse, state: StateManag
     id: itemId,
     name: resolvedName,
     description: resolvedDescription,
-    sentiment: result.sentiment,
+    sentiment: resolvedSentiment,
     category: result.category ?? candidateCategory ?? existingTopic?.category,
     exposure_current: calculateExposureCurrent(exposureImpact, existingTopic?.exposure_current ?? 0),
     exposure_desired: result.exposure_desired ?? 0.5,
@@ -193,6 +201,11 @@ export async function handleTopicUpdate(response: LLMResponse, state: StateManag
     : state.messages_get(personaId);
   await validateAndStoreQuotes(result.quotes, allMessages, itemId, personaDisplayName, personaGroup, state);
 
+  if (isNewItem && embedding) {
+    const extractionModel = (response.request.data as Record<string, unknown>).extraction_model as string | undefined;
+    await queueTopicValidate(topic, state, extractionModel);
+  }
+
   console.log(`[handleTopicUpdate] ${isNewItem ? "Created" : "Updated"} topic "${resolvedName}"`);
 }
 
@@ -217,6 +230,7 @@ export async function handlePersonUpdate(response: LLMResponse, state: StateMana
   const candidateIdentifiers = (response.request.data.candidateIdentifiers ?? []) as PersonIdentifier[];
 
   const candidateName = response.request.data.candidateName as string;
+  const candidateDescription = response.request.data.candidateDescription as string | undefined;
   const personaIds = personaId.split("|").filter(Boolean);
   const primaryId = personaIds[0] ?? personaId;
 
@@ -237,11 +251,15 @@ export async function handlePersonUpdate(response: LLMResponse, state: StateMana
 
   const existingPerson = isNewItem ? undefined : human.people.find(p => p.id === existingItemId);
 
-  const resolvedDescription = typeof result.description === 'string' ? result.description : existingPerson?.description;
-  const resolvedSentiment = result.sentiment !== undefined ? result.sentiment : existingPerson?.sentiment;
+  const resolvedDescription = typeof result.description === 'string' ? result.description : existingPerson?.description ?? candidateDescription;
+  const resolvedSentiment = result.sentiment !== undefined ? result.sentiment : existingPerson?.sentiment ?? 0;
 
-  if (!resolvedDescription || resolvedSentiment === undefined) {
-    throw new Error(`[handlePersonUpdate] Missing required fields: description=${!!resolvedDescription}, sentiment=${resolvedSentiment}`);
+  if (!resolvedDescription) {
+    if (isNewItem) {
+      throw new Error(`[handlePersonUpdate] Cannot create new person "${candidateName}" — no description available`);
+    }
+    console.log(`[handlePersonUpdate] Skipping update for "${candidateName}" — no description available and existing record preserved`);
+    return;
   }
 
   let embedding: number[] | undefined;

package/src/core/handlers/index.ts

@@ -88,4 +88,5 @@ export const handlers: Record<LLMNextStep, ResponseHandler> = {
   handleRoomJudge,
   handlePersonaPreview,
   [LLMNextStep.HandlePersonIdentifierMigration]: handlePersonIdentifierMigration,
+  [LLMNextStep.HandleTopicValidate]: handleDedupCurate,
 };

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

@@ -13,6 +13,7 @@ import {
   type ItemMatchResult,
   type ParticipantContext,
 } from "../../prompts/human/index.js";
+import { buildValidatePrompt } from "../../prompts/ceremony/dedup.js";
 import { chunkExtractionContext } from "./extraction-chunker.js";
 import { getEmbeddingService, findTopK, getTopicEmbeddingText } from "../embedding-service.js";
 import { resolveTokenLimit } from "../llm-client.js";
@@ -290,6 +291,13 @@ export function queueDirectTopicUpdate(
 const EMBEDDING_TOP_K = 20;
 const EMBEDDING_MIN_SIMILARITY = 0.3;
 
+/**
+ * Minimum cosine similarity to trigger the post-create validate step.
+ * Higher than EMBEDDING_MIN_SIMILARITY (0.3) because we need near-duplicates,
+ * not just vague thematic overlap.
+ */
+export const VALIDATE_MIN_SIMILARITY = 0.85;
+
 /**
  * Queue a topic match request using embedding-based similarity (topics only).
  */
@@ -380,15 +388,15 @@ export function queueTopicUpdate(
     candidateCategory: string;
     extraction_model?: string;
   },
-  state: StateManager
+  state: StateManager,
+  resolvedItem?: Topic | null
 ): number {
-  const human = state.getHuman();
   const matchedGuid = matchResult.matched_guid;
   const isNewItem = matchedGuid === null;
 
-  let existingItem: Topic | null = null;
-  if (!isNewItem && matchedGuid) {
-    existingItem = human.topics.find(t => t.id === matchedGuid) ?? null;
+  let existingItem: Topic | null = resolvedItem ?? null;
+  if (!isNewItem && matchedGuid && existingItem === null) {
+    existingItem = state.getHuman().topics.find(t => t.id === matchedGuid) ?? null;
   }
 
   const extractionOptions: ExtractionOptions = { extraction_model: context.extraction_model };
@@ -423,6 +431,7 @@ export function queueTopicUpdate(
         isNewItem,
         existingItemId: existingItem?.id,
         candidateName: isNewItem ? context.candidateName : undefined,
+        candidateDescription: isNewItem ? context.candidateDescription : undefined,
         candidateCategory: context.candidateCategory,
         analyze_from_timestamp: getAnalyzeFromTimestamp(chunk),
       },
@@ -522,15 +531,15 @@ export function queuePersonUpdate(
     candidateIdentifiers?: PersonIdentifier[];
     extraction_model?: string;
   },
-  state: StateManager
+  state: StateManager,
+  resolvedItem?: Person | null
 ): number {
-  const human = state.getHuman();
   const matchedGuid = matchResult.matched_guid;
   const isNewItem = matchedGuid === null;
 
-  let existingItem: Person | null = null;
-  if (!isNewItem && matchedGuid) {
-    existingItem = human.people.find(p => p.id === matchedGuid) ?? null;
+  let existingItem: Person | null = resolvedItem ?? null;
+  if (!isNewItem && matchedGuid && existingItem === null) {
+    existingItem = state.getHuman().people.find(p => p.id === matchedGuid) ?? null;
   }
 
   const candidateIdentifiers = context.candidateIdentifiers ?? [];
@@ -547,7 +556,7 @@ export function queuePersonUpdate(
   }
 
   const userIdentifierTypes = [...new Set(
-    human.people
+    state.getHuman().people
       .flatMap(p => (p.identifiers ?? []).map(i => i.type))
       .filter(Boolean)
   )];
@@ -586,6 +595,7 @@ export function queuePersonUpdate(
         isNewItem,
         existingItemId: existingItem?.id,
         candidateName: context.candidateName,
+        candidateDescription: isNewItem ? context.candidateDescription : undefined,
         candidateRelationship: context.candidateRelationship,
         candidateIdentifiers: isNewItem ? candidateIdentifiers : undefined,
         analyze_from_timestamp: getAnalyzeFromTimestamp(chunk),
@@ -596,4 +606,55 @@ export function queuePersonUpdate(
   return chunks.length;
 }
 
+export async function queueTopicValidate(
+  newTopic: Topic,
+  state: StateManager,
+  extractionModel?: string
+): Promise<void> {
+  if (!newTopic.embedding || newTopic.embedding.length === 0) {
+    console.log(`[queueTopicValidate] Skipping "${newTopic.name}" — no embedding available`);
+    return;
+  }
+
+  const human = state.getHuman();
+  const candidates = human.topics.filter(t => t.id !== newTopic.id && t.embedding && t.embedding.length > 0);
+
+  if (candidates.length === 0) {
+    console.log(`[queueTopicValidate] No existing topics with embeddings to compare against`);
+    return;
+  }
+
+  const topResult = findTopK(newTopic.embedding, candidates, 1);
+  if (topResult.length === 0 || topResult[0].similarity < VALIDATE_MIN_SIMILARITY) {
+    const best = topResult[0];
+    console.log(`[queueTopicValidate] "${newTopic.name}" is genuinely new (best match: ${best ? `"${best.item.name}" @ ${best.similarity.toFixed(3)}` : "none"})`);
+    return;
+  }
+
+  const existingTopic = topResult[0].item;
+  const similarity = topResult[0].similarity;
+
+  console.log(`[queueTopicValidate] Near-duplicate candidate: "${newTopic.name}" ↔ "${existingTopic.name}" (${similarity.toFixed(3)}) — queuing validate`);
+
+  const prompt = buildValidatePrompt({
+    established: existingTopic,
+    newcomer: newTopic,
+    itemType: "topic",
+    similarity,
+  });
+
+  state.queue_enqueue({
+    type: LLMRequestType.JSON,
+    priority: LLMPriority.Normal,
+    model: extractionModel,
+    system: prompt.system,
+    user: prompt.user,
+    next_step: LLMNextStep.HandleTopicValidate,
+    data: {
+      entity_type: "topic",
+      entity_ids: [existingTopic.id, newTopic.id],
+    },
+  });
+}
+
 

package/src/core/orchestrators/index.ts

@@ -8,6 +8,8 @@ export {
   queueTopicUpdate,
   queuePersonUpdate,
   queueEventSummary,
+  queueTopicValidate,
+  VALIDATE_MIN_SIMILARITY,
   type ExtractionContext,
   type ExtractionOptions,
 } from "./human-extraction.js";

package/src/core/types/enums.ts

@@ -51,6 +51,7 @@ export enum LLMNextStep {
   HandleRoomJudge = "handleRoomJudge",
   HandlePersonaPreview = "handlePersonaPreview",
   HandlePersonIdentifierMigration = "handlePersonIdentifierMigration",
+  HandleTopicValidate = "handleTopicValidate",
 }
 
 export enum ProviderType {

package/src/prompts/ceremony/dedup.ts

@@ -1,4 +1,4 @@
-import type { DedupPromptData } from "./types.js";
+import type { DedupPromptData, ValidatePromptData } from "./types.js";
 
 // =============================================================================
 // DEDUP CURATOR — Merge duplicate entities with data preservation
@@ -140,6 +140,94 @@ ${schemaReminder}`;
   return { system, user };
 }
 
+// =============================================================================
+// VALIDATE — Binary merge decision for a newly created record
+// =============================================================================
+
+export function buildValidatePrompt(data: ValidatePromptData): { system: string; user: string } {
+  const typeLabel = data.itemType.charAt(0).toUpperCase() + data.itemType.slice(1);
+  const pct = Math.round(data.similarity * 100);
+
+  const system = `# Your Task
+
+A new ${typeLabel} record was just created from a real conversation. The moment it landed in the system, we checked it against everything already stored and found one record with a similarity score of ${pct}% — high enough that they might be the same thing under different words.
+
+You are the last gate before a duplicate takes root.
+
+**Established record**: Has been in the system. Learned from prior conversations.
+**Newcomer**: Just synthesized from the most recent conversation. Description is current-state, not a log.
+
+## What You're Deciding
+
+Are these the same thing — the same interest, concern, goal, or moment — described twice? Or are they genuinely distinct, and both deserve to exist?
+
+Similarity of meaning is not the same as identity. "Concern about job security" and "Fear of career stagnation" share semantic space. They are not the same record.
+
+Ask yourself: *If a persona referenced the established record in conversation, would the newcomer feel like a repeat? Or would it feel like something different being said?*
+
+If they are the same thing: **merge**. Preserve every unique detail from both. The newcomer's description is synthesized and current — weight it, but don't discard what the established record learned first.
+
+If they are distinct: **keep both**. Return them both in \`update\` unchanged. Leave \`remove\` and \`add\` empty.
+
+## Output Format
+
+\`\`\`json
+{
+  "update": [ /* one or both records — include ALL fields from whichever survive */ ],
+  "remove": [ /* { "to_be_removed": "uuid", "replaced_by": "uuid" } — only if merging */ ],
+  "add": []
+}
+\`\`\`
+
+Rules:
+- \`add\` is always empty here. We are not creating new records from this decision.
+- If merging: the merged record goes in \`update\`, the absorbed record goes in \`remove\`.
+- If keeping both: return both in \`update\` exactly as received. Do not modify either.
+- Descriptions must stay concise — under 300 characters, never over 500. Synthesize; don't concatenate.
+- When merging numeric fields: take the HIGHER value for \`exposure_current\`, \`exposure_desired\`, \`strength\`, \`confidence\`. Average \`sentiment\`.
+- Do NOT invent information. Only what exists in these two records.
+
+Return raw JSON only. No markdown fencing, no commentary.`;
+
+  const payload = JSON.stringify({
+    established: stripEmbedding(data.established),
+    newcomer: stripEmbedding(data.newcomer),
+    item_type: data.itemType,
+    similarity_score: data.similarity,
+  }, null, 2);
+
+  const schemaReminder = `**Return JSON:**
+\n\`\`\`json
+{
+  "update": [
+    {
+      "id": "uuid-of-surviving-record",
+      "type": "${data.itemType}",
+      "name": "canonical name",
+      "description": "merged or unchanged description"
+    }
+  ],
+  "remove": [
+    {
+      "to_be_removed": "uuid-of-absorbed-record",
+      "replaced_by": "uuid-of-surviving-record"
+    }
+  ],
+  "add": []
+}
+\`\`\`
+
+If keeping both, return both in \`update\` unchanged with empty \`remove\` and \`add\`.`;
+
+  const user = `${payload}
+
+---
+
+${schemaReminder}`;
+
+  return { system, user };
+}
+
 // =============================================================================
 // Helpers
 // =============================================================================

package/src/prompts/ceremony/index.ts

@@ -2,7 +2,7 @@ export { buildPersonaExpirePrompt } from "./expire.js";
 export { buildPersonaExplorePrompt } from "./explore.js";
 export { buildDescriptionCheckPrompt } from "./description-check.js";
 export { buildRewriteScanPrompt, buildRewritePrompt } from "./rewrite.js";
-export { buildDedupPrompt } from "./dedup.js";
+export { buildDedupPrompt, buildValidatePrompt } from "./dedup.js";
 export { buildUserDedupPrompt } from "./user-dedup.js";
 export { buildPersonMigrationPrompt, type PersonMigrationPromptData } from "./person-migration.js";
 export type {
@@ -20,4 +20,5 @@ export type {
   RewriteResult,
   DedupPromptData,
   DedupResult,
+  ValidatePromptData,
 } from "./types.js";

package/src/prompts/ceremony/types.ts

@@ -107,6 +107,14 @@ export interface DedupPromptData {
   similarityRange: { min: number; max: number };  // e.g., { min: 0.90, max: 0.98 }
 }
 
+/** Input: exactly 2 records — one established, one just created — for binary merge decision. */
+export interface ValidatePromptData {
+  established: DataItemBase;
+  newcomer: DataItemBase;
+  itemType: RewriteItemType;
+  similarity: number;
+}
+
 /** Output: merge decisions (update/remove/add). */
 export interface DedupResult {
   update: Array<{

package/tui/src/commands/editor.tsx

@@ -26,16 +26,19 @@ export const editorCommand: Command = {
     });
     
     if (result.aborted) {
+      ctx.setInputText("");
       ctx.showNotification("Editor cancelled", "info");
       return;
     }
     
     if (!result.success) {
+      ctx.setInputText("");
       ctx.showNotification("Editor failed to open", "error");
       return;
     }
     
     if (result.content === null) {
+      ctx.setInputText("");
       ctx.showNotification("No changes made", "info");
       return;
     }

package/tui/src/commands/help.tsx

@@ -7,6 +7,6 @@ export const helpCommand: Command = {
   description: "Show help screen",
   usage: "/help or /h",
   execute: async (_args, ctx) => {
-    ctx.showOverlay((_hideOverlay, _hideForEditor) => <HelpOverlay onDismiss={_hideOverlay} />, ctx.renderer);
+    ctx.showOverlay((_hideOverlay, _hideForEditor) => <HelpOverlay onDismiss={_hideOverlay} renderer={ctx.renderer} />, ctx.renderer);
   },
 };

package/tui/src/commands/me.tsx

@@ -6,37 +6,73 @@ import { ConfirmOverlay } from "../components/ConfirmOverlay.js";
 
 type DataType = "facts" | "topics" | "people";
 
-const VALID_TYPES: DataType[] = ["facts", "topics", "people"];
+const TYPE_ALIASES: Record<string, DataType> = {
+  facts: "facts", fact: "facts",
+  topics: "topics", topic: "topics",
+  people: "people", person: "people", persons: "people",
+};
 
 export const meCommand: Command = {
   name: "me",
   aliases: [],
   description: "Edit your data in $EDITOR",
-  usage: "/me [facts|topics|people]",
-  
+  usage: "/me [fact|topic|person] [new | <search>]",
+
   async execute(args, ctx) {
     const human = await ctx.ei.getHuman();
-    
-    const filterArg = args[0]?.toLowerCase();
-    const filterType: DataType | null = filterArg && VALID_TYPES.includes(filterArg as DataType) 
-      ? filterArg as DataType 
-      : null;
-    
-    if (filterArg && !filterType) {
-      ctx.showNotification(`Invalid type: ${filterArg}. Use: facts, topics, people`, "error");
+
+    const typeArg = args[0]?.toLowerCase();
+    const filterType: DataType | null = typeArg ? (TYPE_ALIASES[typeArg] ?? null) : null;
+
+    if (typeArg && !filterType) {
+      ctx.showNotification(`Unknown type: ${typeArg}. Use: fact, topic, person`, "error");
       return;
     }
-    
+
+    const secondArg = args[1]?.toLowerCase();
+    const isNew = secondArg === "new";
+    const searchTerm = !isNew && secondArg ? args.slice(1).join(" ") : null;
+
+    if (isNew && args.length > 2) {
+      ctx.showNotification(
+        `Use /me ${typeArg} new to create, or /me ${typeArg} ${args.slice(2).join(" ")} to search`,
+        "error"
+      );
+      return;
+    }
+
+    if ((isNew || searchTerm) && !filterType) {
+      ctx.showNotification(`Specify a type first: /me fact|topic|person [new | <search>]`, "error");
+      return;
+    }
+
+    const filterItems = <T extends { name: string }>(items: T[]): T[] => {
+      if (isNew) return [];
+      if (searchTerm) return items.filter(i => i.name.toLowerCase().includes(searchTerm.toLowerCase()));
+      return items;
+    };
+
     const filteredHuman = filterType ? {
       ...human,
-      facts: filterType === "facts" ? human.facts : [],
-      topics: filterType === "topics" ? human.topics : [],
-      people: filterType === "people" ? human.people : [],
+      facts:  filterType === "facts"  ? filterItems(human.facts)  : [],
+      topics: filterType === "topics" ? filterItems(human.topics) : [],
+      people: filterType === "people" ? filterItems(human.people) : [],
     } : human;
+
+    const isEmpty = filteredHuman.facts.length === 0
+      && filteredHuman.topics.length === 0
+      && filteredHuman.people.length === 0;
+
+    if (searchTerm && isEmpty) {
+      ctx.showNotification(`No ${filterType} matching "${searchTerm}" — open editor to create one`, "info");
+    }
     
     const personaLookup = new Map(ctx.ei.personas().map(p => [p.id, p.display_name]));
     const allGroups = await ctx.ei.getGroupList();
-    let yamlContent = humanToYAML(filteredHuman, personaLookup, allGroups);
+    const sections = filterType
+      ? new Set<"facts" | "topics" | "people">([filterType])
+      : new Set<"facts" | "topics" | "people">(["facts", "topics", "people"]);
+    let yamlContent = humanToYAML(filteredHuman, personaLookup, allGroups, sections);
     let editorIteration = 0;
     
     while (true) {