ei-tui 0.5.4 → 0.6.1

package/tui/src/util/yaml-settings.ts

@@ -0,0 +1,223 @@
+import YAML from "yaml";
+import type {
+  HumanSettings,
+  CeremonyConfig,
+  OpenCodeSettings,
+  ProviderAccount,
+} from "../../../src/core/types.js";
+import type { ClaudeCodeSettings } from "../../../src/integrations/claude-code/types.js";
+import type { CursorSettings } from "../../../src/integrations/cursor/types.js";
+import { modelGuidToDisplay, displayToModelGuid } from "./yaml-shared.js";
+
+interface EditableSettingsData {
+  default_model?: string | null;
+  oneshot_model?: string | null;
+  rewrite_model?: string | null;
+  time_mode?: "24h" | "12h" | "local" | "utc" | null;
+  name_display?: string | null;
+  default_heartbeat_ms?: number | null;
+  default_context_window_hours?: number | null;
+  message_min_count?: number | null;
+  message_max_age_days?: number | null;
+  ceremony?: {
+    time: string;
+    decay_rate?: number | null;
+    explore_threshold?: number | null;
+    dedup_threshold?: number | null;
+    event_window_hours?: number | null;
+  };
+  opencode?: {
+    integration?: boolean | null;
+    polling_interval_ms?: number | null;
+    last_sync?: string | null;
+    extraction_point?: string | null;
+    extraction_model?: string | null;
+  };
+  claudeCode?: {
+    integration?: boolean | null;
+    polling_interval_ms?: number | null;
+    last_sync?: string | null;
+    extraction_point?: string | null;
+    extraction_model?: string | null;
+  };
+  cursor?: {
+    integration?: boolean | null;
+    polling_interval_ms?: number | null;
+    last_sync?: string | null;
+    extraction_point?: string | null;
+  };
+  backup?: {
+    enabled?: boolean | null;
+    max_backups?: number | null;
+    interval_ms?: number | null;
+  };
+}
+
+export function settingsToYAML(settings: HumanSettings | undefined, accounts: ProviderAccount[]): string {
+  const guidToDisplay = (guid: string | undefined | null): string | null => {
+    if (!guid) return null;
+    return modelGuidToDisplay(guid, accounts);
+  };
+
+  const data: EditableSettingsData = {
+    default_model: guidToDisplay(settings?.default_model),
+    oneshot_model: guidToDisplay(settings?.oneshot_model),
+    rewrite_model: guidToDisplay(settings?.rewrite_model),
+    time_mode: settings?.time_mode ?? null,
+    name_display: settings?.name_display ?? null,
+    default_heartbeat_ms: settings?.default_heartbeat_ms ?? 1800000,
+    default_context_window_hours: settings?.default_context_window_hours ?? 8,
+    message_min_count: settings?.message_min_count ?? 200,
+    message_max_age_days: settings?.message_max_age_days ?? 14,
+    ceremony: {
+      time: settings?.ceremony?.time ?? "09:00",
+      decay_rate: settings?.ceremony?.decay_rate ?? null,
+      explore_threshold: settings?.ceremony?.explore_threshold ?? null,
+      dedup_threshold: settings?.ceremony?.dedup_threshold ?? null,
+      event_window_hours: settings?.ceremony?.event_window_hours ?? null,
+    },
+    opencode: {
+      integration: settings?.opencode?.integration ?? false,
+      polling_interval_ms: settings?.opencode?.polling_interval_ms ?? 60000,
+      extraction_model: guidToDisplay(settings?.opencode?.extraction_model) ?? 'default',
+      last_sync: settings?.opencode?.last_sync ?? null,
+      extraction_point: settings?.opencode?.extraction_point ?? null,
+    },
+    claudeCode: {
+      integration: settings?.claudeCode?.integration ?? false,
+      polling_interval_ms: settings?.claudeCode?.polling_interval_ms ?? 60000,
+      extraction_model: guidToDisplay(settings?.claudeCode?.extraction_model) ?? 'default',
+      last_sync: settings?.claudeCode?.last_sync ?? null,
+      extraction_point: settings?.claudeCode?.extraction_point ?? null,
+    },
+    cursor: {
+      integration: settings?.cursor?.integration ?? false,
+      polling_interval_ms: settings?.cursor?.polling_interval_ms ?? 60000,
+      last_sync: settings?.cursor?.last_sync ?? null,
+      extraction_point: settings?.cursor?.extraction_point ?? null,
+    },
+    backup: {
+      enabled: settings?.backup?.enabled ?? false,
+      max_backups: settings?.backup?.max_backups ?? 24,
+      interval_ms: settings?.backup?.interval_ms ?? 3600000,
+    },
+  };
+
+  return YAML.stringify(data, {
+    lineWidth: 0,
+  })
+  .replace(/^(\s+)(last_sync: .+)$/mg, '$1# [read-only] $2')
+  .replace(/^(\s+)(extraction_point: .+)$/mg, '$1# [read-only] $2')
+  .replace(/^(\s+)(extraction_model: .+)$/mg, '$1$2 # e.g. Anthropic:claude-haiku-4-5');
+}
+
+export function settingsFromYAML(yamlContent: string, original: HumanSettings | undefined, accounts: ProviderAccount[]): HumanSettings {
+  const data = YAML.parse(yamlContent) as EditableSettingsData;
+
+  const nullToUndefined = <T>(value: T | null | undefined): T | undefined =>
+    value === null ? undefined : value;
+
+  const displayToGuid = (display: string | null | undefined): string | undefined => {
+    if (!display || display === 'default') return undefined;
+    return displayToModelGuid(display, accounts) ?? display;
+  };
+
+  let ceremony: CeremonyConfig | undefined;
+  if (data.ceremony) {
+    ceremony = {
+      time: data.ceremony.time,
+      decay_rate: nullToUndefined(data.ceremony.decay_rate),
+      explore_threshold: nullToUndefined(data.ceremony.explore_threshold),
+      dedup_threshold: nullToUndefined(data.ceremony.dedup_threshold),
+      event_window_hours: nullToUndefined(data.ceremony.event_window_hours),
+      last_ceremony: original?.ceremony?.last_ceremony,
+    };
+  }
+
+  let opencode: OpenCodeSettings | undefined;
+  if (data.opencode) {
+    opencode = {
+      integration: nullToUndefined(data.opencode.integration),
+      polling_interval_ms: nullToUndefined(data.opencode.polling_interval_ms),
+      last_sync: original?.opencode?.last_sync,
+      extraction_point: original?.opencode?.extraction_point,
+      processed_sessions: original?.opencode?.processed_sessions,
+      extraction_model: displayToGuid(data.opencode.extraction_model),
+    };
+  }
+
+  let claudeCode: ClaudeCodeSettings | undefined;
+  if (data.claudeCode) {
+    claudeCode = {
+      integration: nullToUndefined(data.claudeCode.integration),
+      polling_interval_ms: nullToUndefined(data.claudeCode.polling_interval_ms),
+      last_sync: original?.claudeCode?.last_sync,
+      extraction_point: original?.claudeCode?.extraction_point,
+      processed_sessions: original?.claudeCode?.processed_sessions,
+      extraction_model: displayToGuid(data.claudeCode.extraction_model),
+    };
+  }
+
+  let cursor: CursorSettings | undefined;
+  if (data.cursor) {
+    cursor = {
+      integration: nullToUndefined(data.cursor.integration),
+      polling_interval_ms: nullToUndefined(data.cursor.polling_interval_ms),
+      last_sync: original?.cursor?.last_sync,
+      extraction_point: original?.cursor?.extraction_point,
+      processed_sessions: original?.cursor?.processed_sessions,
+    };
+  }
+
+  let backup: import('../../../src/core/types.js').BackupConfig | undefined;
+  if (data.backup) {
+    backup = {
+      enabled: nullToUndefined(data.backup.enabled),
+      max_backups: nullToUndefined(data.backup.max_backups),
+      interval_ms: nullToUndefined(data.backup.interval_ms),
+      last_backup: original?.backup?.last_backup,
+    };
+  }
+
+  return {
+    ...original,
+    default_model: displayToGuid(data.default_model),
+    oneshot_model: displayToGuid(data.oneshot_model),
+    rewrite_model: displayToGuid(data.rewrite_model),
+    time_mode: nullToUndefined(data.time_mode),
+    name_display: nullToUndefined(data.name_display),
+    default_heartbeat_ms: nullToUndefined(data.default_heartbeat_ms),
+    default_context_window_hours: nullToUndefined(data.default_context_window_hours),
+    message_min_count: nullToUndefined(data.message_min_count),
+    message_max_age_days: nullToUndefined(data.message_max_age_days),
+    ceremony,
+    opencode,
+    claudeCode,
+    cursor,
+    backup,
+  };
+}
+
+export function validateModelProvider(
+  modelSpec: string | undefined,
+  accounts: ProviderAccount[]
+): string | undefined {
+  if (!modelSpec) return undefined;
+
+  const colonIdx = modelSpec.indexOf(":");
+  const providerPart = colonIdx >= 0 ? modelSpec.substring(0, colonIdx) : modelSpec;
+  const modelPart = colonIdx >= 0 ? modelSpec.substring(colonIdx + 1) : undefined;
+
+  const match = accounts.find(a => a.name.toLowerCase() === providerPart.toLowerCase());
+
+  if (!match) {
+    const available = accounts.map(a => a.name).join(", ");
+    throw new Error(
+      available
+        ? `No provider named "${providerPart}". Available: ${available}`
+        : `No provider named "${providerPart}". Create one with /provider new`
+    );
+  }
+
+  return modelPart ? `${match.name}:${modelPart}` : match.name;
+}

