ei-tui 0.5.4 → 0.6.1

package/src/core/handlers/index.ts

@@ -1,5 +1,8 @@
 import { LLMNextStep } from "../types.js";
+import type { LLMResponse } from "../types.js";
+import type { StateManager } from "../state-manager.js";
 import type { ResponseHandler } from "./persona-response.js";
+import type { PersonIdentifier } from "../types/data-items.js";
 
 export type { ResponseHandler } from "./persona-response.js";
 
@@ -7,20 +10,60 @@ import { handlePersonaResponse, handleToolContinuation, handleOneShot } from "./
 import { handleHeartbeatCheck, handleEiHeartbeat } from "./heartbeat.js";
 import { handlePersonaGeneration, handlePersonaDescriptions, handlePersonaTraitExtraction } from "./persona-generation.js";
 import {
-  handlePersonaExpire,
-  handlePersonaExplore,
-  handleDescriptionCheck,
-  handlePersonaTopicScan,
-  handlePersonaTopicMatch,
-  handlePersonaTopicUpdate,
+  handlePersonaTopicRating,
 } from "./persona-topics.js";
 import { handleFactFind, handleHumanTopicScan, handleHumanPersonScan, handleEventScan } from "./human-extraction.js";
-import { handleTopicMatch, handleTopicUpdate, handlePersonMatch, handlePersonUpdate } from "./human-matching.js";
+import { handleTopicMatch, handleTopicUpdate, handlePersonUpdate } from "./human-matching.js";
 import { handleRewriteScan, handleRewriteRewrite } from "./rewrite.js";
 import { handleDedupCurate } from "./dedup.js";
 import { handleRoomResponse, handleRoomJudge } from "./rooms.js";
 import { handlePersonaPreview } from "./persona-preview.js";
 
+function handlePersonIdentifierMigration(response: LLMResponse, state: StateManager): void {
+  const personId = response.request.data.person_id as string;
+  if (!personId) {
+    console.error("[handlePersonIdentifierMigration] Missing person_id in request data");
+    return;
+  }
+
+  const human = state.getHuman();
+  const person = human.people.find(p => p.id === personId);
+  if (!person) {
+    console.error(`[handlePersonIdentifierMigration] Person not found: ${personId}`);
+    return;
+  }
+
+  const result = response.parsed as { identifiers?: Array<{ type: string; value: string; is_primary?: boolean }> } | undefined;
+  if (!result?.identifiers || !Array.isArray(result.identifiers) || result.identifiers.length === 0) {
+    console.error(`[handlePersonIdentifierMigration] Invalid or empty identifiers for ${person.name}`);
+    return;
+  }
+
+  const hasName = result.identifiers.some(i => i.value === person.name);
+  if (!hasName) {
+    result.identifiers.unshift({ type: "nickname", value: person.name });
+  }
+
+  const hasPrimary = result.identifiers.some(i => i.is_primary);
+  if (!hasPrimary) {
+    result.identifiers[0].is_primary = true;
+  }
+
+  const identifiers: PersonIdentifier[] = result.identifiers.map(i => ({
+    type: i.type,
+    value: i.value,
+    ...(i.is_primary ? { is_primary: i.is_primary } : {}),
+  }));
+
+  state.human_person_upsert({
+    ...person,
+    identifiers,
+    last_updated: new Date().toISOString(),
+  });
+
+  console.log(`[handlePersonIdentifierMigration] Migrated ${identifiers.length} identifier(s) for ${person.name}`);
+}
+
 export const handlers: Record<LLMNextStep, ResponseHandler> = {
   handlePersonaResponse,
   handlePersonaGeneration,
@@ -30,18 +73,12 @@ export const handlers: Record<LLMNextStep, ResponseHandler> = {
   handleHumanPersonScan,
   handleTopicMatch,
   handleTopicUpdate,
-  handlePersonMatch,
   handlePersonUpdate,
   handlePersonaTraitExtraction,
-  handlePersonaTopicScan,
-  handlePersonaTopicMatch,
-  handlePersonaTopicUpdate,
+  handlePersonaTopicRating,
   handleHeartbeatCheck,
   handleEiHeartbeat,
   handleOneShot,
-  handlePersonaExpire,
-  handlePersonaExplore,
-  handleDescriptionCheck,
   handleToolContinuation,
   handleRewriteScan,
   handleRewriteRewrite,
@@ -50,4 +87,5 @@ export const handlers: Record<LLMNextStep, ResponseHandler> = {
   handleRoomResponse,
   handleRoomJudge,
   handlePersonaPreview,
+  [LLMNextStep.HandlePersonIdentifierMigration]: handlePersonIdentifierMigration,
 };

package/src/core/handlers/persona-generation.ts

@@ -36,6 +36,7 @@ export function handlePersonaGeneration(response: LLMResponse, state: StateManag
       sentiment: userTrait?.sentiment ?? t.sentiment ?? 0,
       strength: userTrait?.strength ?? t.strength,
       last_updated: now,
+      learned_on: now,
     };
   });
 
