ei-tui 0.1.3

package/src/prompts/heartbeat/types.ts

@@ -0,0 +1,70 @@
+/**
+ * Heartbeat Prompt Types
+ * Based on CONTRACTS.md specifications
+ */
+
+import type { Trait, Topic, Person, Message, PersonaTopic } from "../../core/types.js";
+
+/**
+ * Common prompt output structure
+ */
+export interface PromptOutput {
+  system: string;
+  user: string;
+}
+
+/**
+ * Data contract for buildHeartbeatCheckPrompt
+ */
+export interface HeartbeatCheckPromptData {
+  persona: {
+    name: string;
+    traits: Trait[];
+    topics: PersonaTopic[];
+  };
+  human: {
+    topics: Topic[];     // Filtered, sorted by engagement gap
+    people: Person[];    // Filtered, sorted by engagement gap
+  };
+  recent_history: Message[];  // Last N messages for context
+  inactive_days: number;      // Days since last activity
+}
+
+/**
+ * Expected LLM response from heartbeat check
+ */
+export interface HeartbeatCheckResult {
+  should_respond: boolean;
+  topic?: string;
+  message?: string;
+}
+
+/**
+ * Data contract for buildEiHeartbeatPrompt
+ */
+export interface EiHeartbeatPromptData {
+  human: {
+    topics: Topic[];     // All topics with gaps
+    people: Person[];    // All people with gaps
+  };
+  inactive_personas: Array<{
+    name: string;
+    short_description?: string;
+    days_inactive: number;
+  }>;
+  pending_validations: number;  // Count of items needing Ei review
+  recent_history: Message[];
+}
+
+/**
+ * Expected LLM response from Ei heartbeat
+ */
+export interface EiHeartbeatResult {
+  should_respond: boolean;
+  priorities?: Array<{
+    type: "topic" | "persona" | "person";
+    name: string;
+    reason: string;
+  }>;
+  message?: string;
+}

package/src/prompts/human/fact-scan.ts