package/tui/src/util/yaml-shared.ts

@@ -0,0 +1,32 @@
+// =============================================================================
+// GUID <-> DISPLAY NAME HELPERS
+// =============================================================================
+
+import type { ProviderAccount } from "../../../src/core/types.js";
+
+/**
+ * Convert a model GUID to "ProviderName:modelName" display string.
+ * Falls back to the raw GUID if the model is not found.
+ */
+export function modelGuidToDisplay(guid: string, accounts: ProviderAccount[]): string {
+  for (const account of accounts) {
+    const model = (account.models ?? []).find(m => m.id === guid);
+    if (model) return `${account.name}:${model.name}`;
+  }
+  return guid; // fallback: return raw GUID if not found
+}
+
+/**
+ * Resolve "ProviderName:modelName" display string back to a model GUID.
+ * Returns undefined if no matching provider+model is found.
+ * Handles colons in model names by treating everything after the first colon as the model name.
+ */
+export function displayToModelGuid(display: string, accounts: ProviderAccount[]): string | undefined {
+  const colonIdx = display.indexOf(':');
+  if (colonIdx < 0) return undefined;
+  const providerName = display.substring(0, colonIdx);
+  const modelName = display.substring(colonIdx + 1);
+  const account = accounts.find(a => a.name === providerName);
+  const model = (account?.models ?? []).find(m => m.name === modelName);
+  return model?.id;
+}

