ei-tui 0.5.0 → 0.5.2

package/src/core/state-manager.ts

@@ -50,15 +50,20 @@ export class StateManager {
       this.queueState.load(state.queue);
       this.tools = state.tools ?? [];
       this.providers = state.providers ?? [];
-      this.migrateLearnedByToIds();
-      this.migrateFactValidation();
-      this.migrateMessageFlags();
-      this.migrateInterestedPersonas();
+      this.runMigrations();
     } else {
       this.humanState.load(createDefaultHumanEntity());
     }
   }
 
+  private runMigrations(): void {
+    this.migrateLearnedByToIds();
+    this.migrateFactValidation();
+    this.migrateMessageFlags();
+    this.migrateInterestedPersonas();
+    this.migrateProviderModel();
+  }
+
   /**
    * Migration: learned_by used to store display names; now stores persona IDs.
    * On load, attempt to resolve display names -> IDs using current persona map.
@@ -222,6 +227,162 @@ export class StateManager {
     }
   }
 
+  private migrateProviderModel(): void {
+    const human = this.humanState.get();
+    const settings = human.settings;
+    if (!settings?.accounts?.length) return;
+
+    const modelLookup = new Map<string, string>();
+
+    // Helper: ensure a model exists in an account and register it in modelLookup.
+    // ref must be in "ProviderName:model-name" format.
+    const ensureModelInAccount = (ref: string): void => {
+      const colonIdx = ref.indexOf(":");
+      if (colonIdx === -1) return;
+      const providerName = ref.substring(0, colonIdx);
+      const modelName = ref.substring(colonIdx + 1);
+      const account = settings.accounts!.find((a) => a.name === providerName);
+      if (!account) return;
+
+      if (!account.models) account.models = [];
+
+      const existing = account.models.find((m) => m.name === modelName);
+      if (existing) {
+        modelLookup.set(ref, existing.id);
+      } else {
+        const newModel = {
+          id: crypto.randomUUID(),
+          name: modelName,
+        };
+        account.models.push(newModel);
+        modelLookup.set(ref, newModel.id);
+      }
+    };
+
+    const isProviderRef = (val: string): boolean => {
+      const colonIdx = val.indexOf(":");
+      if (colonIdx === -1) return false;
+      const providerName = val.substring(0, colonIdx);
+      return settings.accounts!.some((a) => a.name === providerName);
+    };
+
+    // Phase 1: Collect ALL model refs from everywhere they can appear.
+    const allRefs: string[] = [];
+    const pushRef = (ref: string | undefined): void => {
+      if (ref && isProviderRef(ref)) allRefs.push(ref);
+    };
+
+    pushRef(settings.default_model);
+    pushRef(settings.oneshot_model);
+    pushRef(settings.rewrite_model);
+    pushRef(settings.opencode?.extraction_model);
+    pushRef(settings.claudeCode?.extraction_model);
+
+    const personas = this.personaState.getAll();
+    for (const persona of personas) {
+      pushRef(persona.model);
+    }
+
+    // Also include account.default_model values (legacy strings, not yet GUIDs)
+    for (const account of settings.accounts) {
+      if (account.default_model && isProviderRef(account.default_model)) {
+        allRefs.push(account.default_model);
+      }
+    }
+
+    // Phase 2: For each ref, ensure model exists in the matching account.
+    for (const ref of allRefs) {
+      ensureModelInAccount(ref);
+    }
+
+    // Helper: check if a value looks like a UUID (already migrated)
+    const isUUID = (val: string): boolean =>
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val);
+
+    // Phase 3: Ensure every account has a models array and default_model is a GUID.
+    for (const account of settings.accounts) {
+      if (!account.models) {
+        account.models = [];
+      }
+
+      // Handle account.default_model - could be:
+      // 1. Already a GUID (already migrated) - leave it
+      // 2. A "Provider:model" ref - look up in modelLookup
+      // 3. A plain model name like "claude-haiku-4-5-20251001" - add to models[] and convert
+      if (account.default_model) {
+        if (isUUID(account.default_model)) {
+          // Already migrated, nothing to do
+        } else if (isProviderRef(account.default_model)) {
+          // It's a "Provider:model" ref - should be in modelLookup from Phase 2
+          const guid = modelLookup.get(account.default_model);
+          if (guid) account.default_model = guid;
+        } else {
+          // Plain model name - check if it exists in models[], add if not, convert to GUID
+          const existing = account.models.find((m) => m.name === account.default_model);
+          if (existing) {
+            account.default_model = existing.id;
+          } else {
+            const model = {
+              id: crypto.randomUUID(),
+              name: account.default_model,
+              token_limit: (account as any).token_limit as number | undefined,
+              max_output_tokens: undefined as number | undefined,
+            };
+            account.models.push(model);
+            modelLookup.set(`${account.name}:${model.name}`, model.id);
+            account.default_model = model.id;
+          }
+        }
+      }
+
+      // If still no models, create a placeholder
+      if (account.models.length === 0) {
+        const model = { id: crypto.randomUUID(), name: "(default)" };
+        account.models.push(model);
+        modelLookup.set(`${account.name}:(default)`, model.id);
+        account.default_model = model.id;
+      }
+
+      delete (account as any).token_limit;
+    }
+
+    const resolveRef = (ref: string | undefined): string | undefined => {
+      if (!ref) return ref;
+      const guid = modelLookup.get(ref);
+      if (guid) return guid;
+      const colonIdx = ref.indexOf(":");
+      if (colonIdx === -1) return ref;
+      return undefined;
+    };
+
+    settings.default_model = resolveRef(settings.default_model);
+    settings.oneshot_model = resolveRef(settings.oneshot_model);
+    settings.rewrite_model = resolveRef(settings.rewrite_model);
+
+    if (settings.opencode) {
+      settings.opencode.extraction_model = resolveRef(settings.opencode.extraction_model);
+      delete (settings.opencode as any).extraction_token_limit;
+    }
+
+    if (settings.claudeCode) {
+      settings.claudeCode.extraction_model = resolveRef(settings.claudeCode.extraction_model);
+      delete (settings.claudeCode as any).extraction_token_limit;
+    }
+
+    for (const persona of personas) {
+      if (persona.model) {
+        const resolved = resolveRef(persona.model);
+        const colonIdx = (resolved ?? persona.model).indexOf(":");
+        const finalModel = colonIdx !== -1 ? undefined : (resolved ?? persona.model);
+        this.personaState.update(persona.id, { model: finalModel });
+      }
+    }
+
+    this.humanState.set(human);
+    this.scheduleSave();
+    console.log("[StateManager] Migrated provider/model references to GUID-based ModelConfig system");
+  }
+
   /**
    * Returns true if value looks like a persona ID (UUID or the special "ei" id).
    * Display names are free-form strings that won't match UUID format.
@@ -621,6 +782,12 @@ export class StateManager {
     return result;
   }
 
+  queue_deleteItems(ids: string[]): number {
+    const result = this.queueState.deleteItems(ids);
+    if (result > 0) this.scheduleSave();
+    return result;
+  }
+
   queue_dlqLength(): number {
     return this.queueState.dlqLength();
   }
@@ -764,6 +931,67 @@ export class StateManager {
     return result;
   }
 
+  deleteModel(providerId: string, modelId: string): { success: boolean; error?: string; cleared: string[] } {
+    const human = this.humanState.get();
+    const settings = human.settings;
+    if (!settings?.accounts?.length) {
+      return { success: false, error: `Provider not found: ${providerId}`, cleared: [] };
+    }
+
+    const provider = settings.accounts.find(a => a.id === providerId);
+    if (!provider) {
+      return { success: false, error: `Provider not found: ${providerId}`, cleared: [] };
+    }
+
+    if (!provider.models?.find(m => m.id === modelId)) {
+      return { success: false, error: `Model not found: ${modelId}`, cleared: [] };
+    }
+
+    if ((provider.models?.length ?? 0) <= 1) {
+      return { success: false, error: `Cannot delete the last model on a provider`, cleared: [] };
+    }
+
+    const cleared: string[] = [];
+
+    if (settings.default_model === modelId) {
+      settings.default_model = undefined;
+      cleared.push("settings.default_model");
+    }
+    if (settings.oneshot_model === modelId) {
+      settings.oneshot_model = undefined;
+      cleared.push("settings.oneshot_model");
+    }
+    if (settings.rewrite_model === modelId) {
+      settings.rewrite_model = undefined;
+      cleared.push("settings.rewrite_model");
+    }
+    if (settings.opencode?.extraction_model === modelId) {
+      settings.opencode.extraction_model = undefined;
+      cleared.push("settings.opencode.extraction_model");
+    }
+    if (settings.claudeCode?.extraction_model === modelId) {
+      settings.claudeCode.extraction_model = undefined;
+      cleared.push("settings.claudeCode.extraction_model");
+    }
+    if (provider.default_model === modelId) {
+      provider.default_model = undefined;
+      cleared.push("provider.default_model");
+    }
+
+    provider.models = provider.models!.filter(m => m.id !== modelId);
+    this.humanState.set(human);
+
+    for (const persona of this.personaState.getAll()) {
+      if (persona.model === modelId) {
+        this.personaState.update(persona.id, { model: undefined });
+        cleared.push(`persona:${persona.display_name}`);
+      }
+    }
+
+    this.scheduleSave();
+    return { success: true, cleared };
+  }
+
   async flush(): Promise<void> {
     await this.persistenceState.flush();
   }
@@ -788,6 +1016,7 @@ export class StateManager {
     this.providers = state.providers ?? [];
     this.tools = state.tools ?? [];
     this.persistenceState.markExistingData();
+    this.runMigrations();
     this.scheduleSave();
   }
 

package/src/core/tools/index.ts

@@ -81,7 +81,7 @@ export function toOpenAITools(tools: ToolDefinition[]): Record<string, unknown>[
       name: t.name,
       description: t.description,
       parameters: t.input_schema,
-      ...(t.is_submit ? { strict: true } : {}),
+
     },
   }));
 }

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

@@ -67,7 +67,9 @@ export interface Quote {
   data_item_ids: string[];       // FK[] to DataItemBase.id
   persona_groups: string[];      // Visibility groups
   text: string;                  // The quote content
-  speaker: "human" | string;     // Who said it (persona ID or "human")
+  speaker: "human" | string;     // Actual speaker: "human" or the persona's display_name
+  channel?: string;              // Display name of the Channel (persona or room) where captured.
+                                 // Undefined on pre-migration quotes.
   timestamp: string;             // ISO timestamp (from original message)
   start: number | null;          // Character offset in message (null = can't highlight)
   end: number | null;            // Character offset in message (null = can't highlight)

package/src/core/types/entities.ts

@@ -15,7 +15,6 @@ export interface OpenCodeSettings {
   integration?: boolean;
   polling_interval_ms?: number;  // Default: 60000 (1 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
@@ -37,6 +36,23 @@ export interface BackupConfig {
   last_backup?: string;   // ISO timestamp of last backup run
 }
 
+/**
+ * ModelConfig - Configuration and usage tracking for a specific LLM model
+ * 
+ * Models are first-class entities tied to a ProviderAccount. Each model has
+ * its own capability configuration and usage statistics.
+ */
+export interface ModelConfig {
+  id: string;                       // GUID (crypto.randomUUID())
+  name: string;                     // Model identifier, e.g. "claude-haiku-4-5", "(default)"
+  token_limit?: number;             // Input token limit (user sets effective limit)
+  max_output_tokens?: number;       // Output token limit (API-enforced)
+  total_calls?: number;             // Usage counter
+  total_tokens_in?: number;         // Usage counter
+  total_tokens_out?: number;        // Usage counter
+  last_used?: string;               // ISO timestamp
+}
+
 /**
  * ProviderAccount - Configuration for external service connections
  * 
@@ -60,6 +76,7 @@ export interface ProviderAccount {
   // LLM-specific
   default_model?: string;          // Default model for this account
   token_limit?: number;            // Context window override (tokens). Used for extraction chunking.
+  models?: ModelConfig[];          // First-class model registry for this account
   
   // Provider-specific extras (e.g., OpenRouter needs HTTP-Referer, X-Title)
   extra_headers?: Record<string, string>;
@@ -73,9 +90,9 @@ export interface ProviderAccount {
 }
 
 export interface HumanSettings {
-  default_model?: string;
-  oneshot_model?: string;           // Model for AI-assist (wand) requests; falls back to default_model
-  rewrite_model?: string;           // Model for rewrite ceremony step; must be capable (Sonnet/Opus class). Unset = rewrite disabled.
+  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.
+  rewrite_model?: string;           // Model for rewrite ceremony step; must be capable (Sonnet/Opus class). Unset = rewrite disabled. Will store ModelConfig.id GUID post-migration.
   queue_paused?: boolean;
   skip_quote_delete_confirm?: boolean;
   name_display?: string;

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

@@ -327,7 +327,6 @@ export async function importClaudeCodeSessions(
     const ccSettings = stateManager.getHuman().settings?.claudeCode;
     queueAllScans(context, stateManager, {
       extraction_model: ccSettings?.extraction_model,
-      extraction_token_limit: ccSettings?.extraction_token_limit,
       external_filter: "only",
     });
     result.extractionScansQueued += 4;

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

@@ -159,7 +159,6 @@ export interface ClaudeCodeSettings {
   integration?: boolean;
   polling_interval_ms?: number;  // Default: 60000 (1 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/opencode/importer.ts

@@ -256,7 +256,6 @@ export async function importOpenCodeSessions(
         const openCodeSettings = stateManager.getHuman().settings?.opencode;
         queueAllScans(context, stateManager, {
           extraction_model: openCodeSettings?.extraction_model,
-          extraction_token_limit: openCodeSettings?.extraction_token_limit,
           external_filter: "only",
         });
         result.extractionScansQueued += 4;

package/src/storage/merge.ts

@@ -1,4 +1,4 @@
-import type { StorageState, DataItem, Quote, ToolProvider, ToolDefinition, ProviderAccount } from "../core/types.js";
+import type { StorageState, DataItem, Quote, ToolProvider, ToolDefinition, ProviderAccount, ModelConfig } from "../core/types.js";
 
 function mergeByName<T extends { name: string }>(
   local: T[],
@@ -19,6 +19,51 @@ function mergeByName<T extends { name: string }>(
   return merged;
 }
 
+function mergeModels(local: ModelConfig[], remote: ModelConfig[], preferRemote: boolean): ModelConfig[] {
+  const merged = [...local];
+
+  for (const remoteModel of remote) {
+    const localIndex = merged.findIndex(m => m.id === remoteModel.id);
+
+    if (localIndex === -1) {
+      merged.push(remoteModel);
+    } else {
+      const localModel = merged[localIndex];
+      const localCalls = localModel.total_calls ?? 0;
+      const remoteCalls = remoteModel.total_calls ?? 0;
+
+      const total_calls = Math.max(localCalls, remoteCalls);
+      const total_tokens_in = Math.max(localModel.total_tokens_in ?? 0, remoteModel.total_tokens_in ?? 0);
+      const total_tokens_out = Math.max(localModel.total_tokens_out ?? 0, remoteModel.total_tokens_out ?? 0);
+      const last_used = localCalls >= remoteCalls ? localModel.last_used : remoteModel.last_used;
+
+      const base = preferRemote ? { ...localModel, ...remoteModel } : localModel;
+      merged[localIndex] = { ...base, total_calls, total_tokens_in, total_tokens_out, last_used };
+    }
+  }
+
+  return merged;
+}
+
+function mergeById(local: ProviderAccount[], remote: ProviderAccount[], preferRemote: boolean): ProviderAccount[] {
+  const merged = [...local];
+
+  for (const remoteProvider of remote) {
+    const localIndex = merged.findIndex(p => p.id === remoteProvider.id);
+
+    if (localIndex === -1) {
+      merged.push(remoteProvider);
+    } else {
+      const localProvider = merged[localIndex];
+      const mergedModels = mergeModels(localProvider.models ?? [], remoteProvider.models ?? [], preferRemote);
+      const base = preferRemote ? { ...localProvider, ...remoteProvider } : localProvider;
+      merged[localIndex] = { ...base, models: mergedModels };
+    }
+  }
+
+  return merged;
+}
+
 function mergeDataItems<T extends DataItem>(local: T[], remote: T[]): T[] {
   const merged = [...local];
   
@@ -88,7 +133,7 @@ export function yoloMerge(local: StorageState, remote: StorageState): StorageSta
   const preferRemote = remote.timestamp > local.timestamp;
 
   if (remote.human.settings?.accounts && merged.human.settings) {
-    merged.human.settings.accounts = mergeByName<ProviderAccount>(
+    merged.human.settings.accounts = mergeById(
       merged.human.settings?.accounts || [],
       remote.human.settings.accounts,
       preferRemote,

package/tui/src/commands/dlq.ts

@@ -17,7 +17,9 @@ export const dlqCommand: Command = {
       return;
     }
 
-    let yamlContent = queueItemsToYAML(items);
+    const human = await ctx.ei.getHuman();
+    const accounts = human.settings?.accounts ?? [];
+    let yamlContent = queueItemsToYAML(items, accounts);
 
     while (true) {
       const result = await spawnEditor({
@@ -37,14 +39,20 @@ export const dlqCommand: Command = {
       }
 
       try {
-        const updates = queueItemsFromYAML(result.content);
+        const { updates, deletedIds } = queueItemsFromYAML(result.content, accounts);
+        if (deletedIds.length > 0) {
+          ctx.ei.deleteQueueItems(deletedIds);
+        }
         let recovered = 0;
         for (const update of updates) {
           await ctx.ei.updateQueueItem(update.id, update);
           if (update.state === "pending") recovered++;
         }
-        const msg = recovered > 0
-          ? `DLQ updated — ${recovered} item(s) requeued`
+        const parts: string[] = [];
+        if (recovered > 0) parts.push(`${recovered} item(s) requeued`);
+        if (deletedIds.length > 0) parts.push(`${deletedIds.length} deleted`);
+        const msg = parts.length > 0
+          ? `DLQ updated — ${parts.join(", ")}`
           : `DLQ updated (no items requeued)`;
         ctx.showNotification(msg, "info");
         return;