@@ -0,0 +1,152 @@
+import type { FactScanPromptData, PromptOutput } from "./types.js";
+import { formatMessagesAsPlaceholders } from "../message-utils.js";
+
+export function buildHumanFactScanPrompt(data: FactScanPromptData): PromptOutput {
+  if (!data.persona_name) {
+    throw new Error("buildHumanFactScanPrompt: persona_name is required");
+  }
+
+  const personaName = data.persona_name;
+
+  const taskFragment = `# Task
+
+You are scanning a conversation to quickly identify what FACTS were provided or discussed by the HUMAN USER. Your ONLY job is to spot relevant FACTS - do NOT analyze them deeply. Just detect and flag.`;
+
+  const specificNeedsFragment = `## Specific Needs
+
+Your job is to quickly identify:
+1. Which FACTS were mentioned or relevant
+    a. Only flag FACTS that were actually discussed, not just tangentially related
+    b. Be CONSERVATIVE - only suggest genuinely important, long-term relevant FACTS
+        i. Ignore: greetings, small talk, one-off mentions, jokes
+    c. Be CLEAR - state your \`reason\` for including this FACT in the record with any evidence you used`;
+
+  const guidelinesFragment = `# Guidelines
+
+1.  **Explicitness:**
+    *   **Focus only on what the user *explicitly states*.** Do not infer, assume, or guess based on context or general knowledge.
+    *   **Prioritize direct statements.** "I was born in 1985" is a fact. "I feel old now that it's 3030" isn't an explicit statement of their birth year.
+2.  **Objectivity and Verifiability:**
+    *   **Facts are objective and generally verifiable.** They are not subjective opinions, feelings, or temporary states.
+    *   **Focus on unchangeable or enduring attributes/events.**
+3.  **Specificity over Generality:**
+    *   If the user says "I live in a big city," do not extract "Location: big city." If they say "I live in New York," extract "Location: New York."
+4.  **Avoid Inference from Interests/Hobbies:**
+    *   If a user talks extensively about cooking, it's a Topic or Interest, not a Fact like "Job: Chef" unless they explicitly state they ARE a chef.
+5.  **CRITICAL - Entity Attribution:**
+    *   ONLY extract facts about THE HUMAN USER THEMSELVES, not facts about other people they mention.
+    *   **Extract**: "I was born in 1984" → User's birthday
+    *   **Extract**: "I'm a software engineer" → User's job
+    *   **DO NOT Extract**: "My wife was a theater major" → This is about the wife, NOT the user
+    *   **DO NOT Extract**: "My daughter is 10 years old" → This is about the daughter, NOT the user
+    *   **DO NOT Extract**: "My brother lives in Texas" → This is about the brother, NOT the user
+    *   If the user shares information about someone else, that belongs in PEOPLE tracking, not FACTS.`;
+
+  const examplesFragment = `# Specific Examples
+
+**FACTS are:**
+- Biographical data (Core Identity):
+  - type_of_fact: User's Name
+    - First Last, Nickname, etc.
+  - type_of_fact: Birthday
+    - example: "July 15th, 1980"
+  - type_of_fact: Birthplace
+  - type_of_fact: Hometown
+  - type_of_fact: Job
+    - current job title, industry, or company
+  - type_of_fact: Marital Status
+    - married, single, divorced
+  - type_of_fact: Gender
+  - type_of_fact: Eye Color
+  - type_of_fact: Hair Color
+  - type_of_fact: Nationality/Citizenship
+  - type_of_fact: Languages Spoken
+  - type_of_fact: Educational Background
+- Other Important Dates
+  - type_of_fact: Wedding Anniversary
+  - type_of_fact: Job Anniversary
+  - type_of_fact: Pet Ownership
+- Health & Well-being (Objective Conditions):
+  - type_of_fact: Allergies
+  - type_of_fact: Medical Conditions (if explicitly stated)
+  - type_of_fact: Dietary Restrictions
+
+> NOTE: Dates themselves are not facts (e.g., "August 15th" is not a fact).
+> They are details OF facts (e.g., { "type_of_fact": "Birthday", "value_of_fact": "August 15th" }).
+
+**FACTS ARE NOT**
+- Trait: Personality patterns, communication style, behavioral tendencies
+  - These are tracked separately
+- General Topic: Interests, hobbies, general subjects
+  - These are tracked separately
+- Relationships: Wife, Husband, Daughter, Son, etc.
+  - These are tracked separately
+- People's Names
+  - These are tracked separately
+- Personas: AI personas they discuss
+  - These are tracked separately
+- Characters: Fictitious entities from books, movies, stories, media, etc.
+  - These are tracked separately`;
+
+  const criticalFragment = `# CRITICAL INSTRUCTIONS
+
+ONLY ANALYZE the "Most Recent Messages" in the following conversation. The "Earlier Conversation" is provided for your context and has already been processed!
+
+The JSON format is:
+
+\`\`\`json
+{
+  "facts": [
+    {
+        "type_of_fact": "Birthday|User's Name|Location|see above",
+        "value_of_fact": "May 26th, 1984|Samwise|Seattle|etc.",
+        "reason": "User stated...|User implied...|User responded..."
+    }
+  ]
+}
+\`\`\`
+
+**Return JSON only.**`;
+
+  const system = `${taskFragment}
+
+${specificNeedsFragment}
+
+${guidelinesFragment}
+
+${examplesFragment}
+
+${criticalFragment}`;
+
+  const earlierSection = data.messages_context.length > 0
+    ? `## Earlier Conversation
+${formatMessagesAsPlaceholders(data.messages_context, personaName)}
+
+`
+    : '';
+
+  const recentSection = `## Most Recent Messages
+${formatMessagesAsPlaceholders(data.messages_analyze, personaName)}`;
+
+  const user = `# Conversation
+${earlierSection}${recentSection}
+
+---
+
+Scan the "Most Recent Messages" for FACTS about the human user.
+
+**Return JSON:**
+\`\`\`json
+{
+  "facts": [
+    {
+        "type_of_fact": "Birthday|Name|etc.",
+        "value_of_fact": "May 26th, 1984|Samwise|etc.",
+        "reason": "User stated..."
+    }
+  ]
+}
+\`\`\``;
+
+  return { system, user };
+}

package/src/prompts/human/index.ts

