ei-tui 0.7.1 → 0.8.0

package/package.json

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

package/src/cli/commands/facts.ts

@@ -20,6 +20,7 @@ export async function execute(query: string, limit: number, options: { recent?:
     name: fact.name,
     description: fact.description,
     sentiment: fact.sentiment,
-    validated: fact.validated,
+    validated_date: fact.validated_date,
+    sources: fact.sources,
   }));
 }

package/src/cli/commands/people.ts

@@ -22,5 +22,6 @@ export async function execute(query: string, limit: number, options: { recent?:
     relationship: person.relationship,
     sentiment: person.sentiment,
     identifiers: person.identifiers ?? [],
+    sources: person.sources,
   }));
 }

package/src/cli/commands/topics.ts

@@ -21,5 +21,6 @@ export async function execute(query: string, limit: number, options: { recent?:
     description: topic.description,
     category: topic.category,
     sentiment: topic.sentiment,
+    sources: topic.sources,
   }));
 }

package/src/cli/mcp.ts

@@ -2,7 +2,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { retrieveBalanced, lookupById, loadLatestState, type BalancedResult } from "./retrieval.js";
-import type { StorageState } from "../core/types/index.js";
+import type { StorageState } from "../core/types.js";
 import { resolvePersonaId, filterByPersona, filterTypeSpecificByPersona, filterBySource, filterTypeSpecificBySource } from "./persona-filter.js";
 
 // Exported so tests can inject their own transport

package/src/cli/persona-filter.ts

