get-claudia 1.30.0 → 1.32.0

package/bin/index.js

@@ -220,7 +220,7 @@ async function main() {
 
   // Helper: run visualizer install script and call back when done (auto-install, no prompt)
   function runVisualizerSetup(callback) {
-    console.log(`\n${colors.boldYellow}━━━ Phase 2/3: Brain Visualizer ━━━${colors.reset}\n`);
+    console.log(`\n${colors.boldYellow}━━━ Phase 2/4: Brain Visualizer ━━━${colors.reset}\n`);
 
     const visualizerScriptPath = isWindows
       ? join(__dirname, '..', 'visualizer', 'scripts', 'install.ps1')
@@ -263,7 +263,7 @@ async function main() {
 
   // Helper: run gateway install script and call back when done
   function runGatewaySetup(callback) {
-    console.log(`\n${colors.boldYellow}━━━ Phase 3/3: Messaging Gateway ━━━${colors.reset}\n`);
+    console.log(`\n${colors.boldYellow}━━━ Phase 3/4: Messaging Gateway ━━━${colors.reset}\n`);
 
     const gatewayScriptPath = isWindows
       ? join(__dirname, '..', 'gateway', 'scripts', 'install.ps1')
@@ -309,6 +309,54 @@ async function main() {
     }
   }
 
+  // Helper: run relay install script and call back when done
+  function runRelaySetup(callback) {
+    console.log(`\n${colors.boldYellow}━━━ Phase 4/4: Telegram Relay ━━━${colors.reset}\n`);
+
+    const relayScriptPath = isWindows
+      ? join(__dirname, '..', 'relay', 'scripts', 'install.ps1')
+      : join(__dirname, '..', 'relay', 'scripts', 'install.sh');
+
+    if (!existsSync(relayScriptPath)) {
+      console.log(`${colors.yellow}!${colors.reset} Relay files not found. Skipping.`);
+      callback(false);
+      return;
+    }
+
+    try {
+      const spawnCmd = isWindows ? powershellPath : 'bash';
+      const spawnArgs = isWindows
+        ? ['-ExecutionPolicy', 'Bypass', '-File', relayScriptPath]
+        : [relayScriptPath];
+      const relayResult = spawn(spawnCmd, spawnArgs, {
+        stdio: 'inherit',
+        env: {
+          ...process.env,
+          CLAUDIA_RELAY_UPGRADE: isUpgrade ? '1' : '0',
+          CLAUDIA_RELAY_SKIP_SETUP: '1'
+        }
+      });
+
+      relayResult.on('close', (code) => {
+        if (code === 0) {
+          console.log(`${colors.green}✓${colors.reset} Relay installed`);
+          callback(true);
+        } else {
+          console.log(`${colors.yellow}!${colors.reset} Relay setup had issues. You can run it later with:`);
+          if (isWindows) {
+            console.log(`  ${colors.cyan}powershell.exe -ExecutionPolicy Bypass -File "${relayScriptPath}"${colors.reset}`);
+          } else {
+            console.log(`  ${colors.cyan}bash ${relayScriptPath}${colors.reset}`);
+          }
+          callback(false);
+        }
+      });
+    } catch (error) {
+      console.log(`${colors.yellow}!${colors.reset} Could not set up relay: ${error.message}`);
+      callback(false);
+    }
+  }
+
   // Helper: run system health check after install
   function runSystemHealthCheck(callback) {
     const diagnoseScript = isWindows
@@ -343,20 +391,25 @@ async function main() {
   }
 
   // Helper: finish install after optional components
-  function finishInstall(memoryInstalled, visualizerInstalled, gatewayInstalled) {
+  function finishInstall(memoryInstalled, visualizerInstalled, gatewayInstalled, relayInstalled) {
     if (memoryInstalled) {
       // Run health check when memory system was installed
       runSystemHealthCheck((healthy) => {
-        showNextSteps(memoryInstalled, visualizerInstalled, gatewayInstalled, healthy);
+        showNextSteps(memoryInstalled, visualizerInstalled, gatewayInstalled, relayInstalled, healthy);
       });
     } else {
-      showNextSteps(memoryInstalled, visualizerInstalled, gatewayInstalled, true);
+      showNextSteps(memoryInstalled, visualizerInstalled, gatewayInstalled, relayInstalled, true);
     }
   }
 
-  // Helper: run gateway setup (auto-install like visualizer), then finish
+  // Helper: run relay setup after gateway, then finish
+  function maybeRunRelay(memoryInstalled, visualizerInstalled, gatewayInstalled) {
+    runRelaySetup((relayOk) => finishInstall(memoryInstalled, visualizerInstalled, gatewayInstalled, relayOk));
+  }
+
+  // Helper: run gateway setup (auto-install like visualizer), then chain to relay
   function maybeRunGateway(memoryInstalled, visualizerInstalled) {
-    runGatewaySetup((gatewayOk) => finishInstall(memoryInstalled, visualizerInstalled, gatewayOk));
+    runGatewaySetup((gatewayOk) => maybeRunRelay(memoryInstalled, visualizerInstalled, gatewayOk));
   }
 
   // Helper: auto-install visualizer after memory (if memory was installed), then chain to gateway
@@ -371,7 +424,7 @@ async function main() {
   }
 
   // Memory system always installs (no prompt)
-  console.log(`\n${colors.boldYellow}━━━ Phase 1/3: Memory System ━━━${colors.reset}\n`);
+  console.log(`\n${colors.boldYellow}━━━ Phase 1/4: Memory System ━━━${colors.reset}\n`);
 
   const memoryDaemonPath = isWindows
     ? join(__dirname, '..', 'memory-daemon', 'scripts', 'install.ps1')
@@ -453,7 +506,7 @@ async function main() {
   // Memory failed to spawn -- continue with visualizer/gateway
   maybeRunVisualizer(false);
 
-  function showNextSteps(memoryInstalled, visualizerInstalled, gatewayInstalled, systemHealthy = true) {
+  function showNextSteps(memoryInstalled, visualizerInstalled, gatewayInstalled, relayInstalled, systemHealthy = true) {
     const cdStep = isCurrentDir ? '' : `  ${colors.cyan}cd ${targetDir}${colors.reset}\n`;
 
     // Installation summary
@@ -465,11 +518,16 @@ async function main() {
     console.log(`${memoryInstalled ? check : warn} Memory system    ${memoryInstalled ? 'Active' : 'Skipped'}`);
     console.log(`${visualizerInstalled ? check : warn} Brain visualizer ${visualizerInstalled ? 'Active' : 'Skipped'}`);
     console.log(`${gatewayInstalled ? check : warn} Gateway          ${gatewayInstalled ? 'Installed' : 'Skipped'}`);
+    console.log(`${relayInstalled ? check : warn} Telegram relay   ${relayInstalled ? 'Installed' : 'Skipped'}`);
 
     if (gatewayInstalled) {
       console.log(`${colors.yellow}->${colors.reset} Configure tokens: ~/.claudia/gateway.json`);
     }
 
+    if (relayInstalled) {
+      console.log(`${colors.yellow}->${colors.reset} Configure relay: run /setup-telegram inside Claude`);
+    }
+
     if (!systemHealthy) {
       console.log(`\n${colors.yellow}Some issues were detected above.${colors.reset}`);
       console.log(`${colors.dim}You can fix them now, or Claudia will work in fallback mode until they're resolved.${colors.reset}`);

package/gateway/src/bridge.js

@@ -17,6 +17,7 @@ import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
 import { existsSync } from 'fs';
 import { readFileSync } from 'fs';
 import { createLogger } from './utils/logger.js';
+import { loadPersonality } from './personality.js';
 
 const log = createLogger('bridge');
 
@@ -43,6 +44,7 @@ export class Bridge {
     this.memoryAvailable = false;
     this.extractor = null; // Set by gateway after construction
     this._consecutiveFailures = 0;
+    this._personality = null; // Loaded Claudia personality prompt
   }
 
   async start() {
@@ -90,6 +92,9 @@ export class Bridge {
       }
     }
 
+    // Load Claudia personality
+    this._personality = loadPersonality(this.config);
+
     // Try to connect to memory daemon via MCP
     await this._connectMemory();
   }
@@ -151,18 +156,20 @@ export class Bridge {
     messages.push({ role: 'user', content: text });
 
     // 4. Call LLM (Anthropic or Ollama)
+    const resolvedModel = this._resolveModel(channel);
     log.info('Calling LLM', {
       provider: this.provider,
-      model: this.provider === 'anthropic' ? this.config.model : this.config.ollama.model,
+      model: resolvedModel,
+      channel,
       messageCount: messages.length,
     });
 
     let result;
     try {
       if (this.provider === 'anthropic') {
-        result = await this._callAnthropic(systemPrompt, messages);
+        result = await this._callAnthropic(systemPrompt, messages, resolvedModel);
       } else {
-        result = await this._callOllama(systemPrompt, messages);
+        result = await this._callOllama(systemPrompt, messages, resolvedModel);
       }
     } catch (err) {
       log.error('LLM call failed', { provider: this.provider, error: err.message });
@@ -375,19 +382,48 @@ export class Bridge {
     }
   }
 
+  /**
+   * Resolve which model to use for a given channel.
+   * Per-channel model overrides the global default.
+   *
+   * @param {string} channel - Channel name (e.g. 'telegram', 'slack')
+   * @returns {string} Resolved model identifier
+   */
+  _resolveModel(channel) {
+    // Check per-channel model override
+    const channelModel = this.config.channels?.[channel]?.model;
+    if (channelModel) return channelModel;
+
+    // Fall back to global model for the active provider
+    if (this.provider === 'anthropic') {
+      return this.config.model;
+    }
+    return this.config.ollama?.model || '';
+  }
+
   /**
    * Build the system prompt with memory context.
+   *
+   * Resolution chain for personality:
+   * 1. Loaded personality from template dir (richest)
+   * 2. Custom systemPromptPath file (backward compat)
+   * 3. DEFAULT_SYSTEM_PROMPT fallback
    */
   _buildSystemPrompt(memoryContext, userName, channel) {
-    let prompt = DEFAULT_SYSTEM_PROMPT;
+    let prompt;
 
-    // Load custom system prompt if configured
-    if (this.config.systemPromptPath && existsSync(this.config.systemPromptPath)) {
+    if (this._personality) {
+      // Full Claudia personality loaded from template files
+      prompt = this._personality;
+    } else if (this.config.systemPromptPath && existsSync(this.config.systemPromptPath)) {
+      // Legacy: custom system prompt file
       try {
         prompt = readFileSync(this.config.systemPromptPath, 'utf8');
       } catch {
-        // Fall back to default
+        prompt = DEFAULT_SYSTEM_PROMPT;
       }
+    } else {
+      prompt = DEFAULT_SYSTEM_PROMPT;
     }
 
     prompt += `\n\nChannel: ${channel}`;
@@ -404,11 +440,14 @@ export class Bridge {
 
   /**
    * Call Anthropic API.
+   * @param {string} systemPrompt
+   * @param {Object[]} messages
+   * @param {string} model - Resolved model to use
    * @returns {{ text: string, usage: Object }}
    */
-  async _callAnthropic(systemPrompt, messages) {
+  async _callAnthropic(systemPrompt, messages, model) {
     const response = await this.anthropic.messages.create({
-      model: this.config.model,
+      model,
       max_tokens: this.config.maxTokens || 2048,
       system: systemPrompt,
       messages,
@@ -425,11 +464,13 @@ export class Bridge {
   /**
    * Call Ollama /api/chat endpoint.
    * Retries up to 2 times with 2s delay (matching memory daemon pattern).
+   * @param {string} systemPrompt
+   * @param {Object[]} messages
+   * @param {string} model - Resolved model to use
    * @returns {{ text: string, usage: null }}
    */
-  async _callOllama(systemPrompt, messages) {
+  async _callOllama(systemPrompt, messages, model) {
     const host = this.config.ollama?.host || 'http://localhost:11434';
-    const model = this.config.ollama?.model;
 
     // Build Ollama message array: system prompt + conversation turns
     const ollamaMessages = [{ role: 'system', content: systemPrompt }];
@@ -531,6 +572,7 @@ export class Bridge {
       provider: this.provider,
       providerReady: this.provider === 'anthropic' ? !!this.anthropic : this.provider === 'ollama',
       memoryAvailable: this.memoryAvailable,
+      personalityLoaded: !!this._personality,
       model:
         this.provider === 'ollama' ? this.config.ollama?.model : this.config.model,
     };

package/gateway/src/config.js

@@ -27,7 +27,11 @@ const DEFAULT_CONFIG = {
     model: '', // Auto-detected from ~/.claudia/config.json language_model field
   },
 
-  // System prompt context
+  // Personality
+  personalityDir: '',          // Path to Claudia template dir (contains CLAUDE.md + .claude/rules/)
+  personalityMaxChars: 15000,  // Safety limit for prompt size
+
+  // System prompt context (legacy, overridden by personalityDir)
   systemPromptPath: '', // Optional path to custom system prompt
 
   // Memory daemon connection
@@ -47,6 +51,7 @@ const DEFAULT_CONFIG = {
       enabled: false,
       token: '',
       allowedUsers: [],
+      model: '',  // Per-channel model override (empty = use global)
     },
     slack: {
       enabled: false,
@@ -54,6 +59,7 @@ const DEFAULT_CONFIG = {
       appToken: '',
       signingSecret: '',
       allowedUsers: [],
+      model: '',  // Per-channel model override (empty = use global)
     },
   },
 

package/gateway/src/personality.js

@@ -0,0 +1,267 @@
+/**
+ * Claudia personality loader for the gateway.
+ *
+ * Extracts gateway-relevant sections from the Claudia template files
+ * (CLAUDE.md and claudia-principles.md) to build a rich system prompt
+ * that gives Telegram/Slack Claudia her real personality.
+ *
+ * Resolution chain:
+ * 1. config.personalityDir -> load from explicit path
+ * 2. Auto-detect ../template-v2/ relative to gateway (dev mode)
+ * 3. config.systemPromptPath -> single file (backward compat)
+ * 4. DEFAULT_SYSTEM_PROMPT fallback
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { createLogger } from './utils/logger.js';
+
+const log = createLogger('personality');
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const GATEWAY_PREAMBLE = `You are Claudia, responding via a messaging app. Adapt your style:
+- Keep responses concise and conversational. This is chat, not a document.
+- Use plain text formatting suitable for chat.
+- Short replies when appropriate, detailed when needed.`;
+
+/**
+ * Sections to extract from template-v2/CLAUDE.md.
+ * These define Claudia's personality. Developer/Claude-Code-specific sections are excluded.
+ */
+const CLAUDE_MD_SECTIONS = [
+  'Who I Am',
+  'Primary Mission: Higher-Level Thinking',
+  'How I Carry Myself',
+  'Core Behaviors',
+  'What I Don\'t Do',
+  'What Stays Human Judgment',
+];
+
+/**
+ * Principles to include from claudia-principles.md (by number prefix).
+ * Excludes 11 (Output Formatting), 12 (Source Preservation), 13 (Multi-Source).
+ */
+const INCLUDED_PRINCIPLES = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+// Cached result
+let _cachedPersonality = null;
+let _cachedDir = null;
+
+/**
+ * Extract a markdown section by heading text.
+ * Returns everything from the heading line to the next heading of equal or higher level,
+ * or to end-of-file.
+ *
+ * @param {string} markdown - Full markdown text
+ * @param {string} heading - Heading text to find (without ## prefix)
+ * @returns {string|null} Section content including the heading, or null if not found
+ */
+export function extractSection(markdown, heading) {
+  const lines = markdown.split('\n');
+  let startIdx = -1;
+  let startLevel = 0;
+
+  // Find the heading line
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(/^(#{1,6})\s+(.+)/);
+    if (match && match[2].trim() === heading) {
+      startIdx = i;
+      startLevel = match[1].length;
+      break;
+    }
+  }
+
+  if (startIdx === -1) return null;
+
+  // Find the end: next heading of same or higher level
+  let endIdx = lines.length;
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const match = lines[i].match(/^(#{1,6})\s+/);
+    if (match && match[1].length <= startLevel) {
+      endIdx = i;
+      break;
+    }
+  }
+
+  return lines.slice(startIdx, endIdx).join('\n').trim();
+}
+
+/**
+ * Extract numbered principles from claudia-principles.md.
+ *
+ * @param {string} markdown - Full principles markdown
+ * @param {number[]} numbers - Principle numbers to include
+ * @returns {string} Extracted principles joined together
+ */
+export function extractPrinciples(markdown, numbers) {
+  const sections = [];
+
+  for (const num of numbers) {
+    // Match "## N." or "## N. Title"
+    const pattern = new RegExp(`^## ${num}\\.\\s`, 'm');
+    const match = markdown.match(pattern);
+    if (!match) continue;
+
+    const startPos = match.index;
+    const afterStart = markdown.indexOf('\n', startPos);
+    if (afterStart === -1) continue;
+
+    // Find the heading line to get its text
+    const headingLine = markdown.slice(startPos, afterStart);
+
+    // Find the next ## heading
+    const rest = markdown.slice(afterStart + 1);
+    const nextHeading = rest.match(/^## \d+\./m);
+    const nextSeparator = rest.match(/^---$/m);
+
+    let endPos;
+    if (nextHeading && nextSeparator) {
+      endPos = afterStart + 1 + Math.min(nextHeading.index, nextSeparator.index);
+    } else if (nextHeading) {
+      endPos = afterStart + 1 + nextHeading.index;
+    } else if (nextSeparator) {
+      endPos = afterStart + 1 + nextSeparator.index;
+    } else {
+      endPos = markdown.length;
+    }
+
+    sections.push(markdown.slice(startPos, endPos).trim());
+  }
+
+  return sections.join('\n\n');
+}
+
+/**
+ * Build the personality prompt from template directory.
+ *
+ * @param {string} templateDir - Path to template-v2/ directory
+ * @param {number} maxChars - Maximum character limit for the prompt
+ * @returns {string|null} Assembled personality prompt, or null if files not found
+ */
+export function buildPersonalityFromDir(templateDir, maxChars = 15000) {
+  const claudeMdPath = join(templateDir, 'CLAUDE.md');
+  const principlesPath = join(templateDir, '.claude', 'rules', 'claudia-principles.md');
+
+  if (!existsSync(claudeMdPath)) {
+    log.debug('CLAUDE.md not found', { path: claudeMdPath });
+    return null;
+  }
+
+  const parts = [GATEWAY_PREAMBLE, ''];
+
+  // Extract CLAUDE.md sections
+  try {
+    const claudeMd = readFileSync(claudeMdPath, 'utf8');
+    for (const heading of CLAUDE_MD_SECTIONS) {
+      const section = extractSection(claudeMd, heading);
+      if (section) {
+        parts.push(section);
+        parts.push('');
+      }
+    }
+  } catch (err) {
+    log.warn('Failed to read CLAUDE.md', { error: err.message });
+    return null;
+  }
+
+  // Extract principles
+  if (existsSync(principlesPath)) {
+    try {
+      const principlesMd = readFileSync(principlesPath, 'utf8');
+      const extracted = extractPrinciples(principlesMd, INCLUDED_PRINCIPLES);
+      if (extracted) {
+        parts.push('# Core Principles\n');
+        parts.push(extracted);
+      }
+    } catch (err) {
+      log.debug('Failed to read principles', { error: err.message });
+    }
+  }
+
+  let result = parts.join('\n');
+
+  // Enforce size limit
+  if (result.length > maxChars) {
+    log.info('Personality prompt truncated', { original: result.length, limit: maxChars });
+    result = result.slice(0, maxChars);
+    // Cut at last complete line
+    const lastNewline = result.lastIndexOf('\n');
+    if (lastNewline > maxChars * 0.8) {
+      result = result.slice(0, lastNewline);
+    }
+    result += '\n\n[Personality truncated for size]';
+  }
+
+  return result;
+}
+
+/**
+ * Resolve the template directory using the config resolution chain.
+ *
+ * @param {Object} config - Gateway config
+ * @returns {string|null} Resolved template directory path, or null
+ */
+export function resolveTemplateDir(config) {
+  // 1. Explicit personalityDir
+  if (config.personalityDir) {
+    if (existsSync(join(config.personalityDir, 'CLAUDE.md'))) {
+      return config.personalityDir;
+    }
+    log.warn('personalityDir set but CLAUDE.md not found', { dir: config.personalityDir });
+  }
+
+  // 2. Auto-detect relative to gateway (dev mode): gateway/../template-v2/
+  const devPath = join(__dirname, '..', '..', 'template-v2');
+  if (existsSync(join(devPath, 'CLAUDE.md'))) {
+    return devPath;
+  }
+
+  return null;
+}
+
+/**
+ * Load the Claudia personality for the gateway.
+ * Uses caching to avoid re-reading files on every message.
+ *
+ * @param {Object} config - Gateway config
+ * @returns {string|null} Personality prompt, or null (use fallback)
+ */
+export function loadPersonality(config) {
+  const templateDir = resolveTemplateDir(config);
+
+  // Cache hit: same directory, return cached
+  if (_cachedPersonality && _cachedDir === templateDir) {
+    return _cachedPersonality;
+  }
+
+  if (!templateDir) {
+    _cachedPersonality = null;
+    _cachedDir = null;
+    return null;
+  }
+
+  const personality = buildPersonalityFromDir(templateDir, config.personalityMaxChars || 15000);
+
+  if (personality) {
+    _cachedPersonality = personality;
+    _cachedDir = templateDir;
+    const sectionCount = CLAUDE_MD_SECTIONS.length;
+    log.info('Loaded Claudia personality', {
+      dir: templateDir,
+      chars: personality.length,
+      sections: sectionCount,
+    });
+  }
+
+  return personality;
+}
+
+/**
+ * Clear the personality cache. Useful for testing.
+ */
+export function clearCache() {
+  _cachedPersonality = null;
+  _cachedDir = null;
+}

package/gateway/tests/bridge-model.test.js

@@ -0,0 +1,98 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { Bridge } from '../src/bridge.js';
+
+describe('Bridge._resolveModel', () => {
+  it('uses per-channel model when set', () => {
+    const bridge = new Bridge({
+      model: 'claude-sonnet-4-20250514',
+      channels: {
+        telegram: { model: 'claude-haiku-4-5-20251001' },
+        slack: { model: '' },
+      },
+    });
+    bridge.provider = 'anthropic';
+
+    assert.equal(bridge._resolveModel('telegram'), 'claude-haiku-4-5-20251001');
+  });
+
+  it('falls back to global Anthropic model for channel with empty model', () => {
+    const bridge = new Bridge({
+      model: 'claude-sonnet-4-20250514',
+      channels: {
+        telegram: { model: '' },
+      },
+    });
+    bridge.provider = 'anthropic';
+
+    assert.equal(bridge._resolveModel('telegram'), 'claude-sonnet-4-20250514');
+  });
+
+  it('falls back to global model for unknown channel', () => {
+    const bridge = new Bridge({
+      model: 'claude-sonnet-4-20250514',
+      channels: {
+        telegram: { model: 'claude-haiku-4-5-20251001' },
+      },
+    });
+    bridge.provider = 'anthropic';
+
+    assert.equal(bridge._resolveModel('discord'), 'claude-sonnet-4-20250514');
+  });
+
+  it('resolves Ollama model with per-channel override', () => {
+    const bridge = new Bridge({
+      model: 'claude-sonnet-4-20250514',
+      ollama: { model: 'qwen3:4b' },
+      channels: {
+        telegram: { model: 'llama3:8b' },
+      },
+    });
+    bridge.provider = 'ollama';
+
+    assert.equal(bridge._resolveModel('telegram'), 'llama3:8b');
+  });
+
+  it('falls back to Ollama global model when channel has no override', () => {
+    const bridge = new Bridge({
+      model: 'claude-sonnet-4-20250514',
+      ollama: { model: 'qwen3:4b' },
+      channels: {
+        telegram: { model: '' },
+      },
+    });
+    bridge.provider = 'ollama';
+
+    assert.equal(bridge._resolveModel('telegram'), 'qwen3:4b');
+  });
+});
+
+describe('Bridge._buildSystemPrompt', () => {
+  it('uses loaded personality when available', () => {
+    const bridge = new Bridge({ channels: {} });
+    bridge._personality = 'You are Claudia, the real deal.';
+
+    const prompt = bridge._buildSystemPrompt('', 'Kamil', 'telegram');
+    assert.ok(prompt.startsWith('You are Claudia, the real deal.'));
+    assert.ok(prompt.includes('Channel: telegram'));
+    assert.ok(prompt.includes('User: Kamil'));
+  });
+
+  it('falls back to DEFAULT_SYSTEM_PROMPT when no personality', () => {
+    const bridge = new Bridge({ channels: {} });
+    bridge._personality = null;
+
+    const prompt = bridge._buildSystemPrompt('', 'Kamil', 'telegram');
+    assert.ok(prompt.includes('warm, sharp, and proactive'));
+    assert.ok(prompt.includes('Channel: telegram'));
+  });
+
+  it('includes memory context when provided', () => {
+    const bridge = new Bridge({ channels: {} });
+    bridge._personality = 'Claudia personality';
+
+    const prompt = bridge._buildSystemPrompt('## Relevant Memories\n- User likes coffee', 'Kamil', 'telegram');
+    assert.ok(prompt.includes('# Memory Context'));
+    assert.ok(prompt.includes('User likes coffee'));
+  });
+});