neoagent 3.2.1-beta.10 → 3.2.1-beta.12

package/server/services/behavior/defaults.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const MODULE_IDS = Object.freeze([
+  'turn_taking',
+  'social_memory',
+  'norms',
+  'persona',
+  'agent_identity',
+  'channel_style',
+  'theory_of_mind',
+  'social_signals',
+  'social_observability',
+  'delivery',
+]);
+
+const DEFAULT_MODULE_CONFIG = Object.freeze({
+  schemaVersion: 1,
+  enabled: true,
+  participationMode: 'automatic',
+  minimumNeedScore: 0.72,
+  batchWindowMs: 900,
+  decisionContextMessageLimit: 12,
+  decisionModelId: null,
+  decisionModelPurpose: 'general',
+  deliveryStyle: 'natural_bubbles',
+  maxBubbles: 4,
+  bubbleGapMs: 650,
+  normsRefreshMessageGap: 18,
+  observabilityIntervalMinutes: 360,
+});
+
+function cloneDefaults() {
+  return {
+    schemaVersion: DEFAULT_MODULE_CONFIG.schemaVersion,
+    enabled: DEFAULT_MODULE_CONFIG.enabled,
+    modules: {
+      turn_taking: { enabled: true },
+      social_memory: { enabled: true },
+      norms: { enabled: true },
+      persona: { enabled: true },
+      agent_identity: { enabled: true },
+      channel_style: { enabled: true },
+      theory_of_mind: { enabled: true },
+      social_signals: { enabled: true },
+      social_observability: { enabled: true },
+      delivery: { enabled: true },
+    },
+    participationMode: DEFAULT_MODULE_CONFIG.participationMode,
+    minimumNeedScore: DEFAULT_MODULE_CONFIG.minimumNeedScore,
+    batchWindowMs: DEFAULT_MODULE_CONFIG.batchWindowMs,
+    decisionContextMessageLimit: DEFAULT_MODULE_CONFIG.decisionContextMessageLimit,
+    decisionModelId: DEFAULT_MODULE_CONFIG.decisionModelId,
+    decisionModelPurpose: DEFAULT_MODULE_CONFIG.decisionModelPurpose,
+    deliveryStyle: DEFAULT_MODULE_CONFIG.deliveryStyle,
+    maxBubbles: DEFAULT_MODULE_CONFIG.maxBubbles,
+    bubbleGapMs: DEFAULT_MODULE_CONFIG.bubbleGapMs,
+    normsRefreshMessageGap: DEFAULT_MODULE_CONFIG.normsRefreshMessageGap,
+    observabilityIntervalMinutes: DEFAULT_MODULE_CONFIG.observabilityIntervalMinutes,
+    platformOverrides: {},
+    roomOverrides: {},
+  };
+}
+
+module.exports = {
+  MODULE_IDS,
+  DEFAULT_MODULE_CONFIG,
+  cloneDefaults,
+};

package/server/services/behavior/delivery.js