package/tui/src/util/yaml-toolkit.ts

@@ -0,0 +1,55 @@
+import YAML from "yaml";
+import type { ToolProvider, ToolDefinition } from "../../../src/core/types.js";
+
+interface EditableToolkitData {
+  display_name: string;
+  enabled: boolean;
+  config: Record<string, string>;
+  tools?: Record<string, boolean>;
+}
+
+export function toolkitToYAML(provider: ToolProvider, tools: ToolDefinition[]): string {
+  const toolsMap = tools.length > 0
+    ? Object.fromEntries(tools.map(t => [t.display_name, t.enabled]))
+    : undefined;
+  if (provider.builtin) {
+    return YAML.stringify({ enabled: provider.enabled, tools: toolsMap }, { lineWidth: 0 });
+  }
+  const data: EditableToolkitData = {
+    display_name: provider.display_name,
+    enabled: provider.enabled,
+    config: { ...provider.config },
+    tools: toolsMap,
+  };
+  return YAML.stringify(data, { lineWidth: 0 });
+}
+
+export interface ToolkitYAMLResult {
+  updates: Partial<Omit<ToolProvider, 'id' | 'created_at'>>;
+  toolUpdates: Array<{ id: string; enabled: boolean }>;
+}
+
+export function toolkitFromYAML(yamlContent: string, original: ToolProvider, tools: ToolDefinition[]): ToolkitYAMLResult {
+  const data = YAML.parse(yamlContent) as EditableToolkitData;
+
+  if (!data.display_name) {
+    if (!original.display_name) throw new Error("display_name is required");
+    data.display_name = original.display_name;
+  }
+
+  const updates: Partial<Omit<ToolProvider, 'id' | 'created_at'>> = {
+    display_name: data.display_name,
+    enabled: data.enabled ?? original.enabled,
+    config: data.config ?? {},
+  };
+
+  const toolUpdates: Array<{ id: string; enabled: boolean }> = [];
+  if (data.tools) {
+    for (const [displayName, enabled] of Object.entries(data.tools)) {
+      const tool = tools.find(t => t.display_name === displayName);
+      if (tool) toolUpdates.push({ id: tool.id, enabled: Boolean(enabled) });
+    }
+  }
+
+  return { updates, toolUpdates };
+}

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