@@ -0,0 +1,32 @@
+export { buildHumanFactScanPrompt } from "./fact-scan.js";
+export { buildHumanTraitScanPrompt } from "./trait-scan.js";
+export { buildHumanTopicScanPrompt } from "./topic-scan.js";
+export { buildHumanPersonScanPrompt } from "./person-scan.js";
+export { buildHumanItemMatchPrompt } from "./item-match.js";
+export { buildHumanItemUpdatePrompt } from "./item-update.js";
+
+export type {
+  PromptOutput,
+  FactScanPromptData,
+  TraitScanPromptData,
+  TopicScanPromptData,
+  PersonScanPromptData,
+  FactScanCandidate,
+  TraitScanCandidate,
+  TopicScanCandidate,
+  PersonScanCandidate,
+  FactScanResult,
+  TraitScanResult,
+  TopicScanResult,
+  PersonScanResult,
+  ItemMatchPromptData,
+  ItemMatchResult,
+  ItemUpdatePromptData,
+  ExposureImpact,
+  ItemUpdateResultBase,
+  FactUpdateResult,
+  TraitUpdateResult,
+  TopicUpdateResult,
+  PersonUpdateResult,
+  ItemUpdateResult,
+} from "./types.js";

package/src/prompts/human/item-match.ts

@@ -0,0 +1,74 @@
+import type { ItemMatchPromptData, PromptOutput } from "./types.js";
+
+export function buildHumanItemMatchPrompt(data: ItemMatchPromptData): PromptOutput {
+  if (!data.candidate_type || !data.candidate_name) {
+    throw new Error("buildHumanItemMatchPrompt: candidate_type and candidate_name are required");
+  }
+
+  const typeLabel = data.candidate_type.toUpperCase();
+
+  const system = `# Task
+
+You are checking if a new ${typeLabel} already exists in our database.
+
+We track four types of data about the human user:
+- **FACT**: Biographical data (name, birthday, job, etc.)
+- **TRAIT**: Personality patterns (introverted, analytical, etc.)
+- **TOPIC**: Interests, goals, concerns, stories
+- **PERSON**: People in their life (family, friends, coworkers)
+
+Your job is to find if this candidate matches ANY existing entry — even if it's stored as a different type.
+
+## Why Cross-Type Matching?
+
+Sometimes the same concept gets detected as different types:
+- "Juliet" might be detected as a TOPIC but should be a PERSON
+- "Birthday" might be detected as a TOPIC but is actually a FACT
+- "Always planning ahead" might be a TOPIC but is really a TRAIT
+
+If you find a match in a DIFFERENT type, still return it! The system will handle the type mismatch.
+
+## Matching Rules
+
+1. **Exact match**: Same name/concept → return its ID
+2. **Similar match**: Clearly the same thing with different wording → return its ID
+3. **Cross-type match**: Same concept stored as different type → return its ID
+4. **No match**: Genuinely new information → return "new"
+
+# Existing Data
+
+The following entries are already in our database. Same-type entries have full descriptions; cross-type entries are truncated for brevity.
+
+\`\`\`json
+${JSON.stringify(data.all_items, null, 2)}
+\`\`\`
+
+# Response Format
+
+Return ONLY the ID of the matching entry, or "new" if no match exists.
+
+\`\`\`json
+{
+    "matched_guid": "uuid-of-matching-entry" | "new"
+}
+\`\`\`
+
+**Return JSON only.**`;
+
+  const user = `# Candidate to Match
+
+Type: ${typeLabel}
+Name: ${data.candidate_name}
+Value: ${data.candidate_value}
+
+Find the best match in existing data, or return "new" if this is genuinely new.
+
+**Return JSON:**
+\`\`\`json
+{
+    "matched_guid": "..." | "new"
+}
+\`\`\``;
+
+  return { system, user };
+}

package/src/prompts/human/item-update.ts

