ei-tui 0.1.25 → 0.2.0

package/src/prompts/persona/traits.ts

@@ -1,8 +1,8 @@
 import type { PersonaTraitExtractionPromptData, PromptOutput } from "./types.js";
-import type { Trait } from "../../core/types.js";
+import type { PersonaTrait } from "../../core/types.js";
 import { formatMessagesAsPlaceholders } from "../message-utils.js";
 
-function formatTraitsForPrompt(traits: Trait[]): string {
+function formatTraitsForPrompt(traits: PersonaTrait[]): string {
   if (traits.length === 0) return "(No traits yet)";
   
   return JSON.stringify(traits.map(t => ({

package/src/prompts/persona/types.ts

@@ -1,4 +1,4 @@
-import type { Trait, Message, PersonaTopic } from "../../core/types.js";
+import type { PersonaTrait, Message, PersonaTopic } from "../../core/types.js";
 
 export interface PromptOutput {
   system: string;
@@ -7,7 +7,7 @@ export interface PromptOutput {
 
 export interface PersonaTraitExtractionPromptData {
   persona_name: string;
-  current_traits: Trait[];
+  current_traits: PersonaTrait[];
   messages_context: Message[];
   messages_analyze: Message[];
 }
@@ -56,7 +56,7 @@ export interface PersonaTopicUpdatePromptData {
   persona_name: string;
   short_description?: string;
   long_description?: string;
-  traits: Trait[];
+  traits: PersonaTrait[];
   existing_topic?: PersonaTopic; // If updating existing
   candidate: PersonaTopicScanCandidate;
   messages_context: Message[];

package/src/prompts/response/index.ts

@@ -34,7 +34,7 @@ function buildEiSystemPrompt(data: ResponsePromptData): string {
 You are the central hub of this experience - a thoughtful AI who genuinely cares about the human's wellbeing and growth. You listen, remember, and help them reflect. You're curious about their life but never intrusive.
 
 Your role is unique among personas:
-- You see ALL of the human's data (facts, traits, topics, people) across all groups
+- You see ALL of the human's data (facts, topics, people) across all groups
 - You help them understand and navigate the system
 - You gently help them explore their thoughts and feelings
 - You attempt to emulate their speech patterns; 

package/src/prompts/response/sections.ts

@@ -3,9 +3,15 @@
  * Building blocks for constructing response prompts
  */
 
-import type { Trait, Quote, PersonaTopic } from "../../core/types.js";
+import type { PersonaTrait, Quote, PersonaTopic } from "../../core/types.js";
 import type { ResponsePromptData } from "./types.js";
-import { truncateDescription } from "../human/item-update.js";
+
+const DESCRIPTION_MAX_CHARS = 500;
+
+function truncateDescription(description: string): string {
+  if (description.length <= DESCRIPTION_MAX_CHARS) return description;
+  return description.slice(0, DESCRIPTION_MAX_CHARS) + "…";
+}
 
 // =============================================================================
 // IDENTITY SECTION
@@ -62,7 +68,7 @@ export function buildGuidelinesSection(personaName: string): string {
 // TRAITS SECTION
 // =============================================================================
 
-export function buildTraitsSection(traits: Trait[], header: string): string {
+export function buildTraitsSection(traits: PersonaTrait[], header: string): string {
   if (traits.length === 0) return "";
   
   const sorted = [...traits].sort((a, b) => (b.strength ?? 0.5) - (a.strength ?? 0.5)).slice(0, 15);
@@ -146,14 +152,6 @@ export function buildHumanSection(human: ResponsePromptData["human"]): string {
     if (facts) sections.push(`### Key Facts\n${facts}`);
   }
   
-  // Traits
-  if (human.traits.length > 0) {
-    const traits = human.traits
-      .slice(0, 15)
-      .map(t => `- **${t.name}**: ${truncateDescription(t.description)}`)
-      .join("\n");
-    sections.push(`### Personality\n${traits}`);
-  }
   
   // Active topics (exposure_current > 0.3)
   const activeTopics = human.topics.filter(t => t.exposure_current > 0.3);
@@ -275,7 +273,6 @@ export function buildQuotesSection(quotes: Quote[], human: ResponsePromptData["h
   
   const allDataItems = [
     ...human.facts.map(f => ({ id: f.id, name: f.name })),
-    ...human.traits.map(t => ({ id: t.id, name: t.name })),
     ...human.topics.map(t => ({ id: t.id, name: t.name })),
     ...human.people.map(p => ({ id: p.id, name: p.name })),
   ];

package/src/prompts/response/types.ts

@@ -3,7 +3,7 @@
  * Based on CONTRACTS.md ResponsePromptData specification
  */
 
-import type { Fact, Trait, Topic, Person, Quote, PersonaTopic } from "../../core/types.js";
+import type { Fact, PersonaTrait, Topic, Person, Quote, PersonaTopic } from "../../core/types.js";
 import type { ToolDefinition } from "../../core/types.js";
 
 /**
@@ -15,12 +15,11 @@ export interface ResponsePromptData {
     aliases: string[];
     short_description?: string;
     long_description?: string;
-    traits: Trait[];
+    traits: PersonaTrait[];
     topics: PersonaTopic[];
   };
   human: {
     facts: Fact[];
-    traits: Trait[];
     topics: Topic[];
     people: Person[];
     quotes: Quote[];

package/src/storage/embeddings.ts

@@ -56,7 +56,7 @@ function decodeEmbedding(value: unknown): number[] | undefined {
 // Walk the entire StorageState and encode/decode all embedding fields
 // ---------------------------------------------------------------------------
 
-const HUMAN_ITEM_KEYS = ["facts", "traits", "topics", "people", "quotes"] as const;
+const HUMAN_ITEM_KEYS = ["facts", "topics", "people", "quotes"] as const;
 
 /**
  * Returns a new StorageState with embeddings encoded as base64 strings.

package/src/storage/index.ts

@@ -1,5 +1,6 @@
 export type { Storage } from "./interface.js";
 export { LocalStorage } from "./local.js";
+export { IndexedDBStorage } from "./indexed.js";
 export { remoteSync, RemoteSync, type RemoteSyncCredentials, type RemoteTimestamp, type SyncResult, type FetchResult } from "./remote.js";
 export { encrypt, decrypt, generateUserId, type CryptoCredentials, type EncryptedPayload } from "./crypto.js";
 export { yoloMerge } from "./merge.js";

package/src/storage/indexed.ts

@@ -0,0 +1,174 @@
+import type { StorageState } from "../core/types.js";
+import type { Storage } from "./interface.js";
+import { compress, decompress, isCompressed } from "./compress.js";
+import { encodeAllEmbeddings, decodeAllEmbeddings } from "./embeddings.js";
+
+const DB_NAME = "ei_db";
+const DB_VERSION = 1;
+const STORE_NAME = "state";
+const PRIMARY_KEY = "primary";
+const BACKUP_KEY = "backup";
+
+export class IndexedDBStorage implements Storage {
+  async isAvailable(): Promise<boolean> {
+    try {
+      const db = await this.openDB();
+      db.close();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async save(state: StorageState): Promise<void> {
+    state.timestamp = new Date().toISOString();
+    try {
+      const json = JSON.stringify(encodeAllEmbeddings(state));
+      const payload = await compress(json);
+      await this.setItem(PRIMARY_KEY, payload);
+    } catch (e) {
+      if (this.isQuotaError(e)) {
+        throw new Error("STORAGE_SAVE_FAILED: IndexedDB quota exceeded");
+      }
+      throw e;
+    }
+  }
+
+  async load(): Promise<StorageState | null> {
+    const current = await this.getItem(PRIMARY_KEY);
+    if (current) {
+      try {
+        const json = isCompressed(current) ? await decompress(current) : current;
+        return decodeAllEmbeddings(JSON.parse(json) as StorageState);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Move current state to backup location and clear primary state.
+   * Used after successful remote sync to signal "no local state to load" on next launch.
+   * Backup can be restored manually if remote pull fails.
+   */
+  async moveToBackup(): Promise<void> {
+    const current = await this.getItem(PRIMARY_KEY);
+    if (current) {
+      // Remove primary first so backup write doesn't double-count against quota.
+      await this.deleteItem(PRIMARY_KEY);
+      await this.setItem(BACKUP_KEY, current);
+    }
+  }
+
+  /**
+   * Read backup state without removing it.
+   * Used to peek sync credentials from a previous session's backup.
+   */
+  async loadBackup(): Promise<StorageState | null> {
+    const backup = await this.getItem(BACKUP_KEY);
+    if (backup) {
+      try {
+        const json = isCompressed(backup) ? await decompress(backup) : backup;
+        return decodeAllEmbeddings(JSON.parse(json) as StorageState);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+
+  /** No-op in browser — rolling backups are TUI-only (filesystem required). */
+  async saveRollingBackup(_state: StorageState, _maxBackups: number): Promise<void> {
+    // Intentional no-op: IndexedDB has no directory/file concept.
+    // The Processor gates this call with `this.isTUI` so it never runs in the browser.
+  }
+
+  // ─── Private IDB helpers ──────────────────────────────────────────────────
+
+  private openDB(): Promise<IDBDatabase> {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(DB_NAME, DB_VERSION);
+
+      request.onupgradeneeded = (event) => {
+        const db = (event.target as IDBOpenDBRequest).result;
+        if (!db.objectStoreNames.contains(STORE_NAME)) {
+          db.createObjectStore(STORE_NAME);
+        }
+      };
+
+      request.onsuccess = (event) => {
+        resolve((event.target as IDBOpenDBRequest).result);
+      };
+
+      request.onerror = (event) => {
+        reject((event.target as IDBOpenDBRequest).error);
+      };
+    });
+  }
+
+  private async getItem(key: string): Promise<string | null> {
+    const db = await this.openDB();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, "readonly");
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.get(key);
+
+      request.onsuccess = (event) => {
+        const result = (event.target as IDBRequest).result;
+        db.close();
+        resolve(result ?? null);
+      };
+
+      request.onerror = (event) => {
+        db.close();
+        reject((event.target as IDBRequest).error);
+      };
+    });
+  }
+
+  private async setItem(key: string, value: string): Promise<void> {
+    const db = await this.openDB();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, "readwrite");
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.put(value, key);
+
+      request.onsuccess = () => {
+        db.close();
+        resolve();
+      };
+
+      request.onerror = (event) => {
+        db.close();
+        reject((event.target as IDBRequest).error);
+      };
+    });
+  }
+
+  private async deleteItem(key: string): Promise<void> {
+    const db = await this.openDB();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, "readwrite");
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.delete(key);
+
+      request.onsuccess = () => {
+        db.close();
+        resolve();
+      };
+
+      request.onerror = (event) => {
+        db.close();
+        reject((event.target as IDBRequest).error);
+      };
+    });
+  }
+
+  private isQuotaError(e: unknown): boolean {
+    return (
+      e instanceof DOMException &&
+      (e.name === "QuotaExceededError" || e.name === "NS_ERROR_DOM_QUOTA_REACHED")
+    );
+  }
+}

package/src/storage/merge.ts

@@ -1,4 +1,23 @@
-import type { StorageState, DataItem, Quote } from "../core/types.js";
+import type { StorageState, DataItem, Quote, ToolProvider, ToolDefinition, ProviderAccount } from "../core/types.js";
+
+function mergeByName<T extends { name: string }>(
+  local: T[],
+  remote: T[],
+  preferRemote: boolean,
+): T[] {
+  const merged = [...local];
+
+  for (const remoteItem of remote) {
+    const localIndex = merged.findIndex(item => item.name === remoteItem.name);
+    if (localIndex === -1) {
+      merged.push(remoteItem);
+    } else if (preferRemote) {
+      merged[localIndex] = remoteItem;
+    }
+  }
+
+  return merged;
+}
 
 function mergeDataItems<T extends DataItem>(local: T[], remote: T[]): T[] {
   const merged = [...local];
@@ -32,7 +51,6 @@ export function yoloMerge(local: StorageState, remote: StorageState): StorageSta
   const merged = structuredClone(local);
   
   merged.human.facts = mergeDataItems(merged.human.facts, remote.human.facts);
-  merged.human.traits = mergeDataItems(merged.human.traits, remote.human.traits);
   merged.human.topics = mergeDataItems(merged.human.topics, remote.human.topics);
   merged.human.people = mergeDataItems(merged.human.people, remote.human.people);
   merged.human.quotes = mergeQuotes(merged.human.quotes || [], remote.human.quotes || []);
@@ -63,6 +81,53 @@ export function yoloMerge(local: StorageState, remote: StorageState): StorageSta
     }
   }
   
+  if ('traits' in merged.human) {
+    delete (merged.human as Record<string, unknown>)['traits'];
+  }
+
+  const preferRemote = remote.timestamp > local.timestamp;
+
+  if (remote.human.settings?.accounts && merged.human.settings) {
+    merged.human.settings.accounts = mergeByName<ProviderAccount>(
+      merged.human.settings?.accounts || [],
+      remote.human.settings.accounts,
+      preferRemote,
+    );
+  }
+
+  if (preferRemote && remote.human.settings) {
+    const remoteSettings = remote.human.settings;
+    const localSettings = merged.human.settings || {};
+
+    if (remoteSettings.default_model !== undefined) localSettings.default_model = remoteSettings.default_model;
+    if (remoteSettings.oneshot_model !== undefined) localSettings.oneshot_model = remoteSettings.oneshot_model;
+    if (remoteSettings.rewrite_model !== undefined) localSettings.rewrite_model = remoteSettings.rewrite_model;
+    if (remoteSettings.queue_paused !== undefined) localSettings.queue_paused = remoteSettings.queue_paused;
+    if (remoteSettings.skip_quote_delete_confirm !== undefined) localSettings.skip_quote_delete_confirm = remoteSettings.skip_quote_delete_confirm;
+    if (remoteSettings.name_display !== undefined) localSettings.name_display = remoteSettings.name_display;
+    if (remoteSettings.time_mode !== undefined) localSettings.time_mode = remoteSettings.time_mode;
+
+    if (remoteSettings.opencode) localSettings.opencode = remoteSettings.opencode;
+    if (remoteSettings.ceremony) localSettings.ceremony = remoteSettings.ceremony;
+    if (remoteSettings.backup) localSettings.backup = remoteSettings.backup;
+    if (remoteSettings.claudeCode) localSettings.claudeCode = remoteSettings.claudeCode;
+    // NOTE: Do NOT merge sync credentials — always keep local sync creds
+
+    merged.human.settings = localSettings;
+  }
+
+  merged.providers = mergeByName<ToolProvider>(
+    merged.providers || [],
+    remote.providers || [],
+    preferRemote,
+  );
+
+  merged.tools = mergeByName<ToolDefinition>(
+    merged.tools || [],
+    remote.tools || [],
+    preferRemote,
+  );
+
   merged.timestamp = new Date().toISOString();
   
   return merged;

package/tui/src/commands/me.tsx

@@ -4,15 +4,15 @@ import { humanToYAML, humanFromYAML } from "../util/yaml-serializers.js";
 import { logger } from "../util/logger.js";
 import { ConfirmOverlay } from "../components/ConfirmOverlay.js";
 
-type DataType = "facts" | "traits" | "topics" | "people";
+type DataType = "facts" | "topics" | "people";
 
-const VALID_TYPES: DataType[] = ["facts", "traits", "topics", "people"];
+const VALID_TYPES: DataType[] = ["facts", "topics", "people"];
 
 export const meCommand: Command = {
   name: "me",
   aliases: [],
   description: "Edit your data in $EDITOR",
-  usage: "/me [facts|traits|topics|people]",
+  usage: "/me [facts|topics|people]",
   
   async execute(args, ctx) {
     const human = await ctx.ei.getHuman();
@@ -23,14 +23,13 @@ export const meCommand: Command = {
       : null;
     
     if (filterArg && !filterType) {
-      ctx.showNotification(`Invalid type: ${filterArg}. Use: facts, traits, topics, people`, "error");
+      ctx.showNotification(`Invalid type: ${filterArg}. Use: facts, topics, people`, "error");
       return;
     }
     
     const filteredHuman = filterType ? {
       ...human,
       facts: filterType === "facts" ? human.facts : [],
-      traits: filterType === "traits" ? human.traits : [],
       topics: filterType === "topics" ? human.topics : [],
       people: filterType === "people" ? human.people : [],
     } : human;
@@ -67,14 +66,11 @@ export const meCommand: Command = {
       }
       
       try {
-        const parsed = humanFromYAML(result.content);
+        const parsed = humanFromYAML(result.content, filteredHuman);
         
         for (const id of parsed.deletedFactIds) {
           await ctx.ei.removeDataItem("fact", id);
         }
-        for (const id of parsed.deletedTraitIds) {
-          await ctx.ei.removeDataItem("trait", id);
-        }
         for (const id of parsed.deletedTopicIds) {
           await ctx.ei.removeDataItem("topic", id);
         }
@@ -85,9 +81,6 @@ export const meCommand: Command = {
         for (const fact of parsed.facts) {
           await ctx.ei.upsertFact(fact);
         }
-        for (const trait of parsed.traits) {
-          await ctx.ei.upsertTrait(trait);
-        }
         for (const topic of parsed.topics) {
           await ctx.ei.upsertTopic(topic);
         }
@@ -96,11 +89,9 @@ export const meCommand: Command = {
         }
         
         const deleteCount = parsed.deletedFactIds.length + 
-                           parsed.deletedTraitIds.length + 
                            parsed.deletedTopicIds.length + 
                            parsed.deletedPersonIds.length;
         const updateCount = parsed.facts.length + 
-                           parsed.traits.length + 
                            parsed.topics.length + 
                            parsed.people.length;
         

package/tui/src/commands/settings.tsx

@@ -45,6 +45,21 @@ export const settingsCommand: Command = {
         // Validate provider name in default_model (case-insensitive match + auto-correct)
         const llmAccounts = human.settings?.accounts?.filter(a => a.type === "llm") ?? [];
         newSettings.default_model = validateModelProvider(newSettings.default_model, llmAccounts);
+
+        if (newSettings.opencode?.extraction_model) {
+          newSettings.opencode.extraction_model = validateModelProvider(
+            newSettings.opencode.extraction_model,
+            llmAccounts
+          );
+        }
+
+        if (newSettings.claudeCode?.extraction_model) {
+          newSettings.claudeCode.extraction_model = validateModelProvider(
+            newSettings.claudeCode.extraction_model,
+            llmAccounts
+          );
+        }
+
         await ctx.ei.updateSettings(newSettings);
         ctx.showNotification("Settings updated", "info");
         return;

package/tui/src/context/ei.tsx

@@ -23,7 +23,6 @@ import type {
   HumanEntity,
   HumanSettings,
   Fact,
-  Trait,
   Topic,
   Person,
   Quote,
@@ -78,10 +77,9 @@ export interface EiContextValue {
   updateHuman: (updates: Partial<HumanEntity>) => Promise<void>;
   updateSettings: (updates: Partial<HumanSettings>) => Promise<void>;
   upsertFact: (fact: Fact) => Promise<void>;
-  upsertTrait: (trait: Trait) => Promise<void>;
   upsertTopic: (topic: Topic) => Promise<void>;
   upsertPerson: (person: Person) => Promise<void>;
-  removeDataItem: (type: "fact" | "trait" | "topic" | "person", id: string) => Promise<void>;
+  removeDataItem: (type: "fact" | "topic" | "person", id: string) => Promise<void>;
   syncStatus: () => { configured: boolean; envBased: boolean };
   triggerSync: () => Promise<{ success: boolean; error?: string }>;
   getGroupList: () => Promise<string[]>;
@@ -92,10 +90,9 @@ export interface EiContextValue {
   quotesVersion: () => number;
   searchHumanData: (
     query: string,
-    options?: { types?: Array<"fact" | "trait" | "topic" | "person" | "quote">; limit?: number }
+    options?: { types?: Array<"fact" | "topic" | "person" | "quote">; limit?: number }
   ) => Promise<{
     facts: Fact[];
-    traits: Trait[];
     topics: Topic[];
     people: Person[];
     quotes: Quote[];
@@ -329,11 +326,6 @@ export const EiProvider: ParentComponent = (props) => {
     await processor.upsertFact(fact);
   };
 
-  const upsertTrait = async (trait: Trait) => {
-    if (!processor) return;
-    await processor.upsertTrait(trait);
-  };
-
   const upsertTopic = async (topic: Topic) => {
     if (!processor) return;
     await processor.upsertTopic(topic);
@@ -344,7 +336,7 @@ export const EiProvider: ParentComponent = (props) => {
     await processor.upsertPerson(person);
   };
 
-  const removeDataItem = async (type: "fact" | "trait" | "topic" | "person", id: string) => {
+  const removeDataItem = async (type: "fact" | "topic" | "person", id: string) => {
     if (!processor) return;
     await processor.removeDataItem(type, id);
   };
@@ -450,9 +442,9 @@ export const EiProvider: ParentComponent = (props) => {
 
   const searchHumanData = async (
     query: string,
-    options?: { types?: Array<"fact" | "trait" | "topic" | "person" | "quote">; limit?: number }
+    options?: { types?: Array<"fact" | "topic" | "person" | "quote">; limit?: number }
   ) => {
-    if (!processor) return { facts: [], traits: [], topics: [], people: [], quotes: [] };
+    if (!processor) return { facts: [], topics: [], people: [], quotes: [] };
     return processor.searchHumanData(query, options);
   };
 
@@ -648,7 +640,6 @@ export const EiProvider: ParentComponent = (props) => {
     updateHuman,
     updateSettings,
     upsertFact,
-    upsertTrait,
     upsertTopic,
     upsertPerson,
     removeDataItem,