@@ -1,65 +0,0 @@
-import type { PromptOutput } from "./types.js";
-
-export interface PersonMatchPromptData {
-  candidate_name: string;
-  candidate_description: string;
-  candidate_relationship: string;
-  existing_people: Array<{
-    id: string;
-    name: string;
-    description: string;
-    relationship?: string;
-  }>;
-}
-
-export function buildPersonMatchPrompt(data: PersonMatchPromptData): PromptOutput {
-  if (!data.candidate_name) {
-    throw new Error("buildPersonMatchPrompt: candidate_name is required");
-  }
-
-  const system = `# Task
-
-You are checking if a PERSON already exists in our database.
-
-## Matching Rules
-
-1. **Exact match**: Same person by name or clear identity → return their ID
-2. **Similar match**: Same person referred to differently ("Mom" vs "Carol", "my boss" vs "Trumble") → return their ID
-3. **No match**: Genuinely new person → return "new"
-
-Be conservative. If you're unsure, return "new" — a duplicate is worse than a gap.
-
-# Existing People
-
-\`\`\`json
-${JSON.stringify(data.existing_people, null, 2)}
-\`\`\`
-
-# Response Format
-
-Return ONLY the ID of the matching entry, or "new".
-
-\`\`\`json
-{
-  "matched_guid": "uuid-of-matching-entry" | "new"
-}
-\`\`\`
-
-**Return JSON only.**`;
-
-  const user = `# Candidate Person
-
-Name: ${data.candidate_name}
-Description: ${data.candidate_description}
-Relationship: ${data.candidate_relationship}
-
-Find the best match in existing people, or return "new" if this is a genuinely new person.
-
-\`\`\`json
-{
-  "matched_guid": "..." | "new"
-}
-\`\`\``;
-
-  return { system, user };
-}

package/src/prompts/persona/topics-match.ts

@@ -1,70 +0,0 @@
-import type { PersonaTopicMatchPromptData, PromptOutput } from "./types.js";
-import type { PersonaTopic } from "../../core/types.js";
-
-function formatExistingTopics(topics: PersonaTopic[]): string {
-  if (topics.length === 0) return "[]";
-  
-  return JSON.stringify(topics.map(t => ({
-    id: t.id,
-    name: t.name,
-    perspective: t.perspective.substring(0, 100) + (t.perspective.length > 100 ? '...' : ''),
-  })), null, 2);
-}
-
-export function buildPersonaTopicMatchPrompt(data: PersonaTopicMatchPromptData): PromptOutput {
-  if (!data.persona_name || !data.candidate) {
-    throw new Error("buildPersonaTopicMatchPrompt: persona_name and candidate are required");
-  }
-
-  const personaName = data.persona_name;
-
-  const system = `# Task
-
-You are checking if a topic candidate already exists in ${personaName}'s topic list.
-
-# Matching Rules
-
-1. **Exact match**: Same topic name → action "match", return its ID
-2. **Similar match**: Clearly the same topic with different wording → action "match", return its ID
-   - "Steam Deck" and "Steam Deck Modding" → MATCH (same core topic)
-   - "Cooking" and "Italian Cooking" → consider MATCH if the specific is part of the general
-3. **No match**: Genuinely different topic → action "create"
-4. **Skip**: Trivial, off-topic, or too vague to be a meaningful persona topic → action "skip"
-
-# Existing Topics
-
-\`\`\`json
-${formatExistingTopics(data.existing_topics)}
-\`\`\`
-
-# Response Format
-
-\`\`\`json
-{
-  "action": "match" | "create" | "skip",
-  "matched_id": "uuid-of-matching-topic" | null,
-  "reason": "brief explanation"
-}
-\`\`\`
-
-**Return JSON only.**`;
-
-  const user = `# Candidate Topic
-
-Name: ${data.candidate.name}
-Message Count: ${data.candidate.message_count}
-Sentiment Signal: ${data.candidate.sentiment_signal}
-
-Find the best match in ${personaName}'s existing topics, or decide if this should be created or skipped.
-
-**Return JSON:**
-\`\`\`json
-{
-  "action": "match" | "create" | "skip",
-  "matched_id": "..." | null,
-  "reason": "..."
-}
-\`\`\``;
-
-  return { system, user };
-}

