ei-tui 0.6.6 → 0.7.0

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

@@ -1,4 +1,5 @@
-import type { PersonaEntity, HumanEntity, DataItemBase, Quote, RoomEntity } from "./types.js";
+import type { PersonaEntity, HumanEntity, DataItemBase, Quote, RoomEntity, RoomMessage } from "./types.js";
+import { RoomMode, ContextStatus } from "./types.js";
 import { StateManager } from "./state-manager.js";
 import { getEmbeddingService, findTopK } from "./embedding-service.js";
 import type { ResponsePromptData, PromptOutput } from "../prompts/index.js";
@@ -121,7 +122,12 @@ export async function filterHumanDataByVisibility(
       selectRelevantQuotes(human.quotes ?? [], currentMessage),
     ]);
     const { topics, people } = capTopicsAndPeople(rawTopics, rawPeople);
+    const humanName =
+      human.settings?.name_display ||
+      human.facts?.find(f => f.name === "Nickname/Preferred Name")?.description ||
+      "Human";
     return {
+      name: humanName,
       facts,
       topics,
       people,
@@ -158,7 +164,12 @@ export async function filterHumanDataByVisibility(
   ]);
   const { topics, people } = capTopicsAndPeople(rawTopics, rawPeople);
 
+  const humanName =
+    human.settings?.name_display ||
+    human.facts?.find(f => f.name === "Nickname/Preferred Name")?.description ||
+    "Human";
   return {
+    name: humanName,
     facts,
     topics,
     people,
@@ -264,14 +275,30 @@ export async function buildRoomResponsePromptData(
     ? [...sm.getRoomMessages(room.id)].sort((a, b) => a.timestamp.localeCompare(b.timestamp))
     : activePath;
 
-  // Apply time window (same hours setting as 1:1 personas), but guarantee
-  // at least MIN_ROOM_MESSAGES so rooms never feel like they're starting over.
-  // Whichever anchor reaches further back wins.
-  const contextWindowHours = human.settings?.default_context_window_hours ?? 8;
-  const windowCutoff = new Date(Date.now() - contextWindowHours * 60 * 60 * 1000).toISOString();
-  const byTime = allSourceMessages.filter(m => m.timestamp >= windowCutoff);
-  const byCount = allSourceMessages.slice(-MIN_ROOM_MESSAGES);
-  const sourceMessages = byTime.length >= byCount.length ? byTime : byCount;
+  let sourceMessages: RoomMessage[];
+  if (room.mode === RoomMode.FreeForAll) {
+    const contextWindowHours = room.context_window_hours
+      ?? human.settings?.default_context_window_hours
+      ?? 8;
+    const windowCutoff = new Date(Date.now() - contextWindowHours * 60 * 60 * 1000).toISOString();
+    const boundaryMs = room.context_boundary ? new Date(room.context_boundary).getTime() : 0;
+    sourceMessages = allSourceMessages.filter(m => {
+      const msgMs = new Date(m.timestamp).getTime();
+      if (m.context_status === ContextStatus.Always) return true;
+      if (m.context_status === ContextStatus.Never) return false;
+      if (msgMs < new Date(windowCutoff).getTime()) return false;
+      if (boundaryMs && msgMs < boundaryMs) return false;
+      return true;
+    });
+    const byCount = allSourceMessages.slice(-MIN_ROOM_MESSAGES);
+    if (byCount.length > sourceMessages.length) sourceMessages = byCount;
+  } else {
+    const contextWindowHours = human.settings?.default_context_window_hours ?? 8;
+    const windowCutoff = new Date(Date.now() - contextWindowHours * 60 * 60 * 1000).toISOString();
+    const byTime = allSourceMessages.filter(m => m.timestamp >= windowCutoff);
+    const byCount = allSourceMessages.slice(-MIN_ROOM_MESSAGES);
+    sourceMessages = byTime.length >= byCount.length ? byTime : byCount;
+  }
 
   const lastMessage = sourceMessages[sourceMessages.length - 1];
   const currentMessage = lastMessage ? getMessageContent(lastMessage) : undefined;
@@ -297,7 +324,10 @@ export async function buildRoomResponsePromptData(
   }
   otherParticipants.push({
     id: "human",
-    name: human.settings?.name_display ?? "Human",
+    name:
+      human.settings?.name_display ||
+      human.facts?.find(f => f.name === "Nickname/Preferred Name")?.description ||
+      "Human",
     traits: [],
     is_human: true,
   });

package/src/core/queue-manager.ts

@@ -77,3 +77,21 @@ export async function submitOneShot(
     data: { guid },
   });
 }