@@ -1,4 +1,4 @@
-import type { StorageState } from "../core/types/index.js";
+import type { StorageState } from "../core/types.js";
 import type { BalancedResult } from "./retrieval.js";
 
 export function resolvePersonaId(state: StorageState, name: string): string | null {

package/src/cli/retrieval.ts

@@ -94,6 +94,8 @@ export interface FactResult {
   name: string;
   description: string;
   sentiment: number;
+  validated_date?: string;
+  sources?: string[];
 }
 
 export interface PersonResult {
@@ -172,6 +174,8 @@ function mapFact(fact: Fact): FactResult {
     name: fact.name,
     description: fact.description,
     sentiment: fact.sentiment,
+    validated_date: fact.validated_date,
+    sources: fact.sources,
   };
 }
 

package/src/cli.ts

@@ -16,6 +16,13 @@ import { join } from "path";
 import { retrieveBalanced, lookupById, loadLatestState } from "./cli/retrieval";
 import type { StorageState } from "./core/types";
 import { resolvePersonaId, filterByPersona, filterTypeSpecificByPersona, filterBySource, filterTypeSpecificBySource } from "./cli/persona-filter.js";
+import pkg from "../package.json" assert { type: "json" };
+
+const rawArgs = process.argv.slice(2);
+if (rawArgs.includes("--version") || rawArgs.includes("-v")) {
+  process.stdout.write(`${pkg.version}\n`);
+  process.exit(0);
+}
 
 const TYPE_ALIASES: Record<string, string> = {
   quote: "quotes",

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

@@ -52,6 +52,7 @@ export function handleTopicMatch(response: LLMResponse, state: StateManager): vo
     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,
     candidateCategory: response.request.data.candidateCategory as string,
@@ -99,6 +100,7 @@ export function handlePersonMatch(response: LLMResponse, state: StateManager): v
     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,

package/src/core/llm-client.ts

@@ -54,7 +54,7 @@ function buildResolvedModel(account: ProviderAccount, model: ModelConfig): Resol
   const apiModelId = model.model_id ?? model.name;
   return {
     provider: account.name,
-    model: apiModelId === "(default)" ? undefined : apiModelId,
+    model: apiModelId === "default" ? undefined : apiModelId,
     config: {
       name: account.name,
       baseURL: account.url,
@@ -77,6 +77,7 @@ export function resolveModelById(
 }
 
 export function getDisplayName(account: ProviderAccount, model: ModelConfig): string {
+  if (model.name === "default") return account.name;
   return `${account.name}:${model.name}`;
 }
 
@@ -119,7 +120,7 @@ export function resolveModel(modelSpec?: string, accounts?: ProviderAccount[]):
       (acc) => acc.name.toLowerCase() === searchName.toLowerCase() && acc.enabled && acc.type === "llm"
     );
     if (matchingAccount) {
-      const matchingModel = matchingAccount.models?.find((m) => m.name === model);
+      const matchingModel = matchingAccount.models?.find((m) => m.name === model || m.model_id === model);
       if (matchingModel) {
         return buildResolvedModel(matchingAccount, matchingModel);
       }
@@ -162,7 +163,7 @@ function findModelAndAccount(
     const account = accounts.find(
       (a) => a.name.toLowerCase() === providerName.toLowerCase() && a.enabled
     );
-    const model = account?.models?.find((m) => m.name === modelName);
+    const model = account?.models?.find((m) => m.name === modelName || m.model_id === modelName);
     return { model, account };
   }
   // Try matching by model UUID first

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

@@ -12,8 +12,10 @@ import {
   type TopicScanCandidate,
   type ItemMatchResult,
   type ParticipantContext,
+  type PersonaEntitySnapshot,
 } from "../../prompts/human/index.js";
 import { buildValidatePrompt } from "../../prompts/ceremony/dedup.js";
+import { normalizeRoomMessages } from "../handlers/utils.js";
 import { chunkExtractionContext } from "./extraction-chunker.js";
 import { getEmbeddingService, findTopK, getTopicEmbeddingText } from "../embedding-service.js";
 import { resolveTokenLimit } from "../llm-client.js";
@@ -582,6 +584,18 @@ export function queuePersonUpdate(
 
   const primaryPersonaIdForUpdate = context.personaId.split("|")[0];
 
+  const linkedPersonaId = !isNewItem
+    ? (existingItem?.identifiers ?? []).find(i => i.type.toLowerCase() === 'ei persona')?.value
+    : undefined;
+  const linkedPersonaEntity = linkedPersonaId ? state.persona_getById(linkedPersonaId) : undefined;
+  const personaEntitySnapshot: PersonaEntitySnapshot | undefined = linkedPersonaEntity
+    ? {
+        long_description: linkedPersonaEntity.long_description ?? '',
+        traits: (linkedPersonaEntity.traits ?? []).map(t => ({ name: t.name, description: t.description })),
+        topics: (linkedPersonaEntity.topics ?? []).map(t => ({ name: t.name, perspective: t.perspective })),
+      }
+    : undefined;
+
   for (const chunk of chunks) {
     const prompt = buildPersonUpdatePrompt({
       existing_item: existingItem,
@@ -593,6 +607,7 @@ export function queuePersonUpdate(
       persona_name: chunk.personaDisplayName,
       participant_context: buildParticipantContext(primaryPersonaIdForUpdate, state),
       known_identifier_types: userIdentifierTypes,
+      persona_entity: personaEntitySnapshot,
     });
 
     state.queue_enqueue({
@@ -622,6 +637,116 @@ export function queuePersonUpdate(
   return chunks.length;
 }
 
+export function queueTargetedPersonUpdate(
+  personId: string,
+  personaId: string,
+  state: StateManager,
+  roomId?: string
+): number {
+  const existingItem = state.getHuman().people.find(p => p.id === personId) ?? null;
+  if (!existingItem) {
+    console.warn(`[queueTargetedPersonUpdate] Person ${personId} not found`);
+    return 0;
+  }
+
+  let allMessages: Message[];
+  let contextPersonaId: string;
+  let displayName: string;
+
+  if (roomId) {
+    const room = state.getRoom(roomId);
+    if (!room) {
+      console.warn(`[queueTargetedPersonUpdate] Room ${roomId} not found`);
+      return 0;
+    }
+    allMessages = normalizeRoomMessages(state.getRoomActivePath(roomId), state);
+    contextPersonaId = room.persona_ids.join("|");
+    displayName = room.display_name;
+  } else {
+    const persona = state.persona_getById(personaId);
+    if (!persona) {
+      console.warn(`[queueTargetedPersonUpdate] Persona ${personaId} not found`);
+      return 0;
+    }
+    allMessages = state.messages_get(personaId);
+    contextPersonaId = personaId;
+    displayName = persona.display_name;
+  }
+
+  if (allMessages.length === 0) return 0;
+
+  const model = state.getHuman().settings?.default_model;
+  const context: ExtractionContext & {
+    candidateName: string;
+    candidateDescription: string;
+    candidateRelationship: string;
+    extraction_model?: string;
+  } = {
+    personaId: contextPersonaId,
+    personaDisplayName: displayName,
+    messages_context: [],
+    messages_analyze: allMessages,
+    candidateName: existingItem.name,
+    candidateDescription: existingItem.description,
+    candidateRelationship: existingItem.relationship,
+    extraction_model: model,
+    roomId,
+  };
+
+  const matchResult: ItemMatchResult = { matched_guid: personId };
+  return queuePersonUpdate(matchResult, context, state, existingItem);
+}
+
+export function queueTargetedTopicUpdate(
+  topicId: string,
+  personaId: string,
+  state: StateManager,
+  roomId?: string
+): number {
+  const existingItem = state.getHuman().topics.find(t => t.id === topicId) ?? null;
+  if (!existingItem) {
+    console.warn(`[queueTargetedTopicUpdate] Topic ${topicId} not found`);
+    return 0;
+  }
+
+  let allMessages: Message[];
+  let contextPersonaId: string;
+  let displayName: string;
+
+  if (roomId) {
+    const room = state.getRoom(roomId);
+    if (!room) {
+      console.warn(`[queueTargetedTopicUpdate] Room ${roomId} not found`);
+      return 0;
+    }
+    allMessages = normalizeRoomMessages(state.getRoomActivePath(roomId), state);
+    contextPersonaId = room.persona_ids.join("|");
+    displayName = room.display_name;
+  } else {
+    const persona = state.persona_getById(personaId);
+    if (!persona) {
+      console.warn(`[queueTargetedTopicUpdate] Persona ${personaId} not found`);
+      return 0;
+    }
+    allMessages = state.messages_get(personaId);
+    contextPersonaId = personaId;
+    displayName = persona.display_name;
+  }
+
+  if (allMessages.length === 0) return 0;
+
+  const model = state.getHuman().settings?.default_model;
+  const context: ExtractionContext = {
+    personaId: contextPersonaId,
+    personaDisplayName: displayName,
+    messages_context: [],
+    messages_analyze: allMessages,
+    roomId,
+  };
+
+  return queueDirectTopicUpdate(existingItem, context, state, { extraction_model: model });
+}
+
 export async function queueTopicValidate(
   newTopic: Topic,
   state: StateManager,

package/src/core/orchestrators/index.ts

@@ -9,6 +9,8 @@ export {
   queuePersonUpdate,
   queueEventSummary,
   queueTopicValidate,
+  queueTargetedPersonUpdate,
+  queueTargetedTopicUpdate,
   VALIDATE_MIN_SIMILARITY,
   type ExtractionContext,
   type ExtractionOptions,

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

@@ -58,7 +58,7 @@ function buildRoomParticipantContext(roomId: string, state: StateManager): Parti
   };
 }
 
-function getRoomVisibleMessages(state: StateManager, roomId: string): Message[] {
+export function getRoomVisibleMessages(state: StateManager, roomId: string): Message[] {
   const room = state.getRoom(roomId);
   if (!room) return [];
   const rawMessages = room.mode === RoomMode.FreeForAll

package/src/core/personas/opencode-agent.ts

@@ -26,6 +26,7 @@ export function resolveCanonicalAgent(agentName: string): { canonical: string; a
   let name = agentName;
   name = name.replace(/^ai-sdlc[:-]/, "");
   name = name.replace(/\s*\([^)]+\)\s*$/, "").trim();
+  name = name.replace(/\s{2,}\S+.*$/, "").trim();
   name = name.replace(/-/g, " ");
   const canonical = name.replace(/\b\w/g, (c) => c.toUpperCase());
 

package/src/core/processor.ts

@@ -39,7 +39,7 @@ import { ContextStatus as ContextStatusEnum, RoomMode } from "./types.js";
 import { registerReadMemoryExecutor, registerFileReadExecutor } from "./tools/index.js";
 import { createReadMemoryExecutor } from "./tools/builtin/read-memory.js";
 import { EI_WELCOME_MESSAGE, EI_PERSONA_DEFINITION } from "../templates/welcome.js";
-import { shouldStartCeremony, startCeremony, handleCeremonyProgress, queueUserDedupRequest, queueRoomCapture, queuePersonaCapture, checkAndQueueRoomExtraction } from "./orchestrators/index.js";
+import { shouldStartCeremony, startCeremony, handleCeremonyProgress, queueUserDedupRequest, queueRoomCapture, queuePersonaCapture, checkAndQueueRoomExtraction, queueTargetedPersonUpdate, queueTargetedTopicUpdate } from "./orchestrators/index.js";
 import { BUILT_IN_FACTS } from "./constants/built-in-facts.js";
 import { DEFAULT_SEED_TRAITS } from "./constants/seed-traits.js";
 
@@ -1994,6 +1994,14 @@ const toolNextSteps = new Set([
     queueRoomCapture(this.stateManager, roomId);
   }
 
+  captureTargetedPerson(personId: string, personaId: string, roomId?: string): number {
+    return queueTargetedPersonUpdate(personId, personaId, this.stateManager, roomId);
+  }
+
+  captureTargetedTopic(topicId: string, personaId: string, roomId?: string): number {
+    return queueTargetedTopicUpdate(topicId, personaId, this.stateManager, roomId);
+  }
+
   async submitOneShot(guid: string, systemPrompt: string, userPrompt: string): Promise<void> {
     return submitOneShot(
       this.stateManager,

package/src/core/state-manager.ts

@@ -373,11 +373,18 @@ export class StateManager {
         }
       }
 
+      for (const m of account.models) {
+        if (m.name === "(default)") {
+          m.name = "default";
+          if (m.model_id === "(default)") m.model_id = undefined;
+        }
+      }
+
       // If still no models, create a placeholder
       if (account.models.length === 0) {
-        const model = { id: crypto.randomUUID(), name: "(default)" };
+        const model = { id: crypto.randomUUID(), name: "default" };
         account.models.push(model);
-        modelLookup.set(`${account.name}:(default)`, model.id);
+        modelLookup.set(`${account.name}:default`, model.id);
         account.default_model = model.id;
       }
 
@@ -816,13 +823,6 @@ export class StateManager {
 
   messages_remove(personaId: string, messageIds: string[]): Message[] {
     const result = this.personaState.messages_remove(personaId, messageIds);
-    const removedIds = new Set(result.map(m => m.id));
-    const quotes = this.humanState.get().quotes ?? [];
-    for (const quote of quotes) {
-      if (quote.message_id && removedIds.has(quote.message_id)) {
-        quote.message_id = null;
-      }
-    }
     this.scheduleSave();
     return result;
   }

package/src/integrations/claude-code/importer.ts

@@ -12,6 +12,7 @@ import {
   type ExtractionContext,
 } from "../../core/orchestrators/human-extraction.js";
 import { isProcessRunning } from "../process-check.js";
+import { getMachineId } from "../machine-id.js";
 
 // =============================================================================
 // Export Types
@@ -268,7 +269,7 @@ export async function importClaudeCodeSessions(
       personaDisplayName: persona.display_name,
       messages_context: contextMsgs,
       messages_analyze: toAnalyze,
-      sources: [`claudecode:${targetSession.id}`],
+      sources: [`claudecode:${getMachineId()}:${targetSession.id}`],
     };
 
     const ccSettings = stateManager.getHuman().settings?.claudeCode;

package/src/integrations/cursor/importer.ts

@@ -8,6 +8,7 @@ import {
 } from "./types.js";
 import { CursorReader } from "./reader.js";
 import { isProcessRunning } from "../process-check.js";
+import { getMachineId } from "../machine-id.js";
 import {
   queueAllScans,
   type ExtractionContext,
@@ -227,7 +228,7 @@ export async function importCursorSessions(
       personaDisplayName: persona.display_name,
       messages_context: contextMsgs,
       messages_analyze: toAnalyze,
-      sources: [`cursor:${targetSession.id}`],
+      sources: [`cursor:${getMachineId()}:${targetSession.id}`],
     };
 
     queueAllScans(context, stateManager, { external_filter: "only" });

package/src/integrations/machine-id.ts

@@ -0,0 +1,5 @@
+import { hostname } from "node:os";
+
+export function getMachineId(): string {
+  return hostname().split(".")[0].toLowerCase();
+}

package/src/integrations/opencode/importer.ts

@@ -9,6 +9,7 @@ import {
   type ExtractionContext,
 } from "../../core/orchestrators/human-extraction.js";
 import { isProcessRunning } from "../process-check.js";
+import { getMachineId } from "../machine-id.js";
 
 // =============================================================================
 // Constants
@@ -250,7 +251,7 @@ export async function importOpenCodeSessions(
         personaDisplayName: persona.display_name,
         messages_context: contextMsgs,
         messages_analyze: toAnalyze,
-        sources: [`opencode:${targetSession.id}`],
+        sources: [`opencode:${getMachineId()}:${targetSession.id}`],
       };
 
       if (!signal?.aborted) {

package/src/integrations/opencode/types.ts

@@ -180,6 +180,8 @@ export const AGENT_ALIASES: Record<string, string[]> = {
     "sisyphus",
     "Sisyphus",
     "Sisyphus (Ultraworker)",
+    "Sisyphus Ultraworker",
+    "sisyphus ultraworker",
     "Planner-Sisyphus",
     "planner-sisyphus",
   ],

package/src/prompts/human/index.ts

@@ -15,6 +15,7 @@ export type { PersonUpdatePromptData } from "./person-update.js";
 export type {
   PromptOutput,
   ParticipantContext,
+  PersonaEntitySnapshot,
   FactScanPromptData,
   TopicScanPromptData,
   PersonScanPromptData,

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

@@ -1,4 +1,4 @@
-import type { PromptOutput, ParticipantContext } from "./types.js";
+import type { PromptOutput, ParticipantContext, PersonaEntitySnapshot } from "./types.js";
 import type { Person, Message } from "../../core/types.js";
 import { formatMessagesAsPlaceholders } from "../message-utils.js";
 
@@ -12,6 +12,7 @@ export interface PersonUpdatePromptData {
   persona_name: string;
   participant_context?: ParticipantContext;
   known_identifier_types?: string[];
+  persona_entity?: PersonaEntitySnapshot;
 }
 
 function participantContextSection(ctx: ParticipantContext | undefined): string {
@@ -46,6 +47,9 @@ export function buildPersonUpdatePrompt(data: PersonUpdatePromptData): PromptOut
   const personaName = data.persona_name;
   const isNewItem = data.existing_item === null;
   const humanName = data.participant_context?.human_name;
+  const isEiPersona = !isNewItem && (data.existing_item?.identifiers ?? []).some(
+    i => i.type.toLowerCase() === 'ei persona'
+  );
 
   const builtInTypes = ['Full Name', 'First Name', 'Nickname', 'Email', 'GitHub', 'Discord',
     'Roblox', 'Reddit', 'Twitter', 'FF14', 'Relationship', 'Ei Persona'];
@@ -99,19 +103,61 @@ Detail you add should:
 2. **NOT** already be present in the record above`;
 
   // ── DESCRIPTION SECTION ───────────────────────────────────────────────────
-  // New: shorter, no "don't accumulate" guidance (nothing to accumulate yet)
-  // Existing: full synthesis guidance
+  // Three modes:
+  //   isNewItem        → brief, factual bootstrap (1-3 sentences)
+  //   isEiPersona      → living identity log (accumulate, never truncate)
+  //   existing regular → synthesize to current-state (3-4 sentences)
 
-  const descriptionSection = isNewItem
-    ? `A concise summary of who this person is and how they relate to the HUMAN USER. Keep it brief and factual — only what you can confirm from the conversation.
+  let descriptionSection: string;
+
+  if (isNewItem) {
+    descriptionSection = `A concise summary of who this person is and how they relate to the HUMAN USER. Keep it brief and factual — only what you can confirm from the conversation.
 
 - Capture who this person IS — their role in the user's life
 - Be useful to a persona who's never heard this person's name before
 - 1-3 sentences maximum
 - If you know their birth date or birth year, include it as a date (e.g. "born 1986-10-28") — never as a current age (ages change, dates don't)
 
-**ABSOLUTELY VITAL**: Do **NOT** embellish. Record only what the user actually said or demonstrated.`
-    : `A concise summary of who this person is and how they relate to the HUMAN USER. Personas use this to recognize this person and engage meaningfully when they come up.
+**ABSOLUTELY VITAL**: Do **NOT** embellish. Record only what the user actually said or demonstrated.`;
+
+  } else if (isEiPersona) {
+    const entityRef = data.persona_entity
+      ? `## This Persona's Defined Identity (for reference)
+
+The following is ${personName}'s current self-definition — their traits, topics, and long description as set in the Persona editor. Use this as a **baseline**, not a ceiling.
+
+**Long description:**
+${data.persona_entity.long_description}
+
+**Traits:**
+${data.persona_entity.traits.map(t => `- **${t.name}**: ${t.description}`).join('\n')}
+
+**Topics:**
+${data.persona_entity.topics.map(t => `- **${t.name}**: ${t.perspective}`).join('\n')}
+
+`
+      : '';
+
+    descriptionSection = `${entityRef}This record is the HUMAN USER's **observed experience** of ${personName} over time — not the Persona's own definition. Think of it as field notes from someone who has been talking with this Persona across many conversations.
+
+## Your job: add, never truncate
+
+The description is allowed to grow. **Never remove or summarize away existing content.**
+
+Add anything from the Most Recent Messages that:
+- Extends or nuances what's already known (new behaviors, new opinions, recurring themes)
+- Agrees with or contradicts the Persona's defined identity — both are worth capturing
+- Reveals how the HUMAN USER experiences or relates to this Persona specifically
+
+**Do NOT:**
+- Synthesize the existing description down to fewer sentences
+- Replace specific observations with vague summaries
+- Discard detail to "keep it brief" — brevity is wrong here
+
+If the new messages add nothing meaningful, return \`{}\`. Otherwise, return the **full updated description** — existing content preserved, new observations woven in.`;
+
+  } else {
+    descriptionSection = `A concise summary of who this person is and how they relate to the HUMAN USER. Personas use this to recognize this person and engage meaningfully when they come up.
 
 ## CRITICAL: Synthesize, don't accumulate
 
@@ -134,6 +180,7 @@ The description should NOT:
 - Record someone's age — record their birth date or birth year instead (e.g. "born 1981" not "age 44")
 
 **ABSOLUTELY VITAL**: Do **NOT** embellish — personas use their own voice. Record what the user actually said or demonstrated, not your interpretation of its emotional significance.`;
+  }
 
   // ── IDENTIFIERS ───────────────────────────────────────────────────────────
 

package/src/prompts/human/types.ts

@@ -12,6 +12,13 @@ export interface ParticipantContext {
   human_age?: number;            // calculated from Birthday fact — omitted if not set
 }
 
+/** Snapshot of a linked Persona entity — passed to person-update when the Person record has an 'Ei Persona' identifier. */
+export interface PersonaEntitySnapshot {
+  long_description: string;
+  traits: Array<{ name: string; description: string }>;
+  topics: Array<{ name: string; perspective: string }>;
+}
+
 interface BaseScanPromptData {
   messages_context: Message[];
   messages_analyze: Message[];

package/src/prompts/response/sections.ts

@@ -368,7 +368,6 @@ Rooms are shared multi-persona conversations — a space where the Human and mul
 ## Learning About the Human
 As the human chats, the system learns about them:
 - **Facts**: Objective information (job, location, family members)
-- **Traits**: Personality characteristics and tendencies
 - **Topics**: Interests and how they feel about them
 - **People**: Relationships in their life
 - **Quotes**: Memorable things said in conversation (human selects these with ${viewQuotesAction})

package/tui/README.md

@@ -105,8 +105,8 @@ Rooms have three modes, set at creation time:
 
 | Command | Aliases | Description |
 |---------|---------|-------------|
-| `/me` | | Edit all your data (facts, traits, topics, people) in `$EDITOR` |
-| `/me <type>` | | Edit one type: `facts`, `traits`, `topics`, or `people` |
+| `/me` | | Edit all your data (facts, topics, people) in `$EDITOR` |
+| `/me <type>` | | Edit one type: `facts`, `topics`, or `people` |
 | `/dedupe <person\|topic> <term> [term2 ...]` | | Fuzzy-search and merge duplicate people or topics in `$EDITOR`. Unquoted words are individual OR terms; quoted strings match as exact phrases: `/dedupe person Flare "Jeremy Scherer"` finds records matching `Flare` OR `Jeremy Scherer` |
 | `/settings` | `/set` | Edit your global settings in `$EDITOR` |
 | `/setsync <user> <pass>` | `/ss` | Set sync credentials (triggers restart) |

package/tui/src/commands/capture.tsx

@@ -1,10 +1,11 @@
+import { PersonPickerOverlay } from "../components/PersonPickerOverlay.js";
 import type { Command } from "./registry";
 
 export const captureCommand: Command = {
   name: "capture",
   aliases: [],
   description: "Trigger extraction on current chat",
-  usage: "/capture | /capture opencode",
+  usage: "/capture | /capture opencode | /capture person <name> | /capture topic <name>",
 
   async execute(args, ctx) {
     if (args.length === 0) {
@@ -18,12 +19,110 @@ export const captureCommand: Command = {
       return;
     }
 
+    const subcommand = args[0].toLowerCase();
+
+    if (subcommand === "person" || subcommand === "people") {
+      const searchTerm = args.slice(1).join(" ").trim();
+      if (!searchTerm) {
+        ctx.showNotification("Usage: /capture person <name>", "error");
+        return;
+      }
+      const human = await ctx.ei.getHuman();
+      const matches = (human.people ?? []).filter(p =>
+        p.name.toLowerCase().includes(searchTerm.toLowerCase())
+      );
+      if (matches.length === 0) {
+        ctx.showNotification(`No person matching "${searchTerm}" found`, "warn");
+        return;
+      }
+
+      const firePerson = (id: string, name: string) => {
+        const queued = ctx.ei.captureTargetedPerson(id);
+        if (queued === 0) {
+          ctx.showNotification(`No messages to scan for "${name}"`, "warn");
+        } else {
+          ctx.showNotification(`Re-scan queued for "${name}" (${queued} chunk${queued !== 1 ? "s" : ""})`, "info");
+        }
+      };
+
+      if (matches.length === 1) {
+        firePerson(matches[0].id, matches[0].name);
+        return;
+      }
+
+      ctx.showOverlay((hideOverlay) => (
+        <PersonPickerOverlay
+          title={`Multiple matches for "${searchTerm}" — pick one:`}
+          people={matches.map(p => ({
+            id: p.id,
+            name: p.name,
+            relationship: p.relationship,
+            description: p.description,
+          }))}
+          onSelect={(picked) => {
+            hideOverlay();
+            firePerson(picked.id, picked.name);
+          }}
+          onDismiss={hideOverlay}
+        />
+      ), ctx.renderer);
+      return;
+    }
+
+    if (subcommand === "topic") {
+      const searchTerm = args.slice(1).join(" ").trim();
+      if (!searchTerm) {
+        ctx.showNotification("Usage: /capture topic <name>", "error");
+        return;
+      }
+      const human = await ctx.ei.getHuman();
+      const matches = (human.topics ?? []).filter(t =>
+        t.name.toLowerCase().includes(searchTerm.toLowerCase())
+      );
+      if (matches.length === 0) {
+        ctx.showNotification(`No topic matching "${searchTerm}" found`, "warn");
+        return;
+      }
+
+      const fireTopic = (id: string, name: string) => {
+        const queued = ctx.ei.captureTargetedTopic(id);
+        if (queued === 0) {
+          ctx.showNotification(`No messages to scan for "${name}"`, "warn");
+        } else {
+          ctx.showNotification(`Re-scan queued for "${name}" (${queued} chunk${queued !== 1 ? "s" : ""})`, "info");
+        }
+      };
+
+      if (matches.length === 1) {
+        fireTopic(matches[0].id, matches[0].name);
+        return;
+      }
+
+      ctx.showOverlay((hideOverlay) => (
+        <PersonPickerOverlay
+          title={`Multiple matches for "${searchTerm}" — pick one:`}
+          people={matches.map(t => ({
+            id: t.id,
+            name: t.name,
+            relationship: t.category,
+            description: t.description,
+          }))}
+          onSelect={(picked) => {
+            hideOverlay();
+            fireTopic(picked.id, picked.name);
+          }}
+          onDismiss={hideOverlay}
+        />
+      ), ctx.renderer);
+      return;
+    }
+
     const integrationMap: Record<string, "opencode" | "claudeCode" | "cursor"> = {
       opencode: "opencode",
       claudecode: "claudeCode",
       cursor: "cursor",
     };
-    const integrationKey = integrationMap[args[0].toLowerCase()];
+    const integrationKey = integrationMap[subcommand];
     if (integrationKey) {
       const human = await ctx.ei.getHuman();
       const intSettings = human.settings?.[integrationKey];
@@ -31,7 +130,6 @@ export const captureCommand: Command = {
         ctx.showNotification(`${args[0]} integration not enabled. Enable in /settings.`, "warn");
         return;
       }
-      // Reset last_sync to epoch to force immediate scan on next processor tick
       await ctx.ei.updateHuman({
         settings: {
           ...human.settings,
@@ -45,6 +143,6 @@ export const captureCommand: Command = {
       return;
     }
 
-    ctx.showNotification("Named capture not yet supported. Use /room or /persona to switch first.", "warn");
+    ctx.showNotification("Usage: /capture | /capture person <name> | /capture topic <name> | /capture opencode|claudecode|cursor", "warn");
   },
 };

package/tui/src/components/WelcomeOverlay.tsx

@@ -54,7 +54,7 @@ export function WelcomeOverlay(props: WelcomeOverlayProps) {
           Options:
         </text>
         <text fg="#93a1a1">
-          1. Start a local LLM (LM Studio, Ollama) on port 1234
+          1. Start LMStudio (port 1234) or Ollama (port 11434)
         </text>
         <text fg="#93a1a1">
           2. Run /provider new to configure a cloud provider

package/tui/src/context/ei.tsx

@@ -139,6 +139,8 @@ export interface EiContextValue {
   markAllRoomMessagesRead: () => Promise<number>;
   captureRoom: () => void;
   capturePersona: () => void;
+  captureTargetedPerson: (personId: string) => number;
+  captureTargetedTopic: (topicId: string) => number;
   sendSilenceMessage: (silenceReason?: string) => Promise<void>;
   humanRoomMessagePending: () => boolean;
   getArchivedRooms: () => RoomSummary[];
@@ -655,6 +657,24 @@ export const EiProvider: ParentComponent = (props) => {
     processor.capturePersona(personaId);
   };
 
+  const captureTargetedPerson = (personId: string): number => {
+    if (!processor) return 0;
+    const roomId = store.activeRoomId;
+    if (roomId) return processor.captureTargetedPerson(personId, '', roomId);
+    const personaId = store.activePersonaId;
+    if (!personaId) return 0;
+    return processor.captureTargetedPerson(personId, personaId);
+  };
+
+  const captureTargetedTopic = (topicId: string): number => {
+    if (!processor) return 0;
+    const roomId = store.activeRoomId;
+    if (roomId) return processor.captureTargetedTopic(topicId, '', roomId);
+    const personaId = store.activePersonaId;
+    if (!personaId) return 0;
+    return processor.captureTargetedTopic(topicId, personaId);
+  };
+
   const resolveRoomName = (nameOrAlias: string): string | null => {
     if (!processor) return null;
     return processor.resolveRoomName(nameOrAlias);
@@ -721,41 +741,57 @@ export const EiProvider: ParentComponent = (props) => {
           logger.info("E2E_SKIP_LOCAL_DETECT active, skipping local LLM check");
           setShowWelcomeOverlay(true);
         } else if (!hasAccounts) {
-          logger.info("No LLM accounts configured, checking for local LLM...");
-          try {
-            const response = await fetch("http://127.0.0.1:1234/v1/models", {
-              method: "GET",
-              signal: AbortSignal.timeout(3000),
-            });
-            if (response.ok) {
-              logger.info("Local LLM detected, auto-configuring...");
+          logger.info("No LLM accounts configured, checking for local LLMs...");
+
+          const candidates = [
+            { name: "LMStudio", url: "http://127.0.0.1:1234/v1" },
+            { name: "Ollama", url: "http://127.0.0.1:11434/v1" },
+          ];
+
+          const detected = await Promise.all(
+            candidates.map(async (candidate) => {
+              try {
+                const response = await fetch(`${candidate.url}/models`, {
+                  method: "GET",
+                  signal: AbortSignal.timeout(3000),
+                });
+                return response.ok ? candidate : null;
+              } catch {
+                return null;
+              }
+            })
+          );
+
+          const found = detected.filter(Boolean) as typeof candidates;
+
+          if (found.length > 0) {
+            const accounts: ProviderAccount[] = found.map((candidate) => {
               const defaultModelId = crypto.randomUUID();
-              const localAccount: ProviderAccount = {
+              return {
                 id: crypto.randomUUID(),
-                name: "Local LLM",
+                name: candidate.name,
                 type: "llm" as ProviderType,
-                url: "http://127.0.0.1:1234/v1",
+                url: candidate.url,
                 enabled: true,
                 created_at: new Date().toISOString(),
                 default_model: defaultModelId,
-                models: [{ id: defaultModelId, name: "(default)" }],
+                models: [{ id: defaultModelId, name: "default" }],
               };
-              const currentHuman = await processor!.getHuman();
-              await processor!.updateHuman({
-                settings: {
-                  ...currentHuman.settings,
-                  accounts: [localAccount],
-                  default_model: defaultModelId,
-                },
-              });
-              showNotification("Local LLM detected and configured!", "info");
-              logger.info("Local LLM auto-configured successfully");
-            } else {
-              logger.info("Local LLM check failed, showing welcome overlay");
-              setShowWelcomeOverlay(true);
-            }
-          } catch {
-            logger.info("No local LLM found, showing welcome overlay");
+            });
+            const firstDefaultModelId = accounts[0].default_model!;
+            const currentHuman = await processor!.getHuman();
+            await processor!.updateHuman({
+              settings: {
+                ...currentHuman.settings,
+                accounts,
+                default_model: firstDefaultModelId,
+              },
+            });
+            const names = found.map((c) => c.name).join(" and ");
+            showNotification(`${names} detected and configured!`, "info");
+            logger.info(`Auto-configured: ${names}`);
+          } else {
+            logger.info("No local LLMs found, showing welcome overlay");
             setShowWelcomeOverlay(true);
           }
         }
@@ -952,6 +988,8 @@ export const EiProvider: ParentComponent = (props) => {
     markAllRoomMessagesRead,
     captureRoom,
     capturePersona,
+    captureTargetedPerson,
+    captureTargetedTopic,
     sendSilenceMessage,
     humanRoomMessagePending,
     getArchivedRooms,

package/tui/src/storage/file.ts

@@ -178,7 +178,16 @@ export class FileStorage implements Storage {
     while (Date.now() - startTime < LOCK_TIMEOUT_MS) {
       const lockFile = Bun.file(lockPath);
       if (await lockFile.exists()) {
-        const lockContent = await lockFile.text();
+        // Read may throw if another writer deleted the lock between exists() and text() —
+        // treat that as "lock is gone, proceed to acquire" by falling through.
+        let lockContent: string;
+        try {
+          lockContent = await lockFile.text();
+        } catch {
+          // Lock vanished in the race window — retry from top to re-check state cleanly.
+          await new Promise((r) => setTimeout(r, LOCK_RETRY_DELAY_MS));
+          continue;
+        }
         const lockTime = parseInt(lockContent, 10);
         if (!isNaN(lockTime) && Date.now() - lockTime > LOCK_TIMEOUT_MS) {
           try {

package/tui/src/util/help-content.ts

@@ -85,6 +85,8 @@ ROOM COMMANDS
 
     /capture
         Force-extract quotes, topics, and people from the current chat now.
+        /capture person <name>  Re-scan all messages for a specific person.
+        /capture topic <name>   Re-scan all messages for a specific topic.
 
 EXTENDED COMMANDS
     /tools

package/tui/src/util/room-parser.ts

@@ -7,6 +7,9 @@ export function buildRoomYAMLTemplate(personas: PersonaSummary[], initialName =
   const personaLines = activePersonas.map((p) => `  ${p.display_name}: false`).join("\n");
   return `# Room configuration
 # mode: MAP | CYP | FFA
+#
+# CYP NOTE: Ei will NOT automatically extract Topics and People in Choose Your Path rooms.
+# When you reach an important moment, use the /capture command to extract data manually.
 display_name: "${initialName}"
 mode: FFA
 persona_ids:

package/tui/src/util/yaml-provider.ts

@@ -77,8 +77,8 @@ export function newProviderToYAML(name?: string): string {
 
   const modelsYAML = [
     "models:",
-    "  - name: (default)",
-    "    model_id: (default)",
+    "  - name: default",
+    "    model_id: default",
     "    token_limit: null",
     "    max_output_tokens: null",
     "    thinking_budget: null",
@@ -168,8 +168,8 @@ export function providerToYAML(account: ProviderAccount): string {
       modelLines.push(`    _delete: false`);
     }
   } else {
-    modelLines.push("  - name: (default)");
-    modelLines.push(`    model_id: (default)`);
+    modelLines.push("  - name: default");
+    modelLines.push(`    model_id: default`);
     modelLines.push(`    token_limit: null`);
     modelLines.push(`    max_output_tokens: null`);
     modelLines.push(`    thinking_budget: null`);