ei-tui 0.4.3 → 0.5.1

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

@@ -1,7 +1,9 @@
-import type { PersonaEntity, HumanEntity, DataItemBase, Quote } from "./types.js";
+import type { PersonaEntity, HumanEntity, DataItemBase, Quote, RoomEntity } from "./types.js";
 import { StateManager } from "./state-manager.js";
 import { getEmbeddingService, findTopK } from "./embedding-service.js";
-import type { ResponsePromptData } from "../prompts/index.js";
+import type { ResponsePromptData, PromptOutput } from "../prompts/index.js";
+import { buildRoomResponsePrompt } from "../prompts/room/index.js";
+import type { RoomParticipantIdentity, RoomHistoryMessage } from "../prompts/room/types.js";
 
 const QUOTE_LIMIT = 10;
 const DATA_ITEM_LIMIT = 15;
@@ -86,7 +88,14 @@ export async function filterHumanDataByVisibility(
       selectRelevantItems(human.people, DATA_ITEM_LIMIT, currentMessage),
       selectRelevantQuotes(human.quotes ?? [], currentMessage),
     ]);
-    return { facts, topics, people, quotes };
+    return {
+      facts,
+      topics,
+      people,
+      quotes,
+      active_topics: topics.filter(t => t.exposure_current > 0.3),
+      interested_topics: topics.filter(t => t.exposure_desired - t.exposure_current > 0.2),
+    };
   }
 
   const visibleGroups = new Set<string>();
@@ -115,7 +124,14 @@ export async function filterHumanDataByVisibility(
     selectRelevantQuotes(groupFilteredQuotes, currentMessage),
   ]);
 
-  return { facts, topics, people, quotes };
+  return {
+    facts,
+    topics,
+    people,
+    quotes,
+    active_topics: topics.filter(t => t.exposure_current > 0.3),
+    interested_topics: topics.filter(t => t.exposure_desired - t.exposure_current > 0.2),
+  };
 }
 
 // =============================================================================
@@ -185,9 +201,10 @@ export async function buildResponsePromptData(
       name: persona.display_name,
       aliases: persona.aliases ?? [],
       short_description: persona.short_description,
-      long_description: persona.long_description,
+       long_description: persona.long_description,
       traits: persona.traits,
       topics: persona.topics,
+      interested_topics: persona.topics.filter(t => t.exposure_desired - t.exposure_current > 0.2),
     },
     human: filteredHuman,
     visible_personas: visiblePersonas,
@@ -196,3 +213,70 @@ export async function buildResponsePromptData(
     tools,
   };
 }
+
+export async function buildRoomResponsePromptData(
+  sm: StateManager,
+  room: RoomEntity,
+  respondingPersona: PersonaEntity,
+  isTUI: boolean,
+  useAllMessages = false
+): Promise<PromptOutput> {
+  const human = sm.getHuman();
+  const activePath = sm.getRoomActivePath(room.id);
+  const sourceMessages = useAllMessages
+    ? [...sm.getRoomMessages(room.id)].sort((a, b) => a.timestamp.localeCompare(b.timestamp))
+    : activePath;
+  const lastMessage = sourceMessages[sourceMessages.length - 1];
+  const currentMessage = lastMessage?.verbal_response;
+
+  const filteredHuman = await filterHumanDataByVisibility(human, respondingPersona, currentMessage);
+
+  const history: RoomHistoryMessage[] = sourceMessages.map(m => ({
+    speaker_name: m.role === "human"
+      ? (human.settings?.name_display ?? "Human")
+      : (sm.persona_getById(m.persona_id ?? "")?.display_name ?? m.persona_id ?? "Unknown"),
+    speaker_id: m.role === "human" ? "human" : (m.persona_id ?? ""),
+    verbal_response: m.verbal_response,
+    action_response: m.action_response,
+    silence_reason: m.silence_reason,
+  }));
+
+  const otherParticipants: RoomParticipantIdentity[] = [];
+  for (const pid of room.persona_ids) {
+    if (pid === respondingPersona.id) continue;
+    const p = sm.persona_getById(pid);
+    if (p) {
+      otherParticipants.push({
+        id: p.id,
+        name: p.display_name,
+        short_description: p.short_description,
+        long_description: p.long_description,
+        traits: p.traits,
+        is_human: false,
+      });
+    }
+  }
+  otherParticipants.push({
+    id: "human",
+    name: human.settings?.name_display ?? "Human",
+    traits: [],
+    is_human: true,
+  });
+
+  return buildRoomResponsePrompt({
+    room: { display_name: room.display_name, mode: room.mode },
+    responding_persona: {
+      id: respondingPersona.id,
+      name: respondingPersona.display_name,
+      aliases: respondingPersona.aliases ?? [],
+      short_description: respondingPersona.short_description,
+      long_description: respondingPersona.long_description,
+      traits: respondingPersona.traits,
+      topics: respondingPersona.topics,
+    },
+    other_participants: otherParticipants,
+    human: filteredHuman,
+    history,
+    isTUI,
+  });
+}