package/src/prompts/persona/topics-scan.ts

@@ -1,98 +0,0 @@
-import type { PersonaTopicScanPromptData, PromptOutput } from "./types.js";
-import { formatMessagesAsPlaceholders } from "../message-utils.js";
-
-export function buildPersonaTopicScanPrompt(data: PersonaTopicScanPromptData): PromptOutput {
-  if (!data.persona_name) {
-    throw new Error("buildPersonaTopicScanPrompt: persona_name is required");
-  }
-
-  const personaName = data.persona_name;
-
-  const system = `# Task
-
-You are scanning a conversation to quickly identify TOPICS that ${personaName} actively ENGAGED with.
-
-Your ONLY job is to spot topics and count how many messages touched them. Do NOT analyze deeply. Just detect and flag.
-
-# What Counts as Engagement
-
-**Engagement means ${personaName}:**
-- Discussed with knowledge or shared opinions
-- Asked follow-up questions showing interest
-- Offered insights or elaborated on the topic
-- Showed genuine interest through detailed responses
-
-**NOT engagement:**
-- Topic mentioned only by the human (without ${personaName} responding to it)
-- Mentioned in passing without real discussion
-- Generic conversational acknowledgments
-
-# What is a TOPIC
-
-A meaningful subject or concept that ${personaName} cares about or discusses:
-- Hobbies and interests (gaming, cooking, hiking)
-- Current concerns (work stress, health)
-- Media they consume (books, shows, podcasts)
-- Ongoing projects or situations
-- Abstract ideas they're exploring
-
-**NOT TOPICS** (these are traits):
-- Communication style ("talks formally")
-- Personality patterns ("optimistic", "skeptical")
-
-# Response Format
-
-Return a list of topics with message counts.
-
-\`\`\`json
-{
-  "topics": [
-    {
-      "name": "Steam Deck Modding",
-      "message_count": 5,
-      "sentiment_signal": 0.7
-    }
-  ]
-}
-\`\`\`
-
-- \`name\`: Short identifier for the topic
-- \`message_count\`: How many messages in the conversation touched this topic (CRITICAL for filtering noise)
-- \`sentiment_signal\`: Quick read on how ${personaName} feels about it (-1.0 to 1.0)
-
-**CRITICAL**: ONLY analyze "Most Recent Messages". Earlier conversation is context only.
-
-**Return JSON only.**`;
-
-  const earlierSection = data.messages_context.length > 0
-    ? `## Earlier Conversation (context only)
-${formatMessagesAsPlaceholders(data.messages_context, personaName)}
-
-`
-    : '';
-
-  const recentSection = `## Most Recent Messages (analyze these)
-${formatMessagesAsPlaceholders(data.messages_analyze, personaName)}`;
-
-  const user = `# Conversation
-${earlierSection}${recentSection}
-
----
-
-Scan the "Most Recent Messages" for topics ${personaName} actively engaged with.
-
-**Return JSON:**
-\`\`\`json
-{
-  "topics": [
-    {
-      "name": "topic name",
-      "message_count": 3,
-      "sentiment_signal": 0.5
-    }
-  ]
-}
-\`\`\``;
-
-  return { system, user };
-}

package/src/prompts/persona/topics-update.ts