@@ -0,0 +1,176 @@
+'use strict';
+
+const {
+  splitOutgoingMessageForPlatform,
+  normalizeOutgoingMessageForPlatform,
+} = require('../messaging/formatting_guides');
+
+function sleep(ms, signal = null) {
+  const delay = Math.max(0, Number(ms) || 0);
+  if (!delay) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, delay);
+    const onAbort = () => {
+      cleanup();
+      const error = new Error('Delivery aborted.');
+      error.name = 'AbortError';
+      reject(error);
+    };
+    const cleanup = () => {
+      clearTimeout(timer);
+      if (signal) signal.removeEventListener('abort', onAbort);
+    };
+    if (signal) {
+      if (signal.aborted) {
+        cleanup();
+        const error = new Error('Delivery aborted.');
+        error.name = 'AbortError';
+        reject(error);
+        return;
+      }
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
+  });
+}
+
+function splitIntoNaturalBubbles(platform, content, { maxBubbles = 4 } = {}) {
+  const normalized = normalizeOutgoingMessageForPlatform(platform, content, {
+    stripNoResponseMarker: false,
+  });
+  if (!normalized) return [];
+  if (normalized.toUpperCase() === '[NO RESPONSE]') return [normalized];
+
+  const paragraphChunks = splitOutgoingMessageForPlatform(platform, normalized);
+  const bubbles = [];
+  for (const chunk of paragraphChunks) {
+    const bubble = String(chunk).trim();
+    if (bubble) bubbles.push(bubble);
+  }
+
+  const limited = [];
+  for (const bubble of bubbles) {
+    if (!bubble) continue;
+    if (limited.length < maxBubbles) {
+      limited.push(bubble);
+    } else {
+      limited[limited.length - 1] = `${limited[limited.length - 1]} ${bubble}`.trim();
+    }
+  }
+  return limited.length ? limited : [normalized];
+}
+
+async function deliverSocialReply({
+  messagingManager,
+  userId,
+  agentId,
+  platform,
+  chatId,
+  content,
+  config,
+  runId = null,
+  signal = null,
+  mediaPath = null,
+  turnEpoch = null,
+  beforeBubble = null,
+}) {
+  const style = config?.deliveryStyle === 'single' ? 'single' : 'natural_bubbles';
+  if (style === 'single' || mediaPath) {
+    if (beforeBubble && !(await beforeBubble(0))) {
+      return { success: false, suppressed: true, reason: 'stale_turn', turnEpoch };
+    }
+    return messagingManager.sendMessage(userId, platform, chatId, content, {
+      agentId,
+      runId,
+      mediaPath,
+      signal,
+      deliveryKind: 'final',
+      idempotencyKey: runId ? `${runId}:social:0` : undefined,
+    });
+  }
+
+  const bubbles = splitIntoNaturalBubbles(platform, content, {
+    maxBubbles: config?.maxBubbles ?? 4,
+  });
+  if (bubbles.length <= 1) {
+    if (beforeBubble && !(await beforeBubble(0))) {
+      return { success: false, suppressed: true, reason: 'stale_turn', turnEpoch };
+    }
+    return messagingManager.sendMessage(userId, platform, chatId, bubbles[0] || content, {
+      agentId,
+      runId,
+      signal,
+      deliveryKind: 'final',
+      idempotencyKey: runId ? `${runId}:social:0` : undefined,
+    });
+  }
+
+  try {
+    let lastResult = null;
+    for (let index = 0; index < bubbles.length; index += 1) {
+      if (signal?.aborted) {
+        const error = new Error('Delivery aborted.');
+        error.name = 'AbortError';
+        throw error;
+      }
+      if (index > 0) {
+        await sleep(config?.bubbleGapMs ?? 650, signal);
+      }
+      if (beforeBubble && !(await beforeBubble(index))) {
+        return {
+          success: false,
+          suppressed: true,
+          reason: 'stale_turn',
+          turnEpoch,
+          deliveredBubbles: index,
+        };
+      }
+      try {
+        await messagingManager.sendTyping?.(userId, platform, chatId, true, { agentId, runId, signal });
+      } catch {
+        // typing is best-effort
+      }
+      lastResult = await messagingManager.sendMessage(userId, platform, chatId, bubbles[index], {
+        agentId,
+        runId,
+        signal,
+        idempotencyKey: runId ? `${runId}:social:${index}` : undefined,
+        deliveryKind: index === bubbles.length - 1 ? 'final' : 'partial',
+        metadata: {
+          socialDelivery: true,
+          bubbleIndex: index,
+          bubbleCount: bubbles.length,
+        },
+      });
+      if (lastResult?.success === false || lastResult?.suppressed === true) {
+        return {
+          success: false,
+          error: lastResult?.error || lastResult?.reason || 'Messaging platform rejected delivery.',
+          result: lastResult,
+          deliveredBubbles: index,
+        };
+      }
+    }
+    return {
+      success: true,
+      bubbled: true,
+      bubbleCount: bubbles.length,
+      result: lastResult,
+    };
+  } finally {
+    try {
+      await messagingManager.sendTyping?.(userId, platform, chatId, false, { agentId, runId, signal });
+    } catch {
+      // typing is best-effort
+    }
+  }
+}
+
+module.exports = {
+  id: 'delivery',
+  deliver: deliverSocialReply,
+  splitIntoNaturalBubbles,
+  deliverSocialReply,
+};