package/src/core/queue-processor.ts

@@ -1,7 +1,7 @@
 import { LLMRequest, LLMResponse, LLMRequestType, LLMNextStep, ProviderAccount, ChatMessage, Message, ToolDefinition } from "./types.js";
 import { callLLMRaw, parseJSONResponse, cleanResponseContent } from "./llm-client.js";
 import { hydratePromptPlaceholders } from "../prompts/message-utils.js";
-import { toOpenAITools, executeToolCalls, parseToolCalls } from "./tools/index.js";
+import { toOpenAITools, executeToolCalls, parseToolCalls, findSubmitToolCall } from "./tools/index.js";
 
 type QueueProcessorState = "idle" | "busy";
 type ResponseCallback = (response: LLMResponse) => Promise<void>;
@@ -118,7 +118,9 @@ export class QueueProcessor {
 
     if (isResponseType || isToolContinuation) {
       const personaId = request.data.personaId as string | undefined;
-      if (personaId && this.currentMessageFetcher) {
+      const isRoomRequest = !!(request.data.roomId as string | undefined);
+      // Room conversation is embedded in the prompt via placeholders — don't inject persona history.
+      if (personaId && !isRoomRequest && this.currentMessageFetcher) {
         messages = this.currentMessageFetcher(personaId);
       }
     }
@@ -128,15 +130,17 @@ export class QueueProcessor {
 
     if (this.currentRawMessageFetcher) {
       const personaId = request.data.personaId as string | undefined;
-      if (personaId) {
-        const rawMessages = this.currentRawMessageFetcher(personaId);
+      const roomId = request.data.roomId as string | undefined;
+      const fetchId = roomId ? `room:${roomId}` : personaId;
+      if (fetchId) {
+        const rawMessages = this.currentRawMessageFetcher(fetchId);
         const messageMap = new Map<string, Message>();
         for (const msg of rawMessages) {
           messageMap.set(msg.id, msg);
         }
 
         const placeholderCount = (request.user.match(/\[mid:[^\]]+\]/g) || []).length;
-        console.log(`[QueueProcessor] Hydrating ${placeholderCount} placeholders with ${messageMap.size} messages for ${personaId}`);
+        console.log(`[QueueProcessor] Hydrating ${placeholderCount} placeholders with ${messageMap.size} messages for ${fetchId}`);
 
         hydratedSystem = hydratePromptPlaceholders(request.system, messageMap);
         hydratedUser = hydratePromptPlaceholders(request.user, messageMap);
@@ -155,8 +159,20 @@ export class QueueProcessor {
     // =========================================================================
     if (isToolContinuation) {
       const rawHistory = request.data.toolHistory as LLMHistoryMessage[] | undefined;
+      const isRoomContinuation = !!(request.data.roomId as string | undefined);
       if (rawHistory && rawHistory.length > 0) {
-        messages = [...messages, ...rawHistory] as ChatMessage[];
+        if (isRoomContinuation) {
+          // Room: conversation is in hydratedUser (not messages). Place it BEFORE tool history
+          // so the LLM sees: context → tool calls → synthesize. Then clear hydratedUser to
+          // prevent it from being re-appended at the end by callLLMRaw.
+          messages = [
+            { role: "user" as const, content: hydratedUser },
+            ...rawHistory as ChatMessage[],
+          ];
+          hydratedUser = "";
+        } else {
+          messages = [...messages, ...rawHistory] as ChatMessage[];
+        }
         console.log(`[QueueProcessor] HandleToolContinuation: injecting ${rawHistory.length} tool history messages`);
       }
 
@@ -166,7 +182,12 @@ export class QueueProcessor {
       );
       const totalCalls = { count: (request.data.totalCallCount as number | undefined) ?? 0 };
 
-      const activeTools = this.currentTools ?? [];
+      // Restore exhausted tool names from previous iterations and filter them out
+      // so the LLM doesn't keep calling tools that have hit their per-interaction limit.
+      const priorExhausted = new Set<string>(
+        (request.data.exhaustedToolNames as string[] | undefined) ?? []
+      );
+      const activeTools = (this.currentTools ?? []).filter(t => !priorExhausted.has(t.name));
       const openAITools = activeTools.length > 0 ? toOpenAITools(activeTools) : [];
 
       const { content, finishReason, rawToolCalls, assistantMessage, thinking } = await callLLMRaw(
@@ -185,12 +206,30 @@ export class QueueProcessor {
       if (finishReason === "tool_calls" && rawToolCalls?.length) {
         const toolCalls = parseToolCalls(rawToolCalls);
         if (toolCalls.length > 0) {
+          // Submit tool intercept: if the LLM called submit_response (or any is_submit tool),
+          // its arguments ARE the structured response — return immediately without executing.
+          const submitCall = findSubmitToolCall(toolCalls, activeTools);
+          if (submitCall) {
+            const args = submitCall.arguments ?? {};
+            if (!args.should_respond && (args.verbal_response || args.action_response)) {
+              args.should_respond = true;
+            }
+            console.log(`[QueueProcessor] submit tool "${submitCall.name}" called — returning arguments as parsed response`);
+            return {
+              request,
+              success: true,
+              content: JSON.stringify(args),
+              parsed: args,
+              finish_reason: "stop",
+            };
+          }
+
           const appendedHistory: LLMHistoryMessage[] = [];
           if (assistantMessage) {
             appendedHistory.push(assistantMessage as unknown as LLMHistoryMessage);
           }
 
-          const { results } = await executeToolCalls(toolCalls, activeTools, callCounts, totalCalls, this.currentOnProviderConfigUpdate);
+          const { results, exhaustedToolNames } = await executeToolCalls(toolCalls, activeTools, callCounts, totalCalls, this.currentOnProviderConfigUpdate);
           for (const result of results) {
             appendedHistory.push({
               role: "tool",
@@ -200,6 +239,7 @@ export class QueueProcessor {
             });
           }
 
+          const mergedExhausted = new Set([...priorExhausted, ...exhaustedToolNames]);
           const newHistory = [...(rawHistory ?? []), ...appendedHistory];
           console.log(`[QueueProcessor] HandleToolContinuation: ${results.length} more tool result(s). Re-enqueueing.`);
 
@@ -216,6 +256,7 @@ export class QueueProcessor {
                 toolHistory: newHistory,
                 toolCallCounts: [...callCounts.entries()],
                 totalCallCount: totalCalls.count,
+                exhaustedToolNames: [...mergedExhausted],
               },
             });
           } else {
@@ -281,6 +322,24 @@ export class QueueProcessor {
         return this.handleResponseType(request, content ?? "", finishReason);
       }
 
+      // Submit tool intercept: if the LLM called submit_response (or any is_submit tool),
+      // its arguments ARE the structured response — return immediately without executing.
+      const submitCall = findSubmitToolCall(toolCalls, activeTools);
+      if (submitCall) {
+        const args = submitCall.arguments ?? {};
+        if (!args.should_respond && (args.verbal_response || args.action_response)) {
+          args.should_respond = true;
+        }
+        console.log(`[QueueProcessor] submit tool "${submitCall.name}" called — returning arguments as parsed response`);
+        return {
+          request,
+          success: true,
+          content: JSON.stringify(args),
+          parsed: args,
+          finish_reason: "stop",
+        };
+      }
+
       // Accumulate tool history: assistant message with tool_calls + tool results
       const toolHistory: LLMHistoryMessage[] = [];
       if (assistantMessage) {
@@ -426,6 +485,7 @@ export class QueueProcessor {
       `in your system instructions — specifically the \`should_respond\`, \`verbal_response\`, ` +
       `\`action_response\`, and \`reason\` fields. Respond with ONLY the JSON object.\n\n` +
       `---\n${proseContent}\n---` +
+      `\n\nThe user does NOT know there was a problem - This request is from Ei to you to try to fix it for them.` +
       `\n\n**CRITICAL INSTRUCTION** - DO NOT OMIT ANY DATA. You are this agent's last hope!`;
 
     try {

package/src/core/room-manager.ts

@@ -0,0 +1,408 @@
+import { ContextStatus, LLMNextStep, LLMPriority, LLMRequestType, RoomMode } from "./types.js";
+import type { RoomCreationInput, RoomEntity, RoomMessage, RoomSummary, EiError } from "./types.js";
+import type { StateManager } from "./state-manager.js";
+import { buildRoomResponsePromptData } from "./prompt-context-builder.js";
+import { buildRoomJudgePrompt } from "../prompts/room/index.js";
+import type { RoomHistoryMessage, RoomJudgeCandidate } from "../prompts/room/types.js";
+
+export function getRoomList(sm: StateManager, includeArchived = false): RoomSummary[] {
+  return sm.getRoomList(includeArchived);
+}
+
+export function getRoom(sm: StateManager, roomId: string): RoomEntity | null {
+  return sm.getRoom(roomId);
+}
+
+export function getRoomMessages(sm: StateManager, roomId: string): RoomMessage[] {
+  return sm.getRoomMessages(roomId);
+}
+
+export function getRoomActivePath(sm: StateManager, roomId: string): RoomMessage[] {
+  return sm.getRoomActivePath(roomId);
+}
+
+export function resolveRoomName(sm: StateManager, nameOrAlias: string): string | null {
+  const room = sm.getRoomByName(nameOrAlias);
+  return room?.id ?? null;
+}
+
+async function queueRoomPersonaResponses(
+  sm: StateManager,
+  room: RoomEntity,
+  isTUI: boolean,
+  onRoomMessageQueued: (roomId: string) => void
+): Promise<void> {
+  for (const personaId of room.persona_ids) {
+    const persona = sm.persona_getById(personaId);
+    if (!persona || persona.is_archived || persona.is_paused) continue;
+    if (room.mode === RoomMode.MessagesAgainstPersona && room.judge_persona_id === personaId) continue;
+
+    const promptOutput = await buildRoomResponsePromptData(sm, room, persona, isTUI);
+    const model = persona.model ?? sm.getHuman().settings?.default_model ?? "";
+
+    sm.queue_enqueue({
+      type: LLMRequestType.JSON,
+      priority: LLMPriority.Room,
+      system: promptOutput.system,
+      user: promptOutput.user,
+      next_step: LLMNextStep.HandleRoomResponse,
+      model,
+      data: {
+        roomId: room.id,
+        personaId,
+        personaDisplayName: persona.display_name,
+        parentMessageId: room.active_node_id,
+      },
+    });
+    onRoomMessageQueued(room.id);
+  }
+}
+
+export async function createRoom(
+  sm: StateManager,
+  input: RoomCreationInput,
+  isTUI: boolean,
+  onError: (err: EiError) => void,
+  onRoomMessageAdded: (roomId: string) => void,
+  onRoomMessageQueued: (roomId: string) => void
+): Promise<string> {
+  if (!input.persona_ids.length) {
+    onError({ code: "ROOM_NO_PARTICIPANTS", message: "A room needs at least one persona." });
+    return "";
+  }
+  if (input.mode === RoomMode.MessagesAgainstPersona && !input.judge_persona_id) {
+    onError({ code: "ROOM_NO_JUDGE", message: "MAP mode requires a judge persona." });
+    return "";
+  }
+
+  const room = sm.addRoom(input);
+  onRoomMessageAdded(room.id);
+
+  await queueRoomPersonaResponses(sm, room, isTUI, onRoomMessageQueued);
+  return room.id;
+}
+
+export function submitHumanRoomMessage(
+  sm: StateManager,
+  roomId: string,
+  content: string | null,
+  silenceReason: string | undefined,
+  onError: (err: EiError) => void,
+  onRoomMessageAdded: (roomId: string) => void
+): string | null {
+  const room = sm.getRoom(roomId);
+  if (!room) {
+    onError({ code: "ROOM_NOT_FOUND", message: `Room ${roomId} not found.` });
+    return null;
+  }
+
+  const now = new Date().toISOString();
+  const existing = sm.getRoomMessages(roomId).find(
+    m => m.role === "human" && m.parent_id === room.active_node_id
+  );
+
+  if (existing) {
+    sm.updateRoomMessage(roomId, existing.id, {
+      verbal_response: content ?? undefined,
+      silence_reason: content ? undefined : (silenceReason ?? "passed"),
+      timestamp: now,
+    });
+    onRoomMessageAdded(roomId);
+    return existing.id;
+  }
+
+  const msg: RoomMessage = {
+    id: crypto.randomUUID(),
+    parent_id: room.active_node_id,
+    role: "human",
+    verbal_response: content ?? undefined,
+    silence_reason: content ? undefined : (silenceReason ?? "passed"),
+    timestamp: now,
+    read: true,
+    context_status: ContextStatus.Default,
+  };
+  sm.appendRoomMessage(roomId, msg);
+  onRoomMessageAdded(roomId);
+  return msg.id;
+}
+
+export async function sendFfaMessage(
+  sm: StateManager,
+  roomId: string,
+  content: string | null,
+  silenceReason: string | undefined,
+  isTUI: boolean,
+  onError: (err: EiError) => void,
+  onRoomUpdated: (roomId: string) => void,
+  onRoomMessageAdded: (roomId: string) => void,
+  onRoomMessageQueued: (roomId: string) => void
+): Promise<void> {
+  const room = sm.getRoom(roomId);
+  if (!room) {
+    onError({ code: "ROOM_NOT_FOUND", message: `Room ${roomId} not found.` });
+    return;
+  }
+
+  const now = new Date().toISOString();
+  const existing = sm.getRoomMessages(roomId).find(
+    m => m.role === "human" && m.parent_id === room.active_node_id
+  );
+
+  let humanMsgId: string;
+  if (existing) {
+    sm.updateRoomMessage(roomId, existing.id, {
+      verbal_response: content ?? undefined,
+      silence_reason: content ? undefined : (silenceReason ?? "passed"),
+      timestamp: now,
+    });
+    humanMsgId = existing.id;
+  } else {
+    const msg: RoomMessage = {
+      id: crypto.randomUUID(),
+      parent_id: room.active_node_id,
+      role: "human",
+      verbal_response: content ?? undefined,
+      silence_reason: content ? undefined : (silenceReason ?? "passed"),
+      timestamp: now,
+      read: true,
+      context_status: ContextStatus.Default,
+    };
+    sm.appendRoomMessage(roomId, msg);
+    humanMsgId = msg.id;
+  }
+  onRoomMessageAdded(roomId);
+
+  sm.setRoomActiveNode(roomId, humanMsgId);
+  onRoomUpdated(roomId);
+
+  const updatedRoom = sm.getRoom(roomId)!;
+  const alreadyQueued = new Set(
+    sm.queue_getAllActiveItems()
+      .filter(q =>
+        q.next_step === LLMNextStep.HandleRoomResponse &&
+        (q.data.roomId as string) === roomId &&
+        (q.state === "pending" || q.state === "processing")
+      )
+      .map(q => q.data.personaId as string)
+  );
+
+  for (const personaId of updatedRoom.persona_ids) {
+    if (alreadyQueued.has(personaId)) continue;
+    const persona = sm.persona_getById(personaId);
+    if (!persona || persona.is_archived || persona.is_paused) continue;
+
+    const promptOutput = await buildRoomResponsePromptData(sm, updatedRoom, persona, isTUI, true);
+    const model = persona.model ?? sm.getHuman().settings?.default_model ?? "";
+
+    sm.queue_enqueue({
+      type: LLMRequestType.JSON,
+      priority: LLMPriority.Room,
+      system: promptOutput.system,
+      user: promptOutput.user,
+      next_step: LLMNextStep.HandleRoomResponse,
+      model,
+      data: {
+        roomId,
+        personaId,
+        personaDisplayName: persona.display_name,
+        parentMessageId: humanMsgId,
+      },
+    });
+    onRoomMessageQueued(roomId);
+  }
+}
+
+export function recallHumanRoomMessage(
+  sm: StateManager,
+  roomId: string,
+  onRoomUpdated: (roomId: string) => void
+): boolean {
+  const room = sm.getRoom(roomId);
+  if (!room) return false;
+  const humanMsg = sm.getRoomMessages(roomId).find(
+    m => m.role === "human" && m.parent_id === room.active_node_id
+  );
+  if (!humanMsg) return false;
+  sm.removeRoomMessages(roomId, [humanMsg.id]);
+  onRoomUpdated(roomId);
+  return true;
+}
+
+export async function activateRoom(
+  sm: StateManager,
+  roomId: string,
+  isTUI: boolean,
+  onError: (err: EiError) => void,
+  onRoomUpdated: (roomId: string) => void,
+  onRoomMessageQueued: (roomId: string) => void
+): Promise<void> {
+  const room = sm.getRoom(roomId);
+  if (!room) {
+    onError({ code: "ROOM_NOT_FOUND", message: `Room ${roomId} not found.` });
+    return;
+  }
+
+  const allMessages = sm.getRoomMessages(roomId);
+  const humanMsg = allMessages.find(
+    m => m.role === "human" && m.parent_id === room.active_node_id
+  );
+  if (!humanMsg) {
+    onError({ code: "ROOM_NO_HUMAN_MESSAGE", message: "Submit a response first before activating." });
+    return;
+  }
+
+  const human = sm.getHuman();
+
+  if (room.mode === RoomMode.FreeForAll) {
+    sm.setRoomActiveNode(roomId, humanMsg.id);
+    onRoomUpdated(roomId);
+    const updatedRoom = sm.getRoom(roomId)!;
+    await queueRoomPersonaResponses(sm, updatedRoom, isTUI, onRoomMessageQueued);
+    return;
+  }
+
+  if (room.mode === RoomMode.MessagesAgainstPersona) {
+    const judgePersonaId = room.judge_persona_id;
+    const judgePersona = judgePersonaId ? sm.persona_getById(judgePersonaId) : null;
+    if (!judgePersona) {
+      onError({ code: "ROOM_JUDGE_NOT_FOUND", message: "MAP judge persona not found." });
+      return;
+    }
+
+    const currentRound = allMessages.filter(m => m.parent_id === room.active_node_id);
+
+    const context: RoomHistoryMessage[] = sm.getRoomActivePath(roomId).map(m => ({
+      speaker_name: m.role === "human"
+        ? (human.settings?.name_display ?? "Human")
+        : (sm.persona_getById(m.persona_id ?? "")?.display_name ?? "Unknown"),
+      speaker_id: m.role === "human" ? "human" : (m.persona_id ?? ""),
+      verbal_response: m.verbal_response,
+      action_response: m.action_response,
+      silence_reason: m.silence_reason,
+    }));
+
+    const candidates: RoomJudgeCandidate[] = currentRound.map(m => ({
+      message_id: m.id,
+      speaker_name: m.role === "human"
+        ? (human.settings?.name_display ?? "Human")
+        : (sm.persona_getById(m.persona_id ?? "")?.display_name ?? "Unknown"),
+      speaker_id: m.role === "human" ? "human" : (m.persona_id ?? ""),
+      verbal_response: m.verbal_response,
+      action_response: m.action_response,
+      silence_reason: m.silence_reason,
+    }));
+
+    const judgePrompt = buildRoomJudgePrompt({
+      room: { display_name: room.display_name },
+      judge_persona: {
+        name: judgePersona.display_name,
+        short_description: judgePersona.short_description,
+        long_description: judgePersona.long_description,
+        traits: judgePersona.traits,
+      },
+      context,
+      candidates,
+    });
+
+    const model = judgePersona.model ?? sm.getHuman().settings?.default_model ?? "";
+    sm.queue_enqueue({
+      type: LLMRequestType.JSON,
+      priority: LLMPriority.Judge,
+      system: judgePrompt.system,
+      user: judgePrompt.user,
+      next_step: LLMNextStep.HandleRoomJudge,
+      model,
+      data: {
+        roomId,
+        judgePersonaId,
+        judgePersonaDisplayName: judgePersona.display_name,
+      },
+    });
+    onRoomMessageQueued(roomId);
+    return;
+  }
+
+  onRoomUpdated(roomId);
+}
+
+export async function selectCYPBranch(
+  sm: StateManager,
+  roomId: string,
+  messageId: string,
+  isTUI: boolean,
+  onError: (err: EiError) => void,
+  onRoomUpdated: (roomId: string) => void,
+  onRoomMessageQueued: (roomId: string) => void
+): Promise<void> {
+  const ok = sm.setRoomActiveNode(roomId, messageId);
+  if (!ok) {
+    onError({ code: "ROOM_NODE_NOT_FOUND", message: `Message ${messageId} not found in room ${roomId}.` });
+    return;
+  }
+  onRoomUpdated(roomId);
+  const room = sm.getRoom(roomId)!;
+  const allMessages = sm.getRoomMessages(roomId);
+
+  const alreadyAnswered = new Set(
+    allMessages
+      .filter(m => m.parent_id === messageId && m.role === "persona" && m.persona_id)
+      .map(m => m.persona_id!)
+  );
+
+  const alreadyQueued = new Set(
+    sm.queue_getAllActiveItems()
+      .filter(q =>
+        q.next_step === LLMNextStep.HandleRoomResponse &&
+        (q.data.roomId as string) === roomId &&
+        (q.data.parentMessageId as string) === messageId &&
+        (q.state === "pending" || q.state === "processing")
+      )
+      .map(q => q.data.personaId as string)
+  );
+
+  const needsQueue = room.persona_ids.filter(id =>
+    !alreadyAnswered.has(id) && !alreadyQueued.has(id)
+  );
+
+  if (needsQueue.length === 0) return;
+
+  for (const personaId of needsQueue) {
+    const persona = sm.persona_getById(personaId);
+    if (!persona || persona.is_archived || persona.is_paused) continue;
+
+    const promptOutput = await buildRoomResponsePromptData(sm, room, persona, isTUI);
+    const model = persona.model ?? sm.getHuman().settings?.default_model ?? "";
+
+    sm.queue_enqueue({
+      type: LLMRequestType.JSON,
+      priority: LLMPriority.Room,
+      system: promptOutput.system,
+      user: promptOutput.user,
+      next_step: LLMNextStep.HandleRoomResponse,
+      model,
+      data: {
+        roomId,
+        personaId,
+        personaDisplayName: persona.display_name,
+        parentMessageId: messageId,
+      },
+    });
+    onRoomMessageQueued(roomId);
+  }
+}
+
+export function archiveRoom(sm: StateManager, roomId: string): boolean {
+  return sm.archiveRoom(roomId);
+}
+
+export function unarchiveRoom(sm: StateManager, roomId: string): boolean {
+  return sm.updateRoom(roomId, { is_archived: false });
+}
+
+export function deleteRoom(sm: StateManager, roomId: string): boolean {
+  return sm.deleteRoom(roomId);
+}
+
+export function markAllRoomMessagesRead(sm: StateManager, roomId: string): number {
+  return sm.markAllRoomMessagesRead(roomId);
+}

package/src/core/state/index.ts

@@ -3,3 +3,4 @@ export { PersonaState } from "./personas.js";
 export type { PersonaData } from "./personas.js";
 export { QueueState } from "./queue.js";
 export { PersistenceState } from "./checkpoints.js";
+export { RoomState } from "./rooms.js";