ei-tui 0.1.25 → 0.3.1

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

@@ -3,7 +3,6 @@
  * Source of truth: CONTRACTS.md
  */
 
-import type { ValidationLevel } from "./enums.js";
 
 export interface DataItemBase {
   id: string;
@@ -11,6 +10,7 @@ export interface DataItemBase {
   description: string;
   sentiment: number;
   last_updated: string;
+  last_mentioned?: string;        // Set by extraction only, never ceremony. Used for --recent sorting.
   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)
   persona_groups?: string[];
@@ -18,11 +18,10 @@ export interface DataItemBase {
 }
 
 export interface Fact extends DataItemBase {
-  validated: ValidationLevel;
   validated_date: string;
 }
 
-export interface Trait extends DataItemBase {
+export interface PersonaTrait extends DataItemBase {
   strength?: number;
 }
 
@@ -77,4 +76,4 @@ export interface Quote {
 
 export type DataItemType = "fact" | "trait" | "topic" | "person";
 
-export type DataItem = Fact | Trait | Topic | Person;
+export type DataItem = Fact | PersonaTrait | Topic | Person;

package/src/core/types/entities.ts

@@ -3,7 +3,7 @@
  * Source of truth: CONTRACTS.md
  */
 
-import type { Fact, Trait, Topic, Person, Quote, PersonaTopic } from "./data-items.js";
+import type { Fact, PersonaTrait, Topic, Person, Quote, PersonaTopic } from "./data-items.js";
 import type { ProviderType } from "./enums.js";
 
 export interface SyncCredentials {
@@ -14,6 +14,8 @@ export interface SyncCredentials {
 export interface OpenCodeSettings {
   integration?: boolean;
   polling_interval_ms?: number;  // Default: 1800000 (30 min)
+  extraction_model?: string;         // "Provider:model" for extraction. Unset = uses default_model.
+  extraction_token_limit?: number;   // Token budget for extraction chunking. Unset = resolved from model.
   last_sync?: string;  // ISO timestamp
   extraction_point?: string;  // ISO timestamp - cursor for single-session archive scan
   processed_sessions?: Record<string, string>;  // sessionId → ISO timestamp of last import
@@ -25,6 +27,7 @@ export interface CeremonyConfig {
   decay_rate?: number;  // Default: 0.1
   explore_threshold?: number;  // Default: 3
   dedup_threshold?: number;  // Cosine similarity threshold for dedup candidates. Default: 0.85
+  event_window_hours?: number;  // Gap threshold for conversation window detection. Default: 8
 }
 
 export interface BackupConfig {
@@ -83,12 +86,12 @@ export interface HumanSettings {
   ceremony?: CeremonyConfig;
   backup?: BackupConfig;
   claudeCode?: import("../../integrations/claude-code/types.js").ClaudeCodeSettings;
+  cursor?: import("../../integrations/cursor/types.js").CursorSettings;
 }
 
 export interface HumanEntity {
   entity: "human";
   facts: Fact[];
-  traits: Trait[];
   topics: Topic[];
   people: Person[];
   quotes: Quote[];
@@ -107,7 +110,7 @@ export interface PersonaEntity {
   model?: string;
   group_primary?: string | null;
   groups_visible?: string[];
-  traits: Trait[];
+  traits: PersonaTrait[];
   topics: PersonaTopic[];
   is_paused: boolean;
   pause_until?: string;
@@ -129,7 +132,7 @@ export interface PersonaCreationInput {
   aliases?: string[];
   long_description?: string;
   short_description?: string;
-  traits?: Partial<Trait>[];
+  traits?: Partial<PersonaTrait>[];
   topics?: Partial<PersonaTopic>[];
   model?: string;
   group_primary?: string;

package/src/core/types/enums.ts

@@ -9,11 +9,6 @@ export enum ContextStatus {
   Never = "never",
 }
 
-export enum ValidationLevel {
-  None = "none",     // Fresh data, never acknowledged
-  Ei = "ei",         // Ei mentioned it to user (don't mention again)
-  Human = "human",   // User explicitly confirmed (locked)
-}
 export enum LLMRequestType {
   Response = "response",
   JSON = "json",
@@ -30,12 +25,13 @@ export enum LLMNextStep {
   HandlePersonaResponse = "handlePersonaResponse",
   HandlePersonaGeneration = "handlePersonaGeneration",
   HandlePersonaDescriptions = "handlePersonaDescriptions",
-  HandleHumanFactScan = "handleHumanFactScan",
-  HandleHumanTraitScan = "handleHumanTraitScan",
+  HandleFactFind = "handleFactFind",
   HandleHumanTopicScan = "handleHumanTopicScan",
   HandleHumanPersonScan = "handleHumanPersonScan",
-  HandleHumanItemMatch = "handleHumanItemMatch",
-  HandleHumanItemUpdate = "handleHumanItemUpdate",
+  HandleTopicMatch = "handleTopicMatch",
+  HandleTopicUpdate = "handleTopicUpdate",
+  HandlePersonMatch = "handlePersonMatch",
+  HandlePersonUpdate = "handlePersonUpdate",
   HandlePersonaTraitExtraction = "handlePersonaTraitExtraction",
   HandlePersonaTopicScan = "handlePersonaTopicScan",
   HandlePersonaTopicMatch = "handlePersonaTopicMatch",
@@ -54,6 +50,7 @@ export enum LLMNextStep {
   HandleRewriteScan = "handleRewriteScan",
   HandleRewriteRewrite = "handleRewriteRewrite",
   HandleDedupCurate = "handleDedupCurate",
+  HandleEventScan = "handleEventScan",
 }
 
 export enum ProviderType {

package/src/core/types/llm.ts

@@ -18,9 +18,9 @@ export interface Message {
   // Extraction completion flags (omit when false to save space)
   // Single-letter names minimize storage overhead for large message histories
   f?: boolean;                 // Fact extraction completed
-  r?: boolean;                 // tRait extraction completed
+  t?: boolean;                 // Topic extraction completed
   p?: boolean;                 // Person extraction completed
-  o?: boolean;                 // tOpic extraction completed
+  e?: boolean;                 // Event (epic) extraction completed
   // Image generation fields (web-only, ephemeral)
   _synthesis?: boolean;         // True if message was created by multi-message synthesis
 

package/src/core/utils/crossFind.ts

@@ -1,13 +1,12 @@
-import type { HumanEntity, PersonaEntity, Fact, Trait, Topic, Person, Quote, PersonaTopic } from "../types.ts";
+import type { HumanEntity, PersonaEntity, Fact, PersonaTrait, Topic, Person, Quote, PersonaTopic } from "../types.ts";
 export type CrossFindResult =
   | { type: "fact"        } & Fact
-  | { type: "trait"       } & Trait
   | { type: "topic"       } & Topic
   | { type: "person"      } & Person
   | { type: "quote"       } & Quote
   | { type: "persona"     } & PersonaEntity
   | { type: "personaTopic"; personaId: string } & PersonaTopic
-  | { type: "personaTrait"; personaId: string } & Trait;
+  | { type: "personaTrait"; personaId: string } & PersonaTrait;
 
 export function crossFind(
   id: string,
@@ -18,8 +17,6 @@ export function crossFind(
   const fact  = human.facts.find(f => f.id === id);
   if (fact)  return { type: "fact",   ...fact };
 
-  const trait = human.traits.find(t => t.id === id);
-  if (trait) return { type: "trait",  ...trait };
 
   const person = human.people.find(p => p.id === id);
   if (person) return { type: "person", ...person };

package/src/core/utils/event-windows.ts

@@ -0,0 +1,31 @@
+import type { Message } from "../types.js";
+
+const DEFAULT_EVENT_WINDOW_HOURS = 8;
+
+export function buildEventWindows(
+  messages: Message[],
+  gapHours: number = DEFAULT_EVENT_WINDOW_HOURS
+): Message[][] {
+  if (messages.length === 0) return [];
+
+  const gapMs = gapHours * 60 * 60 * 1000;
+  const windows: Message[][] = [];
+  let currentWindow: Message[] = [messages[0]];
+
+  for (let i = 1; i < messages.length; i++) {
+    const prev = new Date(messages[i - 1].timestamp).getTime();
+    const curr = new Date(messages[i].timestamp).getTime();
+
+    if (curr - prev >= gapMs) {
+      windows.push(currentWindow);
+      currentWindow = [];
+    }
+    currentWindow.push(messages[i]);
+  }
+
+  if (currentWindow.length > 0) {
+    windows.push(currentWindow);
+  }
+
+  return windows;
+}

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

@@ -54,9 +54,9 @@ function convertToPreMarkedEiMessage(msg: ClaudeCodeMessage): Message {
   return {
     ...convertToEiMessage(msg),
     f: true,
-    r: true,
+    t: true,
     p: true,
-    o: true,
+    e: true,
   };
 }
 
@@ -130,7 +130,7 @@ function ensureSessionTopic(
     exposure_current: 0.5,
     exposure_desired: 0.3,
     persona_groups: CLAUDE_CODE_TOPIC_GROUPS,
-    learned_by: CLAUDE_CODE_PERSONA_NAME,
+    learned_by: stateManager.persona_getByName(CLAUDE_CODE_PERSONA_NAME)?.id ?? undefined,
     last_updated: new Date().toISOString(),
   };
 
@@ -158,6 +158,10 @@ function updateProcessedState(
       ...human.settings,
       claudeCode: {
         ...human.settings?.claudeCode,
+        // extraction_point is a progress indicator for user visibility only —
+        // it does NOT gate imports. processed_sessions is the sole source of
+        // truth for which sessions have been seen and when.
+        extraction_point: session.lastMessageAt,
         processed_sessions: processedSessions,
       },
     },
@@ -212,7 +216,8 @@ export async function importClaudeCodeSessions(
 
   // ─── Step 2: Find next unprocessed session ────────────────────────────
   const human = stateManager.getHuman();
-  const processedSessions = human.settings?.claudeCode?.processed_sessions ?? {};
+  const settings = human.settings?.claudeCode;
+  const processedSessions = settings?.processed_sessions ?? {};
   const now = Date.now();
 
   let targetSession: ClaudeCodeSession | null = null;
@@ -305,7 +310,11 @@ export async function importClaudeCodeSessions(
       messages_analyze: toAnalyze,
     };
 
-    queueAllScans(context, stateManager);
+    const ccSettings = stateManager.getHuman().settings?.claudeCode;
+    queueAllScans(context, stateManager, {
+      extraction_model: ccSettings?.extraction_model,
+      extraction_token_limit: ccSettings?.extraction_token_limit,
+    });
     result.extractionScansQueued += 4;
   }
 

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

@@ -158,6 +158,9 @@ export const MIN_SESSION_AGE_MS = 20 * 60 * 1000;
 export interface ClaudeCodeSettings {
   integration?: boolean;
   polling_interval_ms?: number;  // Default: 1800000 (30 min)
+  extraction_model?: string;         // "Provider:model" for extraction. Unset = uses default_model.
+  extraction_token_limit?: number;   // Token budget for extraction chunking. Unset = resolved from model.
   last_sync?: string;            // ISO timestamp
+  extraction_point?: string;     // ISO timestamp - floor cursor for processed-session skip
   processed_sessions?: Record<string, string>; // sessionId → ISO timestamp of last import
 }

package/src/integrations/cursor/importer.ts

@@ -0,0 +1,282 @@
+import type { StateManager } from "../../core/state-manager.js";
+import type { Ei_Interface, Topic, Message, ContextStatus, PersonaEntity } from "../../core/types.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";
+import {
+  queueAllScans,
+  type ExtractionContext,
+} from "../../core/orchestrators/human-extraction.js";
+
+export interface CursorImportResult {
+  sessionsProcessed: number;
+  topicsCreated: number;
+  topicsUpdated: number;
+  messagesImported: number;
+  personaCreated: boolean;
+  extractionScansQueued: number;
+}
+
+export interface CursorImporterOptions {
+  stateManager: StateManager;
+  interface?: Ei_Interface;
+  reader?: ICursorReader;
+  signal?: AbortSignal;
+}
+
+const TWELVE_HOURS_MS = 43_200_000;
+const CURSOR_GROUP = "Cursor";
+
+function convertToEiMessage(msg: CursorMessage): Message {
+  return {
+    id: msg.id,
+    role: msg.type === 1 ? "human" : "system",
+    verbal_response: msg.text,
+    timestamp: msg.timestamp,
+    read: true,
+    context_status: "default" as ContextStatus,
+  };
+}
+
+function convertToPreMarkedEiMessage(msg: CursorMessage): Message {
+  return {
+    ...convertToEiMessage(msg),
+    f: true,
+    t: true,
+    p: true,
+    e: true,
+  };
+}
+
+function ensureCursorPersona(
+  stateManager: StateManager,
+  eiInterface?: Ei_Interface
+): PersonaEntity {
+  const existing = stateManager.persona_getByName(CURSOR_PERSONA_NAME);
+  if (existing) return existing;
+
+  const now = new Date().toISOString();
+  const persona: PersonaEntity = {
+    id: crypto.randomUUID(),
+    display_name: CURSOR_PERSONA_NAME,
+    entity: "system",
+    aliases: ["cursor", "cursor ide"],
+    short_description: "Cursor IDE — AI-powered coding environment",
+    long_description:
+      "Cursor is an AI-powered IDE that helps with coding tasks, debugging, architecture decisions, and more.",
+    group_primary: CURSOR_GROUP,
+    groups_visible: [CURSOR_GROUP],
+    traits: [],
+    topics: [],
+    is_paused: false,
+    is_archived: false,
+    is_static: false,
+    heartbeat_delay_ms: TWELVE_HOURS_MS,
+    last_heartbeat: now,
+    last_updated: now,
+    last_activity: now,
+  };
+
+  stateManager.persona_add(persona);
+  eiInterface?.onPersonaAdded?.();
+  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(),
+  };
+
+  stateManager.human_topic_upsert(newTopic);
+  return "created";
+}
+
+function updateProcessedState(
+  stateManager: StateManager,
+  session: CursorSession
+): void {
+  const human = stateManager.getHuman();
+  const lastMessageMs = new Date(session.lastMessageAt).getTime();
+  const extractionPoint = human.settings?.cursor?.extraction_point;
+  const currentPointMs = extractionPoint ? new Date(extractionPoint).getTime() : 0;
+  const newPointMs = Math.max(currentPointMs, lastMessageMs);
+
+  const processedSessions = {
+    ...(human.settings?.cursor?.processed_sessions ?? {}),
+    [session.id]: new Date().toISOString(),
+  };
+
+  // extraction_point is a progress indicator for user visibility only —
+  // it does NOT gate imports. processed_sessions is the sole source of
+  // truth for which sessions have been seen and when.
+  stateManager.setHuman({
+    ...human,
+    settings: {
+      ...human.settings,
+      cursor: {
+        ...human.settings?.cursor,
+        extraction_point: new Date(newPointMs).toISOString(),
+        processed_sessions: processedSessions,
+      },
+    },
+  });
+}
+
+export async function importCursorSessions(
+  options: CursorImporterOptions
+): Promise<CursorImportResult> {
+  const { stateManager, interface: eiInterface, signal } = options;
+  const reader = options.reader ?? new CursorReader();
+
+  const result: CursorImportResult = {
+    sessionsProcessed: 0,
+    topicsCreated: 0,
+    topicsUpdated: 0,
+    messagesImported: 0,
+    personaCreated: false,
+    extractionScansQueued: 0,
+  };
+
+  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 ?? {};
+  const now = Date.now();
+
+  let targetSession: CursorSession | null = null;
+
+  for (const session of allSessions) {
+    const sessionLastMs = new Date(session.lastMessageAt).getTime();
+    const ageMs = now - sessionLastMs;
+
+    if (ageMs < MIN_SESSION_AGE_MS) continue;
+
+    const lastImported = processedSessions[session.id];
+    if (lastImported && sessionLastMs <= new Date(lastImported).getTime()) continue;
+
+    targetSession = session;
+    break;
+  }
+
+  if (!targetSession) {
+    console.log("[Cursor] All sessions processed, nothing new to import");
+    return result;
+  }
+
+  if (signal?.aborted) return result;
+
+  console.log(
+    `[Cursor] Processing session: "${targetSession.name}" ` +
+      `(last message: ${targetSession.lastMessageAt})`
+  );
+
+  const messages = targetSession.messages;
+
+  if (messages.length === 0) {
+    updateProcessedState(stateManager, targetSession);
+    return result;
+  }
+
+  if (signal?.aborted) return result;
+
+  const persona = ensureCursorPersona(stateManager, eiInterface);
+  result.personaCreated = !stateManager.persona_getByName(CURSOR_PERSONA_NAME);
+
+  if (!persona.is_archived) {
+    stateManager.persona_archive(persona.id);
+  }
+
+  const existingMsgs = stateManager.messages_get(persona.id);
+  if (existingMsgs.length > 0) {
+    stateManager.messages_remove(persona.id, existingMsgs.map((m) => m.id));
+  }
+
+  const cutoffIso = processedSessions[targetSession.id] ?? null;
+  const cutoffMs = cutoffIso ? new Date(cutoffIso).getTime() : null;
+  const toAnalyze: Message[] = [];
+
+  for (const msg of messages) {
+    const msgMs = new Date(msg.timestamp).getTime();
+    const isOld = cutoffMs !== null && msgMs < cutoffMs;
+    const eiMsg = isOld ? convertToPreMarkedEiMessage(msg) : convertToEiMessage(msg);
+    stateManager.messages_append(persona.id, eiMsg);
+    result.messagesImported++;
+    if (!isOld) toAnalyze.push(eiMsg);
+  }
+
+  stateManager.messages_sort(persona.id);
+  stateManager.persona_update(persona.id, {
+    last_activity: new Date().toISOString(),
+  });
+  eiInterface?.onMessageAdded?.(persona.id);
+
+  if (toAnalyze.length > 0 && !signal?.aborted) {
+    const allInState = stateManager.messages_get(persona.id);
+    const analyzeIds = new Set(toAnalyze.map((m) => m.id));
+    const analyzeStartIndex = allInState.findIndex((m) => analyzeIds.has(m.id));
+    const contextMsgs = analyzeStartIndex > 0 ? allInState.slice(0, analyzeStartIndex) : [];
+
+    const context: ExtractionContext = {
+      personaId: persona.id,
+      personaDisplayName: persona.display_name,
+      messages_context: contextMsgs,
+      messages_analyze: toAnalyze,
+    };
+
+    queueAllScans(context, stateManager, {});
+    result.extractionScansQueued += 4;
+  }
+
+  result.sessionsProcessed = 1;
+
+  updateProcessedState(stateManager, targetSession);
+
+  console.log(
+    `[Cursor] Session complete: ${result.messagesImported} messages imported, ` +
+      `${result.extractionScansQueued} extraction scans queued`
+  );
+
+  return result;
+}

package/src/integrations/cursor/index.ts

@@ -0,0 +1,10 @@
+export { CursorReader } from "./reader.js";
+export { importCursorSessions } from "./importer.js";
+export type { CursorImportResult, CursorImporterOptions } from "./importer.js";
+export type {
+  ICursorReader,
+  CursorSession,
+  CursorMessage,
+  CursorSettings,
+} from "./types.js";
+export { CURSOR_PERSONA_NAME } from "./types.js";