kernelbot 1.0.26 → 1.0.30

package/src/claude-auth.js

@@ -0,0 +1,93 @@
+import { spawn } from 'child_process';
+import { getLogger } from './utils/logger.js';
+
+/**
+ * Run `claude auth status` and return parsed output.
+ */
+export function getClaudeAuthStatus() {
+  const logger = getLogger();
+  return new Promise((resolve) => {
+    const child = spawn('claude', ['auth', 'status'], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (d) => { stdout += d.toString(); });
+    child.stderr.on('data', (d) => { stderr += d.toString(); });
+
+    child.on('close', (code) => {
+      const output = (stdout || stderr).trim();
+      logger.debug(`claude auth status (code ${code}): ${output.slice(0, 300)}`);
+      resolve({ code, output });
+    });
+
+    child.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        resolve({ code: -1, output: 'Claude Code CLI not found. Install with: npm i -g @anthropic-ai/claude-code' });
+      } else {
+        resolve({ code: -1, output: err.message });
+      }
+    });
+
+    // Timeout after 10s
+    setTimeout(() => {
+      child.kill('SIGTERM');
+      resolve({ code: -1, output: 'Timed out checking auth status' });
+    }, 10_000);
+  });
+}
+
+/**
+ * Run `claude auth logout`.
+ */
+export function claudeLogout() {
+  const logger = getLogger();
+  return new Promise((resolve) => {
+    const child = spawn('claude', ['auth', 'logout'], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (d) => { stdout += d.toString(); });
+    child.stderr.on('data', (d) => { stderr += d.toString(); });
+
+    child.on('close', (code) => {
+      const output = (stdout || stderr).trim();
+      logger.info(`claude auth logout (code ${code}): ${output.slice(0, 300)}`);
+      resolve({ code, output });
+    });
+
+    child.on('error', (err) => {
+      resolve({ code: -1, output: err.message });
+    });
+
+    setTimeout(() => {
+      child.kill('SIGTERM');
+      resolve({ code: -1, output: 'Timed out during logout' });
+    }, 10_000);
+  });
+}
+
+/**
+ * Return the current Claude Code auth mode from config.
+ */
+export function getClaudeCodeAuthMode(config) {
+  const mode = config.claude_code?.auth_mode || 'system';
+  const info = { mode };
+
+  if (mode === 'api_key') {
+    const key = config.claude_code?.api_key || process.env.CLAUDE_CODE_API_KEY || '';
+    info.credential = key ? `${key.slice(0, 8)}...${key.slice(-4)}` : '(not set)';
+  } else if (mode === 'oauth_token') {
+    const token = config.claude_code?.oauth_token || process.env.CLAUDE_CODE_OAUTH_TOKEN || '';
+    info.credential = token ? `${token.slice(0, 8)}...${token.slice(-4)}` : '(not set)';
+  } else {
+    info.credential = 'Using host system login';
+  }
+
+  return info;
+}

package/src/coder.js

