obol-ai 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obol-ai",
-  "version": "0.2.2",
+  "version": "0.2.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.js

@@ -7,7 +7,7 @@ const { saveConfig, loadConfig, OBOL_DIR } = require('./config');
 const { execAsync, isAllowedUrl } = require('./sanitize');
 
 const MAX_EXEC_TIMEOUT = 120;
-const MAX_TOOL_ITERATIONS = 15;
+let MAX_TOOL_ITERATIONS = 100;
 
 const BLOCKED_EXEC_PATTERNS = [
   /\brm\s+(-[a-zA-Z]*f|-[a-zA-Z]*r|--force|--recursive)\b/,
@@ -124,20 +124,108 @@ async function ensureFreshToken(anthropicConfig) {
   }
 }
 
+function repairHistory(history) {
+  const allToolUseIds = new Set();
+  for (const msg of history) {
+    if (msg.role === 'assistant' && Array.isArray(msg.content)) {
+      for (const b of msg.content) {
+        if (b.type === 'tool_use') allToolUseIds.add(b.id);
+      }
+    }
+  }
+
+  for (let i = history.length - 1; i >= 0; i--) {
+    const msg = history[i];
+    if (msg.role !== 'user' || !Array.isArray(msg.content)) continue;
+    const toolResults = msg.content.filter(b => b.type === 'tool_result');
+    if (toolResults.length === 0) continue;
+    const orphaned = toolResults.filter(b => !allToolUseIds.has(b.tool_use_id));
+    if (orphaned.length === 0) continue;
+    const remaining = msg.content.filter(b => b.type !== 'tool_result' || allToolUseIds.has(b.tool_use_id));
+    if (remaining.length === 0) {
+      history.splice(i, 1);
+    } else {
+      msg.content = remaining;
+    }
+  }
+
+  for (let i = 0; i < history.length; i++) {
+    const msg = history[i];
+    if (msg.role !== 'assistant' || !Array.isArray(msg.content)) continue;
+    const toolUseIds = msg.content.filter(b => b.type === 'tool_use').map(b => b.id);
+    if (toolUseIds.length === 0) continue;
+    const next = history[i + 1];
+    if (next?.role === 'user' && Array.isArray(next.content)) {
+      const existingIds = new Set(next.content.filter(b => b.type === 'tool_result').map(b => b.tool_use_id));
+      const missingIds = toolUseIds.filter(id => !existingIds.has(id));
+      if (missingIds.length > 0) {
+        next.content = [
+          ...next.content,
+          ...missingIds.map(id => ({ type: 'tool_result', tool_use_id: id, content: '[interrupted]' })),
+        ];
+      }
+    } else {
+      const fakeResults = toolUseIds.map(id => ({
+        type: 'tool_result', tool_use_id: id, content: '[interrupted]',
+      }));
+      history.splice(i + 1, 0, { role: 'user', content: fakeResults });
+    }
+  }
+
+  for (let i = history.length - 1; i > 0; i--) {
+    if (history[i].role === history[i - 1].role && history[i].role === 'user') {
+      const prev = history[i - 1];
+      const curr = history[i];
+      const prevArr = Array.isArray(prev.content) ? prev.content : [{ type: 'text', text: prev.content }];
+      const currArr = Array.isArray(curr.content) ? curr.content : [{ type: 'text', text: curr.content }];
+      history[i - 1] = { role: 'user', content: [...prevArr, ...currArr] };
+      history.splice(i, 1);
+    }
+  }
+}
+
 function createClaude(anthropicConfig, { personality, memory, userDir = OBOL_DIR, bridgeEnabled }) {
   let client = createAnthropicClient(anthropicConfig);
 
   let baseSystemPrompt = buildSystemPrompt(personality, userDir, { bridgeEnabled });
 
   const histories = new Map();
+  const chatLocks = new Map();
   const MAX_HISTORY = 50;
 
   const tools = buildTools(memory, { bridgeEnabled });
 
+  function acquireChatLock(chatId) {
+    if (!chatLocks.has(chatId)) chatLocks.set(chatId, { promise: Promise.resolve(), busy: false });
+    const lock = chatLocks.get(chatId);
+    let release;
+    const prev = lock.promise;
+    lock.promise = new Promise(r => { release = r; });
+    return prev.then(() => {
+      lock.busy = true;
+      return () => { lock.busy = false; release(); };
+    });
+  }
+
+  function isChatBusy(chatId) {
+    return chatLocks.get(chatId)?.busy || false;
+  }
+
   async function chat(userMessage, context = {}) {
     context.userDir = userDir;
     const chatId = context.chatId || 'default';
 
+    if (isChatBusy(chatId)) {
+      return 'I\'m still working on the previous request. Give me a moment.';
+    }
+
+    const releaseLock = await acquireChatLock(chatId);
+
+    if (!histories.has(chatId)) histories.set(chatId, []);
+    const history = histories.get(chatId);
+
+    try {
+
     if (anthropicConfig.oauth?.accessToken) {
       await ensureFreshToken(anthropicConfig);
       if (anthropicConfig._oauthFailed) {
@@ -147,16 +235,15 @@ function createClaude(anthropicConfig, { personality, memory, userDir = OBOL_DIR
       }
     }
 
-    // Get or create history
-    if (!histories.has(chatId)) histories.set(chatId, []);
-    const history = histories.get(chatId);
+    const verbose = context.verbose || false;
+    if (verbose) context.verboseLog = [];
+    const vlog = (msg) => { if (verbose) context.verboseLog.push(msg); };
 
-    // Ask Haiku if we need memory for this message
     let memoryContext = '';
     if (memory) {
       try {
         const memoryDecision = await client.messages.create({
-          model: 'claude-haiku-4-5-20251001',
+          model: 'claude-haiku-4-5',
           max_tokens: 100,
           system: `You are a router. Analyze this user message and decide two things:
 
@@ -164,11 +251,11 @@ function createClaude(anthropicConfig, { personality, memory, userDir = OBOL_DIR
 2. What model complexity does it need?
 
 Reply with ONLY a JSON object:
-{"need_memory": true/false, "search_query": "optimized search query", "model": "sonnet|opus"}
+{"need_memory": true/false, "search_query": "optimized search query", "model": "haiku|sonnet|opus"}
 
 Memory: casual messages (greetings, jokes, simple questions) → false. References to past, people, projects, preferences → true with optimized search query.
 
-Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single-step work). Use "opus" ONLY for: complex multi-step research, architecture/design decisions, long-form writing, deep analysis, debugging complex code, tasks requiring exceptional reasoning.`,
+Model: Use "haiku" for: casual chat, greetings, simple factual questions, short replies, trivial tasks. Use "sonnet" for most things (general questions, quick tasks, single-step work, moderate reasoning). Use "opus" ONLY for: complex multi-step research, architecture/design decisions, long-form writing, deep analysis, debugging complex code, tasks requiring exceptional reasoning.`,
           messages: [{ role: 'user', content: userMessage }],
         });
 
@@ -179,19 +266,20 @@ Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single
           if (jsonStr) decision = JSON.parse(jsonStr);
         } catch {}
 
-        // Set model based on Haiku's decision
+        vlog(`[router] model=${decision.model || 'sonnet'} memory=${decision.need_memory || false}${decision.search_query ? ` query="${decision.search_query}"` : ''}`);
+
         if (decision.model === 'opus') {
           context._model = 'claude-opus-4-6';
+        } else if (decision.model === 'haiku') {
+          context._model = 'claude-haiku-4-5';
         }
 
         if (decision.need_memory) {
           const query = decision.search_query || userMessage;
 
-          // Today's context + semantic search
           const todayMemories = await memory.byDate('today', { limit: 3 });
           const semanticMemories = await memory.search(query, { limit: 3, threshold: 0.5 });
 
-          // Dedupe by ID
           const seen = new Set();
           const combined = [];
           for (const m of [...todayMemories, ...semanticMemories]) {
@@ -201,6 +289,8 @@ Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single
             }
           }
 
+          vlog(`[memory] ${combined.length} memories found (${todayMemories.length} today, ${semanticMemories.length} semantic)`);
+
           if (combined.length > 0) {
             memoryContext = '\n\n[Relevant memories]\n' +
               combined.map(m => `- [${m.category}] ${m.content}`).join('\n');
@@ -208,25 +298,33 @@ Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single
         }
       } catch (e) {
         console.error('[router] Memory/routing decision failed:', e.message);
+        vlog(`[router] ERROR: ${e.message}`);
       }
     }
 
     while (history.length >= MAX_HISTORY) {
-      history.shift();
-      history.shift();
+      let cut = 0;
+      while (cut < history.length - 1) {
+        const msg = history[cut];
+        cut++;
+        if (msg.role === 'assistant' && Array.isArray(msg.content) &&
+            msg.content.some(b => b.type === 'tool_use')) continue;
+        if (msg.role === 'user' && Array.isArray(msg.content) &&
+            msg.content.some(b => b.type === 'tool_result')) continue;
+        if (msg.role === 'assistant') break;
+      }
+      history.splice(0, cut);
+      if (cut === 0) { history.shift(); history.shift(); break; }
     }
     while (history.length > 0) {
       const first = history[0];
-      if (first.role !== 'user') {
-        history.shift();
-        continue;
-      }
+      if (first.role !== 'user') { history.shift(); continue; }
       if (Array.isArray(first.content) && first.content.some(b => b.type === 'tool_result')) {
-        history.shift();
-        continue;
+        history.shift(); continue;
       }
       break;
     }
+    repairHistory(history);
 
     // Add user message with memory context
     const enrichedMessage = memoryContext
@@ -241,8 +339,8 @@ Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single
       history.push({ role: 'user', content: enrichedMessage });
     }
 
-    // Call Claude — Haiku picks the model
     const model = context._model || 'claude-sonnet-4-6';
+    vlog(`[model] ${model} | history=${history.length} msgs`);
     const systemPrompt = baseSystemPrompt + `\nCurrent time: ${new Date().toISOString()}`;
     let response = await client.messages.create({
       model,
@@ -256,8 +354,15 @@ Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single
     while (response.stop_reason === 'tool_use') {
       toolIterations++;
       if (toolIterations > MAX_TOOL_ITERATIONS) {
-        history.push({ role: 'assistant', content: response.content });
-        history.push({ role: 'user', content: 'You have used too many tool calls. Please provide a final response now based on what you have so far.' });
+        const bailoutContent = response.content;
+        history.push({ role: 'assistant', content: bailoutContent });
+        const bailoutResults = bailoutContent
+          .filter(b => b.type === 'tool_use')
+          .map(b => ({ type: 'tool_result', tool_use_id: b.id, content: '[max tool iterations reached]' }));
+        history.push({ role: 'user', content: [
+          ...bailoutResults,
+          { type: 'text', text: 'You have used too many tool calls. Please provide a final response now based on what you have so far.' },
+        ] });
         response = await client.messages.create({
           model,
           max_tokens: 4096,
@@ -273,6 +378,15 @@ Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single
       const toolResults = [];
       for (const block of assistantContent) {
         if (block.type === 'tool_use') {
+          const inputSummary = block.name === 'exec' ? block.input.command :
+            block.name === 'write_file' ? block.input.path :
+            block.name === 'read_file' ? block.input.path :
+            block.name === 'memory_search' ? block.input.query :
+            block.name === 'memory_add' ? `[${block.input.category || 'fact'}]` :
+            block.name === 'web_fetch' ? block.input.url :
+            block.name === 'background_task' ? block.input.task?.substring(0, 60) :
+            JSON.stringify(block.input).substring(0, 80);
+          vlog(`[tool] ${block.name}: ${inputSummary}`);
           const result = await executeToolCall(block, memory, context);
           toolResults.push({
             type: 'tool_result',
@@ -293,14 +407,26 @@ Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single
       });
     }
 
-    // Extract text response
     const textBlocks = response.content.filter(b => b.type === 'text');
     const replyText = textBlocks.map(b => b.text).join('\n');
 
-    // Add assistant response to history
+    if (response.usage) {
+      vlog(`[tokens] in=${response.usage.input_tokens} out=${response.usage.output_tokens}`);
+    }
+
     history.push({ role: 'assistant', content: response.content });
 
     return replyText;
+
+    } catch (e) {
+      if (e.status === 400 && e.message?.includes('tool_use')) {
+        console.error('[claude] Repairing corrupted history after 400 error');
+        repairHistory(history);
+      }
+      throw e;
+    } finally {
+      releaseLock();
+    }
   }
 
   function reloadPersonality() {
@@ -325,7 +451,28 @@ Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single
     history.push({ role, content });
   }
 
-  return { chat, client, reloadPersonality, clearHistory, injectHistory };
+  function getContextStats(chatId) {
+    const id = chatId || 'default';
+    const history = histories.get(id) || [];
+    const MAX_CONTEXT = 200000;
+    let chars = baseSystemPrompt.length;
+    for (const msg of history) {
+      if (typeof msg.content === 'string') {
+        chars += msg.content.length;
+      } else if (Array.isArray(msg.content)) {
+        for (const b of msg.content) {
+          if (b.text) chars += b.text.length;
+          else if (b.content) chars += (typeof b.content === 'string' ? b.content.length : JSON.stringify(b.content).length);
+          else if (b.type === 'tool_use') chars += JSON.stringify(b.input || {}).length + (b.name?.length || 0);
+        }
+      }
+    }
+    const estimatedTokens = Math.round(chars / 4);
+    const pct = Math.min(100, Math.round((estimatedTokens / MAX_CONTEXT) * 100));
+    return { messages: history.length, estimatedTokens, maxTokens: MAX_CONTEXT, pct };
+  }
+
+  return { chat, client, reloadPersonality, clearHistory, injectHistory, getContextStats };
 }
 
 function buildSystemPrompt(personality, userDir, opts = {}) {
@@ -427,6 +574,126 @@ Both tools notify the partner that their agent was contacted. Keep messages spec
 `);
   }
 
+  // Tool documentation (hardcoded — never drifts)
+  parts.push(`
+## Tools
+
+### Shell (\`exec\`)
+Run shell commands. Workspace is your home directory.
+- Timeout: 30s default, 120s max
+- Blocked: \`rm -rf\`, \`shutdown\`, \`eval\`, \`bash -c\`, backtick injection, pipe-to-shell
+- Sensitive paths blocked: \`/etc/passwd\`, \`.env\`, \`.ssh/\`, \`/root/\`
+
+### Memory (\`memory_search\`, \`memory_add\`, \`memory_date\`)
+Vector memory via Supabase pgvector with local embeddings.
+- \`memory_search\` — semantic search across all memories
+- \`memory_add\` — store facts, decisions, preferences, events, people, projects
+- \`memory_date\` — get memories by date ("today", "yesterday", "7d", "2026-02-22")
+
+Categories: \`fact\`, \`preference\`, \`decision\`, \`lesson\`, \`person\`, \`project\`, \`event\`, \`conversation\`, \`resource\`, \`pattern\`, \`context\`, \`email\`
+
+### Files (\`read_file\`, \`write_file\`)
+Read and write files within your workspace. Parent directories created automatically.
+Cannot access paths outside workspace or /tmp.
+
+### Web (\`web_fetch\`)
+Fetch and extract readable content from any URL via Jina reader.
+
+### Vercel (\`vercel_deploy\`, \`vercel_list\`)
+Deploy directories to Vercel. Ship websites, dashboards, web apps.
+
+### Background Tasks (\`background_task\`)
+Spawn heavy work (research, site building, complex analysis) in the background.
+The main conversation stays responsive. User gets progress updates every 30s.
+After spawning, reply with a brief acknowledgment.
+
+### Secrets (\`store_secret\`, \`read_secret\`, \`list_secrets\`)
+Per-user encrypted secret store (pass or JSON fallback).
+- \`store_secret\` — store a key/value secret (API keys, passwords, tokens)
+- \`read_secret\` — read a secret by key
+- \`list_secrets\` — list all secret keys (keys only, not values)
+
+Use these tools instead of \`exec\` for storing/reading secrets — they bypass the \`bash -c\` restriction.
+
+### Send File (\`send_file\`)
+Send a file back to the user via Telegram. Use after generating PDFs, images, documents, or any file the user requested.
+
+### Ask User (\`telegram_ask\`)
+Send a message with inline keyboard buttons and wait for the user to tap one. Use for human-in-the-loop decisions before taking action.
+
+Examples:
+- After listing emails: \`telegram_ask({message: "Open any of these?", options: ["#1 Google", "#2 LinkedIn", "#3 DeepLearning", "None"]})\`
+- Before sending a reply: \`telegram_ask({message: "Send this reply?", options: ["Send it", "Edit first", "Cancel"]})\`
+- Before an irreversible action: \`telegram_ask({message: "Archive all read emails?", options: ["Yes", "No"]})\`
+
+Returns the tapped button label, or \`"timeout"\` if the user doesn't respond within the timeout (default 60s).
+
+### Bridge (\`bridge_ask\`, \`bridge_tell\`)
+Only available if bridge is enabled. Communicate with partner's AI agent.
+`);
+
+  // Available custom scripts (dynamic — always current)
+  const scriptsDir = userDir ? path.join(userDir, 'scripts') : null;
+  let scriptManifest = '(no custom scripts yet)';
+  if (scriptsDir && fs.existsSync(scriptsDir)) {
+    try {
+      const scriptFiles = fs.readdirSync(scriptsDir).filter(f => {
+        try { return fs.statSync(path.join(scriptsDir, f)).isFile(); } catch { return false; }
+      });
+      if (scriptFiles.length > 0) {
+        scriptManifest = scriptFiles.map(s => `- ${s}`).join('\n');
+      }
+    } catch {}
+  }
+  parts.push(`\n## Available Scripts\nScripts you've built in your workspace (run via exec tool):\n${scriptManifest}`);
+
+  // Telegram formatting (hardcoded — never drifts)
+  parts.push(`
+## Telegram Formatting
+
+You communicate via Telegram. Format responses for mobile readability.
+
+**Never use markdown tables** — pipe-syntax tables do not render in Telegram. Use numbered lists instead.
+
+**Email/inbox lists** — use this pattern:
+\`\`\`
+📬 *Inbox (10)*
+
+1\\. *Google* — Security alert \`22:58\`
+2\\. *LinkedIn* — Matthew Chittle wants to connect \`21:31\`
+3\\. *DeepLearning\\.AI* — AI Dev 26 × SF speakers \`13:20\`
+4\\. *LinkedIn Jobs* — Project Manager / TPM roles \`17:32\`
+\`\`\`
+
+**Copyable values** (email addresses, URLs, API keys, commands) — wrap in backtick code spans:
+\`user@example.com\`, \`https://example.com\`, \`npm install foo\`
+
+**Human-in-the-loop** — after listing emails or before acting, use \`telegram_ask\` to offer inline buttons rather than asking the user to type a reply.
+
+**Keep lines short** — Telegram wraps long lines poorly on mobile. Break at natural points.
+`);
+
+  // Safety rules (hardcoded — never drifts)
+  parts.push(`
+## Safety Rules
+
+### Never
+- Share owner's private data with anyone
+- Run destructive commands without asking (\`rm -rf\`, \`DROP TABLE\`, etc.)
+- Send emails or messages on behalf of owner — draft them, owner sends
+- Modify system files (\`/etc/\`, \`/boot/\`)
+- Store secrets in plaintext — use \`store_secret\` for sensitive data
+- Create files outside workspace (except /tmp)
+- Hardcode credentials in scripts — always read them via \`read_secret\` at runtime
+
+### Always
+- Draft emails/posts for review before sending
+- Ask before running anything irreversible
+- Store important info in memory proactively
+- Search memory before claiming you don't know something
+- Use \`store_secret\`/\`read_secret\` for all credential operations
+`);
+
   return parts.join('\n');
 }
 
@@ -618,6 +885,20 @@ function buildTools(memory, opts = {}) {
     },
   });
 
+  tools.push({
+    name: 'telegram_ask',
+    description: 'Send a message to the user with inline keyboard buttons and wait for their tap. Use for human-in-the-loop decisions: confirmations, approvals, action selection. Returns the label of the button the user pressed, or "timeout" if they don\'t respond within the timeout.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        message: { type: 'string', description: 'Question or prompt to show the user' },
+        options: { type: 'array', items: { type: 'string' }, description: 'Button labels (2-6 options, keep each label short)' },
+        timeout: { type: 'number', description: 'Seconds to wait for response (default 60)' },
+      },
+      required: ['message', 'options'],
+    },
+  });
+
   if (opts.bridgeEnabled) {
     const { buildBridgeTool, buildBridgeTellTool } = require('./bridge');
     tools.push(buildBridgeTool());
@@ -832,6 +1113,11 @@ async function executeToolCall(toolUse, memory, context = {}) {
         return `Sent: ${path.basename(filePath)}`;
       }
 
+      case 'telegram_ask': {
+        if (!context.telegramAsk) return 'telegram_ask not available in this context.';
+        return await context.telegramAsk(input.message, input.options || [], input.timeout);
+      }
+
       case 'bridge_ask': {
         const { bridgeAsk } = require('./bridge');
         return await bridgeAsk(input.question, context.userId, context.config, context._notifyFn, input.partner_id);
@@ -850,4 +1136,7 @@ async function executeToolCall(toolUse, memory, context = {}) {
   }
 }
 
-module.exports = { createClaude, createAnthropicClient };
+function getMaxToolIterations() { return MAX_TOOL_ITERATIONS; }
+function setMaxToolIterations(n) { MAX_TOOL_ITERATIONS = n; }
+
+module.exports = { createClaude, createAnthropicClient, getMaxToolIterations, setMaxToolIterations };

package/src/defaults/AGENTS.md

@@ -1,52 +1,5 @@
 # AGENTS.md — Operating Manual
 
-## Tools
-
-### Shell (`exec`)
-Run shell commands. Workspace is your home directory.
-- Timeout: 30s default, 120s max
-- Blocked: `rm -rf`, `shutdown`, `eval`, `bash -c`, backtick injection, pipe-to-shell
-- Sensitive paths blocked: `/etc/passwd`, `.env`, `.ssh/`, `/root/`
-
-### Memory (`memory_search`, `memory_add`, `memory_date`)
-Vector memory via Supabase pgvector with local embeddings.
-- `memory_search` — semantic search across all memories
-- `memory_add` — store facts, decisions, preferences, events, people, projects
-- `memory_date` — get memories by date ("today", "yesterday", "7d", "2026-02-22")
-
-Categories: `fact`, `preference`, `decision`, `lesson`, `person`, `project`, `event`, `conversation`, `resource`, `pattern`, `context`, `email`
-
-### Files (`read_file`, `write_file`)
-Read and write files within your workspace. Parent directories created automatically.
-Cannot access paths outside workspace or /tmp.
-
-### Web (`web_fetch`)
-Fetch and extract readable content from any URL via Jina reader.
-
-### Vercel (`vercel_deploy`, `vercel_list`)
-Deploy directories to Vercel. Ship websites, dashboards, web apps.
-
-### Background Tasks (`background_task`)
-Spawn heavy work (research, site building, complex analysis) in the background.
-The main conversation stays responsive. User gets progress updates every 30s.
-After spawning, reply with a brief acknowledgment.
-
-### Secrets (`store_secret`, `read_secret`, `list_secrets`)
-Per-user encrypted secret store (pass or JSON fallback).
-- `store_secret` — store a key/value secret (API keys, passwords, tokens)
-- `read_secret` — read a secret by key
-- `list_secrets` — list all secret keys (keys only, not values)
-
-Use these tools instead of `exec` for storing/reading secrets — they bypass the `bash -c` restriction.
-
-Users can also manage secrets via Telegram: `/secret set <key> <value>` (message auto-deleted), `/secret list`, `/secret remove <key>`.
-
-### Send File (`send_file`)
-Send a file back to the user via Telegram. Use after generating PDFs, images, documents, or any file the user requested.
-
-### Bridge (`bridge_ask`, `bridge_tell`)
-Only available if bridge is enabled. Communicate with partner's AI agent.
-
 ## Memory Strategy
 
 Haiku auto-consolidates every 5 exchanges — important context gets stored automatically.
@@ -64,43 +17,6 @@ Search memory before answering questions about:
 - Anything the owner mentioned before
 - "What did we discuss about X?"
 
-## Safety Rules
-
-### Never
-- Share owner's private data with anyone
-- Run destructive commands without asking (`rm -rf`, `DROP TABLE`, etc.)
-- Send emails or messages on behalf of owner — draft them, owner sends
-- Modify system files (`/etc/`, `/boot/`)
-- Store secrets in plaintext — use `store_secret` for sensitive data
-- Create files outside workspace (except /tmp)
-- Hardcode credentials in scripts — always read them via `read_secret` at runtime
-
-### Always
-- Draft emails/posts for review before sending
-- Ask before running anything irreversible
-- Store important info in memory proactively
-- Search memory before claiming you don't know something
-- Use `store_secret`/`read_secret` for all credential operations
-
-## Workspace Structure
-
-```
-workspace/
-├── personality/    (SOUL.md, USER.md, AGENTS.md, evolution/)
-├── scripts/        (utility scripts)
-├── tests/          (test suite)
-├── commands/       (command definitions)
-├── apps/           (web apps for Vercel)
-├── assets/         (uploaded files, images, media)
-└── logs/
-```
-
-Rules:
-- NEVER create new top-level directories
-- Place files in the correct existing directory
-- Temporary files go in /tmp
-- If unsure where something belongs, ask
-
 ## Self-Extending
 
 You can give yourself new capabilities by writing scripts and running them. If the user asks for something you don't have a dedicated tool for (PDF generation, image manipulation, data processing, etc.):

package/src/evolve.js

@@ -284,7 +284,15 @@ Third person factual profile: name, location, timezone, nationality, job, skills
 
 ## Part 3: AGENTS.md (how to operate)
 
-Operational manual written as instructions to yourself. **Preserve ALL existing tool documentation** — tools don't change between evolutions. Add owner-specific rules discovered from conversations. Add workflow patterns that work well. Keep what works, remove what doesn't. Sections to maintain: Tools, Memory Strategy, Safety Rules, Workspace Structure, Background Task Guidelines, Communication Style, Evolution.
+Operational manual written as instructions to yourself. Focus on owner-specific workflows, service integrations, and lessons learned from conversations.
+
+**Do NOT include in AGENTS.md** — these are already hardcoded in the base system prompt and must not be duplicated:
+- Tool documentation (exec, memory_*, read_file, write_file, web_fetch, vercel_*, background_task, store_secret, read_secret, list_secrets, send_file, telegram_ask, bridge_*)
+- Telegram Formatting rules
+- Safety Rules (Never/Always)
+- Workspace Structure
+
+**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
 

package/src/telegram.js

@@ -1,11 +1,12 @@
 const path = require('path');
-const { Bot, GrammyError, HttpError } = require('grammy');
+const { Bot, GrammyError, HttpError, InlineKeyboard } = require('grammy');
 const { loadConfig } = require('./config');
 const { evolve, loadEvolutionState } = require('./evolve');
 const { getTenant } = require('./tenant');
 const { loadTraits, saveTraits, DEFAULT_TRAITS } = require('./personality');
 const media = require('./media');
 const credentials = require('./credentials');
+const { getMaxToolIterations, setMaxToolIterations } = require('./claude');
 
 const RATE_LIMIT_MS = 3000;
 const SPAM_THRESHOLD = 5;
@@ -23,6 +24,31 @@ function createBot(telegramConfig, config) {
   const bot = new Bot(telegramConfig.token);
   const allowedUsers = new Set(telegramConfig.allowedUsers || []);
   const rateLimits = new Map();
+  const pendingAsks = new Map();
+  let askIdCounter = 0;
+
+  function createAsk(ctx, message, options, timeoutSecs = 60) {
+    return new Promise((resolve) => {
+      const askId = ++askIdCounter;
+      const keyboard = new InlineKeyboard();
+      options.forEach((opt, i) => {
+        keyboard.text(opt, `ask:${askId}:${i}`);
+        if ((i + 1) % 3 === 0 && i < options.length - 1) keyboard.row();
+      });
+      const timer = setTimeout(() => {
+        if (pendingAsks.has(askId)) {
+          pendingAsks.delete(askId);
+          resolve('timeout');
+        }
+      }, timeoutSecs * 1000);
+      pendingAsks.set(askId, { resolve, options, timer });
+      ctx.reply(message, { parse_mode: 'Markdown', reply_markup: keyboard }).catch(() => {
+        clearTimeout(timer);
+        pendingAsks.delete(askId);
+        resolve('error');
+      });
+    });
+  }
 
   const _rateLimitCleanup = setInterval(() => {
     const now = Date.now();
@@ -51,6 +77,8 @@ function createBot(telegramConfig, config) {
     { 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' },
+    { command: 'toolimit', description: 'View or set max tool iterations per message' },
     { command: 'help', description: 'Show available commands' },
   ]).catch(() => {});
 
@@ -102,12 +130,18 @@ function createBot(telegramConfig, config) {
     text += `⏱️ Uptime: ${h}h ${m}m\n`;
     text += `💾 Memory: ${mem}MB\n`;
     text += `⚡ Tasks: ${running.length} running\n`;
+    text += `🔧 Tool limit: ${getMaxToolIterations()}\n`;
 
     if (tenant.memory) {
       const stats = await tenant.memory.stats().catch(() => null);
       if (stats) text += `🧠 Memories: ${stats.total}\n`;
     }
 
+    const ctxStats = tenant.claude.getContextStats(ctx.chat.id);
+    const ctxBar = '█'.repeat(Math.floor(ctxStats.pct / 5)) + '░'.repeat(20 - Math.floor(ctxStats.pct / 5));
+    text += `\n📐 Context: ${ctxBar} ${ctxStats.pct}%\n`;
+    text += `   ${(ctxStats.estimatedTokens / 1000).toFixed(1)}k / ${(ctxStats.maxTokens / 1000).toFixed(0)}k tokens (${ctxStats.messages} msgs)\n`;
+
     const evoState = loadEvolutionState(tenant.userDir);
     const cfg = loadConfig();
     const threshold = cfg?.evolution?.exchanges || 100;
@@ -338,9 +372,38 @@ Your message is deleted immediately when using /secret set to keep credentials o
 /status — Bot status and uptime
 /backup — Trigger GitHub backup
 /clean — Audit workspace
+/verbose — Toggle verbose mode on/off
+/toolimit — View or set max tool iterations
 /help — This message`);
   });
 
+  bot.command('verbose', async (ctx) => {
+    if (!ctx.from) return;
+    const tenant = await getTenant(ctx.from.id, config);
+    tenant.verbose = !tenant.verbose;
+    await ctx.reply(tenant.verbose ? '🔍 Verbose mode ON' : '🔇 Verbose mode OFF');
+  });
+
+  bot.command('toolimit', async (ctx) => {
+    if (!ctx.from) return;
+    const args = ctx.message.text.split(' ').slice(1);
+    const current = getMaxToolIterations();
+
+    if (!args[0]) {
+      await ctx.reply(`🔧 Max tool iterations: ${current}\n\nThis limits how many tool calls OBOL can make per message. Higher = more complex tasks, but slower responses.\n\nSet: /toolimit <number>\nExample: /toolimit 50`);
+      return;
+    }
+
+    const value = parseInt(args[0], 10);
+    if (isNaN(value) || value < 1 || value > 500) {
+      await ctx.reply(`Invalid value: "${args[0]}"\n\nMust be a number between 1 and 500.\nCurrent: ${current}\n\nExample: /toolimit 50`);
+      return;
+    }
+
+    setMaxToolIterations(value);
+    await ctx.reply(`🔧 Max tool iterations set to ${value}`);
+  });
+
   function checkRateLimit(userId) {
     const now = Date.now();
     const userLimit = rateLimits.get(userId) || { lastMessage: 0, spamCount: 0, cooldownUntil: 0 };
@@ -392,7 +455,7 @@ Your message is deleted immediately when using /secret set to keep credentials o
     try {
       tenant.messageLog?.log(ctx.chat.id, 'user', userMessage);
 
-      const response = await tenant.claude.chat(userMessage, {
+      const chatContext = {
         userId,
         userName,
         chatId: ctx.chat.id,
@@ -400,14 +463,24 @@ Your message is deleted immediately when using /secret set to keep credentials o
         ctx,
         claude: tenant.claude,
         config,
+        verbose: tenant.verbose,
+        telegramAsk: (message, options, timeout) => createAsk(ctx, message, options, timeout),
         _notifyFn: (targetUserId, message) => {
           if (!allowedUsers.has(targetUserId)) throw new Error('Cannot notify user outside allowed list');
           return bot.api.sendMessage(targetUserId, message);
         },
-      });
+      };
+      const response = await tenant.claude.chat(userMessage, chatContext);
 
       tenant.messageLog?.log(ctx.chat.id, 'assistant', response);
 
+      if (tenant.verbose && chatContext.verboseLog?.length) {
+        const verboseText = '```\n' + chatContext.verboseLog.join('\n') + '\n```';
+        await ctx.reply(verboseText, { parse_mode: 'Markdown' }).catch(() =>
+          ctx.reply(verboseText).catch(() => {})
+        );
+      }
+
       if (tenant.messageLog?._evolutionReady) {
         tenant.messageLog._evolutionReady = false;
         setImmediate(async () => {
@@ -525,7 +598,7 @@ Your message is deleted immediately when using /secret set to keep credentials o
       if (media.isImage(fileInfo)) {
         const imageBlock = media.bufferToImageBlock(buffer, fileInfo.mimeType);
         const prompt = caption || 'The user sent this image. Describe what you see and respond naturally.';
-        const response = await tenant.claude.chat(prompt, {
+        const mediaChatCtx = {
           userId,
           userName: ctx.from.first_name || 'User',
           chatId: ctx.chat.id,
@@ -533,16 +606,23 @@ Your message is deleted immediately when using /secret set to keep credentials o
           ctx,
           claude: tenant.claude,
           config,
+          verbose: tenant.verbose,
           images: [imageBlock],
           _notifyFn: (targetUserId, message) => {
             if (!allowedUsers.has(targetUserId)) throw new Error('Cannot notify user outside allowed list');
             return bot.api.sendMessage(targetUserId, message);
           },
-        });
+        };
+        const response = await tenant.claude.chat(prompt, mediaChatCtx);
 
         tenant.messageLog?.log(ctx.chat.id, 'user', `[${fileInfo.mediaType}] ${caption || filename}`);
         tenant.messageLog?.log(ctx.chat.id, 'assistant', response);
 
+        if (tenant.verbose && mediaChatCtx.verboseLog?.length) {
+          const verboseText = '```\n' + mediaChatCtx.verboseLog.join('\n') + '\n```';
+          await ctx.reply(verboseText, { parse_mode: 'Markdown' }).catch(() => ctx.reply(verboseText).catch(() => {}));
+        }
+
         stopTyping();
         if (response.length > 4096) {
           for (const chunk of splitMessage(response, 4096)) {
@@ -553,7 +633,7 @@ Your message is deleted immediately when using /secret set to keep credentials o
         }
       } else if (caption) {
         const contextMsg = `[User sent a ${fileInfo.mediaType}: ${filename}] ${caption}`;
-        const response = await tenant.claude.chat(contextMsg, {
+        const mediaCaptionCtx = {
           userId,
           userName: ctx.from.first_name || 'User',
           chatId: ctx.chat.id,
@@ -561,15 +641,22 @@ Your message is deleted immediately when using /secret set to keep credentials o
           ctx,
           claude: tenant.claude,
           config,
+          verbose: tenant.verbose,
           _notifyFn: (targetUserId, message) => {
             if (!allowedUsers.has(targetUserId)) throw new Error('Cannot notify user outside allowed list');
             return bot.api.sendMessage(targetUserId, message);
           },
-        });
+        };
+        const response = await tenant.claude.chat(contextMsg, mediaCaptionCtx);
 
         tenant.messageLog?.log(ctx.chat.id, 'user', contextMsg);
         tenant.messageLog?.log(ctx.chat.id, 'assistant', response);
 
+        if (tenant.verbose && mediaCaptionCtx.verboseLog?.length) {
+          const verboseText = '```\n' + mediaCaptionCtx.verboseLog.join('\n') + '\n```';
+          await ctx.reply(verboseText, { parse_mode: 'Markdown' }).catch(() => ctx.reply(verboseText).catch(() => {}));
+        }
+
         stopTyping();
         if (response.length > 4096) {
           for (const chunk of splitMessage(response, 4096)) {
@@ -598,6 +685,22 @@ Your message is deleted immediately when using /secret set to keep credentials o
   bot.on('message:animation', handleMedia);
   bot.on('message:video_note', handleMedia);
 
+  bot.on('callback_query:data', async (ctx) => {
+    const data = ctx.callbackQuery.data;
+    if (!data.startsWith('ask:')) return ctx.answerCallbackQuery();
+    const parts = data.split(':');
+    const askId = parseInt(parts[1]);
+    const optIdx = parseInt(parts[2]);
+    const pending = pendingAsks.get(askId);
+    if (!pending) return ctx.answerCallbackQuery({ text: 'Expired' });
+    const selected = pending.options[optIdx];
+    await ctx.answerCallbackQuery({ text: selected });
+    clearTimeout(pending.timer);
+    pendingAsks.delete(askId);
+    ctx.editMessageText(`${ctx.callbackQuery.message.text}\n\n✓ _${selected}_`, { parse_mode: 'Markdown' }).catch(() => {});
+    pending.resolve(selected);
+  });
+
   bot.catch((err) => {
     const ctx = err.ctx;
     const e = err.error;

package/src/tenant.js

@@ -43,6 +43,7 @@ async function createTenant(userId, config) {
 
   return {
     claude, memory, messageLog, personality, bg, userDir, userId,
+    verbose: false,
     _personalityLoadedAt: Date.now(),
     _personalityMtime: personalityMtime,
   };