ei-tui 0.4.3 → 0.5.1

package/src/core/state/personas.ts

@@ -213,10 +213,20 @@ export class PersonaState {
     return removed;
   }
 
-  messages_getUnextracted(personaId: string, flag: "f" | "t" | "p" | "e", limit?: number): Message[] {
+  messages_getUnextracted(
+    personaId: string,
+    flag: "f" | "t" | "p" | "e",
+    limit?: number,
+    external_filter?: "include" | "exclude" | "only"
+  ): Message[] {
     const data = this.personas.get(personaId);
     if (!data) return [];
-    const unextracted = data.messages.filter(m => m[flag] !== true);
+    let unextracted = data.messages.filter(m => m[flag] !== true);
+    if (external_filter === "exclude") {
+      unextracted = unextracted.filter(m => m.external !== true);
+    } else if (external_filter === "only") {
+      unextracted = unextracted.filter(m => m.external === true);
+    }
     if (limit && unextracted.length > limit) {
       return unextracted.slice(0, limit).map(m => ({ ...m }));
     }

package/src/core/state/queue.ts

@@ -55,7 +55,7 @@ export class QueueState {
     if (this.paused || this.queue.length === 0) return null;
     const available = this.queue.filter(r => r.state === "pending");
     if (available.length === 0) return null;
-    const priorityOrder = { high: 0, normal: 1, low: 2 };
+    const priorityOrder = { high: 0, judge: 1, room: 2, normal: 3, low: 4 };
     const sorted = [...available].sort(
       (a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]
     );
@@ -72,7 +72,7 @@ export class QueueState {
     if (this.paused || this.queue.length === 0) return null;
     const available = this.queue.filter(r => r.state === "pending");
     if (available.length === 0) return null;
-    const priorityOrder = { high: 0, normal: 1, low: 2 };
+    const priorityOrder = { high: 0, judge: 1, room: 2, normal: 3, low: 4 };
     const sorted = [...available].sort(
       (a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]
     );

package/src/core/state/rooms.ts

@@ -0,0 +1,182 @@
+/**
+ * EI V1 Room State
+ * Source of truth: CONTRACTS.md
+ */
+
+import type { RoomEntity, RoomMessage, RoomSummary } from "../types.js";
+
+export class RoomState {
+  private rooms: Map<string, RoomEntity> = new Map();
+
+  load(rooms: Record<string, RoomEntity> | undefined): void {
+    if (!rooms) return;
+    this.rooms = new Map(Object.entries(rooms));
+  }
+
+  export(): Record<string, RoomEntity> {
+    const result: Record<string, RoomEntity> = {};
+    for (const [id, room] of this.rooms) {
+      result[id] = room;
+    }
+    return result;
+  }
+
+  getAll(includeArchived = false): RoomEntity[] {
+    const all = Array.from(this.rooms.values());
+    return includeArchived ? all : all.filter(r => !r.is_archived);
+  }
+
+  getById(id: string): RoomEntity | null {
+    return this.rooms.get(id) ?? null;
+  }
+
+  getByName(nameOrAlias: string): RoomEntity | null {
+    const search = nameOrAlias.toLowerCase();
+    for (const room of this.rooms.values()) {
+      if (room.display_name.toLowerCase() === search) return room;
+    }
+    const partial: RoomEntity[] = [];
+    for (const room of this.rooms.values()) {
+      if (room.display_name.toLowerCase().includes(search)) partial.push(room);
+    }
+    return partial.length === 1 ? partial[0] : null;
+  }
+
+  add(room: RoomEntity): void {
+    this.rooms.set(room.id, room);
+  }
+
+  update(roomId: string, updates: Partial<RoomEntity>): boolean {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    Object.assign(room, updates, { last_updated: new Date().toISOString() });
+    return true;
+  }
+
+  archive(roomId: string): boolean {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    room.is_archived = true;
+    room.last_updated = new Date().toISOString();
+    return true;
+  }
+
+  delete(roomId: string): boolean {
+    return this.rooms.delete(roomId);
+  }
+
+  getSummary(roomId: string): RoomSummary | null {
+    const room = this.rooms.get(roomId);
+    if (!room) return null;
+    return {
+      id: room.id,
+      display_name: room.display_name,
+      mode: room.mode,
+      persona_ids: room.persona_ids,
+      active_node_id: room.active_node_id,
+      is_archived: room.is_archived,
+      last_activity: room.last_activity,
+      unread_count: this.messages_countUnread(roomId),
+    };
+  }
+
+  messages_get(roomId: string): RoomMessage[] {
+    return this.rooms.get(roomId)?.messages ?? [];
+  }
+
+  messages_getActivePath(roomId: string): RoomMessage[] {
+    const room = this.rooms.get(roomId);
+    if (!room || !room.active_node_id) return [];
+
+    const byId = new Map(room.messages.map(m => [m.id, m]));
+    const path: RoomMessage[] = [];
+    let current: RoomMessage | undefined = byId.get(room.active_node_id);
+    while (current) {
+      path.unshift(current);
+      current = current.parent_id ? byId.get(current.parent_id) : undefined;
+    }
+    return path;
+  }
+
+  messages_getChildren(roomId: string, parentId: string | null): RoomMessage[] {
+    const room = this.rooms.get(roomId);
+    if (!room) return [];
+    return room.messages.filter(m => m.parent_id === parentId);
+  }
+
+  messages_append(roomId: string, message: RoomMessage): void {
+    const room = this.rooms.get(roomId);
+    if (!room) return;
+    room.messages.push(message);
+    room.last_activity = message.timestamp;
+    room.last_updated = new Date().toISOString();
+  }
+
+  messages_update(roomId: string, messageId: string, updates: Partial<RoomMessage>): boolean {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    const msg = room.messages.find(m => m.id === messageId);
+    if (!msg) return false;
+    Object.assign(msg, updates);
+    room.last_updated = new Date().toISOString();
+    return true;
+  }
+
+  messages_remove(roomId: string, messageIds: string[]): void {
+    const room = this.rooms.get(roomId);
+    if (!room) return;
+    const idsSet = new Set(messageIds);
+    room.messages = room.messages.filter(m => !idsSet.has(m.id));
+    room.last_updated = new Date().toISOString();
+  }
+
+  messages_setActiveNode(roomId: string, messageId: string): boolean {
+    const room = this.rooms.get(roomId);
+    if (!room) return false;
+    const exists = room.messages.some(m => m.id === messageId);
+    if (!exists) return false;
+    room.active_node_id = messageId;
+    room.last_updated = new Date().toISOString();
+    return true;
+  }
+
+  messages_countUnread(roomId: string): number {
+    const room = this.rooms.get(roomId);
+    if (!room) return 0;
+    const activePath = new Set(this.messages_getActivePath(roomId).map(m => m.id));
+    return room.messages.filter(m =>
+      m.role === "persona" && !m.read && activePath.has(m.id)
+    ).length;
+  }
+
+  messages_markAllRead(roomId: string): number {
+    const room = this.rooms.get(roomId);
+    if (!room) return 0;
+    let count = 0;
+    for (const msg of room.messages) {
+      if (!msg.read) { msg.read = true; count++; }
+    }
+    return count;
+  }
+
+  messages_getUnextracted(roomId: string, flag: "f" | "t" | "p" | "e"): RoomMessage[] {
+    const activePath = new Set(this.messages_getActivePath(roomId).map(m => m.id));
+    return (this.rooms.get(roomId)?.messages ?? [])
+      .filter(m => activePath.has(m.id) && m[flag] !== true)
+      .map(m => ({ ...m }));
+  }
+
+  messages_markExtracted(roomId: string, messageIds: string[], flag: "f" | "t" | "p" | "e"): number {
+    const room = this.rooms.get(roomId);
+    if (!room) return 0;
+    const ids = new Set(messageIds);
+    let count = 0;
+    for (const msg of room.messages) {
+      if (ids.has(msg.id) && msg[flag] !== true) {
+        msg[flag] = true;
+        count++;
+      }
+    }
+    return count;
+  }
+}

package/src/core/state-manager.ts

@@ -12,6 +12,10 @@ import type {
   QueueFailResult,
   ToolDefinition,
   ToolProvider,
+  RoomEntity,
+  RoomMessage,
+  RoomSummary,
+  RoomCreationInput,
 } from "./types.js";
 import { BUILT_IN_FACT_NAMES } from './constants/built-in-facts.js';
 import type { Storage } from "../storage/interface.js";
@@ -20,12 +24,14 @@ import {
   PersonaState,
   QueueState,
   PersistenceState,
+  RoomState,
   createDefaultHumanEntity,
 } from "./state/index.js";
 
 export class StateManager {
   private humanState = new HumanState();
   private personaState = new PersonaState();
+  private roomState = new RoomState();
   private queueState = new QueueState();
   private persistenceState = new PersistenceState();
   private providers: ToolProvider[] = [];
@@ -40,6 +46,7 @@ export class StateManager {
     if (state) {
       this.humanState.load(state.human);
       this.personaState.load(state.personas);
+      this.roomState.load(state.rooms);
       this.queueState.load(state.queue);
       this.tools = state.tools ?? [];
       this.providers = state.providers ?? [];
@@ -230,12 +237,126 @@ export class StateManager {
       timestamp: new Date().toISOString(),
       human: this.humanState.get(),
       personas: this.personaState.export(),
+      rooms: this.roomState.export(),
       queue: this.queueState.export(),
       providers: this.providers,
       tools: this.tools,
     };
   }
 
+  getRoomList(includeArchived = false): RoomSummary[] {
+    return this.roomState.getAll(includeArchived)
+      .map(r => this.roomState.getSummary(r.id)!)
+      .sort((a, b) => new Date(b.last_activity).getTime() - new Date(a.last_activity).getTime());
+  }
+
+  getRoom(roomId: string): RoomEntity | null {
+    return this.roomState.getById(roomId);
+  }
+
+  getRoomByName(name: string): RoomEntity | null {
+    return this.roomState.getByName(name);
+  }
+
+  addRoom(input: RoomCreationInput): RoomEntity {
+    const now = new Date().toISOString();
+    const initialMessage: RoomMessage = {
+      id: crypto.randomUUID(),
+      parent_id: null,
+      role: "human",
+      verbal_response: input.initial_message,
+      timestamp: now,
+      read: true,
+      context_status: "default" as import("./types.js").ContextStatus,
+    };
+    const room: RoomEntity = {
+      id: crypto.randomUUID(),
+      display_name: input.display_name,
+      entity: "room",
+      mode: input.mode,
+      persona_ids: input.persona_ids,
+      judge_persona_id: input.judge_persona_id,
+      active_node_id: initialMessage.id,
+      is_archived: false,
+      created_at: now,
+      last_updated: now,
+      last_activity: now,
+      messages: [initialMessage],
+    };
+    this.roomState.add(room);
+    this.scheduleSave();
+    return room;
+  }
+
+  updateRoom(roomId: string, updates: Partial<RoomEntity>): boolean {
+    const ok = this.roomState.update(roomId, updates);
+    if (ok) this.scheduleSave();
+    return ok;
+  }
+
+  archiveRoom(roomId: string): boolean {
+    const ok = this.roomState.archive(roomId);
+    if (ok) this.scheduleSave();
+    return ok;
+  }
+
+  deleteRoom(roomId: string): boolean {
+    const ok = this.roomState.delete(roomId);
+    if (ok) this.scheduleSave();
+    return ok;
+  }
+
+  getRoomMessages(roomId: string): RoomMessage[] {
+    return this.roomState.messages_get(roomId);
+  }
+
+  getRoomActivePath(roomId: string): RoomMessage[] {
+    return this.roomState.messages_getActivePath(roomId);
+  }
+
+  getRoomChildren(roomId: string, parentId: string | null): RoomMessage[] {
+    return this.roomState.messages_getChildren(roomId, parentId);
+  }
+
+  appendRoomMessage(roomId: string, message: RoomMessage): void {
+    this.roomState.messages_append(roomId, message);
+    this.scheduleSave();
+  }
+
+  updateRoomMessage(roomId: string, messageId: string, updates: Partial<RoomMessage>): boolean {
+    const ok = this.roomState.messages_update(roomId, messageId, updates);
+    if (ok) this.scheduleSave();
+    return ok;
+  }
+
+  setRoomActiveNode(roomId: string, messageId: string): boolean {
+    const ok = this.roomState.messages_setActiveNode(roomId, messageId);
+    if (ok) this.scheduleSave();
+    return ok;
+  }
+
+  removeRoomMessages(roomId: string, messageIds: string[]): void {
+    if (messageIds.length === 0) return;
+    this.roomState.messages_remove(roomId, messageIds);
+    this.scheduleSave();
+  }
+
+  markAllRoomMessagesRead(roomId: string): number {
+    const count = this.roomState.messages_markAllRead(roomId);
+    if (count > 0) this.scheduleSave();
+    return count;
+  }
+
+  getRoomUnextractedMessages(roomId: string, flag: "f" | "t" | "p" | "e"): RoomMessage[] {
+    return this.roomState.messages_getUnextracted(roomId, flag);
+  }
+
+  markRoomMessagesExtracted(roomId: string, messageIds: string[], flag: "f" | "t" | "p" | "e"): number {
+    const count = this.roomState.messages_markExtracted(roomId, messageIds, flag);
+    if (count > 0) this.scheduleSave();
+    return count;
+  }
+
   private scheduleSave(): void {
     this.persistenceState.scheduleSave(this.buildStorageState());
   }
@@ -421,8 +542,8 @@ export class StateManager {
     return result;
   }
 
-  messages_getUnextracted(personaId: string, flag: "f" | "t" | "p" | "e", limit?: number): Message[] {
-    return this.personaState.messages_getUnextracted(personaId, flag, limit);
+  messages_getUnextracted(personaId: string, flag: "f" | "t" | "p" | "e", limit?: number, external_filter?: "include" | "exclude" | "only"): Message[] {
+    return this.personaState.messages_getUnextracted(personaId, flag, limit, external_filter);
   }
 
   messages_markExtracted(personaId: string, messageIds: string[], flag: "f" | "t" | "p" | "e"): number {
@@ -662,6 +783,7 @@ export class StateManager {
   restoreFromState(state: StorageState): void {
     this.humanState.load(state.human);
     this.personaState.load(state.personas);
+    this.roomState.load(state.rooms);
     this.queueState.load(state.queue);
     this.providers = state.providers ?? [];
     this.tools = state.tools ?? [];

package/src/core/tool-manager.ts

@@ -54,7 +54,7 @@ export async function removeToolProvider(sm: StateManager, id: string): Promise<
 // =============================================================================
 
 export function getToolList(sm: StateManager): ToolDefinition[] {
-  return sm.tools_getAll();
+  return sm.tools_getAll().filter(t => !t.is_submit);
 }
 
 export function getTool(sm: StateManager, id: string): ToolDefinition | null {

package/src/core/tools/index.ts

@@ -81,10 +81,25 @@ export function toOpenAITools(tools: ToolDefinition[]): Record<string, unknown>[
       name: t.name,
       description: t.description,
       parameters: t.input_schema,
+      ...(t.is_submit ? { strict: true } : {}),
     },
   }));
 }
 
+/**
+ * Returns the first tool call in the batch that maps to an is_submit tool, or undefined.
+ * When a submit tool is called, its arguments ARE the structured response — no execution needed.
+ */
+export function findSubmitToolCall(
+  toolCalls: ToolCall[],
+  activeTools: ToolDefinition[]
+): ToolCall | undefined {
+  const submitNames = new Set(
+    activeTools.filter(t => t.is_submit).map(t => t.name)
+  );
+  return toolCalls.find(call => submitNames.has(call.name));
+}
+
 // =============================================================================
 // Tool call execution
 // =============================================================================

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/enums.ts

@@ -17,6 +17,8 @@ export enum LLMRequestType {
 
 export enum LLMPriority {
   High = "high",
+  Judge = "judge",
+  Room = "room",
   Normal = "normal",
   Low = "low",
 }
@@ -51,6 +53,9 @@ export enum LLMNextStep {
   HandleRewriteRewrite = "handleRewriteRewrite",
   HandleDedupCurate = "handleDedupCurate",
   HandleEventScan = "handleEventScan",
+  HandleRoomResponse = "handleRoomResponse",
+  HandleRoomJudge = "handleRoomJudge",
+  HandlePersonaPreview = "handlePersonaPreview",
 }
 
 export enum ProviderType {
@@ -58,3 +63,9 @@ export enum ProviderType {
   Storage = "storage",
   Image = "image",
 }
+
+export enum RoomMode {
+  ChooseYourPath = "choose_your_path",
+  FreeForAll = "free_for_all",
+  MessagesAgainstPersona = "messages_against_persona",
+}

package/src/core/types/integrations.ts

@@ -39,6 +39,7 @@ export interface ToolDefinition {
   enabled: boolean;
   created_at: string;                  // ISO timestamp
   max_calls_per_interaction?: number;  // Max times LLM may call this tool per response turn. Default: 3.
+  is_submit?: boolean;                 // If true, calling this tool IS the structured response — terminates the tool loop immediately and its arguments become response.parsed
 }
 
 // =============================================================================
@@ -108,6 +109,12 @@ export interface Ei_Interface {
   onToolAdded?: () => void;
   onToolUpdated?: (id: string) => void;
   onToolRemoved?: () => void;
+  onRoomAdded?: () => void;
+  onRoomRemoved?: () => void;
+  onRoomUpdated?: (roomId: string) => void;
+  onRoomMessageAdded?: (roomId: string) => void;
+  onRoomMessageQueued?: (roomId: string) => void;
+  onRoomMessageProcessing?: (roomId: string) => void;
 }
 
 // =============================================================================
@@ -137,7 +144,8 @@ export interface StorageState {
       messages: Message[];
     }
   >;
+  rooms?: Record<string, import("./rooms.js").RoomEntity>;
   queue: LLMRequest[];
-  providers: ToolProvider[];    // Tool provider registry (Ei, Brave, etc.)
-  tools: ToolDefinition[];      // Platform-level tool registry
+  providers: ToolProvider[];
+  tools: ToolDefinition[];
 }

package/src/core/types/llm.ts

@@ -23,6 +23,9 @@ export interface Message {
   e?: boolean;                 // Event (epic) extraction completed
   // Image generation fields (web-only, ephemeral)
   _synthesis?: boolean;         // True if message was created by multi-message synthesis
+  speaker_name?: string;       // Display name of actual speaker; set on room messages for clean hydration
+
+  external?: boolean;          // Set by integration importers (OpenCode, Cursor, Claude Code); invisible to LLM context
 
 }
 

package/src/core/types/rooms.ts

@@ -0,0 +1,59 @@
+/**
+ * EI V1 Room Types
+ * Source of truth: CONTRACTS.md
+ */
+
+import type { RoomMode, ContextStatus } from "./enums.js";
+
+export interface RoomMessage {
+  id: string;
+  parent_id: string | null;
+  role: "human" | "persona";
+  persona_id?: string;
+  verbal_response?: string;
+  action_response?: string;
+  silence_reason?: string;
+  timestamp: string;
+  read: boolean;
+  context_status: ContextStatus;
+
+  f?: boolean;
+  t?: boolean;
+  p?: boolean;
+  e?: boolean;
+}
+
+export interface RoomEntity {
+  id: string;
+  display_name: string;
+  entity: "room";
+  mode: RoomMode;
+  persona_ids: string[];
+  judge_persona_id?: string;
+  active_node_id: string | null;
+  is_archived: boolean;
+  created_at: string;
+  last_updated: string;
+  last_activity: string;
+  capture_used?: boolean;
+  messages: RoomMessage[];
+}
+
+export interface RoomCreationInput {
+  display_name: string;
+  mode: RoomMode;
+  persona_ids: string[];
+  judge_persona_id?: string;
+  initial_message: string;
+}
+
+export interface RoomSummary {
+  id: string;
+  display_name: string;
+  mode: RoomMode;
+  persona_ids: string[];
+  active_node_id: string | null;
+  is_archived: boolean;
+  last_activity: string;
+  unread_count: number;
+}

package/src/core/types.ts

@@ -11,3 +11,4 @@ export * from "./types/data-items.js";
 export * from "./types/entities.js";
 export * from "./types/llm.js";
 export * from "./types/integrations.js";
+export * from "./types/rooms.js";

package/src/core/utils/decay.ts

@@ -1,18 +1,24 @@
 /**
- * Logarithmic decay utility for exposure values.
- * Ported from V0: v0/src/topic-decay.ts
+ * Exponential decay utility for exposure values.
  * 
- * The formula decays faster at extremes (0 and 1), slower in the middle.
- * K=0.1 means ~10% decay per day at midpoint (0.5).
+ * Formula: v(t) = v₀ · e^(-K · days)
+ * 
+ * K=0.1 means ~9.5% decay per day regardless of current value.
+ * Decays fastest immediately after peak, slows as it approaches 0.
+ * A topic at 1.0 reaches ~0.5 after ~7 days, ~0.05 after ~30 days.
+ * 
+ * This replaced the old logistic approximation (K * v * (1-v) * hours)
+ * which had the wrong shape: it decayed FASTEST at 0.5, not at 1.0,
+ * and was aggressive enough to drop 0.2 → 0 in a single day.
  */
 
-export function calculateLogarithmicDecay(
+export function calculateExponentialDecay(
   currentValue: number,
   hoursSinceUpdate: number,
   K: number = 0.1
 ): number {
-  const decay = K * currentValue * (1 - currentValue) * hoursSinceUpdate;
-  return Math.max(0, Math.min(1, currentValue - decay));
+  const days = hoursSinceUpdate / 24;
+  return Math.max(0, Math.min(1, currentValue * Math.exp(-K * days)));
 }
 
 export function applyDecayToValue(
@@ -28,6 +34,6 @@ export function applyDecayToValue(
     return { newValue: currentValue, hoursSinceUpdate };
   }
   
-  const newValue = calculateLogarithmicDecay(currentValue, hoursSinceUpdate, K);
+  const newValue = calculateExponentialDecay(currentValue, hoursSinceUpdate, K);
   return { newValue, hoursSinceUpdate };
 }

package/src/core/utils/exposure.ts

@@ -0,0 +1,14 @@
+import type { ExposureImpact } from "../../prompts/human/types.js";
+
+export function calculateExposureCurrent(impact: ExposureImpact | undefined, current: number = 0): number {
+  const target = (() => {
+    switch (impact) {
+      case "high": return 0.9;
+      case "medium": return 0.6;
+      case "low": return 0.3;
+      case "none": return 0.1;
+      default: return 0.5;
+    }
+  })();
+  return Math.max(target, current);
+}