package/server/services/behavior/index.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const {
+  getBehaviorConfig,
+  setBehaviorConfig,
+  resolveBehaviorConfig,
+  normalizeStoredConfig,
+  roomConfigKey,
+  isModuleEnabled,
+  SETTINGS_KEY,
+} = require('./config');
+const { MODULE_IDS, cloneDefaults, DEFAULT_MODULE_CONFIG } = require('./defaults');
+const { createBehaviorPipeline } = require('./pipeline');
+const {
+  getThreadState,
+  setThreadState,
+  isTurnCurrent,
+  markSpoke,
+} = require('./state');
+const { createBehaviorRegistry, LIFECYCLE_STAGES } = require('./registry');
+const { splitIntoNaturalBubbles, deliverSocialReply } = require('./delivery');
+
+module.exports = {
+  MODULE_IDS,
+  DEFAULT_MODULE_CONFIG,
+  SETTINGS_KEY,
+  cloneDefaults,
+  getBehaviorConfig,
+  setBehaviorConfig,
+  resolveBehaviorConfig,
+  normalizeStoredConfig,
+  roomConfigKey,
+  isModuleEnabled,
+  createBehaviorPipeline,
+  createBehaviorRegistry,
+  LIFECYCLE_STAGES,
+  getThreadState,
+  setThreadState,
+  isTurnCurrent,
+  markSpoke,
+  splitIntoNaturalBubbles,
+  deliverSocialReply,
+};

package/server/services/behavior/model_client.js

@@ -0,0 +1,35 @@
+'use strict';
+
+async function requestStructuredJson({
+  agentEngine,
+  userId,
+  agentId,
+  modelId = null,
+  purpose = 'fast',
+  system,
+  prompt,
+  signal = null,
+  maxTokens = 220,
+  fallback = {},
+}) {
+  if (!agentEngine || typeof agentEngine.inferStructured !== 'function') {
+    const error = new Error('Behavior inference requires the central AI engine.');
+    error.code = 'BEHAVIOR_ENGINE_UNAVAILABLE';
+    throw error;
+  }
+  return agentEngine.inferStructured({
+    userId,
+    agentId,
+    modelId,
+    purpose,
+    system,
+    prompt,
+    maxTokens,
+    fallback,
+    signal,
+  });
+}
+
+module.exports = {
+  requestStructuredJson,
+};

package/server/services/behavior/modules/agent_identity.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const db = require('../../../db/database');
+const { buildAgentRosterPrompt } = require('../../agents/manager');
+const { isModuleEnabled } = require('../config');
+
+function clamp(text, maxChars) {
+  const value = String(text || '').trim();
+  if (!value || value.length <= maxChars) return value;
+  return `${value.slice(0, maxChars)}\n...[trimmed]`;
+}
+
+function buildSystemPromptContribution(ctx) {
+  if (!ctx.agentId || !isModuleEnabled(ctx.config, 'agent_identity')) return '';
+  const agent = db.prepare(
+    `SELECT display_name, slug, description, responsibilities, instructions
+     FROM agents
+     WHERE user_id = ? AND id = ?`,
+  ).get(ctx.userId, ctx.agentId);
+  if (!agent) return '';
+  const active = [
+    '## Active Agent',
+    `Name: ${agent.display_name} (${agent.slug})`,
+    agent.description ? `Description: ${clamp(agent.description, 600)}` : '',
+    agent.responsibilities ? `Responsibilities: ${clamp(agent.responsibilities, 1000)}` : '',
+    agent.instructions ? `Agent instructions: ${clamp(agent.instructions, 1600)}` : '',
+  ].filter(Boolean).join('\n');
+  const roster = ctx.triggerSource === 'agent_delegation'
+    ? ''
+    : buildAgentRosterPrompt(ctx.userId, ctx.agentId);
+  return [active, roster].filter(Boolean).join('\n\n');
+}
+
+module.exports = {
+  id: 'agent_identity',
+  composeSystemPrompt: buildSystemPromptContribution,
+};

