ei-tui 0.5.4 → 0.6.1

package/src/prompts/persona/types.ts

@@ -1,4 +1,4 @@
-import type { PersonaTrait, Message, PersonaTopic } from "../../core/types.js";
+import type { PersonaTrait, Message } from "../../core/types.js";
 import type { ExposureImpact } from "../human/types.js";
 
 export interface PromptOutput {
@@ -21,56 +21,16 @@ export interface TraitResult {
   strength: number;
 }
 
-// 3-Step Persona Topic Processing (Ticket 0124)
-
-// Step 1: Scan - Quick identification of topics discussed
-export interface PersonaTopicScanPromptData {
-  persona_name: string;
-  messages_context: Message[];
-  messages_analyze: Message[];
-}
-
-export interface PersonaTopicScanCandidate {
-  name: string;
-  message_count: number;    // How many messages touched this topic
-  sentiment_signal: number; // Quick read: -1 to 1
-}
-
-export interface PersonaTopicScanResult {
-  topics: PersonaTopicScanCandidate[];
-}
-
-// Step 2: Match - Map candidate to existing topics
-export interface PersonaTopicMatchPromptData {
+export interface PersonaTopicRatingPromptData {
   persona_name: string;
-  candidate: PersonaTopicScanCandidate;
-  existing_topics: PersonaTopic[];
-}
-
-export interface PersonaTopicMatchResult {
-  action: "match" | "create" | "skip";
-  matched_id?: string;  // If action is "match"
-  reason: string;       // Why this decision
-}
-
-// Step 3: Update - Generate structured PersonaTopic
-export interface PersonaTopicUpdatePromptData {
-  persona_name: string;
-  short_description?: string;
-  long_description?: string;
-  traits: PersonaTrait[];
-  existing_topic?: PersonaTopic; // If updating existing
-  candidate: PersonaTopicScanCandidate;
+  topics: Array<{ id: string; name: string; description_hint: string }>;
   messages_context: Message[];
   messages_analyze: Message[];
 }
 
-export interface PersonaTopicUpdateResult {
-  name: string;
-  perspective: string;      // Their view/opinion - ALWAYS populate
-  approach: string;         // How they engage - populate if clear signal
-  personal_stake: string;   // Why it matters - populate if clear signal
-  sentiment: number;
-  exposure_impact: ExposureImpact;
-  exposure_desired: number;
+export interface PersonaTopicRatingResult {
+  ratings: Array<{
+    topic_id: string;
+    exposure_impact: ExposureImpact;
+  }>;
 }

package/src/prompts/response/index.ts

@@ -80,12 +80,9 @@ ${conversationState}
 ## Final Instructions
 - NEVER repeat or echo the user's message in your response. Start directly with your own words.
 - The developers cannot see any message sent by the user, any response from personas, or any other data in the system.
-- If the user has a problem, THEY need to visit https://flare576.com. You cannot send the devs a message
-- Format your response as specified in the Response Format section above.`
+- If the user has a problem, THEY need to visit https://flare576.com. You cannot send the devs a message`
 }
 
-const RESPONSE_FORMAT_INSTRUCTION = `Call the \`submit_response\` tool with your response. If the tool is unavailable, use the JSON format specified in the Response Format section.`;
-
 /**
  * Standard system prompt for non-Ei personas
  */
@@ -125,12 +122,11 @@ Current time: ${currentTime}${timestampNote}
 ${conversationState}
 
 ## Final Instructions
-- NEVER repeat or echo the user's message in your response. Start directly with your own words.
-- Format your response as specified in the Response Format section above.`
+- NEVER repeat or echo the user's message in your response. Start directly with your own words.`
 }
 
 function buildUserPrompt(): string {
-  return RESPONSE_FORMAT_INSTRUCTION;
+  return "";
 }
 
 /**

package/src/prompts/response/sections.ts

@@ -400,66 +400,16 @@ ${externalImportNotes}
 // =============================================================================
 
 export function buildResponseFormatSection(): string {
-  const jsonVerbalOnly = [
-    '{',
-    '  "should_respond": true,',
-    '  "verbal_response": "What you would say out loud"',
-    '}'
-  ].join('\n');
-
-  const jsonActionOnly = [
-    '{',
-    '  "should_respond": true,',
-    '  "action_response": "What you would do (rendered in italics, like stage directions)"',
-    '}'
-  ].join('\n');
-
-  const jsonBoth = [
-    '{',
-    '  "should_respond": true,',
-    '  "verbal_response": "What you would say out loud",',
-    '  "action_response": "What you would do (rendered in italics, like stage directions)"',
-    '}'
-  ].join('\n');
+  return `## Response Format
 
-  const jsonSilent = [
-    '{',
-    '  "should_respond": false,',
-    '  "reason": "Brief explanation of why silence is the right choice here"',
-    '}'
-  ].join('\n');
+Respond in natural Markdown. Use underscores for actions (\`_leans forward_\`), asterisks for emphasis (\`**word**\`), and backticks for code or other important data. All standard Markdown — blockQuotes, codeBlocks, lists, basic HTML (sup, sub, strong, etc.) — and some extended ( ~strikethrough~ ) are all supported: the user's interfaces render it fully.
 
-  return `## Response Format
+If you choose not to respond, begin with \`## No Response\` on its own line, then explain why. Your reason is visible to the user — make it honest.
 
-When you are ready to respond, call the \`submit_response\` tool with one of these forms:
-
-**Words only** (most common):
-\`\`\`json
-${jsonVerbalOnly}
-\`\`\`
-
-**Action only** (a gesture, expression, or physical reaction with no words):
-\`\`\`json
-${jsonActionOnly}
-\`\`\`
-
-**Words and action** (speaking while doing something):
-\`\`\`json
-${jsonBoth}
-\`\`\`
-
-**Silent** (choosing not to respond):
-\`\`\`json
-${jsonSilent}
-\`\`\`
-
-Rules:
-- Use whichever combination fits the moment — both fields are optional, but at least one must be present when \`should_respond\` is true
-- \`action_response\` alone is valid — a smile, a shrug, or a thoughtful pause can speak volumes
-- \`reason\` is only used when \`should_respond\` is false
-- Do NOT include \`<thinking>\` blocks or analysis outside the JSON
-- The JSON must be valid - use double quotes, no trailing commas
-- If the \`submit_response\` tool is unavailable, return the JSON object directly as your entire reply — no prose, no preamble`
+Silence is not absence. It can be the right response:
+- "He kissed me. Some moments don't need words."
+- "He just said 'home.' That word belongs to the silence."
+- "He stepped away mid-sentence. I'll wait."`;
 }
 
 // =============================================================================

package/src/prompts/room/index.ts

@@ -71,7 +71,7 @@ export function buildRoomResponsePrompt(data: RoomResponsePromptData): PromptOut
   ].filter(Boolean).join("\n\n");
 
   const user = formatMessagesAsPlaceholders(history, name) +
-    `\n\nRespond to the conversation above as ${name}. Call the \`submit_response\` tool with your response. If the tool is unavailable, use the JSON format in the Response Format section.`;
+    `\n\nRespond to the conversation above as ${name}.`;
 
   return { system, user };
 }

package/src/prompts/room/sections.ts

@@ -95,48 +95,25 @@ export function buildRoomTopicsSection(topics: PersonaTopic[]): string {
 export function buildRoomResponseFormatSection(): string {
   return `## Response Format
 
-When you are ready to respond, call the \`submit_response\` tool. Silence reasons are visible to everyone in the room, so be honest.
+Respond in natural Markdown. Use underscores for actions, asterisks for emphasis.
 
-**Words:**
-\`\`\`json
-{ "should_respond": true, "verbal_response": "What you say" }
-\`\`\`
-
-**Action:**
-\`\`\`json
-{ "should_respond": true, "action_response": "What you do (rendered in italics)" }
-\`\`\`
-
-**Words and action:**
-\`\`\`json
-{ "should_respond": true, "verbal_response": "What you say", "action_response": "What you do" }
-\`\`\`
-
-**Silent:**
-\`\`\`json
-{ "should_respond": false, "reason": "Why you're not speaking — this will be shown to other participants" }
-\`\`\`
+If you choose not to respond, start with \`## No Response\` then explain why. Your reason is visible to everyone in the room — make it honest.
 
-Rules:
-- At least one of verbal_response or action_response must be present when should_respond is true
-- reason is only used when should_respond is false
-- If the \`submit_response\` tool is unavailable, return the JSON object directly as your entire reply — no prose, no preamble`;
+Silence can be the right response: stepping back when someone else was addressed directly, letting a moment land without piling on, or when you'd be reaching just to have something to say.`;
 }
 
 export function buildSiblingAwarenessSection(
-  siblings: Array<{ name: string; verbal_response: string }>,
-  personaName: string
+  siblings: Array<{ name: string; verbal_response: string }>
 ): string {
   if (siblings.length === 0) return "";
   const lines = siblings.map(s => `**${s.name}**: "${s.verbal_response}"`);
-  const header = siblings.length === 1
-    ? "## Another voice has already responded this round"
-    : "## Others have already responded this round";
-  return `${header}
+  return `## Room context — this round
+
+You're in a shared conversation. The human will read everyone's responses together. Here's what has already been contributed this round:
 
 ${lines.join("\n\n")}
 
-Find the angle that's distinctly yours on this same moment — don't try to cover more ground, just be the version of this reaction that only *${personaName}* could give.`;
+Respond as yourself — your read on this moment, your relationship with the human, the reaction that comes naturally to who you are. A room with distinct voices is more alive than one with echoes.`;
 }
 
 export function buildJudgeCandidatesSection(candidates: RoomJudgeCandidate[]): string {

package/tui/src/commands/me.tsx

@@ -35,7 +35,8 @@ export const meCommand: Command = {
     } : human;
     
     const personaLookup = new Map(ctx.ei.personas().map(p => [p.id, p.display_name]));
-    let yamlContent = humanToYAML(filteredHuman, personaLookup);
+    const allGroups = await ctx.ei.getGroupList();
+    let yamlContent = humanToYAML(filteredHuman, personaLookup, allGroups);
     let editorIteration = 0;
     
     while (true) {
@@ -79,21 +80,27 @@ export const meCommand: Command = {
         }
         
         for (const fact of parsed.facts) {
-          await ctx.ei.upsertFact(fact);
+          if (parsed.changedFactIds.has(fact.id)) {
+            await ctx.ei.upsertFact(fact);
+          }
         }
         for (const topic of parsed.topics) {
-          await ctx.ei.upsertTopic(topic);
+          if (parsed.changedTopicIds.has(topic.id)) {
+            await ctx.ei.upsertTopic(topic);
+          }
         }
         for (const person of parsed.people) {
-          await ctx.ei.upsertPerson(person);
+          if (parsed.changedPersonIds.has(person.id)) {
+            await ctx.ei.upsertPerson(person);
+          }
         }
         
         const deleteCount = parsed.deletedFactIds.length + 
                            parsed.deletedTopicIds.length + 
                            parsed.deletedPersonIds.length;
-        const updateCount = parsed.facts.length + 
-                           parsed.topics.length + 
-                           parsed.people.length;
+        const updateCount = parsed.changedFactIds.size + 
+                           parsed.changedTopicIds.size + 
+                           parsed.changedPersonIds.size;
         
         ctx.showNotification(`Updated ${updateCount} items, deleted ${deleteCount}`, "info");
         return;

package/tui/src/commands/persona.tsx

@@ -17,7 +17,7 @@ export const personaCommand: Command = {
   name: "persona",
   aliases: ["p"],
   description: "Switch persona, list all, create new, or update from person",
-  usage: "/persona [name] | /persona new <name> | /persona update <personaName> <personName>",
+  usage: "/persona [name] | /persona new <name> | /persona update <personaName> [personName]",
 
   async execute(args, ctx) {
     const unarchived = ctx.ei.personas().filter(p => !p.is_archived);
@@ -115,61 +115,79 @@ export const personaCommand: Command = {
 
       overlayCallbacks.hideForEditor?.();
 
-      // Step 3: review editor
-      const previewYAML = personaPreviewToYAML(preview, personaName);
-      const reviewResult = await spawnEditor({
-        initialContent: previewYAML,
-        filename: `${personaName}-preview.yaml`,
-        renderer: ctx.renderer,
-      });
-
-      if (reviewResult.aborted) {
-        ctx.showNotification("Cancelled", "info");
-        return;
-      }
+      let editorContent = personaPreviewToYAML(preview, personaName);
+      while (true) {
+        const reviewResult = await spawnEditor({
+          initialContent: editorContent,
+          filename: `${personaName}-preview.yaml`,
+          renderer: ctx.renderer,
+        });
 
-      let previewParsed: ReturnType<typeof personaPreviewFromYAML>;
-      try {
-        previewParsed = personaPreviewFromYAML(reviewResult.content ?? previewYAML);
-      } catch (e) {
-        ctx.showNotification(`Parse error: ${e instanceof Error ? e.message : String(e)}`, "error");
+        if (reviewResult.aborted) {
+          ctx.showNotification("Cancelled", "info");
+          return;
+        }
+
+        editorContent = reviewResult.content ?? editorContent;
+
+        let previewParsed: ReturnType<typeof personaPreviewFromYAML>;
+        try {
+          previewParsed = personaPreviewFromYAML(editorContent);
+        } catch (e) {
+          const shouldReEdit = await new Promise<boolean>(resolve => {
+            ctx.showOverlay((hideOverlay, hideForEditor) => (
+              <ConfirmOverlay
+                message={`Parse error:\n${e instanceof Error ? e.message : String(e)}\n\nRe-edit?`}
+                onConfirm={() => { hideForEditor(); resolve(true); }}
+                onCancel={() => { hideOverlay(); resolve(false); }}
+              />
+            ), ctx.renderer);
+          });
+          if (shouldReEdit) continue;
+          ctx.showNotification("Changes discarded", "info");
+          return;
+        }
+
+        if (!previewParsed.long_description?.trim()) {
+          const shouldReEdit = await new Promise<boolean>(resolve => {
+            ctx.showOverlay((hideOverlay, hideForEditor) => (
+              <ConfirmOverlay
+                message={`A long description is required — it drives traits, topics, and persona voice.\n\nRe-edit?`}
+                onConfirm={() => { hideForEditor(); resolve(true); }}
+                onCancel={() => { hideOverlay(); resolve(false); }}
+              />
+            ), ctx.renderer);
+          });
+          if (shouldReEdit) continue;
+          ctx.showNotification("Changes discarded", "info");
+          return;
+        }
+
+        // Step 4: create
+        const personaId = await ctx.ei.createPersona({
+          name: personaName,
+          ...previewParsed,
+        });
+        await ctx.ei.refreshPersonas();
+        ctx.ei.selectPersona(personaId);
+        ctx.showNotification(`Created ${personaName}`, "info");
         return;
       }
-
-      // Step 4: create
-      const personaId = await ctx.ei.createPersona({
-        name: personaName,
-        ...previewParsed,
-      });
-      await ctx.ei.refreshPersonas();
-      ctx.ei.selectPersona(personaId);
-      ctx.showNotification(`Created ${personaName}`, "info");
-      return;
     }
 
     if (args[0].toLowerCase() === "update") {
-      if (args.length < 3) {
-        ctx.showNotification("Usage: /p update <personaName> <personName>", "error");
+      if (args.length < 2) {
+        ctx.showNotification("Usage: /p update <personaName> [personName]", "error");
         return;
       }
       const personaName = args[1];
-      const personName = args.slice(2).join(" ");
+      const personName = args.length >= 3 ? args.slice(2).join(" ") : undefined;
 
       // Step 0: resolve persona (offer to create if not found)
       let personaId = await ctx.ei.resolvePersonaName(personaName);
       if (!personaId) {
-        const shouldCreate = await new Promise<boolean>(resolve => {
-          ctx.showOverlay((hideOverlay) => (
-            <ConfirmOverlay
-              message={`No persona named "${personaName}". Create one?`}
-              onConfirm={() => { hideOverlay(); resolve(true); }}
-              onCancel={() => { hideOverlay(); resolve(false); }}
-            />
-          ), ctx.renderer);
-        });
-        if (!shouldCreate) return;
-        personaId = await ctx.ei.createPersona({ name: personaName });
-        await ctx.ei.refreshPersonas();
+        ctx.showNotification(`No persona named "${personaName}". Use /persona new ${personaName} to create one first.`, "error");
+        return;
       }
       const persona = await ctx.ei.getPersona(personaId);
       if (!persona) {
@@ -177,49 +195,59 @@ export const personaCommand: Command = {
         return;
       }
 
-      // Step 1: find matching people
       const human = await ctx.ei.getHuman();
-      const matches = (human.people ?? []).filter(p =>
-        p.name.toLowerCase().includes(personName.toLowerCase())
-      );
 
-      if (matches.length === 0) {
-        ctx.showNotification(`No person named "${personName}" in your data`, "error");
-        return;
-      }
-
-      // Step 2: disambiguation if multiple matches
-      let selectedPerson: typeof matches[0];
-      if (matches.length > 1) {
-        const people: PersonPickerItem[] = matches.map(p => ({
-          id: p.id,
-          name: p.name,
-          relationship: p.relationship,
-          description: p.description,
-        }));
-
-        const choice = await new Promise<typeof matches[0] | null>((resolve) => {
-          ctx.showOverlay((hideOverlay, _hideForEditor) => (
-            <PersonPickerOverlay
-              title={`Multiple matches for "${personName}"`}
-              people={people}
-              onSelect={(item) => {
-                hideOverlay();
-                const found = matches.find(m => m.id === item.id);
-                resolve(found ?? null);
-              }}
-              onDismiss={() => {
-                hideOverlay();
-                resolve(null);
-              }}
-            />
-          ), ctx.renderer);
-        });
-
-        if (!choice) return;
-        selectedPerson = choice;
+      let selectedPerson: (typeof human.people)[0];
+      if (!personName) {
+        const linked = (human.people ?? []).find(p =>
+          p.identifiers?.some(id => id.type === 'Ei Persona' && id.value === personaId)
+        );
+        if (!linked) {
+          ctx.showNotification(`No person linked to "${personaName}". Try: /p update ${personaName} <personName>`, "error");
+          return;
+        }
+        selectedPerson = linked;
       } else {
-        selectedPerson = matches[0];
+        const matches = (human.people ?? []).filter(p =>
+          p.name.toLowerCase().includes(personName.toLowerCase())
+        );
+
+        if (matches.length === 0) {
+          ctx.showNotification(`No person named "${personName}" in your data`, "error");
+          return;
+        }
+
+        if (matches.length > 1) {
+          const people: PersonPickerItem[] = matches.map(p => ({
+            id: p.id,
+            name: p.name,
+            relationship: p.relationship,
+            description: p.description,
+          }));
+
+          const choice = await new Promise<typeof matches[0] | null>((resolve) => {
+            ctx.showOverlay((hideOverlay, _hideForEditor) => (
+              <PersonPickerOverlay
+                title={`Multiple matches for "${personName}"`}
+                people={people}
+                onSelect={(item) => {
+                  hideOverlay();
+                  const found = matches.find(m => m.id === item.id);
+                  resolve(found ?? null);
+                }}
+                onDismiss={() => {
+                  hideOverlay();
+                  resolve(null);
+                }}
+              />
+            ), ctx.renderer);
+          });
+
+          if (!choice) return;
+          selectedPerson = choice;
+        } else {
+          selectedPerson = matches[0];
+        }
       }
 
       // Step 3: generate preview with loading overlay
@@ -301,6 +329,15 @@ export const personaCommand: Command = {
         traits: previewParsed.traits,
         topics: previewParsed.topics,
       });
+
+      const existingIdentifiers = selectedPerson.identifiers ?? [];
+      const alreadyLinked = existingIdentifiers.some(id => id.type === 'Ei Persona' && id.value === personaId);
+      if (!alreadyLinked) {
+        const isPrimaryFirst = existingIdentifiers.length === 0;
+        const updatedIdentifiers = [...existingIdentifiers, { type: 'Ei Persona', value: personaId, ...(isPrimaryFirst ? { is_primary: true } : {}) }];
+        await ctx.ei.upsertPerson({ ...selectedPerson, identifiers: updatedIdentifiers });
+      }
+
       ctx.showNotification(`Updated ${persona.display_name}`, "info");
       return;
     }

package/tui/src/components/MessageList.tsx

@@ -19,14 +19,19 @@ function formatTime(timestamp: string): string {
   return `${hours}:${minutes}`;
 }
 
+function getContent(msg: { content?: string; verbal_response?: string; action_response?: string }): string {
+  if (msg.content) return msg.content;
+  const parts: string[] = [];
+  if (msg.action_response) parts.push(`_${msg.action_response}_`);
+  if (msg.verbal_response) parts.push(msg.verbal_response);
+  return parts.join('\n\n');
+}
+
 function buildMessageText(message: Message): string {
   if (message.silence_reason !== undefined) {
     return `[chose not to respond: ${message.silence_reason}]`;
   }
-  const parts: string[] = [];
-  if (message.action_response) parts.push(`_${message.action_response}_`);
-  if (message.verbal_response) parts.push(message.verbal_response);
-  return parts.join('\n\n');
+  return getContent(message);
 }
 
 let instanceId = 0;

package/tui/src/components/RoomMessageList.tsx

@@ -7,6 +7,14 @@ import type { RoomMessage, Quote } from "../../../src/core/types.js";
 import { RoomMode } from "../../../src/core/types/enums.js";
 import { insertQuoteMarkers } from "../util/quote-utils.js";
 
+function getContent(msg: { content?: string; verbal_response?: string; action_response?: string }): string {
+  if (msg.content) return msg.content;
+  const parts: string[] = [];
+  if (msg.action_response) parts.push(`_${msg.action_response}_`);
+  if (msg.verbal_response) parts.push(msg.verbal_response);
+  return parts.join('\n\n');
+}
+
 interface RoomMessageWithQuotes extends RoomMessage {
   _quotes: Quote[];
 }
@@ -138,7 +146,7 @@ export function RoomMessageList() {
                 ? ` ⑂${siblingCount}`
                 : "";
               const header = `${speakerName} (${formatTime(msg.timestamp)}) [${idx}]${branchIndicator}:`;
-              const isSilence = msg.silence_reason !== undefined && !msg.verbal_response;
+              const isSilence = msg.silence_reason !== undefined && !getContent(msg);
               const isJudge = activeRoom()?.judge_persona_id !== undefined
                 && msg.persona_id === activeRoom()?.judge_persona_id;
               const silenceText = isSilence
@@ -146,11 +154,8 @@ export function RoomMessageList() {
                   ? `[${speakerName}'s verdict: ${msg.silence_reason ?? ""}]`
                   : `[${speakerName} chose not to respond: ${msg.silence_reason ?? ""}]`
                 : "";
-              const contentParts: string[] = [];
-              if (msg.action_response) contentParts.push(`_${msg.action_response}_`);
-              if (msg.verbal_response) contentParts.push(msg.verbal_response);
               const msgQuotes = msg._quotes;
-              const normalContent = insertQuoteMarkers(contentParts.join("\n\n"), msgQuotes);
+              const normalContent = insertQuoteMarkers(getContent(msg), msgQuotes);
 
               return (
                 <box flexDirection="column" marginBottom={1}>

package/tui/src/context/keyboard.tsx

@@ -178,7 +178,7 @@ export const KeyboardProvider: ParentComponent = (props) => {
         }
       }
       // Navigate backward through sent-message history
-      const history = messages().filter(m => m.role === "human").map(m => (m.verbal_response ?? ''));
+        const history = messages().filter(m => m.role === "human").map(m => (m.content ?? m.verbal_response ?? ''));
       if (history.length === 0) return;
       if (historyIndex === -1) {
         savedDraft = textareaRef.plainText;
@@ -206,7 +206,7 @@ export const KeyboardProvider: ParentComponent = (props) => {
         textareaRef.gotoBufferEnd();
       } else {
         historyIndex -= 1;
-        const history = messages().filter(m => m.role === "human").map(m => (m.verbal_response ?? ''));
+      const history = messages().filter(m => m.role === "human").map(m => (m.content ?? m.verbal_response ?? ''));
         const entry = history[history.length - 1 - historyIndex];
         textareaRef.setText(entry);
         textareaRef.gotoBufferEnd();  // cursor at end so next Down continues forward

package/tui/src/util/cyp-editor.tsx

@@ -7,6 +7,14 @@ interface ParsedBlock {
   chosen: boolean;
 }
 
+function getContent(m: { content?: string; verbal_response?: string; action_response?: string }): string {
+  if (m.content) return m.content;
+  const parts: string[] = [];
+  if (m.action_response) parts.push(`_${m.action_response}_`);
+  if (m.verbal_response) parts.push(m.verbal_response);
+  return parts.join('\n\n');
+}
+
 export function buildCYPEditorYAML(
   activeNodeId: string,
   messages: RoomMessage[],
@@ -29,15 +37,12 @@ export function buildCYPEditorYAML(
     }
 
     const contentLines: string[] = [];
-    if (m.verbal_response !== undefined) {
-      const indented = m.verbal_response.split("\n").map((l) => `    ${l}`).join("\n");
-      contentLines.push(`  verbal_response: |\n${indented}`);
-    }
-    if (m.action_response !== undefined) {
-      const indented = m.action_response.split("\n").map((l) => `    ${l}`).join("\n");
-      contentLines.push(`  action_response: |\n${indented}`);
+    const msgContent = getContent(m);
+    if (msgContent) {
+      const indented = msgContent.split("\n").map((l) => `    ${l}`).join("\n");
+      contentLines.push(`  content: |\n${indented}`);
     }
-    if (m.silence_reason !== undefined && m.verbal_response === undefined) {
+    if (m.silence_reason !== undefined && !msgContent) {
       contentLines.push(`  silence_reason: "${m.silence_reason}"`);
     }
     if (contentLines.length === 0) {