@@ -50,6 +51,7 @@ export function handlePersonaGeneration(response: LLMResponse, state: StateManag
       sentiment: t.sentiment ?? 0,
       strength: t.strength,
       last_updated: now,
+      learned_on: now,
     }));
 
   const mergedTraits: PersonaTrait[] = mergedLlmTraits.length > 0

package/src/core/handlers/persona-response.ts

@@ -7,6 +7,7 @@ import {
 import type { StateManager } from "../state-manager.js";
 import type { PersonaResponseResult } from "../../prompts/response/index.js";
 import { handlers } from "./index.js";
+import { cleanResponseContent } from "../llm-client.js";
 
 export type ResponseHandler = (response: LLMResponse, state: StateManager) => void | Promise<void>;
 
@@ -18,18 +19,48 @@ export function handlePersonaResponse(response: LLMResponse, state: StateManager
     return;
   }
 
-  // Always mark user messages as read - even if persona chooses not to respond,
-  // the messages were "seen" and processed
   state.messages_markPendingAsRead(personaId);
 
-  // Structured JSON path: queue-processor parsed valid JSON into `parsed`
+  const raw = cleanResponseContent(response.content ?? "").trim();
+
+  if (raw.length > 0) {
+    const lines = raw.split('\n');
+    const isNoResponse = lines[0].replace(/[^a-zA-Z]/g, '').toLowerCase() === 'noresponse';
+
+    if (isNoResponse) {
+      const reason = lines.slice(1).join('\n').trim();
+      console.log(`[silence] ${personaDisplayName}: ${reason || "(no reason given)"}`);
+      const silentMessage: Message = {
+        id: crypto.randomUUID(),
+        role: "system",
+        silence_reason: reason || undefined,
+        timestamp: new Date().toISOString(),
+        read: false,
+        context_status: ContextStatus.Default,
+      };
+      state.messages_append(personaId, silentMessage);
+    } else {
+      const message: Message = {
+        id: crypto.randomUUID(),
+        role: "system",
+        content: raw,
+        timestamp: new Date().toISOString(),
+        read: false,
+        context_status: ContextStatus.Default,
+      };
+      state.messages_append(personaId, message);
+      console.log(`[handlePersonaResponse] Appended Markdown response to ${personaDisplayName}`);
+    }
+    return;
+  }
+
   if (response.parsed !== undefined) {
     const result = response.parsed as PersonaResponseResult;
 
     if (!result.should_respond) {
       const reason = result.reason;
       if (reason) {
-        console.log(`[handlePersonaResponse] ${personaDisplayName} chose silence: ${reason}`);
+        console.log(`[silence] ${personaDisplayName}: ${reason}`);
         const silentMessage: Message = {
           id: crypto.randomUUID(),
           role: "system",
@@ -40,12 +71,11 @@ export function handlePersonaResponse(response: LLMResponse, state: StateManager
         };
         state.messages_append(personaId, silentMessage);
       } else {
-        console.log(`[handlePersonaResponse] ${personaDisplayName} chose not to respond (no reason given)`);
+        console.log(`[silence] ${personaDisplayName}: (no reason given)`);
       }
       return;
     }
 
-    // Build message with structured fields
     const verbal = result.verbal_response || undefined;
     const action = result.action_response || undefined;
 
@@ -68,22 +98,7 @@ export function handlePersonaResponse(response: LLMResponse, state: StateManager
     return;
   }
 
-  // Legacy plain-text fallback
-  if (!response.content) {
-    console.log(`[handlePersonaResponse] ${personaDisplayName} chose not to respond (no reason given)`);
-    return;
-  }
-
-  const message: Message = {
-    id: crypto.randomUUID(),
-    role: "system",
-    verbal_response: response.content ?? undefined,
-    timestamp: new Date().toISOString(),
-    read: false,
-    context_status: ContextStatus.Default,
-  };
-  state.messages_append(personaId, message);
-  console.log(`[handlePersonaResponse] Appended response to ${personaDisplayName}`);
+  console.warn(`[silence] ${personaDisplayName}: empty response after cleaning`);
 }
 
 /**

package/src/core/handlers/persona-topics.ts

@@ -1,306 +1,70 @@
 import {
-  LLMRequestType,
-  LLMPriority,
-  LLMNextStep,
   type LLMResponse,
   type PersonaTopic,
 } from "../types.js";
 import type { StateManager } from "../state-manager.js";
-import type { PersonaExpireResult, PersonaExploreResult, DescriptionCheckResult } from "../../prompts/ceremony/types.js";
-import type {
-  PersonaTopicScanResult,
-  PersonaTopicScanCandidate,
-  PersonaTopicMatchResult,
-  PersonaTopicUpdateResult,
-} from "../../prompts/persona/types.js";
-import {
-  queueExplorePhase,
-  queueDescriptionCheck,
-  queuePersonaTopicMatch,
-  queuePersonaTopicUpdate,
-  type PersonaTopicContext,
-} from "../orchestrators/index.js";
-import { buildPersonaDescriptionsPrompt } from "../../prompts/generation/index.js";
-import { splitMessagesByTimestamp } from "./utils.js";
+import type { PersonaTopicRatingResult } from "../../prompts/persona/types.js";
 import { calculateExposureCurrent } from "../utils/exposure.js";
 
 export const MIN_MESSAGE_COUNT_FOR_CREATE = 2;
 
-export function handlePersonaExpire(response: LLMResponse, state: StateManager): void {
+export function handlePersonaTopicRating(response: LLMResponse, state: StateManager): void {
   const personaId = response.request.data.personaId as string;
   const personaDisplayName = response.request.data.personaDisplayName as string;
-  if (!personaId) {
-    console.error("[handlePersonaExpire] No personaId in request data");
+  if (!personaId || !personaDisplayName) {
+    console.error("[handlePersonaTopicRating] Missing personaId or personaDisplayName in request data");
     return;
   }
 
-  const result = response.parsed as PersonaExpireResult | undefined;
-  const persona = state.persona_getById(personaId);
-  
-  if (!persona) {
-    console.error(`[handlePersonaExpire] Persona not found: ${personaDisplayName}`);
+  const result = response.parsed as PersonaTopicRatingResult | undefined;
+  if (!result?.ratings || !Array.isArray(result.ratings)) {
+    console.log("[handlePersonaTopicRating] No ratings returned or invalid result");
     return;
   }
 
-  const idsToRemove = new Set(result?.topic_ids_to_remove ?? []);
-  const remainingTopics = persona.topics.filter((t: PersonaTopic) => !idsToRemove.has(t.id));
-  const removedCount = persona.topics.length - remainingTopics.length;
-
-  if (removedCount > 0) {
-    state.persona_update(personaId, { 
-      topics: remainingTopics,
-      last_updated: new Date().toISOString(),
-    });
-    console.log(`[handlePersonaExpire] Removed ${removedCount} topic(s) from ${personaDisplayName}`);
-  } else {
-    console.log(`[handlePersonaExpire] No topics removed for ${personaDisplayName}`);
-  }
-
-  const human = state.getHuman();
-  const exploreThreshold = human.settings?.ceremony?.explore_threshold ?? 3;
-
-  if (remainingTopics.length < exploreThreshold) {
-    console.log(`[handlePersonaExpire] ${personaDisplayName} has ${remainingTopics.length} topic(s) (< ${exploreThreshold}), triggering Explore`);
-    queueExplorePhase(personaId, state);
-  } else {
-    queueDescriptionCheck(personaId, state);
-  }
-}
-
-export function handlePersonaExplore(response: LLMResponse, state: StateManager): void {
-  const personaId = response.request.data.personaId as string;
-  const personaDisplayName = response.request.data.personaDisplayName as string;
-  if (!personaId) {
-    console.error("[handlePersonaExplore] No personaId in request data");
-    return;
+  const messageIds = response.request.data.message_ids as string[] | undefined;
+  if (messageIds?.length) {
+    const shortId = personaId.slice(0, 8);
+    const roomId = response.request.data.roomId as string | undefined;
+    if (roomId) {
+      state.markRoomMessagesPersonaExtracted(roomId, messageIds, shortId);
+    } else {
+      state.messages_markPersonaExtracted(personaId, messageIds, shortId);
+    }
   }
 
-  const result = response.parsed as PersonaExploreResult | undefined;
   const persona = state.persona_getById(personaId);
-
   if (!persona) {
-    console.error(`[handlePersonaExplore] Persona not found: ${personaDisplayName}`);
-    queueDescriptionCheck(personaId, state);
-    return;
-  }
-
-  const newTopics = result?.new_topics ?? [];
-  if (newTopics.length === 0) {
-    console.log(`[handlePersonaExplore] No new topics generated for ${personaDisplayName}`);
-    queueDescriptionCheck(personaId, state);
+    console.error(`[handlePersonaTopicRating] Persona not found: ${personaDisplayName}`);
     return;
   }
 
   const now = new Date().toISOString();
-  const existingNames = new Set(persona.topics.map((t: PersonaTopic) => t.name.toLowerCase()));
-
-  const topicsToAdd: PersonaTopic[] = newTopics
-    .filter(t => !existingNames.has(t.name.toLowerCase()))
-    .map(t => ({
-      id: crypto.randomUUID(),
-      name: t.name,
-      perspective: t.perspective || "",
-      approach: t.approach || "",
-      personal_stake: t.personal_stake || "",
-      sentiment: t.sentiment,
-      exposure_current: t.exposure_current ?? 0.2,
-      exposure_desired: t.exposure_desired ?? 0.6,
-      last_updated: now,
-    }));
-
-  if (topicsToAdd.length > 0) {
-    const allTopics = [...persona.topics, ...topicsToAdd];
-    state.persona_update(personaId, { 
-      topics: allTopics,
-      last_updated: now,
-    });
-    console.log(`[handlePersonaExplore] Added ${topicsToAdd.length} new topic(s) to ${personaDisplayName}: ${topicsToAdd.map(t => t.name).join(", ")}`);
-  }
-
-  queueDescriptionCheck(personaId, state);
-}
-
-export function handleDescriptionCheck(response: LLMResponse, state: StateManager): void {
-  const personaId = response.request.data.personaId as string;
-  const personaDisplayName = response.request.data.personaDisplayName as string;
-  if (!personaId) {
-    console.error("[handleDescriptionCheck] No personaId in request data");
-    return;
-  }
-
-  const result = response.parsed as DescriptionCheckResult | undefined;
-  if (!result) {
-    console.error("[handleDescriptionCheck] No parsed result");
-    return;
-  }
-
-  console.log(`[handleDescriptionCheck] ${personaDisplayName}: ${result.should_update ? "UPDATE NEEDED" : "No update needed"} - ${result.reason ?? "no reason given"}`);
+  let updatedCount = 0;
 
-  if (!result.should_update) {
-    console.log(`[handleDescriptionCheck] Ceremony complete for ${personaDisplayName}`);
-    return;
-  }
-
-  const persona = state.persona_getById(personaId);
-  if (!persona) {
-    console.error(`[handleDescriptionCheck] Persona not found: ${personaDisplayName}`);
-    return;
-  }
-
-  const prompt = buildPersonaDescriptionsPrompt({
-    name: persona.display_name,
-    aliases: persona.aliases ?? [],
-    traits: persona.traits,
-    topics: persona.topics,
-  });
-
-  state.queue_enqueue({
-    type: LLMRequestType.JSON,
-    priority: LLMPriority.Low,
-    system: prompt.system,
-    user: prompt.user,
-    next_step: LLMNextStep.HandlePersonaDescriptions,
-    data: { personaId, personaDisplayName },
-  });
-
-  console.log(`[handleDescriptionCheck] Queued description regeneration for ${personaDisplayName}`);
-}
-
-export function handlePersonaTopicScan(response: LLMResponse, state: StateManager): void {
-  const personaId = response.request.data.personaId as string;
-  const personaDisplayName = response.request.data.personaDisplayName as string;
-  if (!personaId || !personaDisplayName) {
-    console.error("[handlePersonaTopicScan] Missing personaId or personaDisplayName in request data");
-    return;
-  }
-
-  const result = response.parsed as PersonaTopicScanResult | undefined;
-  if (!result?.topics || !Array.isArray(result.topics)) {
-    console.log("[handlePersonaTopicScan] No topics detected or invalid result");
-    return;
-  }
-
-  const analyzeFrom = response.request.data.analyze_from_timestamp as string | null;
-  const allMessages = state.messages_get(personaId);
-  const { messages_context, messages_analyze } = splitMessagesByTimestamp(allMessages, analyzeFrom);
-
-  const context: PersonaTopicContext = {
-    personaId,
-    personaDisplayName,
-    messages_context,
-    messages_analyze,
-  };
-
-  for (const candidate of result.topics) {
-    queuePersonaTopicMatch(candidate, context, state);
-  }
-  console.log(`[handlePersonaTopicScan] Queued ${result.topics.length} topic(s) for matching`);
-}
-
-export function handlePersonaTopicMatch(response: LLMResponse, state: StateManager): void {
-  const personaId = response.request.data.personaId as string;
-  const personaDisplayName = response.request.data.personaDisplayName as string;
-  const candidate = response.request.data.candidate as PersonaTopicScanCandidate;
-  const analyzeFrom = response.request.data.analyze_from_timestamp as string | null;
-
-  if (!personaId || !personaDisplayName || !candidate) {
-    console.error("[handlePersonaTopicMatch] Missing required data");
-    return;
-  }
-
-  const result = response.parsed as PersonaTopicMatchResult | undefined;
-  if (!result) {
-    console.error("[handlePersonaTopicMatch] No parsed result");
-    return;
-  }
-
-  if (result.action === "match") {
-    console.log(`[handlePersonaTopicMatch] "${candidate.name}" matched existing topic`);
-  } else if (result.action === "create") {
-    if (candidate.message_count < MIN_MESSAGE_COUNT_FOR_CREATE) {
-      console.log(`[handlePersonaTopicMatch] "${candidate.name}" skipped: message_count ${candidate.message_count} < ${MIN_MESSAGE_COUNT_FOR_CREATE}`);
-      return;
+  const updatedTopics = persona.topics.map((topic: PersonaTopic) => {
+    const rating = result.ratings.find(r => r.topic_id === topic.id);
+    if (!rating || rating.exposure_impact === "none") {
+      return topic;
     }
-    console.log(`[handlePersonaTopicMatch] "${candidate.name}" will be created`);
-  } else if (result.action === "skip") {
-    console.log(`[handlePersonaTopicMatch] "${candidate.name}" skipped: ${result.reason}`);
-    return;
-  }
 
-  const allMessages = state.messages_get(personaId);
-  const { messages_context, messages_analyze } = splitMessagesByTimestamp(allMessages, analyzeFrom);
+    const newExposure = calculateExposureCurrent(rating.exposure_impact, topic.exposure_current);
+    updatedCount++;
 
-  const context: PersonaTopicContext = {
-    personaId,
-    personaDisplayName,
-    messages_context,
-    messages_analyze,
-  };
-
-  queuePersonaTopicUpdate(candidate, result, context, state);
-}
-
-export function handlePersonaTopicUpdate(response: LLMResponse, state: StateManager): void {
-  const personaId = response.request.data.personaId as string;
-  const personaDisplayName = response.request.data.personaDisplayName as string;
-  const existingTopicId = response.request.data.existingTopicId as string | null;
-  const isNewTopic = response.request.data.isNewTopic as boolean;
-
-  if (!personaId) {
-    console.error("[handlePersonaTopicUpdate] No personaId in request data");
-    return;
-  }
-
-  const result = response.parsed as PersonaTopicUpdateResult | undefined;
-  if (!result) {
-    console.error("[handlePersonaTopicUpdate] No parsed result");
-    return;
-  }
-
-  const persona = state.persona_getById(personaId);
-  if (!persona) {
-    console.error(`[handlePersonaTopicUpdate] Persona not found: ${personaDisplayName}`);
-    return;
-  }
-
-  const now = new Date().toISOString();
-
-  if (isNewTopic) {
-    const newTopic: PersonaTopic = {
-      id: crypto.randomUUID(),
-      name: result.name,
-      perspective: result.perspective || "",
-      approach: result.approach || "",
-      personal_stake: result.personal_stake || "",
-      sentiment: result.sentiment,
-      exposure_current: calculateExposureCurrent(result.exposure_impact, 0),
-      exposure_desired: result.exposure_desired,
+    return {
+      ...topic,
+      exposure_current: newExposure,
       last_updated: now,
     };
+  });
 
-    const allTopics = [...persona.topics, newTopic];
-    state.persona_update(personaId, { topics: allTopics, last_updated: now });
-    console.log(`[handlePersonaTopicUpdate] Created new topic "${result.name}" for ${personaDisplayName}`);
-  } else if (existingTopicId) {
-    const updatedTopics = persona.topics.map((t: PersonaTopic) => {
-      if (t.id !== existingTopicId) return t;
-
-      const newExposure = Math.max(calculateExposureCurrent(result.exposure_impact, t.exposure_current), t.exposure_current);
-
-      return {
-        ...t,
-        name: result.name,
-        perspective: result.perspective || t.perspective,
-        approach: result.approach || t.approach,
-        personal_stake: result.personal_stake || t.personal_stake,
-        sentiment: result.sentiment,
-        exposure_current: newExposure,
-        exposure_desired: result.exposure_desired,
-        last_updated: now,
-      };
+  if (updatedCount > 0) {
+    state.persona_update(personaId, {
+      topics: updatedTopics,
+      last_updated: now,
     });
-
-    state.persona_update(personaId, { topics: updatedTopics, last_updated: now });
-    console.log(`[handlePersonaTopicUpdate] Updated topic "${result.name}" for ${personaDisplayName}`);
+    console.log(`[handlePersonaTopicRating] Updated ${updatedCount}/${persona.topics.length} topics for ${personaDisplayName}`);
+  } else {
+    console.log(`[handlePersonaTopicRating] No topic exposure updates for ${personaDisplayName}`);
   }
 }

package/src/core/handlers/rewrite.ts

@@ -218,6 +218,7 @@ export async function handleRewriteRewrite(response: LLMResponse, state: StateMa
       description: item.description,
       sentiment: item.sentiment ?? 0,
       last_updated: now,
+      learned_on: now,
       learned_by: "ei",
       persona_groups: unionGroups,
       interested_personas: unionPersonas,
@@ -244,6 +245,8 @@ export async function handleRewriteRewrite(response: LLMResponse, state: StateMa
         }
         const person: Person = {
           ...baseFields,
+          identifiers: [],
+          validated_date: '',
           relationship: item.relationship ?? "Unknown",
           exposure_current: 0.5,
           exposure_desired: 0.5,

package/src/core/handlers/rooms.ts

@@ -8,6 +8,7 @@ import type { StateManager } from "../state-manager.js";
 import type { PersonaResponseResult } from "../../prompts/response/index.js";
 import type { RoomJudgeResult } from "../../prompts/room/index.js";
 import { buildRoomResponsePromptData } from "../prompt-context-builder.js";
+import { cleanResponseContent } from "../llm-client.js";
 
 export function handleRoomResponse(response: LLMResponse, state: StateManager): void {
   const roomId = response.request.data.roomId as string;
@@ -21,13 +22,49 @@ export function handleRoomResponse(response: LLMResponse, state: StateManager):
   }
 
   const now = new Date().toISOString();
+  const raw = cleanResponseContent(response.content ?? "").trim();
+
+  if (raw.length > 0) {
+    const lines = raw.split('\n');
+    const isNoResponse = lines[0].replace(/[^a-zA-Z]/g, '').toLowerCase() === 'noresponse';
+
+    if (isNoResponse) {
+      const reason = lines.slice(1).join('\n').trim();
+      console.log(`[silence] ${personaDisplayName}: ${reason || "(no reason given)"}`);
+      const msg: RoomMessage = {
+        id: crypto.randomUUID(),
+        parent_id: parentMessageId,
+        role: "persona",
+        persona_id: personaId,
+        silence_reason: reason || undefined,
+        timestamp: now,
+        read: false,
+        context_status: ContextStatus.Default,
+      };
+      state.appendRoomMessage(roomId, msg);
+    } else {
+      const msg: RoomMessage = {
+        id: crypto.randomUUID(),
+        parent_id: parentMessageId,
+        role: "persona",
+        persona_id: personaId,
+        content: raw,
+        timestamp: now,
+        read: false,
+        context_status: ContextStatus.Default,
+      };
+      state.appendRoomMessage(roomId, msg);
+      console.log(`[handleRoomResponse] Appended Markdown response from ${personaDisplayName} to room ${roomId}`);
+    }
+    return;
+  }
 
   if (response.parsed !== undefined) {
     const result = response.parsed as PersonaResponseResult;
 
     if (!result.should_respond) {
       const reason = result.reason;
-      console.log(`[handleRoomResponse] ${personaDisplayName} chose silence in room ${roomId}: ${reason ?? "(no reason)"}`);
+      console.log(`[silence] ${personaDisplayName}: ${reason ?? "(no reason given)"}`);
       if (reason) {
         const msg: RoomMessage = {
           id: crypto.randomUUID(),
@@ -64,27 +101,11 @@ export function handleRoomResponse(response: LLMResponse, state: StateManager):
       context_status: ContextStatus.Default,
     };
     state.appendRoomMessage(roomId, msg);
-    console.log(`[handleRoomResponse] Appended response from ${personaDisplayName} to room ${roomId}`);
-    return;
-  }
-
-  if (!response.content) {
-    console.log(`[handleRoomResponse] ${personaDisplayName} no response (empty content)`);
+    console.log(`[handleRoomResponse] Appended structured response from ${personaDisplayName} to room ${roomId}`);
     return;
   }
 
-  const msg: RoomMessage = {
-    id: crypto.randomUUID(),
-    parent_id: parentMessageId,
-    role: "persona",
-    persona_id: personaId,
-    verbal_response: response.content,
-    timestamp: now,
-    read: false,
-    context_status: ContextStatus.Default,
-  };
-  state.appendRoomMessage(roomId, msg);
-  console.log(`[handleRoomResponse] Appended plain-text response from ${personaDisplayName} to room ${roomId}`);
+  console.warn(`[silence] ${personaDisplayName}: empty response after cleaning`);
 }
 
 export async function handleRoomJudge(response: LLMResponse, state: StateManager): Promise<void> {
@@ -159,7 +180,7 @@ export async function handleRoomJudge(response: LLMResponse, state: StateManager
     const model = persona.model ?? state.getHuman().settings?.default_model ?? "";
 
     state.queue_enqueue({
-      type: LLMRequestType.JSON,
+      type: LLMRequestType.Raw,
       priority: LLMPriority.Room,
       system: promptData.system,
       user: promptData.user,