@@ -1,154 +0,0 @@
-import type { PersonaTopicUpdatePromptData, PromptOutput } from "./types.js";
-import type { PersonaTopic, PersonaTrait } from "../../core/types.js";
-import { formatMessagesAsPlaceholders } from "../message-utils.js";
-
-function formatTraitsForPrompt(traits: PersonaTrait[]): string {
-  if (traits.length === 0) return "(No traits defined)";
-  return traits.map(t => `- ${t.name}: ${t.description}`).join('\n');
-}
-
-function formatExistingTopic(topic: PersonaTopic | undefined): string {
-  if (!topic) return "**NEW TOPIC** - Creating from scratch";
-  
-  return `**EXISTING TOPIC** - Updating:
-\`\`\`json
-${JSON.stringify({
-  name: topic.name,
-  perspective: topic.perspective,
-  approach: topic.approach,
-  personal_stake: topic.personal_stake,
-  sentiment: topic.sentiment,
-  exposure_current: topic.exposure_current,
-  exposure_desired: topic.exposure_desired,
-}, null, 2)}
-\`\`\``;
-}
-
-export function buildPersonaTopicUpdatePrompt(data: PersonaTopicUpdatePromptData): PromptOutput {
-  if (!data.persona_name || !data.candidate) {
-    throw new Error("buildPersonaTopicUpdatePrompt: persona_name and candidate are required");
-  }
-
-  const personaName = data.persona_name;
-  const isNewTopic = !data.existing_topic;
-
-  const system = `# Task
-
-You are generating or updating a PersonaTopic for ${personaName}.
-
-${isNewTopic ? `This is a NEW topic - create all fields from scratch based on the conversation.` : `This is an EXISTING topic - update fields based on new conversation evidence.`}
-
-# Persona Context
-
-**Name**: ${personaName}
-${data.short_description ? `**Description**: ${data.short_description}` : ''}
-${data.long_description ? `**Background**: ${data.long_description}` : ''}
-
-**Personality Traits**:
-${formatTraitsForPrompt(data.traits)}
-
-# Current Topic State
-
-${formatExistingTopic(data.existing_topic)}
-
-# Field Definitions
-
-## name
-Short identifier for the topic. Only change for clarification.
-
-## perspective
-${personaName}'s view or opinion on this topic. What do they think about it?
-
-**ALWAYS populate this field.** Use conversation content + persona traits to infer their view.
-
-Example: "The Shire represents everything worth fighting for - simple pleasures, good food, and the bonds of community."
-
-## approach
-How ${personaName} prefers to engage with this topic. Their style of discussion.
-
-**Only populate if there's a clear pattern** in how they discuss this topic. Leave empty string if unclear.
-
-Example: "Frodo speaks of the Shire with wistful longing, often comparing other places to it unfavorably."
-
-## personal_stake
-Why this topic matters to ${personaName} personally. Their connection to it.
-
-**Only populate if there's evidence** of personal connection. Leave empty string if unclear.
-
-Example: "As a hobbit who left home, the Shire is both memory and motivation."
-
-## sentiment
-How ${personaName} feels about this topic. Scale: -1.0 (hate) to 1.0 (love).
-
-## exposure_impact
-How much this topic was discussed in the recent messages. Choose one:
-- "high" — Major topic, multiple substantive exchanges
-- "medium" — Meaningful mention, discussed with some depth
-- "low" — Brief or passing mention
-- "none" — Barely mentioned, tangential at best
-
-## exposure_desired
-How much ${personaName} wants to discuss this topic. Scale: 0.0 to 1.0.
-
-**RARELY change** for existing topics. Only adjust if there's explicit preference signal.
-
-**For new topics**: Infer from how enthusiastically ${personaName} engaged.
-
-# Critical Instructions
-
-1. ONLY analyze "Most Recent Messages" - earlier messages are context only
-2. Do NOT invent details not supported by the conversation
-3. Do NOT apply flowery or poetic language - be factual
-4. If a field cannot be determined, use empty string (for text) or preserve existing value (for numbers)
-
-**Return JSON:**
-\`\`\`json
-{
-  "name": "Topic Name",
-  "perspective": "Their view on this topic",
-  "approach": "",
-  "personal_stake": "",
-  "sentiment": 0.5,
-  "exposure_impact": "medium",
-  "exposure_desired": 0.5
-}
-\`\`\``;
-
-  const earlierSection = data.messages_context.length > 0
-    ? `## Earlier Conversation (context only)
-${formatMessagesAsPlaceholders(data.messages_context, personaName)}
-
-`
-    : '';
-
-  const recentSection = `## Most Recent Messages (analyze these)
-${formatMessagesAsPlaceholders(data.messages_analyze, personaName)}`;
-
-  const user = `# Conversation
-${earlierSection}${recentSection}
-
----
-
-# Topic Candidate
-
-Name: ${data.candidate.name}
-Message Count: ${data.candidate.message_count}
-Sentiment Signal: ${data.candidate.sentiment_signal}
-
-${isNewTopic ? 'Create' : 'Update'} the PersonaTopic based on how ${personaName} engaged with this topic.
-
-**Return JSON:**
-\`\`\`json
-{
-  "name": "...",
-  "perspective": "...",
-  "approach": "...",
-  "personal_stake": "...",
-  "sentiment": 0.5,
-  "exposure_impact": "medium",
-  "exposure_desired": 0.5
-}
-\`\`\``;
-
-  return { system, user };
-}