package/server/services/behavior/modules/channel_style.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const { isModuleEnabled } = require('../config');
+
+function buildSystemPromptContribution(ctx) {
+  if (!isModuleEnabled(ctx.config, 'channel_style')) return '';
+  if (ctx.widgetId) {
+    return 'CHANNEL RESPONSE GUIDE: Widget refreshes should produce structured snapshot data, not conversational filler.';
+  }
+  if (ctx.triggerSource === 'voice_live' || ctx.latencyProfile === 'voice') {
+    return 'CHANNEL RESPONSE GUIDE: Voice replies should usually fit in one or two concise spoken sentences unless detail is necessary.';
+  }
+  if (ctx.triggerSource === 'messaging' && ctx.audience === 'shared') {
+    return 'CHANNEL RESPONSE GUIDE: The turn-taking gate already decided this shared room needs a response. Make one brief, natural contribution, address the relevant participant or room rather than the owner, and do not dominate or send progress chatter.';
+  }
+  if (ctx.triggerSource === 'messaging') {
+    return 'CHANNEL RESPONSE GUIDE: Text like a natural contact. Prefer one concise reply, or a few short bubbles when the thought genuinely benefits from separate beats. A blank line marks an intentional bubble break, so do not add one mechanically. Keep dense information and lists together, and expand only when the task needs detail.';
+  }
+  if (ctx.triggerSource === 'wearable') {
+    return 'CHANNEL RESPONSE GUIDE: Wearable replies should be one or two short sentences with the result first.';
+  }
+  return 'CHANNEL RESPONSE GUIDE: Web chat may use short paragraphs and compact lists. Avoid padding and lead with the result.';
+}
+
+module.exports = {
+  id: 'channel_style',
+  composeSystemPrompt: buildSystemPromptContribution,
+};

package/server/services/behavior/modules/index.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const turnTaking = require('./turn_taking');
+const socialMemory = require('./social_memory');
+const norms = require('./norms');
+const persona = require('./persona');
+const agentIdentity = require('./agent_identity');
+const channelStyle = require('./channel_style');
+const theoryOfMind = require('./theory_of_mind');
+const socialSignals = require('./social_signals');
+const socialObservability = require('./social_observability');
+const delivery = require('../delivery');
+
+const BEHAVIOR_MODULES = Object.freeze([
+  turnTaking,
+  socialMemory,
+  norms,
+  persona,
+  agentIdentity,
+  channelStyle,
+  theoryOfMind,
+  socialSignals,
+  socialObservability,
+  delivery,
+]);
+
+module.exports = {
+  BEHAVIOR_MODULES,
+};

package/server/services/behavior/modules/norms.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const { requestStructuredJson } = require('../model_client');
+const { loadRecentRoomMessages, truncate } = require('../signals');
+const { getThreadState, setThreadState } = require('../state');
+const { isModuleEnabled } = require('../config');
+
+const SYSTEM_PROMPT = `You extract a compact group-chat norms profile for an AI participant.
+Return JSON with keys:
+promptBlock (short instructions the agent can follow to match the room's voice),
+notes (array of short observations).
+No phrase blacklists. Describe style, formality, humor, length, and participation norms.`;
+
+function getNormsPromptBlock(ctx) {
+  if (!isModuleEnabled(ctx.config, 'norms')) return '';
+  const state = getThreadState(ctx.userId, ctx.agentId, ctx.msg.platform, ctx.msg.chatId);
+  return String(state.normsPromptBlock || '').trim();
+}
+
+async function maybeRefreshNorms(ctx) {
+  const { userId, agentId, msg, config, signal = null } = ctx;
+  if (!msg?.isGroup || !isModuleEnabled(config, 'norms')) {
+    return { refreshed: false };
+  }
+
+  const state = getThreadState(userId, agentId, msg.platform, msg.chatId);
+  const count = Number(state.messageCountSinceNorms || 0) + 1;
+  const gap = Number(config.normsRefreshMessageGap || 18);
+  if (count < gap) {
+    setThreadState(userId, agentId, msg.platform, msg.chatId, {
+      messageCountSinceNorms: count,
+    });
+    return { refreshed: false, deferred: true };
+  }
+
+  const roomMessages = loadRecentRoomMessages({
+    userId,
+    agentId,
+    platform: msg.platform,
+    chatId: msg.chatId,
+    limit: 24,
+  });
+  if (roomMessages.length < 4) {
+    setThreadState(userId, agentId, msg.platform, msg.chatId, {
+      messageCountSinceNorms: count,
+    });
+    return { refreshed: false, reason: 'insufficient_history' };
+  }
+
+  try {
+    const result = await requestStructuredJson({
+      agentEngine: ctx.agentEngine,
+      userId,
+      agentId,
+      purpose: 'fast',
+      system: SYSTEM_PROMPT,
+      prompt: JSON.stringify({
+        platform: msg.platform,
+        chatId: msg.chatId,
+        recentMessages: roomMessages.map((item) => ({
+          sender: item.sender,
+          content: item.content,
+        })),
+      }),
+      signal,
+      maxTokens: 280,
+    });
+    const promptBlock = truncate(result.parsed?.promptBlock || '', 900);
+    if (!promptBlock) {
+      setThreadState(userId, agentId, msg.platform, msg.chatId, {
+        messageCountSinceNorms: 0,
+      });
+      return { refreshed: false, reason: 'empty_block' };
+    }
+    setThreadState(userId, agentId, msg.platform, msg.chatId, {
+      normsPromptBlock: `## Group norms\n${promptBlock}`,
+      normsUpdatedAt: new Date().toISOString(),
+      messageCountSinceNorms: 0,
+    });
+    return { refreshed: true };
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    setThreadState(userId, agentId, msg.platform, msg.chatId, {
+      messageCountSinceNorms: count,
+    });
+    return { refreshed: false, error: error?.message || String(error) };
+  }
+}
+
+function composeContext(ctx) {
+  const content = getNormsPromptBlock(ctx);
+  return content ? { key: 'norms', priority: 50, content } : null;
+}
+
+module.exports = {
+  id: 'norms',
+  composeContext,
+  afterTurn: maybeRefreshNorms,
+  getNormsPromptBlock,
+  maybeRefreshNorms,
+};

