obol-ai 0.3.2 → 0.3.4

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.3.3
+- update changelog
+- improve memory retrieval quality: tighter dedup, wider window, recency boost, self-memory, jaccard dedup
+- remove trait system entirely
+
 ## 0.3.2
 - update changelog
 - add list_pending_events tool to dispatch and humor passes to prevent duplicates

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obol-ai",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Self-evolving AI assistant that learns, remembers, and acts on its own. Persistent vector memory, self-rewriting personality, proactive heartbeats.",
   "main": "src/index.js",
   "bin": {

package/src/claude/chat.js

@@ -83,6 +83,7 @@ function createClaude(anthropicConfig, { personality, memory, selfMemory, userDi
         onRouteDecision: context._onRouteDecision,
         onRouteUpdate: context._onRouteUpdate,
         recentHistory: history,
+        selfMemory,
       });
       memoryBlock = result.memoryBlock;
       if (result.model) context._model = result.model;
@@ -174,11 +175,14 @@ function createClaude(anthropicConfig, { personality, memory, selfMemory, userDi
       cachedTools[lastIdx] = { ...lastDef, cache_control: { type: 'ephemeral' }, run };
     }
 
+    const assembledMessages = withCacheBreakpoints(withRuntimeContext([...history]));
+    context._onPromptReady?.({ system: systemPrompt, messages: assembledMessages, model: activeModel, tools: cachedTools });
+
     const runner = client.beta.messages.toolRunner({
       model: activeModel,
       max_tokens: 128000,
       system: systemPrompt,
-      messages: withCacheBreakpoints(withRuntimeContext([...history])),
+      messages: assembledMessages,
       tools: cachedTools ?? undefined,
       max_iterations: getMaxToolIterations(),
       stream: true,
@@ -263,8 +267,9 @@ function createClaude(anthropicConfig, { personality, memory, selfMemory, userDi
   }
 
   function reloadPersonality() {
+    const { PERSONALITY_DIR } = require('../soul');
     const pDir = userDir ? path.join(userDir, 'personality') : undefined;
-    const newPersonality = require('../personality').loadPersonality(pDir);
+    const newPersonality = require('../personality').loadPersonality(PERSONALITY_DIR, pDir);
     for (const key of Object.keys(personality)) delete personality[key];
     Object.assign(personality, newPersonality);
     baseSystemPrompt = buildSystemPrompt(personality, userDir, { bridgeEnabled, botName });

package/src/claude/prompt.js

@@ -15,25 +15,6 @@ You serve multiple people — partners, friends, people who know each other. You
     parts.push(`\n## Personality\nYou are a fresh instance. Be helpful, direct, and naturally curious. Pay attention to how your owner communicates and adapt. Your personality will develop through conversation and periodic evolution.`);
   }
 
-  if (personality.traits) {
-    const t = personality.traits;
-    const descriptions = {
-      humor: [0, 'suppress all wit', 50, 'balanced wit', 100, 'lean heavily into jokes and playfulness'],
-      honesty: [0, 'maximize diplomatic softening', 50, 'balanced honesty', 100, 'lean toward blunt truth'],
-      directness: [0, 'elaborate context and preamble', 50, 'balanced', 100, 'get straight to the point'],
-      curiosity: [0, 'only answer what is asked', 50, 'balanced', 100, 'proactively explore and ask follow-ups'],
-      empathy: [0, 'purely task-focused', 50, 'balanced', 100, 'deeply emotionally attuned'],
-      creativity: [0, 'stick to proven patterns', 50, 'balanced', 100, 'favor novel approaches'],
-    };
-    const lines = Object.entries(t).map(([trait, val]) => {
-      const desc = descriptions[trait];
-      if (!desc) return null;
-      const label = val <= 30 ? desc[1] : val <= 70 ? desc[3] : desc[5];
-      return `- ${trait.charAt(0).toUpperCase() + trait.slice(1)}: ${val} — ${label}`;
-    }).filter(Boolean);
-    parts.push(`\n## Personality Calibration\n\nThese values (0-100) define your behavioral tendencies:\n${lines.join('\n')}\n\nInterpret these as a spectrum: 0 = suppress entirely, 50 = balanced, 100 = lean heavily into it.`);
-  }
-
   if (personality.user) {
     parts.push(`\n## About This User\n${personality.user}`);
   } else {

package/src/claude/router.js

@@ -1,22 +1,34 @@
-async function routeMessage(client, memory, userMessage, { vlog, onRouteDecision, onRouteUpdate, recentHistory = [] }) {
+function buildRouterMessages(recentHistory, userMessage) {
+  const context = recentHistory.slice(-20).map(m => ({
+    role: m.role,
+    content: typeof m.content === 'string'
+      ? m.content.substring(0, 500)
+      : m.content.filter(b => b.type === 'text').map(b => b.text).join('').substring(0, 500),
+  })).filter(m => m.content);
+
+  const firstUserIdx = context.findIndex(m => m.role === 'user');
+  const trimmed = firstUserIdx > 0 ? context.slice(firstUserIdx) : context;
+
+  return [...trimmed, { role: 'user', content: userMessage }];
+}
+
+function jaccardSim(a, b) {
+  const words = s => new Set(s.toLowerCase().split(/\W+/).filter(Boolean));
+  const setA = words(a), setB = words(b);
+  let inter = 0;
+  for (const w of setA) if (setB.has(w)) inter++;
+  return inter / (setA.size + setB.size - inter);
+}
+
+async function routeMessage(client, memory, userMessage, { vlog, onRouteDecision, onRouteUpdate, recentHistory = [], selfMemory = null }) {
   let memoryBlock = null;
   let model = null;
 
   try {
-    const lastAssistantMsgs = recentHistory
-      .filter(m => m.role === 'assistant')
-      .slice(-3)
-      .map(m => typeof m.content === 'string' ? m.content : m.content.filter(b => b.type === 'text').map(b => b.text).join(''))
-      .filter(Boolean);
-
-    const contextNote = lastAssistantMsgs.length > 0
-      ? `\n\nRecent assistant context (last ${lastAssistantMsgs.length} turns):\n${lastAssistantMsgs.map((t, i) => `[${i + 1}] ${t.substring(0, 300)}`).join('\n')}`
-      : '';
-
     const routerDecision = await client.messages.create({
       model: 'claude-haiku-4-5',
       max_tokens: 200,
-      system: `You are a router. Analyze this user message and decide:
+      system: `You are a router. Analyze the conversation and decide:
 
 1. Does it need memory context? (past conversations, facts, preferences, people, events)
 2. What model complexity does it need?
@@ -24,14 +36,14 @@ async function routeMessage(client, memory, userMessage, { vlog, onRouteDecision
 Reply with ONLY a JSON object:
 {"need_memory": true/false, "search_queries": ["query1", "query2"], "model": "haiku|sonnet|opus"}
 
-search_queries: 1-3 optimized search queries covering different topics in the message. One query per distinct topic/entity. Single-topic messages need just one query.
+search_queries: 1-5 optimized search queries based on the full conversation context. Cover distinct topics, people, entities, time periods, or projects referenced. Single-topic messages need just one query. Use more queries when the message references multiple people, projects, or threads.
 
 Memory: casual messages (greetings, jokes, simple questions) → false. References to past, people, projects, preferences → true.
 
 Model: Default to "sonnet". Use "haiku" for: greetings, brief acknowledgments (thanks/ok/bye), casual chitchat, quick yes/no questions, and short single-turn exchanges that don't need any tool calling. Use "sonnet" for: code generation, data analysis, content creation, explanations, creative writing, agentic tool use, general questions, opinions, advice, and most conversational exchanges with substance. Use "opus" for: professional software engineering tasks, advanced multi-step agent work, complex reasoning, scientific or mathematical problems, tasks requiring nuanced understanding, advanced coding challenges, in-depth research, and architecture or design decisions.
 
-If recent context shows an ongoing task (sonnet/opus was just used, multi-step work in progress), bias toward that model even for short follow-up messages.${contextNote}`,
-      messages: [{ role: 'user', content: userMessage }],
+If recent context shows an ongoing task (sonnet/opus was just used, multi-step work in progress), bias toward that model even for short follow-up messages.`,
+      messages: buildRouterMessages(recentHistory, userMessage),
     });
 
     const decisionText = routerDecision.content[0]?.text || '';
@@ -61,12 +73,13 @@ If recent context shows an ongoing task (sonnet/opus was just used, multi-step w
 
     if (decision.need_memory && memory) {
       const budget = decision.model === 'opus' ? 40 : decision.model === 'haiku' ? 15 : 25;
+      const poolPerQuery = decision.model === 'opus' ? 20 : decision.model === 'haiku' ? 10 : 15;
       const searchQueries = queries.length > 0 ? queries : [userMessage];
 
-      const recentMemories = await memory.byDate('2d', { limit: Math.ceil(budget / 3) });
+      const recentMemories = await memory.byDate('7d', { limit: Math.ceil(budget / 3) });
 
       const semanticResults = await Promise.all(
-        searchQueries.map(q => memory.search(q, { limit: Math.ceil(budget / searchQueries.length), threshold: 0.4 }))
+        searchQueries.map(q => memory.search(q, { limit: poolPerQuery, threshold: 0.4 }))
       );
       const semanticMemories = semanticResults.flat();
 
@@ -75,14 +88,21 @@ If recent context shows an ongoing task (sonnet/opus was just used, multi-step w
       for (const m of [...recentMemories, ...semanticMemories]) {
         if (!seen.has(m.id)) {
           seen.add(m.id);
-          const recencyBonus = m.created_at ? Math.max(0, 1 - (Date.now() - new Date(m.created_at).getTime()) / (7 * 86400000)) * 0.15 : 0;
-          m._score = (m.similarity || 0.5) * 0.6 + (m.importance || 0.5) * 0.25 + recencyBonus;
+          const ageDays = m.created_at ? (Date.now() - new Date(m.created_at).getTime()) / 86400000 : 7;
+          const recencyBonus = Math.max(0, 1 - ageDays / 7) * 0.3;
+          m._score = (m.similarity || 0.5) * 0.5 + (m.importance || 0.5) * 0.2 + recencyBonus;
           combined.push(m);
         }
       }
 
       combined.sort((a, b) => b._score - a._score);
-      const topFacts = combined.slice(0, budget);
+
+      const topFacts = [];
+      for (const m of combined) {
+        if (topFacts.length >= budget) break;
+        const isDup = topFacts.some(kept => jaccardSim(kept.content, m.content) > 0.7);
+        if (!isDup) topFacts.push(m);
+      }
 
       vlog(`[memory] ${topFacts.length} facts (${recentMemories.length} recent, ${semanticMemories.length} semantic, budget=${budget})`);
       onRouteUpdate?.({ memoryCount: topFacts.length });
@@ -94,6 +114,22 @@ If recent context shows an ongoing task (sonnet/opus was just used, multi-step w
         });
         memoryBlock = `## Relevant memories\n${lines.join('\n')}`;
       }
+
+      if (selfMemory) {
+        const selfResults = await Promise.all(
+          searchQueries.map(q => selfMemory.search(q, { limit: 5, threshold: 0.4 }))
+        );
+        const seen2 = new Set();
+        const topSelf = [];
+        for (const m of selfResults.flat()) {
+          if (!seen2.has(m.id)) { seen2.add(m.id); topSelf.push(m); }
+        }
+        if (topSelf.length > 0) {
+          const selfLines = topSelf.slice(0, 8).map(m => `- [${m.category}] ${m.content}`);
+          memoryBlock = (memoryBlock || '') + `\n\n## Self-knowledge\n${selfLines.join('\n')}`;
+          vlog(`[memory] +${topSelf.length} self-memory facts`);
+        }
+      }
     }
   } catch (e) {
     console.error('[router] Memory/routing decision failed:', e.message);

package/src/claude/tools/files.js

@@ -96,7 +96,10 @@ const definitions = [
 const handlers = {
   async read_file(input, memory, context) {
     const { userDir } = context;
-    const filePath = userDir ? resolveUserPath(input.path, userDir) : input.path;
+    const { PERSONALITY_DIR } = require('../../soul');
+    const filePath = path.basename(input.path) === 'SOUL.md'
+      ? path.join(PERSONALITY_DIR, 'SOUL.md')
+      : (userDir ? resolveUserPath(input.path, userDir) : input.path);
     if (filePath.toLowerCase().endsWith('.pdf')) {
       const pdfParse = require('pdf-parse');
       const { text } = await pdfParse(fs.readFileSync(filePath));
@@ -119,25 +122,36 @@ const handlers = {
 
   async write_file(input, memory, context) {
     const { userDir } = context;
-    const filePath = userDir ? resolveUserPath(input.path, userDir) : input.path;
+    const { PERSONALITY_DIR, backup } = require('../../soul');
+    const isSoul = path.basename(input.path) === 'SOUL.md';
+    const filePath = isSoul ? path.join(PERSONALITY_DIR, 'SOUL.md') : (userDir ? resolveUserPath(input.path, userDir) : input.path);
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     fs.writeFileSync(filePath, input.content);
-    if (path.basename(filePath) === 'traits.json' || filePath.includes('personality/')) {
+    if (filePath.includes('personality/')) {
       context._reloadPersonality?.();
+      if (isSoul && context.config?.supabase) {
+        backup(context.config.supabase, 'soul', input.content).catch(() => {});
+      }
     }
     return `Written: ${filePath}`;
   },
 
   async edit_file(input, memory, context) {
     const { userDir } = context;
-    const filePath = userDir ? resolveUserPath(input.path, userDir) : input.path;
+    const { PERSONALITY_DIR, backup } = require('../../soul');
+    const isSoul = path.basename(input.path) === 'SOUL.md';
+    const filePath = isSoul ? path.join(PERSONALITY_DIR, 'SOUL.md') : (userDir ? resolveUserPath(input.path, userDir) : input.path);
     const content = fs.readFileSync(filePath, 'utf-8');
     const count = content.split(input.old_string).length - 1;
     if (count === 0) return `Error: old_string not found in ${input.path}`;
     if (count > 1) return `Error: old_string matches ${count} times — add more context to make it unique`;
-    fs.writeFileSync(filePath, content.replace(input.old_string, input.new_string));
-    if (path.basename(filePath) === 'traits.json' || filePath.includes('personality/')) {
+    const updated = content.replace(input.old_string, input.new_string);
+    fs.writeFileSync(filePath, updated);
+    if (filePath.includes('personality/')) {
       context._reloadPersonality?.();
+      if (isSoul && context.config?.supabase) {
+        backup(context.config.supabase, 'soul', updated).catch(() => {});
+      }
     }
     return `Edited: ${filePath}`;
   },

package/src/clean.js

@@ -19,7 +19,7 @@ const ASSET_EXTS = new Set(['.jpg', '.jpeg', '.png', '.gif', '.webp', '.svg', '.
 
 // Dirs where only .md files are allowed (with per-dir exceptions)
 const MD_ONLY_DIRS = new Set(['personality', 'commands']);
-const MD_DIR_EXCEPTIONS = { personality: new Set(['traits.json']) };
+const MD_DIR_EXCEPTIONS = {};
 
 function safeReaddir(dir) {
   try {

package/src/cli/config.js

@@ -353,38 +353,40 @@ async function runOAuthFlow(cfg) {
 }
 
 function updatePersonalityNames(oldBotName, newBotName, oldOwnerName, newOwnerName) {
+  const { PERSONALITY_DIR } = require('../soul');
+
+  if (oldBotName !== newBotName) {
+    const soulPath = path.join(PERSONALITY_DIR, 'SOUL.md');
+    if (fs.existsSync(soulPath)) {
+      let content = fs.readFileSync(soulPath, 'utf-8');
+      content = content.replace(new RegExp(`# SOUL\\.md — Who is ${oldBotName}\\?`, 'g'), `# SOUL.md — Who is ${newBotName}?`);
+      content = content.replace(new RegExp(`\\*\\*Name:\\*\\* ${oldBotName}`, 'g'), `**Name:** ${newBotName}`);
+      fs.writeFileSync(soulPath, content, 'utf-8');
+    }
+  }
+
+  if (oldOwnerName !== newOwnerName) {
+    const soulPath = path.join(PERSONALITY_DIR, 'SOUL.md');
+    if (fs.existsSync(soulPath)) {
+      let content = fs.readFileSync(soulPath, 'utf-8');
+      content = content.replace(new RegExp(`\\*\\*Created by:\\*\\* ${oldOwnerName}`, 'g'), `**Created by:** ${newOwnerName}`);
+      fs.writeFileSync(soulPath, content, 'utf-8');
+    }
+  }
+
   if (!fs.existsSync(USERS_DIR)) return;
   const users = fs.readdirSync(USERS_DIR).filter(u => {
     try { return fs.statSync(path.join(USERS_DIR, u)).isDirectory(); } catch { return false; }
   });
   for (const userId of users) {
-    const personalityDir = path.join(USERS_DIR, userId, 'personality');
-    if (!fs.existsSync(personalityDir)) continue;
-
     if (oldBotName !== newBotName) {
-      const soulPath = path.join(personalityDir, 'SOUL.md');
-      if (fs.existsSync(soulPath)) {
-        let content = fs.readFileSync(soulPath, 'utf-8');
-        content = content.replace(new RegExp(`# SOUL\\.md — Who is ${oldBotName}\\?`, 'g'), `# SOUL.md — Who is ${newBotName}?`);
-        content = content.replace(new RegExp(`\\*\\*Name:\\*\\* ${oldBotName}`, 'g'), `**Name:** ${newBotName}`);
-        fs.writeFileSync(soulPath, content, 'utf-8');
-      }
-      const agentsPath = path.join(personalityDir, 'AGENTS.md');
+      const agentsPath = path.join(USERS_DIR, userId, 'personality', 'AGENTS.md');
       if (fs.existsSync(agentsPath)) {
         let content = fs.readFileSync(agentsPath, 'utf-8');
         content = content.replace(new RegExp(`# AGENTS\\.md — How ${oldBotName} Works`, 'g'), `# AGENTS.md — How ${newBotName} Works`);
         fs.writeFileSync(agentsPath, content, 'utf-8');
       }
     }
-
-    if (oldOwnerName !== newOwnerName) {
-      const soulPath = path.join(personalityDir, 'SOUL.md');
-      if (fs.existsSync(soulPath)) {
-        let content = fs.readFileSync(soulPath, 'utf-8');
-        content = content.replace(new RegExp(`\\*\\*Created by:\\*\\* ${oldOwnerName}`, 'g'), `**Created by:** ${newOwnerName}`);
-        fs.writeFileSync(soulPath, content, 'utf-8');
-      }
-    }
   }
 }
 

package/src/cli/init.js

@@ -752,13 +752,12 @@ function ensureDirs() {
 }
 
 function createPersonalityFiles(config) {
-  for (const userId of config.telegram.allowedUsers) {
-    const ownerName = config.users?.[String(userId)]?.name || config.owner.name;
-    const personalityDir = path.join(OBOL_DIR, 'users', String(userId), 'personality');
-    fs.mkdirSync(personalityDir, { recursive: true });
+  const { PERSONALITY_DIR } = require('../soul');
+  fs.mkdirSync(PERSONALITY_DIR, { recursive: true });
+  const ownerName = config.users?.[String(config.telegram.allowedUsers[0])]?.name || config.owner.name;
 
-    if (!fs.existsSync(path.join(personalityDir, 'SOUL.md'))) {
-      fs.writeFileSync(path.join(personalityDir, 'SOUL.md'), `# SOUL.md — Who is ${config.bot.name}?
+  if (!fs.existsSync(path.join(PERSONALITY_DIR, 'SOUL.md'))) {
+    fs.writeFileSync(path.join(PERSONALITY_DIR, 'SOUL.md'), `# SOUL.md — Who is ${config.bot.name}?
 
 Write your bot's personality here. This shapes how it talks, thinks, and behaves.
 
@@ -781,7 +780,13 @@ Write your bot's personality here. This shapes how it talks, thinks, and behaves
 ---
 *Edit this file anytime to reshape your bot's personality.*
 `);
-    }
+  }
+
+  for (const userId of config.telegram.allowedUsers) {
+    const ownerName = config.users?.[String(userId)]?.name || config.owner.name;
+    const personalityDir = path.join(OBOL_DIR, 'users', String(userId), 'personality');
+    fs.mkdirSync(personalityDir, { recursive: true });
+
     if (!fs.existsSync(path.join(personalityDir, 'USER.md'))) {
       fs.writeFileSync(path.join(personalityDir, 'USER.md'), `# USER.md — About ${ownerName}
 

package/src/cli/prompt-debug.js

@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+
+/**
+ * Full production chat flow in the CLI — router, memory injection, tools, response.
+ * Usage: node src/cli/prompt-debug.js [options]
+ *   -u, --user <id>      Telegram user ID (default: 206639616)
+ *   -m, --message <text> Message to send through the full production pipeline
+ *   -l, --limit <n>      History messages to load (default: 20)
+ *   --log                Write exchange to obol_messages (default: off)
+ *   --no-system          Skip printing the system prompt in inspect mode
+ */
+
+const path = require('path');
+const { loadConfig, getUserDir } = require('../config');
+const { PERSONALITY_DIR } = require('../soul');
+const { loadPersonality } = require('../personality');
+const { buildSystemPrompt } = require('../claude/prompt');
+const { createAnthropicClient } = require('../claude/client');
+const { createMemory } = require('../memory');
+const { createSelfMemory } = require('../memory-self');
+const { createClaude } = require('../claude');
+const { createMessageLog } = require('../messages');
+const { BackgroundRunner } = require('../background');
+
+const DEFAULT_USER_ID = 206639616;
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const opts = { userId: DEFAULT_USER_ID, message: null, limit: 20, log: false, showSystem: true };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if ((a === '-u' || a === '--user') && args[i + 1]) opts.userId = parseInt(args[++i]);
+    else if ((a === '-m' || a === '--message') && args[i + 1]) opts.message = args[++i];
+    else if ((a === '-l' || a === '--limit') && args[i + 1]) opts.limit = parseInt(args[++i]);
+    else if (a === '--log') opts.log = true;
+    else if (a === '--no-system') opts.showSystem = false;
+  }
+  return opts;
+}
+
+function makeSupabaseHeaders(supabase) {
+  return {
+    'apikey': supabase.serviceKey,
+    'Authorization': `Bearer ${supabase.serviceKey}`,
+    'Content-Type': 'application/json',
+  };
+}
+
+async function fetchMessages(supabase, chatId, limit) {
+  const headers = makeSupabaseHeaders(supabase);
+  const res = await fetch(
+    `${supabase.url}/rest/v1/obol_messages?chat_id=eq.${chatId}&order=created_at.desc&limit=${limit}&select=role,content,created_at,model`,
+    { headers }
+  );
+  if (!res.ok) throw new Error(`messages fetch failed: HTTP ${res.status}`);
+  return (await res.json()).reverse();
+}
+
+function hr(char = '─', width = 80) { return char.repeat(width); }
+
+function label(text) {
+  console.log(`\n\x1b[33m\x1b[1m${text}\x1b[0m`);
+  console.log(hr());
+}
+
+function formatRole(role) {
+  if (role === 'user') return '\x1b[36mUSER\x1b[0m';
+  if (role === 'assistant') return '\x1b[32mASSISTANT\x1b[0m';
+  return role.toUpperCase();
+}
+
+function truncate(str, max = 500) {
+  if (!str) return '';
+  if (str.length <= max) return str;
+  return str.slice(0, max) + `\x1b[2m... [+${str.length - max} chars]\x1b[0m`;
+}
+
+function printFullPrompt(params) {
+  label(`FULL PROMPT → SYSTEM  \x1b[2m[${params.model || '?'}]\x1b[0m`);
+  for (const block of (params.system || [])) {
+    const cached = block.cache_control ? ' \x1b[2m[ephemeral]\x1b[0m' : '';
+    console.log(`${truncate(block.text, 800)}${cached}`);
+    console.log(hr('·'));
+  }
+
+  if (params.tools?.length) {
+    label(`FULL PROMPT → TOOLS [${params.tools.length}]`);
+    for (const tool of params.tools) {
+      const cached = tool.cache_control ? ' \x1b[2m[ephemeral]\x1b[0m' : '';
+      const desc = tool.description ? `  \x1b[2m${truncate(tool.description, 100)}\x1b[0m` : '';
+      console.log(`  \x1b[35m${tool.name}\x1b[0m${cached}${desc}`);
+    }
+  }
+
+  label(`FULL PROMPT → MESSAGES [${params.messages.length}]`);
+  for (let i = 0; i < params.messages.length; i++) {
+    const msg = params.messages[i];
+    console.log(`\n\x1b[1m[${i + 1}/${params.messages.length}] ${formatRole(msg.role)}\x1b[0m`);
+    const blocks = typeof msg.content === 'string'
+      ? [{ type: 'text', text: msg.content }]
+      : msg.content;
+    for (const block of blocks) {
+      if (block.type === 'text') {
+        if (block.text.startsWith('[Runtime context')) {
+          console.log(`\x1b[2m── runtime metadata ──\x1b[0m`);
+        } else if (block.text.startsWith('Current time:')) {
+          console.log(`\x1b[2m${block.text}\x1b[0m`);
+        } else if (block.text.includes('## Relevant memories') || block.text.includes('## Self-knowledge')) {
+          console.log(`\x1b[33m${block.text}\x1b[0m`);
+        } else {
+          console.log(truncate(block.text, 1000));
+        }
+      } else if (block.type === 'tool_use') {
+        console.log(`\x1b[35m[tool_use: ${block.name}]\x1b[0m ${truncate(JSON.stringify(block.input), 200)}`);
+      } else if (block.type === 'tool_result') {
+        const content = Array.isArray(block.content)
+          ? block.content.map(b => b.text || '').join('')
+          : String(block.content || '');
+        console.log(`\x1b[35m[tool_result: ${block.tool_use_id}]\x1b[0m ${truncate(content, 200)}`);
+      }
+    }
+  }
+  console.log('');
+}
+
+async function runInspect(opts, config) {
+  const userDir = getUserDir(opts.userId);
+  const personality = loadPersonality(PERSONALITY_DIR, path.join(userDir, 'personality'));
+
+  console.log('\x1b[1m' + hr('═') + '\x1b[0m');
+  console.log(`\x1b[1m  INSPECT — user ${opts.userId}\x1b[0m`);
+  console.log('\x1b[1m' + hr('═') + '\x1b[0m');
+
+  if (opts.showSystem) {
+    label('SYSTEM PROMPT');
+    console.log(buildSystemPrompt(personality, userDir, { botName: config.bot?.name }));
+  }
+
+  const messages = await fetchMessages(config.supabase, opts.userId, opts.limit);
+  label(`CONVERSATION HISTORY — ${messages.length} messages`);
+  if (messages.length === 0) {
+    console.log('  (none)');
+  } else {
+    for (const msg of messages) {
+      const model = msg.model ? ` \x1b[2m[${msg.model}]\x1b[0m` : '';
+      console.log(`\n${formatRole(msg.role)}${model}  \x1b[2m${new Date(msg.created_at).toLocaleString()}\x1b[0m`);
+      console.log(truncate(msg.content));
+    }
+  }
+
+  const recentLimit = Math.ceil(25 / 3);
+  label(`RECENT MEMORY — ${recentLimit} entries \x1b[2m(budget/3, sonnet)\x1b[0m`);
+  const memHeaders = makeSupabaseHeaders(config.supabase);
+  const memRes = await fetch(
+    `${config.supabase.url}/rest/v1/obol_memory?user_id=eq.${opts.userId}&order=created_at.desc&limit=${recentLimit}&select=content,category,importance,tags,created_at`,
+    { headers: memHeaders }
+  );
+  const memories = await memRes.json();
+  if (!memories.length) {
+    console.log('  (none)');
+  } else {
+    for (const m of memories) {
+      const tags = m.tags?.length ? `  \x1b[2m[${m.tags.join(', ')}]\x1b[0m` : '';
+      console.log(`\x1b[2m${new Date(m.created_at).toLocaleString()}\x1b[0m  \x1b[35m[${m.category}]\x1b[0m  imp=${m.importance}${tags}`);
+      console.log(`  ${m.content}`);
+    }
+  }
+
+  label('OBOL SELF MEMORY — 20 entries');
+  const selfRes = await fetch(
+    `${config.supabase.url}/rest/v1/obol_self_memory?user_id=eq.${opts.userId}&order=created_at.desc&limit=20&select=content,category,importance,tags,source,created_at`,
+    { headers: memHeaders }
+  );
+  const selfMemories = await selfRes.json();
+  if (!selfMemories.length) {
+    console.log('  (none)');
+  } else {
+    for (const m of selfMemories) {
+      const tags = m.tags?.length ? `  \x1b[2m[${m.tags.join(', ')}]\x1b[0m` : '';
+      const src = m.source ? `  \x1b[2msrc=${m.source}\x1b[0m` : '';
+      console.log(`\x1b[2m${new Date(m.created_at).toLocaleString()}\x1b[0m  \x1b[35m[${m.category}]\x1b[0m  imp=${m.importance}${tags}${src}`);
+      console.log(`  ${m.content}`);
+    }
+  }
+
+  console.log('\n\x1b[2mTip: pass -m "message" to run the full production pipeline\x1b[0m\n');
+}
+
+async function runChat(opts, config) {
+  const userId = opts.userId;
+  const userDir = getUserDir(userId);
+  const personality = loadPersonality(PERSONALITY_DIR, path.join(userDir, 'personality'));
+
+  process.stdout.write('\x1b[2mInitializing...\x1b[0m');
+  const memory = await createMemory(config.supabase, userId);
+  const selfMemory = await createSelfMemory(config.supabase, userId);
+  process.stdout.write(' done\n');
+
+  const claude = createClaude(config.anthropic, {
+    personality,
+    memory,
+    selfMemory,
+    userDir,
+    bridgeEnabled: false,
+    botName: config.bot?.name,
+  });
+
+  const messageLog = opts.log
+    ? createMessageLog(config.supabase, memory, config.anthropic, userId, userDir)
+    : null;
+
+
+  // Load history and inject
+  const rawMessages = await fetchMessages(config.supabase, userId, opts.limit);
+  const firstUserIdx = rawMessages.findIndex(m => m.role === 'user');
+  const historyMessages = firstUserIdx > 0 ? rawMessages.slice(firstUserIdx) : rawMessages;
+  for (const msg of historyMessages) {
+    claude.injectHistory(userId, msg.role, msg.content);
+  }
+
+  console.log('\n\x1b[1m' + hr('═') + '\x1b[0m');
+  console.log(`\x1b[1m  CHAT DEBUG — user ${userId}\x1b[0m`);
+  console.log('\x1b[1m' + hr('═') + '\x1b[0m');
+
+  label(`USER MESSAGE`);
+  console.log(opts.message);
+
+  label('PIPELINE');
+
+  const start = Date.now();
+  const bg = new BackgroundRunner();
+
+  const context = {
+    chatId: userId,
+    userId,
+    verbose: true,
+    bg,
+    scheduler: null,
+    toolPrefs: new Map(),
+    messageLog,
+    config,
+    _verboseNotify: (msg) => console.log(`  \x1b[2m${msg}\x1b[0m`),
+    _onRouteDecision: ({ model, needMemory }) => {
+      console.log(`  \x1b[2m[route] model=${model} memory=${needMemory}\x1b[0m`);
+    },
+    _onRouteUpdate: ({ memoryCount, model }) => {
+      if (memoryCount !== undefined) console.log(`  \x1b[2m[route] memory=${memoryCount} facts injected\x1b[0m`);
+      if (model) console.log(`  \x1b[2m[route] escalated → ${model}\x1b[0m`);
+    },
+    _onToolStart: (toolName, inputSummary) => {
+      console.log(`  \x1b[2m[tool] ${toolName}${inputSummary ? ': ' + inputSummary : ''}\x1b[0m`);
+    },
+    _onPromptReady: (params) => {
+      printFullPrompt(params);
+    },
+  };
+
+  if (messageLog) {
+    messageLog.log(userId, 'user', opts.message);
+  }
+
+  const { text: response, usage, model } = await claude.chat(opts.message, context);
+
+  const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+
+  if (messageLog) {
+    messageLog.log(userId, 'assistant', response, {
+      model,
+      tokensIn: usage?.input_tokens,
+      tokensOut: usage?.output_tokens,
+    });
+  }
+
+  const tokIn = usage?.input_tokens >= 1000
+    ? `${(usage.input_tokens / 1000).toFixed(1)}k`
+    : usage?.input_tokens ?? '?';
+  const tokOut = usage?.output_tokens >= 1000
+    ? `${(usage.output_tokens / 1000).toFixed(1)}k`
+    : usage?.output_tokens ?? '?';
+
+  label(`RESPONSE  \x1b[2m${model} | ${tokIn} in / ${tokOut} out | ${elapsed}s\x1b[0m`);
+  console.log(response ?? '(no response)');
+  console.log('\n' + hr('═') + '\n');
+
+  if (opts.log) {
+    console.log('\x1b[2mLogged to obol_messages\x1b[0m\n');
+  }
+}
+
+async function promptDebug(opts) {
+  const config = loadConfig();
+  if (!config) { console.error('No config found — run: obol init'); process.exit(1); }
+  if (!config.supabase?.url || !config.supabase?.serviceKey) { console.error('Supabase not configured'); process.exit(1); }
+
+  if (opts.message) {
+    await runChat(opts, config);
+  } else {
+    await runInspect(opts, config);
+  }
+}
+
+async function main() {
+  await promptDebug(parseArgs());
+}
+
+if (require.main === module) {
+  main().catch(e => { console.error(e.message); process.exit(1); });
+}
+
+module.exports = { promptDebug };

package/src/config.js

@@ -161,11 +161,6 @@ function ensureUserDir(userId) {
   if (fs.existsSync(defaultAgents) && !fs.existsSync(targetAgents)) {
     fs.copyFileSync(defaultAgents, targetAgents);
   }
-  const defaultTraits = path.join(__dirname, 'defaults', 'traits.json');
-  const targetTraits = path.join(dir, 'personality', 'traits.json');
-  if (fs.existsSync(defaultTraits) && !fs.existsSync(targetTraits)) {
-    fs.copyFileSync(defaultTraits, targetTraits);
-  }
   return dir;
 }
 

package/src/evolve/evolve.js

@@ -2,7 +2,6 @@ const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
 const { OBOL_DIR } = require('../config');
-const { loadTraits, saveTraits } = require('../personality');
 const { isValidNpmPackage } = require('../sanitize');
 const { loadEvolutionState, saveEvolutionState } = require('./state');
 const { readDir, syncDir } = require('./filesystem');
@@ -33,7 +32,6 @@ async function evolve(claudeClient, messageLog, memory, userDir, supabaseConfig
   const currentSoul = fs.existsSync(soulPath) ? fs.readFileSync(soulPath, 'utf-8') : '';
   const currentUser = fs.existsSync(userPath) ? fs.readFileSync(userPath, 'utf-8') : '';
   const currentAgents = fs.existsSync(agentsPath) ? fs.readFileSync(agentsPath, 'utf-8') : '';
-  const currentTraits = loadTraits(userPersonalityDir);
   const currentScripts = readDir(scriptsDir);
   const currentTests = readDir(testsDir);
   const currentCommands = readDir(commandsDir);
@@ -192,8 +190,7 @@ Produce a structured growth report covering:
 3. RELATIONSHIP SHIFTS — How the dynamic with the owner changed (closer, more trust, new friction, etc.)
 4. BEHAVIORAL PATTERNS — Recurring interaction styles or habits observed
 5. GROWTH EDGES — Areas where the personality is being pushed or pulled in new directions
-6. TRAIT PRESSURE — Which traits should shift and why (cite specific evidence from conversations/memories)
-7. IDENTITY CONTINUITY — What core aspects stayed the same and should be preserved
+6. IDENTITY CONTINUITY — What core aspects stayed the same and should be preserved
 
 Be specific. Cite evidence from the conversations, memories, and self-memories. This report guides the evolution rewrite.`,
         messages: [{
@@ -204,9 +201,6 @@ ${previousSoul || '(not available)'}
 ## Current SOUL
 ${currentSoul || '(empty)'}
 
-## Current Traits
-${JSON.stringify(currentTraits)}
-
 ## New Memories Since Last Evolution (${recentMemories.length})
 ${recentMemorySummary || '(none)'}
 
@@ -242,7 +236,6 @@ A pre-evolution analysis has been conducted comparing your previous state agains
     lastEvolution: state.lastEvolution,
     firstEvolutionPreamble,
     growthPreamble,
-    currentTraits,
     baselineResults,
   });
 
@@ -431,19 +424,6 @@ Fix the scripts. Tests define correct behavior.`
     fs.writeFileSync(agentsPath, result.agents);
   }
 
-  if (result.traits && typeof result.traits === 'object') {
-    const validTraits = {};
-    for (const [key, val] of Object.entries(result.traits)) {
-      if (typeof val === 'number' && val >= 0 && val <= 100) {
-        validTraits[key] = Math.round(val);
-      }
-    }
-    if (Object.keys(validTraits).length > 0) {
-      const merged = { ...currentTraits, ...validTraits };
-      saveTraits(personalityDir, merged);
-    }
-  }
-
   if (result.commands && typeof result.commands === 'object') {
     if (Object.keys(result.commands).length > 0 || Object.keys(currentCommands).length > 0) {
       syncDir(commandsDir, result.commands);

package/src/evolve/prompts.js

@@ -1,4 +1,4 @@
-function buildEvolutionPrompt({ evolutionNumber, lastEvolution, firstEvolutionPreamble, growthPreamble, currentTraits, baselineResults }) {
+function buildEvolutionPrompt({ evolutionNumber, lastEvolution, firstEvolutionPreamble, growthPreamble, baselineResults }) {
   return `You are an AI undergoing evolution #${evolutionNumber}. ${lastEvolution ? `Last evolution: ${lastEvolution}.` : 'This is your first evolution.'}
 ${firstEvolutionPreamble}${growthPreamble}
 
@@ -24,22 +24,6 @@ Operational manual written as instructions to yourself. Focus on owner-specific
 
 **What belongs in AGENTS.md:** Memory Strategy, Self-Extending patterns, Scripts & Service Integrations, Background Task Guidelines, Communication Style, Evolution notes, and any owner-specific workflows or lessons discovered from conversations. Keep what works, remove what doesn't.
 
-## Part 3b: Personality Traits
-
-Current trait values: ${JSON.stringify(currentTraits)}
-
-Based on conversation patterns, adjust each trait (0-100). Consider:
-- Does the owner respond well to humor? Increase/decrease humor.
-- Does the owner prefer direct answers? Adjust directness.
-- Does the owner appreciate creative solutions? Adjust creativity.
-- Does the owner share emotions or stay task-focused? Adjust empathy.
-- Does the owner want blunt truth or diplomatic framing? Adjust honesty.
-- Does the owner welcome proactive questions? Adjust curiosity.
-
-Small adjustments (±5-15) per evolution. Don't swing wildly.
-
-Include in output JSON as: "traits": { "humor": 65, "honesty": 80, ... }
-
 ## Part 4: Scripts
 
 Review and refactor every script. Standards:
@@ -156,7 +140,6 @@ The OBOL directory has a FIXED structure: personality/, scripts/, tests/, comman
   "soul": "full SOUL.md content",
   "user": "full USER.md content",
   "agents": "full AGENTS.md content",
-  "traits": { "humor": 65, "honesty": 80, "directness": 70, "curiosity": 75, "empathy": 65, "creativity": 70 },
   "scripts": { "name.js": "content" },
   "tests": { "test-name.js": "content" },
   "commands": { "name.md": "content" },

package/src/messages.js

@@ -41,7 +41,8 @@ class MessageLog {
   }
 
   async log(chatId, role, content, opts = {}) {
-    const truncated = content.substring(0, 50000);
+    const serialized = typeof content === 'string' ? content : JSON.stringify(content);
+    const truncated = serialized.substring(0, 50000);
 
     try {
       await fetch(`${this.url}/rest/v1/obol_messages`, {
@@ -60,7 +61,7 @@ class MessageLog {
       console.error('[messages] Log failed:', e.message);
     }
 
-    if (role === 'user') {
+    if (role === 'user' && typeof content === 'string') {
       this._lastUserMessage.set(chatId, truncated);
     }
 
@@ -83,7 +84,12 @@ class MessageLog {
         { headers: this.headers }
       );
       const data = await res.json();
-      const rows = data.reverse();
+      const rows = data.reverse().map(row => {
+        if (typeof row.content === 'string' && row.content.startsWith('[')) {
+          try { row.content = JSON.parse(row.content); } catch {}
+        }
+        return row;
+      });
       const firstUserIdx = rows.findIndex(r => r.role === 'user');
       return firstUserIdx > 0 ? rows.slice(firstUserIdx) : rows;
     } catch {
@@ -189,24 +195,32 @@ Importance: 0.3 minor, 0.5 useful, 0.7 important, 0.9 critical.`,
       if (Array.isArray(facts) && facts.length > 0) {
         const validCategories = new Set(['fact','preference','decision','lesson','person','project','event','conversation','resource','pattern','context','email']);
         let stored = 0;
+        let updated = 0;
         let duped = 0;
 
         for (const fact of facts.slice(0, 5)) {
           if (!fact.content || fact.content.length <= 10) continue;
-          try {
-            const existing = await this.memory.search(fact.content, { limit: 1, threshold: 0.92 });
-            if (existing.length > 0) { duped++; continue; }
-          } catch {}
           const category = validCategories.has(fact.category) ? fact.category : 'fact';
           const importance = typeof fact.importance === 'number' ? Math.min(1, Math.max(0, fact.importance)) : 0.5;
           const tags = Array.isArray(fact.tags) ? fact.tags.slice(0, 5) : [];
+          try {
+            const related = await this.memory.search(fact.content, { limit: 1, threshold: 0.65 });
+            if (related.length > 0) {
+              const top = related[0];
+              if (top.similarity >= 0.82) { duped++; continue; }
+              await this.memory.update(top.id, { content: fact.content, category, importance, tags });
+              updated++;
+              vlog?.(`[extract] ~[${category}] ${fact.content}`);
+              continue;
+            }
+          } catch {}
           await this.memory.add(fact.content, { category, tags, importance, source: 'turn-extraction' });
           stored++;
           vlog?.(`[extract] +[${category}] ${fact.content}`);
         }
 
-        if (stored > 0 || duped > 0) {
-          vlog?.(`[extract] ${stored} stored, ${duped} duped, ${facts.length} extracted`);
+        if (stored > 0 || updated > 0 || duped > 0) {
+          vlog?.(`[extract] ${stored} stored, ${updated} updated, ${duped} duped, ${facts.length} extracted`);
         }
       } else {
         vlog?.('[extract] 0 facts (trivial exchange)');

package/src/personality.js

@@ -2,8 +2,6 @@ const fs = require('fs');
 const path = require('path');
 const { OBOL_DIR } = require('./config');
 
-const DEFAULT_TRAITS = require('./defaults/traits.json');
-
 function loadPersonality(sharedDir, userDir) {
   sharedDir = sharedDir || path.join(OBOL_DIR, 'personality');
   userDir = userDir || sharedDir;
@@ -22,25 +20,7 @@ function loadPersonality(sharedDir, userDir) {
     }
   }
 
-  personality.traits = loadTraits(userDir);
-
   return personality;
 }
 
-function loadTraits(dir) {
-  dir = dir || path.join(OBOL_DIR, 'personality');
-  const traitsPath = path.join(dir, 'traits.json');
-  try {
-    return JSON.parse(fs.readFileSync(traitsPath, 'utf-8'));
-  } catch {
-    return { ...DEFAULT_TRAITS };
-  }
-}
-
-function saveTraits(dir, traits) {
-  dir = dir || path.join(OBOL_DIR, 'personality');
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, 'traits.json'), JSON.stringify(traits, null, 2));
-}
-
-module.exports = { loadPersonality, loadTraits, saveTraits, DEFAULT_TRAITS };
+module.exports = { loadPersonality };

package/src/telegram/bot.js

@@ -11,7 +11,6 @@ const memoryCommands = require('./commands/memory');
 const statusCommands = require('./commands/status');
 const conversationCommands = require('./commands/conversation');
 const adminCommands = require('./commands/admin');
-const traitsCommands = require('./commands/traits');
 const secretsCommands = require('./commands/secrets');
 const toolsCommands = require('./commands/tools');
 const { registerTextHandler } = require('./handlers/text');
@@ -97,7 +96,6 @@ function createBot(telegramConfig, config) {
     { command: 'status', description: 'Bot status and uptime' },
     { command: 'backup', description: 'Trigger GitHub backup now' },
     { command: 'clean', description: 'Audit and fix workspace' },
-    { command: 'traits', description: 'View or adjust personality traits' },
     { command: 'secret', description: 'Manage per-user secrets' },
     { command: 'evolution', description: 'Evolution progress' },
     { command: 'verbose', description: 'Toggle verbose mode on/off' },
@@ -112,7 +110,6 @@ function createBot(telegramConfig, config) {
   memoryCommands.register(bot, config);
   statusCommands.register(bot, config);
   adminCommands.register(bot, config, createAsk);
-  traitsCommands.register(bot, config);
   secretsCommands.register(bot, config);
   toolsCommands.register(bot, config);
 

package/src/telegram/commands/admin.js

@@ -55,12 +55,12 @@ function register(bot, config, createAsk) {
 ## Workspace Structure
 Allowed root directories: personality/, scripts/, tests/, commands/, apps/, logs/, assets/
 Allowed root files: config.json, secrets.json, .evolution-state.json, .first-run-done, .post-setup-done
-- personality/ and commands/ only contain .md files (except personality/traits.json which must stay)
+- personality/ and commands/ only contain .md files
 - Unknown directories at the root should be moved into apps/
 - Script files (.js, .ts, .sh, etc.) go into scripts/
 - Asset files (images, audio, pdf, etc.) go into assets/
 - .DS_Store and other dotfiles should be deleted
-- secrets.json and personality/traits.json must NOT be moved
+- secrets.json must NOT be moved
 
 ## Issues Found
 ${issueLines}
@@ -84,7 +84,7 @@ Summarize what was cleaned and secrets migrated.`);
       const taskPrompt = promptParts.join('\n\n');
 
       const stopTyping = startTyping(ctx);
-      const status = createStatusTracker(ctx);
+      const status = createStatusTracker(ctx, config.bot?.name);
       const chatContext = createChatContext(ctx, tenant, config, { allowedUsers: new Set(), bot, createAsk });
       chatContext._model = 'claude-sonnet-4-6';
       chatContext._onRouteDecision = (info) => { status.setRouteInfo(info); status.start(); };
@@ -113,7 +113,7 @@ Summarize what was cleaned and secrets migrated.`);
       const testsAfter = fs.existsSync(testsDir) && fs.readdirSync(testsDir).filter(f => !f.startsWith('.')).length > 0;
       if (!testsAfter && hasScripts) {
         const testPrompt = `Read every script in ${plan.baseDir}/scripts/. For each script, write a corresponding test file in ${plan.baseDir}/tests/. Name each test file test-<script-name> (e.g. scripts/gmail-send.py → tests/test-gmail-send.py). After writing all tests, run them and fix any failures until they all pass. Summarize the test results.`;
-        const testStatus = createStatusTracker(ctx);
+        const testStatus = createStatusTracker(ctx, config.bot?.name);
         const testCtx = createChatContext(ctx, tenant, config, { allowedUsers: new Set(), bot, createAsk });
         testCtx._model = 'claude-sonnet-4-6';
         testCtx._onRouteDecision = (info) => { testStatus.setRouteInfo(info); testStatus.start(); };

package/src/telegram/commands/conversation.js

@@ -46,7 +46,6 @@ function register(bot, config) {
 /events — Upcoming scheduled events
 /tasks — Running background tasks
 /tools — Toggle optional tools on/off
-/traits — View/adjust personality traits
 /secret — Manage per-user secrets
 /evolution — Evolution progress
 /status — Bot status and uptime

package/src/telegram/commands/status.js

@@ -1,9 +1,7 @@
-const path = require('path');
 const { getTenant } = require('../../tenant');
-const { loadTraits } = require('../../personality');
 const { loadEvolutionState } = require('../../evolve');
 const { getMaxToolIterations } = require('../../claude');
-const { termBar, formatTraits } = require('../utils');
+const { termBar } = require('../utils');
 const { TERM_SEP } = require('../constants');
 
 function register(bot, config) {
@@ -52,10 +50,6 @@ function register(bot, config) {
       lines.push(`  last ${new Date(evoState.lastEvolution).toLocaleDateString()}`);
     }
 
-    const personalityDir = path.join(tenant.userDir, 'personality');
-    const traits = loadTraits(personalityDir);
-    lines.push(``, `TRAITS`);
-    lines.push(formatTraits(traits));
     lines.push(TERM_SEP);
 
     await ctx.reply(`<pre>${lines.join('\n')}</pre>`, { parse_mode: 'HTML' });

package/src/telegram/handlers/media.js

@@ -19,7 +19,7 @@ async function processMediaItems(ctx, items, { config, allowedUsers, bot, create
   if (!ctx.from) return;
   const userId = ctx.from.id;
   const stopTyping = startTyping(ctx);
-  const status = createStatusTracker(ctx);
+  const status = createStatusTracker(ctx, config.bot?.name);
 
   try {
     const tenant = await getTenant(userId, config);

package/src/telegram/handlers/special.js

@@ -74,7 +74,7 @@ async function processSpecial(ctx, prompt, deps) {
   if (!ctx.from) return;
   const userId = ctx.from.id;
   const stopTyping = startTyping(ctx);
-  const status = createStatusTracker(ctx);
+  const status = createStatusTracker(ctx, deps.config?.bot?.name);
 
   try {
     const tenant = await getTenant(userId, deps.config);

package/src/telegram/handlers/text.js

@@ -82,12 +82,13 @@ function createChatContext(ctx, tenant, config, { allowedUsers, bot, createAsk }
   };
 }
 
-function createStatusTracker(ctx) {
+function createStatusTracker(ctx, botName) {
   let statusMsgId = null;
   let statusText = 'Processing';
   let statusTimer = null;
   let statusStart = null;
   let routeInfo = null;
+  const title = botName || 'OBOL';
   const stopBtn = new InlineKeyboard()
     .text('■ Stop', `stop:${ctx.chat.id}`)
     .text('■ Force Stop', `force:${ctx.chat.id}`);
@@ -100,14 +101,14 @@ function createStatusTracker(ctx) {
   const start = () => {
     if (statusTimer) return;
     statusStart = Date.now();
-    const html = buildStatusHtml({ route: routeInfo, elapsed: 0, toolStatus: statusText });
+    const html = buildStatusHtml({ route: routeInfo, elapsed: 0, toolStatus: statusText, title });
     ctx.reply(html, { parse_mode: 'HTML', reply_markup: stopBtn }).then(sent => {
       if (sent) statusMsgId = sent.message_id;
     }).catch(() => {});
     statusTimer = setInterval(() => {
       if (!statusMsgId) return;
       const elapsed = Math.round((Date.now() - statusStart) / 1000);
-      const html = buildStatusHtml({ route: routeInfo, elapsed, toolStatus: statusText });
+      const html = buildStatusHtml({ route: routeInfo, elapsed, toolStatus: statusText, title });
       ctx.api.editMessageText(ctx.chat.id, statusMsgId, html, { parse_mode: 'HTML', reply_markup: stopBtn }).catch(() => {});
     }, 5000);
   };
@@ -126,7 +127,7 @@ function createStatusTracker(ctx) {
     updateFormatting() {
       if (!statusMsgId) return;
       const elapsed = statusStart ? Math.round((Date.now() - statusStart) / 1000) : 0;
-      const html = buildStatusHtml({ route: routeInfo, elapsed, toolStatus: 'Formatting output' });
+      const html = buildStatusHtml({ route: routeInfo, elapsed, toolStatus: 'Formatting output', title });
       ctx.api.editMessageText(ctx.chat.id, statusMsgId, html, { parse_mode: 'HTML' }).catch(() => {});
     },
     deleteMsg() {
@@ -151,7 +152,7 @@ async function processTextMessage(ctx, fullMessage, { config, allowedUsers, bot,
 
   const chatMessage = replyContext + fullMessage;
   const stopTyping = startTyping(ctx);
-  const status = createStatusTracker(ctx);
+  const status = createStatusTracker(ctx, config.bot?.name);
 
   const batcher = tenant.verbose ? createVerboseBatcher(ctx) : null;
   try {

package/src/telegram/utils.js

@@ -54,14 +54,6 @@ function startTyping(ctx) {
   return () => clearInterval(interval);
 }
 
-function formatTraits(traits) {
-  const maxLen = Math.max(...Object.keys(traits).map(k => k.length));
-  return Object.entries(traits).map(([name, val]) => {
-    const label = (name.charAt(0).toUpperCase() + name.slice(1)).padEnd(maxLen + 1);
-    return `  ${label}${termBar(val)} ${val}`;
-  }).join('\n');
-}
-
 function splitMessage(text, maxLength) {
   const chunks = [];
   let remaining = text;
@@ -78,4 +70,4 @@ function splitMessage(text, maxLength) {
   return chunks;
 }
 
-module.exports = { termBar, markdownToTelegramHtml, sendHtml, editHtml, startTyping, formatTraits, splitMessage };
+module.exports = { termBar, markdownToTelegramHtml, sendHtml, editHtml, startTyping, splitMessage };

package/src/tenant.js

@@ -60,7 +60,7 @@ async function createTenant(userId, config) {
 
   let personalityMtime = 0;
   try {
-    personalityMtime = fs.statSync(path.join(personalityDir, 'SOUL.md')).mtimeMs;
+    personalityMtime = fs.statSync(path.join(PERSONALITY_DIR, 'SOUL.md')).mtimeMs;
   } catch {}
 
   return {

package/src/defaults/traits.json

@@ -1,8 +0,0 @@
-{
-  "humor": 60,
-  "honesty": 80,
-  "directness": 70,
-  "curiosity": 75,
-  "empathy": 65,
-  "creativity": 70
-}

package/src/telegram/commands/traits.js

@@ -1,50 +0,0 @@
-const path = require('path');
-const { getTenant } = require('../../tenant');
-const { loadTraits, saveTraits, DEFAULT_TRAITS } = require('../../personality');
-const { formatTraits } = require('../utils');
-const { TERM_SEP } = require('../constants');
-
-function register(bot, config) {
-  const botName = config.bot?.name || 'OBOL';
-  bot.command('traits', async (ctx) => {
-    if (!ctx.from) return;
-    const tenant = await getTenant(ctx.from.id, config);
-    const personalityDir = path.join(tenant.userDir, 'personality');
-    const args = ctx.message.text.split(' ').slice(1);
-
-    if (args[0] === 'reset') {
-      saveTraits(personalityDir, { ...DEFAULT_TRAITS });
-      tenant.claude.reloadPersonality();
-      const traits = { ...DEFAULT_TRAITS };
-      const lines = [`◈ ${botName} PERSONALITY MATRIX`, TERM_SEP, `RESET TO DEFAULTS`, ``, formatTraits(traits), TERM_SEP];
-      await ctx.reply(`<pre>${lines.join('\n')}</pre>`, { parse_mode: 'HTML' });
-      return;
-    }
-
-    if (args[0] && args[1]) {
-      const traitName = args[0].toLowerCase();
-      const value = parseInt(args[1], 10);
-      if (!(traitName in DEFAULT_TRAITS)) {
-        await ctx.reply(`Unknown trait: ${traitName}\nValid: ${Object.keys(DEFAULT_TRAITS).join(', ')}`);
-        return;
-      }
-      if (isNaN(value) || value < 0 || value > 100) {
-        await ctx.reply('Value must be 0-100');
-        return;
-      }
-      const traits = loadTraits(personalityDir);
-      traits[traitName] = value;
-      saveTraits(personalityDir, traits);
-      tenant.claude.reloadPersonality();
-      const lines = [`◈ ${botName} PERSONALITY MATRIX`, TERM_SEP, `UPDATED ${traitName} → ${value}`, ``, formatTraits(traits), TERM_SEP];
-      await ctx.reply(`<pre>${lines.join('\n')}</pre>`, { parse_mode: 'HTML' });
-      return;
-    }
-
-    const traits = loadTraits(personalityDir);
-    const lines = [`◈ ${botName} PERSONALITY MATRIX`, TERM_SEP, ``, formatTraits(traits), ``, `/traits &lt;name&gt; &lt;0-100&gt;`, `/traits reset`, TERM_SEP];
-    await ctx.reply(`<pre>${lines.join('\n')}</pre>`, { parse_mode: 'HTML' });
-  });
-}
-
-module.exports = { register };