+
+export async function submitOneShotJSON(
+  sm: StateManager,
+  getOneshotModel: () => string | undefined,
+  guid: string,
+  systemPrompt: string,
+  userPrompt: string
+): Promise<void> {
+  sm.queue_enqueue({
+    type: LLMRequestType.JSON,
+    priority: LLMPriority.High,
+    system: systemPrompt,
+    user: userPrompt,
+    next_step: LLMNextStep.HandleOneShotJSON,
+    model: getOneshotModel(),
+    data: { guid },
+  });
+}

package/src/core/room-manager.ts

@@ -149,8 +149,19 @@ export async function sendFfaMessage(
   }
 
   const now = new Date().toISOString();
+
+  // FFA human messages always hang off the room root (the initial message with parent_id === null)
+  // so the tree is a flat star: root → every human turn, each human turn → persona responses.
+  // This gives the context window a bounded, predictable shape instead of a chain.
+  const ffaRootMsg = sm.getRoomMessages(roomId).find(m => m.parent_id === null);
+  if (!ffaRootMsg) {
+    onError({ code: "ROOM_NO_ROOT", message: "FFA room has no root message. Try archiving and recreating the room." });
+    return;
+  }
+  const ffaParentId = ffaRootMsg.id;
+
   const existing = sm.getRoomMessages(roomId).find(
-    m => m.role === "human" && m.parent_id === room.active_node_id
+    m => m.role === "human" && m.id === room.active_node_id && m.parent_id === ffaParentId
   );
 
   let humanMsgId: string;