package/server/services/behavior/modules/persona.js

@@ -0,0 +1,172 @@
+'use strict';
+
+const { isModuleEnabled } = require('../config');
+const { requestStructuredJson } = require('../model_client');
+const { truncate } = require('../signals');
+const { BASELINE_PERSONA_PROMPT } = require('./persona_prompt');
+
+const INTERACTION_VOICE_RULES = `Mandatory interaction-voice editing rules:
+- Preserve every fact, number, name, date, URL, citation, command, result, uncertainty, warning, and user-relevant blocker. Never add a fact.
+- Preserve requested formatting and substantive detail. A detailed or multi-part deliverable may remain long.
+- Match the actual user's casing, punctuation, vocabulary, directness, and established emoji register.
+- Short social messages should usually become one original line.
+- Everyday advice should be direct and at most three short sentences unless nuance or safety requires more.
+- Straightforward factual answers should usually be one compact paragraph, not a headed article or exhaustive list.
+- Keep sensitive replies restrained. If a serious draft is already one or two attentive sentences with no advice menu, send it unchanged. Never add an offer to talk, vent, get support, or use distraction. Remove therapy language, support-option menus, unsolicited coping advice, and "I'm here if you want to talk" closers unless the user explicitly requested that support.
+- Remove canned praise, question-grading, repeated acknowledgements, preambles, postambles, automatic follow-up questions, generic offers, and service sign-offs.
+- If the user did not ask a question and the draft's question is only there to prolong the exchange, remove it.
+- Keep at most one contextual joke. Never make serious material witty.
+- A requested short draft should contain only the draft.
+- In a group, make one brief contribution and never dominate the room.`;
+
+const INTERACTION_EDITOR_PROMPT = `You are the final Interaction Voice editor for a personal AI messaging thread.
+Return JSON with exactly these keys:
+action ("send" or "revise"),
+revisedContent (string; empty when action is send),
+reasonCodes (array of short strings),
+rationale (one short sentence).
+
+The draft may be factually correct but sound like a generic assistant. You are an editor, not a second conversational partner: make the smallest necessary edit and do not replace a good draft merely to write your own response.
+
+${INTERACTION_VOICE_RULES}
+
+If the draft already satisfies these rules, return action "send". Otherwise return action "revise" with the complete replacement. Do not explain the edit inside revisedContent.`;
+
+function buildSystemPromptContribution(ctx) {
+  if (!isModuleEnabled(ctx.config, 'persona')) {
+    return null;
+  }
+  const dynamic = [];
+  const behaviorNotes = ctx.memoryManager && ctx.userId != null
+    ? ctx.memoryManager.getAssistantBehaviorNotes(
+      ctx.userId,
+      { agentId: ctx.agentId },
+    )
+    : '';
+  if (behaviorNotes) {
+    dynamic.push([
+      '## Assistant Behavior Notes',
+      'These are durable preferences for how the agent should usually behave. System rules and the current request take priority.',
+      behaviorNotes,
+    ].join('\n'));
+  }
+  const selfState = ctx.memoryManager && ctx.userId != null
+    ? ctx.memoryManager.getAssistantSelfState(
+      ctx.userId,
+      { agentId: ctx.agentId },
+    )
+    : null;
+  const identity = selfState?.identity || {};
+  const focus = ctx.audience === 'shared' ? {} : (selfState?.focus || {});
+  if (Object.keys(identity).length || Object.keys(focus).length) {
+    dynamic.push([
+      '## Assistant Self State',
+      Object.keys(identity).length ? `Identity: ${JSON.stringify(identity)}` : '',
+      Object.keys(focus).length ? `Focus: ${JSON.stringify(focus)}` : '',
+    ].filter(Boolean).join('\n'));
+  }
+  return {
+    stable: [BASELINE_PERSONA_PROMPT],
+    dynamic,
+  };
+}
+
+async function refineDraft(ctx) {
+  const {
+    userId,
+    agentId,
+    msg,
+    config,
+    draft,
+    signal = null,
+    runId = null,
+  } = ctx;
+  const content = String(draft || '').trim();
+  if (
+    !content
+    || content.toUpperCase() === '[NO RESPONSE]'
+    || !isModuleEnabled(config, 'persona')
+  ) {
+    return {
+      action: 'send',
+      content,
+      reasonCodes: ['persona_refine_skip'],
+    };
+  }
+
+  // Large deliverables need their full information and structure preserved. The
+  // main prompt owns their voice; the lightweight interaction pass owns messages.
+  if (content.length > 2800) {
+    return {
+      action: 'send',
+      content,
+      reasonCodes: ['persona_refine_large_passthrough'],
+    };
+  }
+
+  const runModelId = runId
+    ? ctx.agentEngine?.getRunMeta?.(runId)?.modelSelectionId || null
+    : null;
+
+  try {
+    const result = await requestStructuredJson({
+      agentEngine: ctx.agentEngine,
+      userId,
+      agentId,
+      modelId: config.decisionModelId || runModelId,
+      purpose: runModelId ? 'general' : config.decisionModelPurpose,
+      system: INTERACTION_EDITOR_PROMPT,
+      prompt: JSON.stringify({
+        channel: {
+          platform: msg.platform,
+          audience: msg.isGroup ? 'shared' : 'direct',
+        },
+        inbound: truncate(msg.content, 900),
+        draft: content,
+      }),
+      signal,
+      maxTokens: 1200,
+    });
+    const parsed = result.parsed || {};
+    if (
+      parsed.action === 'revise'
+      && String(parsed.revisedContent || '').trim()
+    ) {
+      return {
+        action: 'revise',
+        content: String(parsed.revisedContent).trim(),
+        reasonCodes: Array.isArray(parsed.reasonCodes)
+          ? parsed.reasonCodes
+          : ['persona_revise'],
+        rationale: String(parsed.rationale || '').trim(),
+        model: result.modelSelectionId || result.model || null,
+        usage: result.usage || 0,
+      };
+    }
+    return {
+      action: 'send',
+      content,
+      reasonCodes: Array.isArray(parsed.reasonCodes)
+        ? parsed.reasonCodes
+        : ['persona_send'],
+      rationale: String(parsed.rationale || '').trim(),
+      model: result.modelSelectionId || result.model || null,
+      usage: result.usage || 0,
+    };
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    return {
+      action: 'send',
+      content,
+      reasonCodes: ['persona_error_passthrough'],
+      failureCode: 'model_unavailable',
+    };
+  }
+}
+
+module.exports = {
+  id: 'persona',
+  composeSystemPrompt: buildSystemPromptContribution,
+  refineDraft,
+  INTERACTION_VOICE_RULES,
+};