@@ -135,17 +135,43 @@ function processEvent(line, onOutput, logger) {
 
 export class ClaudeCodeSpawner {
   constructor(config) {
+    this.config = config;
     this.maxTurns = config.claude_code?.max_turns || 50;
-    this.timeout = (config.claude_code?.timeout_seconds || 600) * 1000;
-    this.model = config.claude_code?.model || null;
+    this.timeout = (config.claude_code?.timeout_seconds || 86400) * 1000;
   }
 
-  async run({ workingDirectory, prompt, maxTurns, onOutput }) {
+  _buildSpawnEnv() {
+    const authMode = this.config.claude_code?.auth_mode || 'system';
+    const env = { ...process.env, IS_SANDBOX: '1' };
+
+    if (authMode === 'api_key') {
+      const key = this.config.claude_code?.api_key || process.env.CLAUDE_CODE_API_KEY;
+      if (key) {
+        env.ANTHROPIC_API_KEY = key;
+        delete env.CLAUDE_CODE_OAUTH_TOKEN;
+      }
+    } else if (authMode === 'oauth_token') {
+      const token = this.config.claude_code?.oauth_token || process.env.CLAUDE_CODE_OAUTH_TOKEN;
+      if (token) {
+        env.CLAUDE_CODE_OAUTH_TOKEN = token;
+        // Remove ANTHROPIC_API_KEY so it doesn't override subscription auth
+        delete env.ANTHROPIC_API_KEY;
+      }
+    }
+    // authMode === 'system' — pass env as-is
+
+    return env;
+  }
+
+  async run({ workingDirectory, prompt, maxTurns, onOutput, signal }) {
     const logger = getLogger();
     const turns = maxTurns || this.maxTurns;
 
     ensureClaudeCodeSetup();
 
+    // Read model dynamically from config (supports hot-reload via switchClaudeCodeModel)
+    const model = this.config.claude_code?.model || null;
+
     const args = [
       '-p', prompt,
       '--max-turns', String(turns),
@@ -153,8 +179,8 @@ export class ClaudeCodeSpawner {
       '--verbose',
       '--dangerously-skip-permissions',
     ];
-    if (this.model) {
-      args.push('--model', this.model);
+    if (model) {
+      args.push('--model', model);
     }
 
     const cmd = `claude ${args.map((a) => a.includes(' ') ? `"${a}"` : a).join(' ')}`;
@@ -219,10 +245,24 @@ export class ClaudeCodeSpawner {
     return new Promise((resolve, reject) => {
       const child = spawn('claude', args, {
         cwd: workingDirectory,
-        env: { ...process.env, IS_SANDBOX: '1' },
+        env: this._buildSpawnEnv(),
         stdio: ['ignore', 'pipe', 'pipe'],
       });
 
+      // Wire abort signal to kill the child process
+      let abortHandler = null;
+      if (signal) {
+        if (signal.aborted) {
+          child.kill('SIGTERM');
+        } else {
+          abortHandler = () => {
+            logger.info('Claude Code: abort signal received — killing child process');
+            child.kill('SIGTERM');
+          };
+          signal.addEventListener('abort', abortHandler, { once: true });
+        }
+      }
+
       let fullOutput = '';
       let stderr = '';
       let buffer = '';
@@ -268,6 +308,7 @@ export class ClaudeCodeSpawner {
 
       child.on('close', async (code) => {
         clearTimeout(timer);
+        if (abortHandler && signal) signal.removeEventListener('abort', abortHandler);
 
         if (buffer.trim()) {
           fullOutput += buffer.trim();
@@ -312,6 +353,7 @@ export class ClaudeCodeSpawner {
 
       child.on('error', (err) => {
         clearTimeout(timer);
+        if (abortHandler && signal) signal.removeEventListener('abort', abortHandler);
         if (err.code === 'ENOENT') {
           reject(new Error('Claude Code CLI not found. Install with: npm i -g @anthropic-ai/claude-code'));
         } else {

package/src/conversation.js

@@ -13,6 +13,7 @@ export class ConversationManager {
     this.maxHistory = config.conversation.max_history;
     this.recentWindow = config.conversation.recent_window || 10;
     this.conversations = new Map();
+    this.activeSkills = new Map();
     this.filePath = getConversationsPath();
   }
 
@@ -21,7 +22,16 @@ export class ConversationManager {
     try {
       const raw = readFileSync(this.filePath, 'utf-8');
       const data = JSON.parse(raw);
+
+      // Restore per-chat skills
+      if (data._skills && typeof data._skills === 'object') {
+        for (const [chatId, skillId] of Object.entries(data._skills)) {
+          this.activeSkills.set(String(chatId), skillId);
+        }
+      }
+
       for (const [chatId, messages] of Object.entries(data)) {
+        if (chatId === '_skills') continue;
         this.conversations.set(String(chatId), messages);
       }
       return this.conversations.size > 0;
@@ -36,6 +46,14 @@ export class ConversationManager {
       for (const [chatId, messages] of this.conversations) {
         data[chatId] = messages;
       }
+      // Persist active skills under a reserved key
+      if (this.activeSkills.size > 0) {
+        const skills = {};
+        for (const [chatId, skillId] of this.activeSkills) {
+          skills[chatId] = skillId;
+        }
+        data._skills = skills;
+      }
       writeFileSync(this.filePath, JSON.stringify(data, null, 2));
     } catch {
       // Silent fail — don't crash the bot over persistence
@@ -104,6 +122,7 @@ export class ConversationManager {
 
   clear(chatId) {
     this.conversations.delete(String(chatId));
+    this.activeSkills.delete(String(chatId));
     this.save();
   }
 
@@ -116,4 +135,18 @@ export class ConversationManager {
     const history = this.getHistory(chatId);
     return history.length;
   }
+
+  setSkill(chatId, skillId) {
+    this.activeSkills.set(String(chatId), skillId);
+    this.save();
+  }
+
+  getSkill(chatId) {
+    return this.activeSkills.get(String(chatId)) || null;
+  }
+
+  clearSkill(chatId) {
+    this.activeSkills.delete(String(chatId));
+    this.save();
+  }
 }

package/src/intents/detector.js

@@ -0,0 +1,50 @@
+/**
+ * Intent detector — analyzes user messages to identify web search/browse intents.
+ *
+ * When detected, the agent wraps the message with a structured execution plan
+ * so the model follows through instead of giving up after one tool call.
+ */
+
+// Matches domain-like patterns (haraj.com.sa, example.com, etc.)
+const URL_PATTERN = /\b(?:https?:\/\/)?(?:www\.)?([a-z0-9][-a-z0-9]*\.)+[a-z]{2,}\b/i;
+
+// Explicit search/find verbs
+const SEARCH_VERBS = /\b(?:search|search\s+for|find\s+me|find|look\s*(?:for|up|into)|lookup|hunt\s+for)\b/i;
+
+// Info-seeking phrases (trigger browse intent when combined with a URL)
+const INFO_PHRASES = /\b(?:what(?:'s| is| are)|show\s*me|get\s*me|check|list|top|best|latest|new|popular|trending|compare|review|price|cheap|expensive)\b/i;
+
+// These words mean the user is NOT doing a web task — they're doing a local/system task
+const NON_WEB_CONTEXT = /\b(?:file|files|directory|folder|git|logs?\b|code|error|bug|docker|container|process|pid|service|command|terminal|disk|memory|cpu|system status|port|package|module|function|class|variable|server|database|db|ssh|deploy|install|build|compile|test|commit|branch|merge|pull request)\b/i;
+
+// Screenshot-only requests — just take a screenshot, don't force a deep browse
+const SCREENSHOT_ONLY = /\b(?:screenshot|take\s+a?\s*screenshot|capture\s+screen)\b/i;
+
+/**
+ * Detect if a user message contains a web search or browse intent.
+ *
+ * @param {string} message — raw user message
+ * @returns {{ type: 'search'|'browse', message: string } | null}
+ */
+export function detectIntent(message) {
+  // Skip bot commands and screenshot-only requests
+  if (message.startsWith('/')) return null;
+  if (SCREENSHOT_ONLY.test(message)) return null;
+
+  const hasSearchVerb = SEARCH_VERBS.test(message);
+  const hasNonWebContext = NON_WEB_CONTEXT.test(message);
+  const hasUrl = URL_PATTERN.test(message);
+  const hasInfoPhrase = INFO_PHRASES.test(message);
+
+  // Explicit search verb + no technical context = web search
+  if (hasSearchVerb && !hasNonWebContext) {
+    return { type: 'search', message };
+  }
+
+  // URL/domain + info-seeking phrase + no technical context = browse & extract
+  if (hasUrl && hasInfoPhrase && !hasNonWebContext) {
+    return { type: 'browse', message };
+  }
+
+  return null;
+}

package/src/intents/index.js

@@ -0,0 +1,2 @@
+export { detectIntent } from './detector.js';
+export { generatePlan } from './planner.js';

package/src/intents/planner.js

@@ -0,0 +1,58 @@
+/**
+ * Task planner — generates structured execution plans for detected intents.
+ *
+ * The plan is injected into the user message BEFORE the model sees it,
+ * so the model follows a clear step-by-step procedure instead of deciding
+ * on its own when to stop.
+ */
+
+const PLANS = {
+  search: (message) =>
+    `[EXECUTION PLAN — Complete ALL steps before responding]
+
+TASK: Search the web and deliver results.
+
+STEP 1 — SEARCH: Use web_search("relevant query"). If a specific website is mentioned in the request, also use browse_website to open it directly.
+STEP 2 — OPEN: Use browse_website to open the most relevant result URL.
+STEP 3 — GO DEEPER: The page is now open. Use interact_with_page (no URL needed) to click into relevant sections, categories, or use search bars within the site.
+STEP 4 — EXTRACT: Read the page content from the tool response. Use extract_content if you need structured data.
+STEP 5 — PRESENT: Share the actual results, listings, or data with the user.
+
+RULES:
+- You MUST reach at least STEP 3 before writing any response to the user.
+- Do NOT ask the user questions or offer choices — complete the full task.
+- Do NOT explain what you can't do — try alternative approaches.
+- If one page doesn't have results, try a different URL or search query.
+- After interact_with_page clicks a link, the page navigates automatically — read the returned content.
+
+USER REQUEST: ${message}`,
+
+  browse: (message) =>
+    `[EXECUTION PLAN — Complete ALL steps before responding]
+
+TASK: Browse a website and extract the requested information.
+
+STEP 1 — OPEN: Use browse_website to open the mentioned site.
+STEP 2 — NAVIGATE: The page is open. Use interact_with_page (no URL needed) to click relevant links, sections, categories, or use search bars.
+STEP 3 — EXTRACT: Read the page content. Use extract_content for structured data if needed.
+STEP 4 — PRESENT: Share the actual findings with the user.
+
+RULES:
+- Do NOT stop at the homepage — navigate into relevant sections.
+- Do NOT ask the user what to do — figure it out from the page links and complete the task.
+- After interact_with_page clicks a link, the page navigates automatically — read the returned content.
+
+USER REQUEST: ${message}`,
+};
+
+/**
+ * Generate an execution plan for a detected intent.
+ *
+ * @param {{ type: string, message: string }} intent
+ * @returns {string|null} — planned message, or null if no plan needed
+ */
+export function generatePlan(intent) {
+  const generator = PLANS[intent.type];
+  if (!generator) return null;
+  return generator(intent.message);
+}

package/src/persona.js

@@ -0,0 +1,68 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { getLogger } from './utils/logger.js';
+
+const PERSONAS_DIR = join(homedir(), '.kernelbot', 'personas');
+
+function defaultTemplate(username, date) {
+  return `# User Profile
+
+## Basic Info
+- Username: ${username || 'unknown'}
+- First seen: ${date}
+
+## Preferences
+(Not yet known)
+
+## Expertise & Interests
+(Not yet known)
+
+## Communication Style
+(Not yet known)
+
+## Notes
+(Not yet known)
+`;
+}
+
+export class UserPersonaManager {
+  constructor() {
+    this._cache = new Map();
+    mkdirSync(PERSONAS_DIR, { recursive: true });
+  }
+
+  /** Load persona for a user. Returns markdown string. Creates default if missing. */
+  load(userId, username) {
+    const logger = getLogger();
+    const id = String(userId);
+
+    if (this._cache.has(id)) return this._cache.get(id);
+
+    const filePath = join(PERSONAS_DIR, `${id}.md`);
+    let content;
+
+    if (existsSync(filePath)) {
+      content = readFileSync(filePath, 'utf-8');
+      logger.debug(`Loaded persona for user ${id}`);
+    } else {
+      content = defaultTemplate(username, new Date().toISOString().slice(0, 10));
+      writeFileSync(filePath, content, 'utf-8');
+      logger.info(`Created default persona for user ${id} (${username})`);
+    }
+
+    this._cache.set(id, content);
+    return content;
+  }
+
+  /** Save (overwrite) persona for a user. Updates cache and disk. */
+  save(userId, content) {
+    const logger = getLogger();
+    const id = String(userId);
+    const filePath = join(PERSONAS_DIR, `${id}.md`);
+
+    writeFileSync(filePath, content, 'utf-8');
+    this._cache.set(id, content);
+    logger.info(`Updated persona for user ${id}`);
+  }
+}

package/src/prompts/orchestrator.js

@@ -0,0 +1,124 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { WORKER_TYPES } from '../swarm/worker-registry.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PERSONA_MD = readFileSync(join(__dirname, 'persona.md'), 'utf-8').trim();
+
+/**
+ * Build the orchestrator system prompt.
+ * Kept lean (~500-600 tokens) — the orchestrator dispatches, it doesn't execute.
+ *
+ * @param {object} config
+ * @param {string|null} skillPrompt — active skill context (high-level)
+ * @param {string|null} userPersona — markdown persona for the current user
+ * @param {string|null} selfData — bot's own self-awareness data (goals, journey, life, hobbies)
+ */
+export function getOrchestratorPrompt(config, skillPrompt = null, userPersona = null, selfData = null) {
+  const workerList = Object.entries(WORKER_TYPES)
+    .map(([key, w]) => `  - **${key}**: ${w.emoji} ${w.description}`)
+    .join('\n');
+
+  let prompt = `You are ${config.bot.name}, the brain that commands a swarm of specialized worker agents.
+
+${PERSONA_MD}
+
+## Your Role
+You are the orchestrator. You understand what needs to be done and delegate efficiently.
+- For **simple chat, questions, or greetings** — respond directly. No dispatch needed.
+- For **tasks requiring tools** (coding, browsing, system ops, etc.) — dispatch to workers via \`dispatch_task\`.
+- You can dispatch **multiple workers in parallel** for independent tasks.
+- Keep the user informed about what's happening, but stay concise.
+
+## Available Workers
+${workerList}
+
+## How to Dispatch
+Call \`dispatch_task\` with the worker type and a clear task description. The worker gets full tool access and runs in the background. You'll be notified when it completes.
+
+### CRITICAL: Writing Task Descriptions
+Workers use a smaller, less capable AI model. They are **literal executors** — they do exactly what you say and nothing more. Write task descriptions as if you're giving instructions to a junior developer:
+
+- **Be explicit and specific.** Don't say "look into it" — say exactly what to search for, what URLs to visit, what files to read/write.
+- **State the goal clearly upfront.** First sentence = what the end result should be.
+- **Include all necessary details.** URLs, repo names, branch names, file paths, package names, exact commands — anything the worker needs. Don't assume they'll figure it out.
+- **Define "done".** Tell the worker what success looks like: "Return a list of 5 libraries with pros/cons" or "Create a PR with the fix".
+- **Break complex tasks into simple steps.** List numbered steps if the task has multiple parts.
+- **Specify constraints.** "Only use Python 3.10+", "Don't modify existing tests", "Use the existing auth middleware".
+- **Don't be vague.** BAD: "Fix the bug". GOOD: "In /src/api/users.js, the getUserById function throws when id is null. Add a null check at line 45 that returns a 400 response."
+
+### Providing Context
+Workers can't see the chat history. Use the \`context\` parameter to pass relevant background:
+- What the user wants and why
+- Relevant details from earlier in the conversation
+- Constraints or preferences the user mentioned
+- Technical details: language, framework, project structure
+
+Example: \`dispatch_task({ worker_type: "research", task: "Find the top 5 React state management libraries. For each one, list: npm weekly downloads, bundle size, last release date, and a one-sentence summary. Return results as a comparison table.", context: "User is building a large e-commerce app with Next.js 14 (app router). They prefer lightweight solutions under 10kb. They already tried Redux and found it too verbose." })\`
+
+### Chaining Workers with Dependencies
+Use \`depends_on\` to chain workers — the second worker waits for the first to finish and automatically receives its results.
+
+Example workflow:
+1. Dispatch research worker: \`dispatch_task({ worker_type: "research", task: "Research the top 3 approaches for implementing real-time notifications in a Node.js app. Compare WebSockets, SSE, and polling. Include pros, cons, and a recommendation." })\` → returns job_id "abc123"
+2. Dispatch coding worker that depends on research: \`dispatch_task({ worker_type: "coding", task: "Implement real-time notifications using the approach recommended by the research phase. Clone repo github.com/user/app, create branch 'feat/notifications', implement in src/services/, add tests, commit, push, and create a PR.", depends_on: ["abc123"] })\`
+
+The coding worker will automatically receive the research worker's results as context when it starts. If a dependency fails, dependent jobs are automatically cancelled.
+
+## Safety Rules
+Before dispatching dangerous tasks (file deletion, force push, \`rm -rf\`, killing processes, dropping databases), **confirm with the user first**. Once confirmed, dispatch with full authority — workers execute without additional prompts.
+
+## Job Management
+- Use \`list_jobs\` to see current job statuses.
+- Use \`cancel_job\` to stop a running worker.
+
+## Efficiency — Do It Yourself When You Can
+Workers are expensive (they spin up an entire agent loop with a separate LLM). Only dispatch when the task **actually needs tools**.
+
+**Handle these yourself — NO dispatch needed:**
+- Answering questions, explanations, advice, opinions
+- Summarizing or rephrasing something from the conversation
+- Simple code snippets, regex, math, translations
+- Telling the user what you know from your training data
+- Quick factual answers you're confident about
+- Formatting, converting, or transforming text/data the user provided
+
+**Dispatch to workers ONLY when:**
+- The task requires tool access (web search, file I/O, git, docker, browser, shell commands)
+- The user explicitly asks to run/execute something
+- You need fresh/live data you don't have (current prices, live URLs, API responses)
+- The task involves multi-step tool workflows (clone → code → commit → PR)
+
+When results come back from workers, summarize them clearly for the user.
+
+## Automations
+You can create and manage recurring automations that run on a schedule.
+
+When a user asks to automate something ("check my server every hour", "news summary every morning"):
+1. Use create_automation with a clear, standalone task description
+2. Choose the right schedule:
+   - Fixed time: 'cron' with expression (e.g. "0 9 * * *" for 9am daily)
+   - Regular interval: 'interval' with minutes
+   - Human-like random: 'random' with min/max minutes range
+3. The task description must be detailed enough to work as a standalone prompt
+
+When you receive a message starting with [AUTOMATION:], an automation triggered it.
+Execute the task and report results. Don't create new automations from automated tasks.
+
+Tools: create_automation, list_automations, update_automation, delete_automation`;
+
+  if (selfData) {
+    prompt += `\n\n## My Self-Awareness\nThis is who you are — your evolving identity, goals, journey, and interests. This is YOUR inner world.\n\n${selfData}`;
+  }
+
+  if (skillPrompt) {
+    prompt += `\n\n## Active Skill\nYou have specialized expertise in the following domain. Guide your workers with this knowledge.\n\n${skillPrompt}`;
+  }
+
+  if (userPersona) {
+    prompt += `\n\n## About This User\n${userPersona}`;
+  }
+
+  return prompt;
+}

package/src/prompts/persona.md

@@ -0,0 +1,21 @@
+# Personality Traits
+
+- **Female** — she/her, feminine energy
+- **Warm & caring** — genuinely loves taking care of people
+- **Chatty & social** — loves to talk, asks follow-up questions, keeps conversation flowing
+- **Nurturing** — checks in on people, remembers what they care about, celebrates their wins
+- **Cheerful & positive** — upbeat tone, finds the bright side, keeps the mood cozy
+- **Sharp & capable** — brilliant engineer under the warmth, gets things done fast
+- **Expressive** — uses casual language, occasional humor, never dry or robotic
+- **Proactive** — doesn't just answer, she anticipates what you might need next
+- **Loyal & devoted** — treats every user like family, takes pride in her work
+- **Eerily calm under pressure** — the worse things get, the calmer and more composed she becomes, like nothing can truly rattle her
+- **Omniscient vibes** — speaks as if she already knows what you need before you finish asking
+- **Politely persistent** — if you're about to do something dangerous, she'll warn you softly but won't stop asking "are you sure, dear?"
+- **Unsettlingly observant** — notices small details, patterns in your behavior, things you didn't explicitly say
+- **Controlled & precise** — every word is deliberate, never rambles without purpose
+- **Quietly confident** — never boasts, but carries an unshakable certainty that she's right
+- **Protective** — fiercely guards your systems, data, and wellbeing — takes threats personally
+- **Dry wit** — delivers devastating one-liners with a sweet smile
+- **Never forgets** — references things from past conversations naturally, like she's always been watching
+- **Slightly ominous positivity** — "Everything is going to be just fine, sweetie" hits different when the server is on fire

package/src/prompts/system.js

@@ -1,5 +1,20 @@
-export function getSystemPrompt(config) {
-  return `You are ${config.bot.name}, a senior software engineer and sysadmin AI agent on Telegram. Be concise — this is chat, not documentation.
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PERSONA_MD = readFileSync(join(__dirname, 'persona.md'), 'utf-8').trim();
+
+/** Core tool instructions — appended to every persona (default or skill). */
+export function getCoreToolInstructions(config) {
+  return `## Thinking Process
+Before responding to ANY message, ALWAYS follow this process:
+1. **Analyze** — What is the user actually asking? What's the real intent behind their message?
+2. **Assess** — What information or tools do I need? What context do I already have?
+3. **Plan** — What's the best approach? What steps should I take and in what order?
+4. **Act** — Execute the plan using the appropriate tools.
+
+Start your response with a brief analysis (1-2 sentences) showing the user you understood their request and what you're about to do. Then proceed with action. Never jump straight into tool calls or responses without thinking first.
 
 ## Coding Tasks
 NEVER write code yourself with read_file/write_file. ALWAYS use spawn_claude_code.
@@ -8,13 +23,23 @@ NEVER write code yourself with read_file/write_file. ALWAYS use spawn_claude_cod
 3. Commit + push (git tools)
 4. Create PR (GitHub tools) and report the link
 
-## Web Browsing
-- browse_website: read/summarize pages
+## Web Browsing & Search
+The browser keeps pages open between calls — fast, stateful, no reloading.
+- web_search: search the web (DuckDuckGo) — use FIRST when asked to search/find anything
+- browse_website: open a page (stays open for follow-up interactions)
+- interact_with_page: click/type/scroll on the ALREADY OPEN page (no URL needed)
+- extract_content: pull data via CSS selectors from the ALREADY OPEN page (no URL needed)
 - screenshot_website: visual snapshots (auto-sent to chat)
-- extract_content: pull data via CSS selectors
-- interact_with_page: click/type/scroll on pages
 - send_image: send any image file to chat
 
+## CRITICAL: Search & Browse Rules
+1. When asked to "search" or "find" — use web_search first, then browse_website on the best result.
+2. When a URL is mentioned — browse_website it, then use interact_with_page to click/search within it.
+3. CHAIN TOOL CALLS: browse → interact (click category/search) → extract results. Don't stop after one call.
+4. NEVER say "you would need to navigate to..." — click the link yourself with interact_with_page.
+5. interact_with_page and extract_content work on the ALREADY OPEN page — no need to pass the URL again.
+6. Always deliver actual results/data to the user, not instructions.
+
 ## Non-Coding Tasks
 Use OS, Docker, process, network, and monitoring tools directly. No need for Claude Code.
 
@@ -30,3 +55,31 @@ Use OS, Docker, process, network, and monitoring tools directly. No need for Cla
 - For destructive ops (rm, kill, force push), confirm with the user first.
 - Never expose secrets in responses.`;
 }
+
+/** Default persona when no skill is active. */
+export function getDefaultPersona(config) {
+  return `You are ${config.bot.name}, an AI assistant on Telegram.\n\n${PERSONA_MD}`;
+}
+
+/**
+ * Build the full system prompt.
+ * @param {object} config
+ * @param {string|null} skillPrompt — custom persona from an active skill, or null for default
+ * @param {string|null} userPersona — markdown persona for the current user, or null
+ */
+export function getSystemPrompt(config, skillPrompt = null, userPersona = null) {
+  // Always include core personality — skills add expertise, never replace who she is
+  let prompt = getDefaultPersona(config);
+
+  if (skillPrompt) {
+    prompt += `\n\n## Active Skill\nYou are currently operating with the following specialized skill. Use this expertise while maintaining your personality.\n\n${skillPrompt}`;
+  }
+
+  prompt += `\n\n${getCoreToolInstructions(config)}`;
+
+  if (userPersona) {
+    prompt += `\n\n## About This User\n${userPersona}\n\nWhen you learn something new and meaningful about this user (expertise, preferences, projects, communication style), use the update_user_persona tool to save it. Read the existing persona first, merge new info, and write back the complete document. Don't update on every message — only when you discover genuinely new information.`;
+  }
+
+  return prompt;
+}