@@ -164,7 +175,7 @@ export async function sendFfaMessage(
   } else {
     const msg: RoomMessage = {
       id: crypto.randomUUID(),
-      parent_id: room.active_node_id,
+      parent_id: ffaParentId,
       role: "human",
       verbal_response: content ?? undefined,
       silence_reason: content ? undefined : (silenceReason ?? "passed"),
@@ -278,9 +289,14 @@ export async function activateRoom(
 
     const currentRound = allMessages.filter(m => m.parent_id === room.active_node_id);
 
+    const humanDisplayName =
+      human.settings?.name_display ||
+      human.facts?.find(f => f.name === "Nickname/Preferred Name")?.description ||
+      "Human";
+
     const context: RoomHistoryMessage[] = sm.getRoomActivePath(roomId).map(m => ({
       speaker_name: m.role === "human"
-        ? (human.settings?.name_display ?? "Human")
+        ? humanDisplayName
         : (sm.persona_getById(m.persona_id ?? "")?.display_name ?? "Unknown"),
       speaker_id: m.role === "human" ? "human" : (m.persona_id ?? ""),
       verbal_response: getMessageContent(m) || undefined,
@@ -290,7 +306,7 @@ export async function activateRoom(
     const candidates: RoomJudgeCandidate[] = currentRound.map(m => ({
       message_id: m.id,
       speaker_name: m.role === "human"
-        ? (human.settings?.name_display ?? "Human")
+        ? humanDisplayName
         : (sm.persona_getById(m.persona_id ?? "")?.display_name ?? "Unknown"),
       speaker_id: m.role === "human" ? "human" : (m.persona_id ?? ""),
       verbal_response: getMessageContent(m) || undefined,
@@ -305,6 +321,7 @@ export async function activateRoom(
         long_description: judgePersona.long_description,
         traits: judgePersona.traits,
       },
+      human: { name: humanDisplayName },
       context,
       candidates,
     });

package/src/core/state-manager.ts

@@ -17,7 +17,9 @@ import type {
   RoomSummary,
   RoomCreationInput,
 } from "./types.js";
+import { RoomMode } from "./types.js";
 import { BUILT_IN_FACT_NAMES } from './constants/built-in-facts.js';
+import type { ThemeDefinition } from './types/entities.js';
 import type { Storage } from "../storage/interface.js";
 import {
   HumanState,
@@ -68,6 +70,8 @@ export class StateManager {
     this.migrateInterestedPersonas();
     this.migrateProviderModel();
     this.migrateRoomMessageContent();
+    this.migrateThemes();
+    this.migrateFfaParentIds();
   }
 
   private migrateRoomMessageContent(): void {
@@ -566,6 +570,38 @@ export class StateManager {
     this.persistenceState.scheduleSave(this.buildStorageState());
   }
 
+  private migrateThemes(): void {
+    const human = this.humanState.get();
+    if (!human.settings) return;
+    if (human.settings.custom_themes !== undefined) return;
+    human.settings.custom_themes = [];
+    this.humanState.set(human);
+  }
+
+  private migrateFfaParentIds(): void {
+    const rooms = this.roomState.getAll(true);
+    let migratedCount = 0;
+
+    for (const room of rooms) {
+      if (room.mode !== RoomMode.FreeForAll) continue;
+      const rootMsg = room.messages.find(m => m.parent_id === null);
+      if (!rootMsg) continue;
+
+      for (const msg of room.messages) {
+        if (msg.role !== "human") continue;
+        if (msg.id === rootMsg.id) continue;
+        if (msg.parent_id === rootMsg.id) continue;
+        msg.parent_id = rootMsg.id;
+        migratedCount++;
+      }
+    }
+
+    if (migratedCount > 0) {
+      this.scheduleSave();
+      console.log(`[StateManager] Migrated ${migratedCount} FFA human messages to root parent_id`);
+    }
+  }
+
   getHuman(): HumanEntity {
     return this.humanState.get();
   }
@@ -575,6 +611,44 @@ export class StateManager {
     this.scheduleSave();
   }
 
+  human_theme_getActive(): string | undefined {
+    return this.getHuman().settings?.active_theme;
+  }
+
+  human_theme_setActive(id: string | undefined): void {
+    const human = this.getHuman();
+    human.settings ??= {};
+    human.settings.active_theme = id;
+    this.setHuman(human);
+  }
+
+  human_theme_getAll(): ThemeDefinition[] {
+    return this.getHuman().settings?.custom_themes ?? [];
+  }
+
+  human_theme_upsert(theme: ThemeDefinition): void {
+    const human = this.getHuman();
+    human.settings ??= {};
+    human.settings.custom_themes ??= [];
+    const idx = human.settings.custom_themes.findIndex(t => t.id === theme.id);
+    if (idx >= 0) {
+      human.settings.custom_themes[idx] = theme;
+    } else {
+      human.settings.custom_themes.push(theme);
+    }
+    this.setHuman(human);
+  }
+
+  human_theme_remove(id: string): boolean {
+    const human = this.getHuman();
+    const themes = human.settings?.custom_themes ?? [];
+    const idx = themes.findIndex(t => t.id === id);
+    if (idx < 0) return false;
+    themes.splice(idx, 1);
+    this.setHuman(human);
+    return true;
+  }
+
   human_fact_upsert(fact: Fact): void {
     this.humanState.fact_upsert(fact);
     this.scheduleSave();

package/src/core/tools/builtin/read-memory.ts

@@ -57,7 +57,7 @@ export function createReadMemoryExecutor(searchHumanData: SearchHumanData, getPe
       const output: Record<string, unknown[]> = {};
       if (results.facts.length > 0) output.facts = results.facts.map(f => ({ name: f.name, description: f.description }));
       if (results.topics.length > 0) output.topics = results.topics.map(t => ({ name: t.name, description: t.description }));
-      if (results.people.length > 0) output.people = results.people.map(p => ({ name: p.name, relationship: p.relationship, description: p.description }));
+      if (results.people.length > 0) output.people = results.people.map(p => ({ name: p.name, relationship: p.relationship, description: p.description, identifiers: p.identifiers ?? [] }));
       if (results.quotes.length > 0) output.quotes = results.quotes.map(q => ({ text: q.text, speaker: q.speaker }));
 
       if (Object.keys(output).length === 0) {

package/src/core/types/data-items.ts

@@ -15,6 +15,7 @@ export interface DataItemBase {
   learned_by?: string;           // Persona ID that originally learned this item (stable UUID)
   last_changed_by?: string;      // Persona ID that most recently updated this item (stable UUID)
   interested_personas?: string[]; // Persona IDs that have extracted/touched this item (accumulated)
+  sources?: string[];            // Namespaced source identifiers — where items were learned from. Format: "provider:id" (e.g., "opencode:ses_abc123", "cursor:composerId"). Grow-only union.
   persona_groups?: string[];
   embedding?: number[];
   rewrite_checked?: boolean;     // True after rewrite scan finds no changes. Cleared automatically when extraction upserts a fresh item.

package/src/core/types/entities.ts

@@ -91,6 +91,14 @@ export interface ProviderAccount {
   created_at: string;              // ISO timestamp
 }
 
+export interface ThemeDefinition {
+  id: string;
+  name: string;
+  base?: string;
+  encoded: string;
+  created_at: string;
+}
+
 export interface HumanSettings {
   default_model?: string;           // Will store ModelConfig.id GUID post-migration
   oneshot_model?: string;           // Model for AI-assist (wand) requests; falls back to default_model. Will store ModelConfig.id GUID post-migration.
@@ -111,6 +119,8 @@ export interface HumanSettings {
   backup?: BackupConfig;
   claudeCode?: import("../../integrations/claude-code/types.js").ClaudeCodeSettings;
   cursor?: import("../../integrations/cursor/types.js").CursorSettings;
+  active_theme?: string;
+  custom_themes?: ThemeDefinition[];
 }
 
 export interface HumanEntity {
@@ -152,6 +162,9 @@ export interface PersonaEntity {
   tools?: string[];              // IDs of ToolDefinitions this persona can use. Empty/absent = no tool access.
   reflection_last_asked?: string;   // ISO timestamp. Set ONLY when Persona explicitly surfaces identity drift (mentioned_reflection: true).
   description_embedding?: number[]; // Embedding of long_description (short_description fallback). Excludes traits. See embedding-service.ts:getPersonaDescriptionText.
+  avatar_emoji?: string;            // Single emoji character used as avatar in place of initials.
+  avatar_image?: string;            // Base64-encoded 64×64 image used as avatar (takes priority over avatar_emoji).
+  preferred_theme?: string;         // Theme ID (built-in name or ThemeDefinition.id). Applied to chat panel when this persona is active.
 }
 
 export interface PersonaCreationInput {

package/src/core/types/enums.ts

@@ -38,6 +38,7 @@ export enum LLMNextStep {
   HandleHeartbeatCheck = "handleHeartbeatCheck",
   HandleEiHeartbeat = "handleEiHeartbeat",
   HandleOneShot = "handleOneShot",
+  HandleOneShotJSON = "handleOneShotJSON",
   // Tool calling continuation (second LLM call after tool execution, may loop for more tool calls).
   // data.toolHistory: serialized LLMHistoryMessage[] (assistant + tool result messages)
   // data.toolCallCounts: serialized Map entries [[name, count], ...] carrying per-tool call counts

package/src/core/types/integrations.ts

@@ -56,6 +56,9 @@ export interface PersonaSummary {
   unread_count: number;
   last_activity?: string;
   context_boundary?: string;
+  avatar_emoji?: string;
+  avatar_image?: string;
+  preferred_theme?: string;
 }
 
 export interface MessageQueryOptions {
@@ -99,6 +102,7 @@ export interface Ei_Interface {
   onError?: (error: EiError) => void;
   onStateImported?: () => void;
   onOneShotReturned?: (guid: string, content: string) => void;
+  onOneShotJSONReturned?: (guid: string, parsed: unknown) => void;
   onContextBoundaryChanged?: (personaId: string) => void;
   onSaveAndExitStart?: () => void;
   onSaveAndExitFinish?: () => void;

package/src/core/types/rooms.ts

@@ -38,6 +38,8 @@ export interface RoomEntity {
   last_updated: string;
   last_activity: string;
   capture_used?: boolean;
+  context_window_hours?: number;  // FFA only; falls back to human.settings.default_context_window_hours
+  context_boundary?: string;      // FFA only; ISO timestamp; same semantics as persona context_boundary
   messages: RoomMessage[];
 }
 

package/src/core/utils/identifier-utils.ts

@@ -1,8 +1,32 @@
 import type { PersonIdentifier } from "../types/data-items.js";
 import type { StateManager } from "../state-manager.js";
+import { BUILT_IN_IDENTIFIER_TYPES } from "../constants/built-in-identifier-types.js";
 
 export const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
+function toNormalizedKey(s: string): string {
+  return s.replace(/[^a-z0-9]/gi, '').toLowerCase();
+}
+
+// Fuzzy-matches LLM-provided type against built-in + in-use types (strip non-alphanumeric, lowercase).
+// "nickname" -> "Nickname", "full_name" -> "Full Name", "EMAIL" -> "Email", "Slack RNP" -> "Slack RNP" (custom, no match)
+export function normalizeIdentifierType(llmType: string, state: StateManager): string {
+  const inUseTypes = state.getHuman().people.flatMap(p =>
+    (p.identifiers ?? []).map(i => i.type)
+  );
+
+  const canonicalMap = new Map<string, string>();
+  for (const t of [...BUILT_IN_IDENTIFIER_TYPES, ...inUseTypes]) {
+    const key = toNormalizedKey(t);
+    if (!canonicalMap.has(key)) {
+      canonicalMap.set(key, t);
+    }
+  }
+
+  const normalized = toNormalizedKey(llmType);
+  return canonicalMap.get(normalized) ?? llmType;
+}
+
 export function sanitizeEiPersonaIdentifiers(
   identifiers: PersonIdentifier[],
   state: StateManager

package/src/core/utils/theme-codec.ts

@@ -0,0 +1,78 @@
+import type { ThemeDefinition } from "../types/entities.js";
+
+const VERSION = "v1";
+const PREFIX = `ei-theme:${VERSION}:`;
+const TOKEN_COUNT = 37;
+const HEX_LENGTH = 6;
+
+export const THEME_TOKEN_ORDER: readonly string[] = [
+  "bg-primary", "bg-secondary", "bg-tertiary",
+  "border", "border-light",
+  "text-primary", "text-secondary", "text-muted",
+  "accent", "accent-hover",
+  "success", "success-hover",
+  "warning", "warning-text",
+  "danger",
+  "status-thinking", "status-ready", "status-unread", "status-paused",
+  "room-cyp", "room-ffa", "room-map",
+  "archive-bg-start", "archive-bg-end", "archive-border",
+  "ai-assist-start", "ai-assist-end",
+  "code-bg", "code-bg-controls", "code-border",
+  "code-text", "code-text-muted",
+  "code-accent", "code-string", "code-error", "code-success", "code-special",
+] as const;
+
+export const BUILT_IN_THEME_NAMES: readonly string[] = [
+  "default", "dark", "coder", "depressing", "cotton-candy",
+  "crimuh", "spoopy", "lovey-dovey", "lucky",
+] as const;
+
+export type ThemeTokenMap = Record<string, string>;
+
+export function encodeTheme(tokens: ThemeTokenMap): string {
+  const hex = THEME_TOKEN_ORDER.map((key) => {
+    const value = tokens[`--ei-${key}`] ?? tokens[key] ?? "000000";
+    return value.replace(/^#/, "").toLowerCase().padEnd(HEX_LENGTH, "0").slice(0, HEX_LENGTH);
+  }).join("");
+  return PREFIX + btoa(hex);
+}
+
+export function decodeTheme(encoded: string): ThemeTokenMap | null {
+  if (!encoded.startsWith(PREFIX)) return null;
+  try {
+    const hex = atob(encoded.slice(PREFIX.length));
+    if (hex.length !== TOKEN_COUNT * HEX_LENGTH) return null;
+    const tokens: ThemeTokenMap = {};
+    for (let i = 0; i < TOKEN_COUNT; i++) {
+      const key = THEME_TOKEN_ORDER[i];
+      tokens[`--ei-${key}`] = `#${hex.slice(i * HEX_LENGTH, (i + 1) * HEX_LENGTH)}`;
+    }
+    return tokens;
+  } catch {
+    return null;
+  }
+}
+
+export function themeToStyleString(tokens: ThemeTokenMap): string {
+  return Object.entries(tokens)
+    .map(([k, v]) => `  ${k}: ${v};`)
+    .join("\n");
+}
+
+export function isBuiltInTheme(id: string): boolean {
+  return (BUILT_IN_THEME_NAMES as readonly string[]).includes(id);
+}
+
+export function makeThemeDefinition(
+  name: string,
+  tokens: ThemeTokenMap,
+  base?: string,
+): ThemeDefinition {
+  return {
+    id: crypto.randomUUID(),
+    name,
+    base,
+    encoded: encodeTheme(tokens),
+    created_at: new Date().toISOString(),
+  };
+}

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

@@ -1,10 +1,9 @@
 import type { StateManager } from "../../core/state-manager.js";
-import type { Ei_Interface, Topic, Message, ContextStatus, PersonaEntity, PersonaTrait } from "../../core/types.js";
+import type { Ei_Interface, Message, ContextStatus, PersonaEntity, PersonaTrait } from "../../core/types.js";
 import { DEFAULT_SEED_TRAITS } from "../../core/constants/seed-traits.js";
 import type { IClaudeCodeReader, ClaudeCodeSession, ClaudeCodeMessage } from "./types.js";
 import {
   CLAUDE_CODE_PERSONA_NAME,
-  CLAUDE_CODE_TOPIC_GROUPS,
   MIN_SESSION_AGE_MS,
 } from "./types.js";
 import { ClaudeCodeReader } from "./reader.js";
@@ -20,8 +19,6 @@ import { isProcessRunning } from "../process-check.js";
 
 export interface ClaudeCodeImportResult {
   sessionsProcessed: number;
-  topicsCreated: number;
-  topicsUpdated: number;
   messagesImported: number;
   personaCreated: boolean;
   extractionScansQueued: number;
@@ -109,47 +106,6 @@ function ensureClaudeCodePersona(
   return persona;
 }
 
-// =============================================================================
-// Topic Management
-// =============================================================================
-
-function ensureSessionTopic(
-  session: ClaudeCodeSession,
-  stateManager: StateManager
-): "created" | "updated" | "unchanged" {
-  const human = stateManager.getHuman();
-  const existingTopic = human.topics.find((t) => t.id === session.id);
-
-  if (existingTopic) {
-    if (existingTopic.name !== session.title) {
-      const updatedTopic: Topic = {
-        ...existingTopic,
-        name: session.title,
-        last_updated: new Date().toISOString(),
-      };
-      stateManager.human_topic_upsert(updatedTopic);
-      return "updated";
-    }
-    return "unchanged";
-  }
-
-  const newTopic: Topic = {
-    id: session.id,
-    name: session.title,
-    description: `Claude Code session in ${session.cwd}`,
-    sentiment: 0,
-    exposure_current: 0.5,
-    exposure_desired: 0.3,
-    persona_groups: CLAUDE_CODE_TOPIC_GROUPS,
-    learned_by: stateManager.persona_getByName(CLAUDE_CODE_PERSONA_NAME)?.id ?? undefined,
-    last_updated: new Date().toISOString(),
-    learned_on: new Date().toISOString(),
-  };
-
-  stateManager.human_topic_upsert(newTopic);
-  return "created";
-}
-
 // =============================================================================
 // State Helpers
 // =============================================================================
@@ -205,26 +161,15 @@ export async function importClaudeCodeSessions(
 
   const result: ClaudeCodeImportResult = {
     sessionsProcessed: 0,
-    topicsCreated: 0,
-    topicsUpdated: 0,
     messagesImported: 0,
     personaCreated: false,
     extractionScansQueued: 0,
   };
 
-  // ─── Step 1: Ensure topics exist for ALL sessions ─────────────────────
+  // ─── Step 1: Get all sessions ─────────────────────────────────────────
   const allSessions = await reader.getSessions();
 
-  for (const session of allSessions) {
-    const topicResult = ensureSessionTopic(session, stateManager);
-    if (topicResult === "created") result.topicsCreated++;
-    else if (topicResult === "updated") result.topicsUpdated++;
-  }
-
   if (signal?.aborted) return result;
-  if (result.topicsCreated > 0 || result.topicsUpdated > 0) {
-    eiInterface?.onHumanUpdated?.();
-  }
 
   // ─── Step 2: Find next unprocessed session ────────────────────────────
   const human = stateManager.getHuman();
@@ -323,6 +268,7 @@ export async function importClaudeCodeSessions(
       personaDisplayName: persona.display_name,
       messages_context: contextMsgs,
       messages_analyze: toAnalyze,
+      sources: [`claudecode:${targetSession.id}`],
     };
 
     const ccSettings = stateManager.getHuman().settings?.claudeCode;

package/src/integrations/cursor/importer.ts

@@ -1,10 +1,9 @@
 import type { StateManager } from "../../core/state-manager.js";
-import type { Ei_Interface, Topic, Message, ContextStatus, PersonaEntity, PersonaTrait } from "../../core/types.js";
+import type { Ei_Interface, Message, ContextStatus, PersonaEntity, PersonaTrait } from "../../core/types.js";
 import { DEFAULT_SEED_TRAITS } from "../../core/constants/seed-traits.js";
 import type { ICursorReader, CursorSession, CursorMessage } from "./types.js";
 import {
   CURSOR_PERSONA_NAME,
-  CURSOR_TOPIC_GROUPS,
   MIN_SESSION_AGE_MS,
 } from "./types.js";
 import { CursorReader } from "./reader.js";
@@ -16,8 +15,6 @@ import {
 
 export interface CursorImportResult {
   sessionsProcessed: number;
-  topicsCreated: number;
-  topicsUpdated: number;
   messagesImported: number;
   personaCreated: boolean;
   extractionScansQueued: number;
@@ -97,43 +94,6 @@ function ensureCursorPersona(
   return persona;
 }
 
-function ensureSessionTopic(
-  session: CursorSession,
-  stateManager: StateManager
-): "created" | "updated" | "unchanged" {
-  const human = stateManager.getHuman();
-  const existingTopic = human.topics.find((t) => t.id === session.id);
-
-  if (existingTopic) {
-    if (existingTopic.name !== session.name) {
-      const updatedTopic: Topic = {
-        ...existingTopic,
-        name: session.name,
-        last_updated: new Date().toISOString(),
-      };
-      stateManager.human_topic_upsert(updatedTopic);
-      return "updated";
-    }
-    return "unchanged";
-  }
-
-  const newTopic: Topic = {
-    id: session.id,
-    name: session.name,
-    description: `Cursor session in ${session.workspacePath}`,
-    sentiment: 0,
-    exposure_current: 0.5,
-    exposure_desired: 0.3,
-    persona_groups: CURSOR_TOPIC_GROUPS,
-    learned_by: stateManager.persona_getByName(CURSOR_PERSONA_NAME)?.id ?? undefined,
-    last_updated: new Date().toISOString(),
-    learned_on: new Date().toISOString(),
-  };
-
-  stateManager.human_topic_upsert(newTopic);
-  return "created";
-}
-
 function updateProcessedState(
   stateManager: StateManager,
   session: CursorSession
@@ -173,8 +133,6 @@ export async function importCursorSessions(
 
   const result: CursorImportResult = {
     sessionsProcessed: 0,
-    topicsCreated: 0,
-    topicsUpdated: 0,
     messagesImported: 0,
     personaCreated: false,
     extractionScansQueued: 0,
@@ -182,16 +140,7 @@ export async function importCursorSessions(
 
   const allSessions = await reader.getSessions();
 
-  for (const session of allSessions) {
-    const topicResult = ensureSessionTopic(session, stateManager);
-    if (topicResult === "created") result.topicsCreated++;
-    else if (topicResult === "updated") result.topicsUpdated++;
-  }
-
   if (signal?.aborted) return result;
-  if (result.topicsCreated > 0 || result.topicsUpdated > 0) {
-    eiInterface?.onHumanUpdated?.();
-  }
 
   const human = stateManager.getHuman();
   const processedSessions = human.settings?.cursor?.processed_sessions ?? {};
@@ -278,6 +227,7 @@ export async function importCursorSessions(
       personaDisplayName: persona.display_name,
       messages_context: contextMsgs,
       messages_analyze: toAnalyze,
+      sources: [`cursor:${targetSession.id}`],
     };
 
     queueAllScans(context, stateManager, { external_filter: "only" });