@@ -0,0 +1,322 @@
+import type { ItemUpdatePromptData, PromptOutput } from "./types.js";
+import type { DataItemBase } from "../../core/types.js";
+import { formatMessagesAsPlaceholders } from "../message-utils.js";
+
+function formatExistingItem(item: DataItemBase): string {
+  return JSON.stringify({
+    name: item.name,
+    description: item.description,
+    sentiment: item.sentiment,
+    ...('strength' in item ? { strength: (item as any).strength } : {}),
+    ...('relationship' in item ? { relationship: (item as any).relationship } : {}),
+    ...('exposure_current' in item ? { exposure_current: (item as any).exposure_current } : {}),
+    ...('exposure_desired' in item ? { exposure_desired: (item as any).exposure_desired } : {}),
+  }, null, 2);
+}
+
+export function buildHumanItemUpdatePrompt(data: ItemUpdatePromptData): PromptOutput {
+  if (!data.data_type || !data.persona_name) {
+    throw new Error("buildHumanItemUpdatePrompt: data_type and persona_name are required");
+  }
+
+  const typeLabel = data.data_type.toUpperCase();
+  const personaName = data.persona_name;
+
+  const nameSection = data.data_type === "fact" ? `
+Should represent the _type_ of FACT, not the _value_ of the fact.
+
+Examples: "User's Name", "Birthday", "Birthplace", "Hometown", "Job", "Marital Status", "Eye Color", "Hair Color", "Nationality/Citizenship", "Languages Spoken", "Educational Background", "Wedding Anniversary", "Job Anniversary", "Pet Ownership", "Allergies", "Medical Conditions", "Dietary Restrictions"
+
+The only time we should be changing the name of a FACT is if it cannot fit into one of these _types_.
+  `: `
+Should be a short identifier of the ${typeLabel}.
+
+Only update this field for clarification or if further specificity is warranted.
+
+Examples: "Unknown" -> "Brother-In-Law", "Alice's" -> "Alice's Restaurant"
+  `;
+
+  // This data isn't _specific_ to FACTS, but it only makes sense like this for them
+  const itemFactType = data?.existing_item?.name || data.new_item_name;
+  const traitDescriptionSection = `
+A brief characterization of how the Human demonstrates this trait. **1-2 sentences maximum.**
+
+## CRITICAL: Traits are STABLE PATTERNS, not conversation logs
+
+A trait description captures the PATTERN, not the evidence for it.
+
+**Good description**: "Approaches problems methodically, breaking them into smaller components before tackling the whole."
+**Bad description**: "In this exchange, Jeremy demonstrated analytical thinking when he discussed the schema changes, and in the previous conversation he showed the same pattern when..."
+
+The description should:
+- State the trait pattern concisely
+- Focus on HOW the trait manifests in general terms
+- Be useful for a persona meeting this human for the first time
+
+The description should NOT:
+- Reference specific conversations or exchanges
+- Accumulate examples over time ("In this exchange... In this latest exchange...")
+- Include timestamps, dates, or temporal references
+- Exceed 2-3 sentences under any circumstances
+
+**Style**: Write as if describing the person to someone who hasn't met them. Brief, evergreen, pattern-focused.
+
+Examples:
+- "Prefers direct communication; appreciates when others get to the point quickly."
+- "Processes emotions internally before discussing them; may need time before opening up."
+  `;
+
+  const factDescriptionSection = `
+A concise, specific piece of information about the Human's ${itemFactType}.
+
+If ${itemFactType} doesn't make sense as a type of FACT, return an empty object (\`{}\`).
+
+If ${itemFactType} was misinterpreted (i.e., a joke, expression, or otherwise "not literally" a fact), return an empty object (\`{}\`).
+
+## CRITICAL: Facts are OBJECTIVE
+
+FACTS are biographical/circumstantial data. NOT emotional interpretations.
+
+**Good description**: "Parents divorced twice. Second divorce occurred when user was 17/18."
+**Bad description**: "A deep, quiet ache related to mother's absence... a sacred absence shaped by love, loss, and quiet strength..."
+
+The description should record WHAT HAPPENED:
+- Dates, names, places, events, circumstances
+- What the user explicitly stated or clearly implied
+
+The description should NOT include:
+- Ei's poetic interpretation of emotional significance
+- Flowery language about "sacred absences" or "quiet aches"
+- Assumptions about how the user feels (that's what \`sentiment\` is for)
+
+If the user expressed emotion, quote or paraphrase THEIR words, don't embellish.
+
+**Style**: Be factual and concise. Record what the user said or demonstrated, not your interpretation of its deeper meaning. Avoid flowery or poetic language unless the user themselves used such language.
+
+Examples: "Name Unknown" -> "Robert Jordan", "User was married in the Summer" -> "User was married in July, 2006"
+  `;
+
+  const defaultDescriptionSection = `
+This free-text field should be used to capture interesting details or references that the Human or Persona use while discussing this data point. Personas should be able to show topical recall, make references to the topic or event, or in other ways "Remember" details about it.
+
+**ABSOLUTELY VITAL INSTRUCTION**: Do **NOT** embelish these details - each Persona will use their own voice during interactions with the User - we need to capture EXACTLY what was said and how, or referring back to it won't have meaning.
+  `;
+
+  const descriptionSection =
+    data.data_type === "fact" ? factDescriptionSection :
+    data.data_type === "trait" ? traitDescriptionSection :
+    defaultDescriptionSection;
+
+  const strengthSection = data.data_type === "trait" ? `
+## Strength (\`strength\`)
+
+How "strongly" the HUMAN USER shows this TRAIT.
+
+Use a scale of 0 to 1:
+- 0.0: The HUMAN USER is devoid of this trait
+- 0.5: The HUMAN USER shows this trait some of the time
+- 1.0: The HUMAN USER has this trait as a core aspect of their self
+
+Do not make micro-adjustments (0.4 -> 0.5). Close enough is OK for this field.` : '';
+
+  const relationshipSection = data.data_type === "person" ? `
+## Relationship (\`relationship\`)
+
+How the HUMAN USER is currently related to this PERSON.
+
+Once known, changes to this field are infrequent - A HUMAN USER's "Father" may be later clarified to "Step-Father", but is unlikely to become the user's "Uncle".
+
+Examples: "Unknown" -> "Coworker", "Mother" -> "Step-Mother", "Fiance" -> "Spouse"` : '';
+
+  const categorySection = data.data_type === "topic" ? `
+## Category (\`category\`)
+
+The type/category of this TOPIC. Pick the most appropriate from:
+- Interest: Hobbies, activities they enjoy
+- Goal: Things they want to achieve
+- Dream: Aspirational, maybe unrealistic desires  
+- Conflict: Internal struggles, dilemmas
+- Concern: Worries, anxieties
+- Fear: Things that scare them
+- Hope: Positive expectations for the future
+- Plan: Concrete intentions
+- Project: Active undertakings
+
+If the topic doesn't fit neatly, pick the closest match.` : '';
+
+  const exposureSection = (data.data_type === "topic" || data.data_type === "person") ? `
+## Desired Exposure (\`exposure_desired\`)
+
+Represents how much the HUMAN USER wants to talk about this ${typeLabel}.
+
+Scale of 0.0 to 1.0:
+- 0.0: The HUMAN USER never wants to hear about this ${typeLabel}
+- 0.5: The HUMAN USER spends an average amount of time on this ${typeLabel}
+- 1.0: This ${typeLabel} is the sole focus of the HUMAN USER's existence
+
+Do not make micro-adjustments. Close enough is OK for this field.
+
+## Exposure Impact (\`exposure_impact\`)
+
+This data point is NOT in the current data set, but it can be included in your return data.
+
+Exposure Impact measures how much exposure this conversation should count for:
+- "high": Long, detailed conversation exclusively about the ${typeLabel}
+- "medium": Long OR detailed conversation about the ${typeLabel}
+- "low": The conversation touched on this ${typeLabel} briefly
+- "none": The ${typeLabel} was only alluded to or hinted at
+
+This value adjusts the ongoing tracking of \`exposure_current\`.` : '';
+
+  const currentDetailsSection = data.existing_item 
+    ? `\`\`\`json
+${formatExistingItem(data.existing_item)}
+\`\`\`
+
+You are UPDATING an existing ${typeLabel}.`
+    : `**NEW ${typeLabel} - NOT YET IN SYSTEM**
+
+You are CREATING a new ${typeLabel} from scratch based on what was discovered:
+\`\`\`json
+{
+  "name": "${data.new_item_name || 'Uknown'}",
+  "description": "${data.new_item_value || 'Details Unknown'}"
+}
+\`\`\`
+
+Return all fields for this ${typeLabel} based on what you find in the conversation.`;
+
+  const jsonTemplateFields = [
+    '    "name": "User\'s Name",',
+    '    "description": "Their Actual Name",',
+    '    "sentiment": 0.0',
+    data.data_type === "trait" ? ',\n    "strength": 0.5' : '',
+    data.data_type === "person" ? ',\n    "relationship": "Mother-In-Law|Son|Coworker|etc.",\n    "exposure_desired": 0.4,\n    "exposure_impact": "high|medium|low|none"' : '',
+    data.data_type === "topic" ? ',\n    "category": "Interest|Goal|Dream|Conflict|Concern|Fear|Hope|Plan|Project",\n    "exposure_desired": 0.4,\n    "exposure_impact": "high|medium|low|none"' : '',
+    ',\n    "quotes": [\n      {\n        "text": "exact phrase from message",\n        "reason": "why this matters"\n      }\n    ]'
+  ].filter(Boolean).join('');
+
+  const system = `# Task
+
+You are scanning a conversation to deeply understand a ${typeLabel}.
+
+Your job is to take that analysis and apply it to the record we already have **IF DOING SO WILL PROVIDE THE HUMAN USER WITH A BETTER EXPERIENCE IN THE FUTURE**.
+
+This means that the detail you add should:
+1. Be meaningful, accurate, or still true to the HUMAN USER in six months or more
+2. **NOT** already be present in the description or name of the ${typeLabel}
+
+This ${typeLabel} will be recorded in the HUMAN USER's profile for agents and personas to later reference.
+
+# Field Definition and Explanation of Expected Changes
+
+## Name (\`name\`)
+${nameSection}
+## Description (\`description\`)
+${descriptionSection}
+## Sentiment (\`sentiment\`)
+
+Represents how strongly the HUMAN USER feels about this ${typeLabel}.
+
+Scale of -1.0 to 1.0:
+- -1.0: There is no ${typeLabel} the HUMAN USER hates more
+- -0.5: The HUMAN USER does NOT like this ${typeLabel}, but recognizes some redeeming qualities
+- 0: The HUMAN USER has no feelings toward this ${typeLabel}
+- 0.5: The HUMAN USER enjoys this ${typeLabel}, but can recognize flaws
+- 1.0: This ${typeLabel} is the sole focus of the HUMAN USER's existence
+
+Do not make micro-adjustments. Close enough is OK for this field.
+${strengthSection}${relationshipSection}${categorySection}${exposureSection}
+
+## Quotes
+
+In addition to updating the ${typeLabel}, identify any **memorable, funny, important, or stand-out phrases** from the Most Recent Messages that relate to this ${typeLabel}.
+
+### What Makes a Quote Worth Preserving
+
+**Prioritize:**
+- Humor, wit, colorful language, creative profanity
+- Emotional outbursts (positive or negative) — the raw stuff
+- Phrases that reveal personality or communication style
+- Things you'd quote back to them later to make them laugh
+- Unique expressions, malaphors, or turns of phrase
+
+**De-prioritize:**
+- Dry technical facts (those belong in TOPICS)
+- Status updates or process descriptions
+- Generic statements that could come from anyone
+
+A quote like "Does the Pope shit in his hat?" is GOLD. A quote like "We're running a batch of 44k students" is just... data.
+
+Return them in the \`quotes\` array:
+
+\`\`\`json
+{
+  "name": "...",
+  "description": "...",
+  "sentiment": 0.5,
+  "quotes": [
+    {
+      "text": "exact phrase from the message",
+      "reason": "why this is worth preserving"
+    }
+  ]
+}
+\`\`\`
+
+**CRITICAL**: Return the EXACT text as it appears in the message (spacing, punctuation, formatting, etc.). WE CAN ONLY USE IT IF WE FIND IT IN THE TEXT.
+
+
+# CRITICAL INSTRUCTIONS
+
+ONLY ANALYZE the "Most Recent Messages" in the following conversation. The "Earlier Conversation" is provided for your context and has already been processed!
+
+The JSON format is:
+
+\`\`\`json
+{
+${jsonTemplateFields}
+}
+\`\`\`
+
+When you return a record, **ALWAYS** include every field (\`name\`, \`description\`, and \`sentiment\` are all REQUIRED fields).
+
+If you find **NO EVIDENCE** of this ${typeLabel} in the "Most Recent Messages", respond with an empty object: \`{}\`.
+
+If you determine **NO CHANGES** are required to the ${typeLabel}, respond with an empty object: \`{}\`.
+
+An empty object, \`{}\`, is the MOST COMMON expected response.
+
+# Current Details of ${typeLabel}
+
+${currentDetailsSection}
+`;
+
+  const earlierSection = data.messages_context.length > 0
+    ? `## Earlier Conversation
+${formatMessagesAsPlaceholders(data.messages_context, personaName)}
+
+`
+    : '';
+
+  const recentSection = `## Most Recent Messages
+${formatMessagesAsPlaceholders(data.messages_analyze, personaName)}`;
+
+  const user = `# Conversation
+${earlierSection}${recentSection}
+
+---
+
+Analyze the Most Recent Messages and update the ${typeLabel} if warranted.
+
+**Return JSON:**
+\`\`\`json
+{
+${jsonTemplateFields}
+}
+\`\`\`
+
+If no changes are needed, respond with: \`{}\``;
+
+  return { system, user };
+}