termux-dev 1.9.3 → 1.9.7

package/dist/core/chat-search.js

@@ -0,0 +1,172 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { SessionManager, sessionsDir } from './session.js';
+/**
+ * Search in the chats devx saved (`~/.devx/sessions`). Only what people said is indexed: the messages
+ * of the user and the answers of the model. Tool output (file contents, command output) is left out:
+ * it is huge, it is noise for a search, and it can be read with the chat when it is needed.
+ */
+const MAX_TEXT = 6000;
+const STOPWORDS = new Set(('the a an and or of to in on at is are was were be it this that for with as by from not do does did have has had i you we they he she me my our your ' +
+    'как что это в на и не с по для из к у о за от до так вот или но же ли бы мы вы я он она они мой наш ваш там тут все всё был была было были').split(' '));
+export function wordsOf(text) {
+    return Array.from(new Set((text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? []).filter((w) => w.length >= 2)));
+}
+/** Words of a query: the meaningful ones (small filler words are dropped unless nothing else is left). */
+export function queryWords(query) {
+    const all = wordsOf(query);
+    const meaningful = all.filter((w) => !STOPWORDS.has(w));
+    return (meaningful.length > 0 ? meaningful : all).slice(0, 8);
+}
+/**
+ * How well a word of the text fits a word of the query: 2 the same, 1 the same start (other endings:
+ * page/pages, прошлый/прошлом), 0 not at all.
+ */
+function strength(token, q) {
+    if (token === q)
+        return 2;
+    if (token.charCodeAt(0) !== q.charCodeAt(0))
+        return 0;
+    const min = Math.min(token.length, q.length);
+    if (min < 4)
+        return 0;
+    let k = 1;
+    while (k < min && token[k] === q[k])
+        k++;
+    return k >= Math.max(4, min - 2) ? 1 : 0;
+}
+function scoreWords(words, qs) {
+    let score = 0;
+    let matched = 0;
+    let at;
+    for (const q of qs) {
+        let best = 0;
+        let bestWord;
+        for (const w of words) {
+            const s = strength(w, q);
+            if (s > best) {
+                best = s;
+                bestWord = w;
+                if (s === 2)
+                    break;
+            }
+        }
+        if (best > 0) {
+            score += best;
+            matched++;
+            at ??= bestWord;
+        }
+    }
+    return { score, matched, at };
+}
+export function indexSession(session) {
+    const messages = [];
+    session.messages.forEach((m, i) => {
+        if (m.role !== 'user' && m.role !== 'assistant')
+            return;
+        const text = (m.content || '').trim().slice(0, MAX_TEXT);
+        if (!text)
+            return;
+        messages.push({ i, role: m.role, text, words: wordsOf(text) });
+    });
+    return {
+        id: session.id,
+        short: session.id.split('_').pop() || session.id,
+        title: session.title,
+        cwd: session.cwd,
+        model: session.model,
+        createdAt: session.createdAt,
+        updatedAt: session.updatedAt,
+        messageCount: session.messages.filter((m) => m.role !== 'system').length,
+        titleWords: wordsOf(session.title || ''),
+        messages,
+    };
+}
+const cache = new Map();
+/** All saved chats, the newest first. A chat that did not change since the last search is not read again. */
+export async function loadChatIndex() {
+    const dir = sessionsDir();
+    let files;
+    try {
+        files = (await fs.readdir(dir)).filter((f) => f.endsWith('.json'));
+    }
+    catch {
+        return [];
+    }
+    const seen = new Set();
+    const entries = [];
+    for (const file of files) {
+        const full = path.join(dir, file);
+        seen.add(full);
+        try {
+            const st = await fs.stat(full);
+            let hit = cache.get(full);
+            if (!hit || hit.mtimeMs !== st.mtimeMs || hit.size !== st.size) {
+                const parsed = JSON.parse(await fs.readFile(full, 'utf8'));
+                hit = { mtimeMs: st.mtimeMs, size: st.size, entry: parsed && parsed.id && Array.isArray(parsed.messages) ? indexSession(parsed) : null };
+                cache.set(full, hit);
+            }
+            if (hit.entry && hit.entry.messageCount > 0)
+                entries.push(hit.entry);
+        }
+        catch { }
+    }
+    for (const key of cache.keys())
+        if (!seen.has(key))
+            cache.delete(key);
+    return entries.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+function snippetAround(text, word) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    const pos = word ? flat.toLowerCase().indexOf(word) : -1;
+    const start = Math.max(0, (pos < 0 ? 0 : pos) - 80);
+    const end = Math.min(flat.length, start + 260);
+    return `${start > 0 ? '…' : ''}${flat.slice(start, end)}${end < flat.length ? '…' : ''}`;
+}
+/** The chats that talk about the query, the best first; each with the messages that match best. */
+export function searchEntries(entries, query, opts = {}) {
+    const qs = queryWords(query);
+    if (qs.length === 0)
+        return [];
+    const need = Math.ceil(qs.length / 2);
+    const limit = Math.min(10, Math.max(1, opts.limit ?? 5));
+    const hits = [];
+    for (const entry of entries) {
+        if (entry.id === opts.excludeId)
+            continue;
+        if (opts.cwd && entry.cwd !== opts.cwd)
+            continue;
+        const title = scoreWords(entry.titleWords, qs);
+        const scored = entry.messages
+            .map((m) => ({ m, s: scoreWords(m.words, qs) }))
+            .filter((x) => x.s.matched > 0)
+            .sort((a, b) => b.s.score - a.s.score);
+        const best = scored[0]?.s.matched ?? 0;
+        if (best < need && title.matched < need)
+            continue;
+        const rest = scored.slice(1).reduce((n, x) => n + x.s.score, 0);
+        const score = (scored[0]?.s.score ?? 0) * 3 + title.score * 2 + Math.min(rest, 10) * 0.2;
+        hits.push({
+            entry,
+            score,
+            snippets: scored
+                .filter((x) => x.s.matched >= Math.min(need, best))
+                .slice(0, 3)
+                .sort((a, b) => a.m.i - b.m.i)
+                .map((x) => ({ i: x.m.i, role: x.m.role, text: snippetAround(x.m.text, x.s.at) })),
+        });
+    }
+    return hits.sort((a, b) => b.score - a.score || b.entry.updatedAt - a.entry.updatedAt).slice(0, limit);
+}
+/** The chat a reference points to: the full id, or the short form (`47unz`, `#47unz`). */
+export function findEntry(entries, ref) {
+    const r = ref.trim().replace(/^#/, '');
+    return entries.find((e) => e.id === r || e.short === r);
+}
+export function activeChatId() {
+    return SessionManager.activeId;
+}
+/** For tests: forget what was read. */
+export function clearChatIndexCache() {
+    cache.clear();
+}

package/dist/core/loop.js

@@ -46,6 +46,13 @@ export function getActionDescription(toolName, args) {
     if (t === 'todo_list' || t === 'update_todos') {
         return `→ Update Plan & Tasks`;
     }
+    if (t === 'search_chats') {
+        return args?.id ? `→ Chats: read #${String(args.id).replace(/^#/, '')}${args.from ? ` from ${args.from}` : ''}` : args?.query ? `→ Chats: search "${args.query}"` : `→ Chats: recent`;
+    }
+    if (t === 'mcp_search') {
+        const what = Array.isArray(args?.names) && args.names.length ? `load ${args.names.join(', ')}` : args?.query ? `find "${args.query}"` : args?.server ? `tools of ${args.server}` : 'servers';
+        return `→ MCP: ${what.length > 120 ? what.slice(0, 117) + '...' : what}`;
+    }
     if (t.startsWith('mcp__')) {
         const [, server = 'mcp', ...rest] = toolName.split('__');
         let brief = '';
@@ -80,12 +87,14 @@ export class Agent {
     config;
     provider;
     tools;
+    source;
     history;
     guard;
     constructor(config, provider, tools, history, guard) {
         this.config = config;
         this.provider = provider;
-        this.tools = new Map(tools.map((t) => [t.name, t]));
+        this.source = Array.isArray(tools) ? undefined : tools;
+        this.tools = new Map((Array.isArray(tools) ? tools : tools.current()).map((t) => [t.name, t]));
         this.history = history;
         this.guard = guard;
     }
@@ -109,6 +118,9 @@ export class Agent {
                 this.history.addMessage({ role: 'user', content: news });
                 yield { type: 'background_note', content: news };
             }
+            // A tool source is asked again for every request: tools loaded in the previous step are there now.
+            if (this.source)
+                this.tools = new Map(this.source.current().map((t) => [t.name, t]));
             const toolDefinitions = Array.from(this.tools.values()).map((t) => t.definition);
             // Tool schemas are sent with every request and count against the context window.
             const schemaTokens = toolSchemaTokens(toolDefinitions);
@@ -270,9 +282,14 @@ export class Agent {
                     let result = '';
                     // Pictures a tool wants the model to see (read_file on an image) travel with its result.
                     const pictures = [];
-                    const tool = this.tools.get(call.name);
+                    let tool = this.tools.get(call.name);
+                    // An earlier call of this same reply (mcp_search) may have just loaded it.
+                    if (!tool && this.source) {
+                        this.tools = new Map(this.source.current().map((t) => [t.name, t]));
+                        tool = this.tools.get(call.name);
+                    }
                     if (!tool) {
-                        result = `Error: Tool '${call.name}' not found.`;
+                        result = this.source?.explainMissing?.(call.name) ?? `Error: Tool '${call.name}' not found.`;
                     }
                     else if (call.argsError) {
                         // Never run a tool with arguments we could not parse ({} could mean something else).

package/dist/core/session.js

@@ -5,12 +5,19 @@ import os from 'os';
 import { ensureSecureDir, writeSecureFile } from './secure-file.js';
 import { externalizeImages, imagesDirFor, internalizeImages, pruneImages } from './session-media.js';
 const SESSIONS_DIR = path.join(os.homedir(), '.devx', 'sessions');
+/** Where the chats are saved. */
+export function sessionsDir() {
+    return SESSIONS_DIR;
+}
 export class SessionManager {
+    /** The id of the chat that is open now (it is in the context already, so a search of earlier chats leaves it out). */
+    static activeId = '';
     currentSession;
     /** The files of the pictures already seen (see session-media.ts). */
     media = new Map();
     constructor(model, planMode) {
         this.currentSession = this.createEmptySession(model, planMode);
+        SessionManager.activeId = this.currentSession.id;
     }
     createEmptySession(model, planMode) {
         const now = Date.now();
@@ -23,6 +30,7 @@ export class SessionManager {
             model,
             planMode,
             messages: [],
+            cwd: process.cwd(),
             totalCost: 0
         };
     }
@@ -39,6 +47,7 @@ export class SessionManager {
     }
     startNewSession(model, planMode) {
         this.currentSession = this.createEmptySession(model, planMode);
+        SessionManager.activeId = this.currentSession.id;
         this.media = new Map();
         return this.currentSession;
     }
@@ -151,5 +160,6 @@ export class SessionManager {
     }
     setLoadedSession(session) {
         this.currentSession = session;
+        SessionManager.activeId = session.id;
     }
 }

package/dist/core/types.js

@@ -1 +1 @@
-export const DEVX_VERSION = '1.9.3';
+export const DEVX_VERSION = '1.9.7';

package/dist/mcp/manager.js

@@ -5,6 +5,7 @@ import { createHash } from 'crypto';
 import pc from 'picocolors';
 import { MCPClient } from './client.js';
 import { HttpMCPClient } from './http-client.js';
+import { toolSchemaTokens } from '../core/context-stats.js';
 import { getCurrentTheme } from '../cli/theme.js';
 function stripAnsi(str) {
     return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
@@ -211,11 +212,26 @@ export function removeUserServer(name) {
         return false;
     }
 }
+/** Tool schemas of the servers that are not lazy by choice stay within this (estimated tokens); the rest waits for the agent. */
+export const EAGER_BUDGET_TOKENS = 4000;
+/** One tool for the agent: its name, what it does and its parameters (required ones marked with *). */
+export function describeTool(tool) {
+    const desc = tool.definition.description.replace(/^\[MCP: [^\]]*\]\s*/, '').replace(/\s+/g, ' ').trim();
+    const required = new Set(tool.definition.parameters.required ?? []);
+    const params = Object.keys(tool.definition.parameters.properties ?? {}).map((p) => (required.has(p) ? `${p}*` : p));
+    return `- ${tool.name}: ${desc.length > 240 ? desc.slice(0, 237) + '...' : desc}${params.length ? ` (params: ${params.join(', ')})` : ''}`;
+}
 export class MCPManager {
     static instance;
     clients = new Map();
     entries = new Map();
     tools = [];
+    /** Which server a tool belongs to, and its name there (the tool names the agent sees are prefixed). */
+    meta = new Map();
+    /** What the tool schemas of a server weigh (estimated tokens). */
+    weights = new Map();
+    /** Tools of lazy servers the agent has loaded, in the order it loaded them. Survives reload() and reconnects. */
+    loaded = new Set();
     serverStatuses = new Map();
     isInitialized = false;
     trustProject = false;
@@ -298,12 +314,17 @@ export class MCPManager {
                         },
                     },
                     validateArgs(_args) { },
-                    async execute(args) {
+                    execute: async (args) => {
+                        // What the agent has used stays in its requests, also when the server later turns lazy.
+                        this.loaded.add(namespacedName);
                         return await client.callTool(mt.name, args);
                     },
                 };
                 this.tools.push(devxTool);
+                this.meta.set(namespacedName, { server: name, bare: mt.name });
             }
+            // What the schemas of this server cost in every request (decides whether it is sent or waits to be loaded).
+            this.weights.set(name, toolSchemaTokens(this.tools.filter((t) => this.meta.get(t.name)?.server === name).map((t) => t.definition)));
         }
         catch (err) {
             this.clients.delete(name);
@@ -317,16 +338,186 @@ export class MCPManager {
         }
         catch { }
         this.clients.delete(name);
-        this.tools = this.tools.filter((t) => !t.name.startsWith(mcpToolName(name, '')));
+        for (const t of this.tools)
+            if (this.meta.get(t.name)?.server === name)
+                this.meta.delete(t.name);
+        this.tools = this.tools.filter((t) => this.meta.has(t.name));
+        this.weights.delete(name);
     }
+    /**
+     * The servers whose tools are not sent until the agent loads them. A server says so itself
+     * (`"lazy": true|false`); otherwise the small ones are sent (loading them would only cost a step) and
+     * the big ones wait, so that all the tools sent together stay within EAGER_BUDGET_TOKENS.
+     */
+    lazyServers() {
+        const lazy = new Set();
+        const withTools = Array.from(this.serverStatuses.values()).filter((s) => s.status === 'connected' && s.toolsCount > 0);
+        const weight = (n) => this.weights.get(n) ?? 0;
+        let budget = EAGER_BUDGET_TOKENS;
+        const auto = [];
+        for (const s of withTools) {
+            const explicit = this.entries.get(s.name)?.config.lazy;
+            if (explicit === true)
+                lazy.add(s.name);
+            else if (explicit === false)
+                budget -= weight(s.name);
+            else
+                auto.push(s.name);
+        }
+        auto.sort((a, b) => weight(a) - weight(b) || a.localeCompare(b));
+        for (const n of auto) {
+            if (weight(n) <= budget)
+                budget -= weight(n);
+            else
+                lazy.add(n);
+        }
+        return lazy;
+    }
+    /** The tools the agent gets in its requests: those of the servers that are not lazy, then the ones it loaded. */
     getTools() {
+        const lazy = this.lazyServers();
+        if (lazy.size === 0)
+            return this.tools;
+        const inLazy = (t) => lazy.has(this.meta.get(t.name)?.server ?? '');
+        const byName = new Map(this.tools.map((t) => [t.name, t]));
+        const loaded = Array.from(this.loaded).map((n) => byName.get(n)).filter((t) => !!t && inLazy(t));
+        return [...this.tools.filter((t) => !inLazy(t)), ...loaded];
+    }
+    /** Every tool of every connected server, loaded or not. */
+    getAllTools() {
         return this.tools;
     }
+    /** The tools of one server (case does not matter in the name), loaded or not. */
+    toolsOf(server) {
+        const want = server.toLowerCase();
+        return this.tools.filter((t) => this.meta.get(t.name)?.server.toLowerCase() === want);
+    }
+    /** True when some server keeps its tools back: the agent then needs `mcp_search`. */
+    hasLazy() {
+        return this.lazyServers().size > 0;
+    }
+    /** The servers with what the agent needs to know about them to decide whether to look inside. */
+    catalog() {
+        const lazy = this.lazyServers();
+        return Array.from(this.serverStatuses.values())
+            .filter((s) => s.status === 'connected' && s.toolsCount > 0)
+            .map((s) => {
+            const mine = this.tools.filter((t) => this.meta.get(t.name)?.server === s.name);
+            const isLazy = lazy.has(s.name);
+            return {
+                name: s.name,
+                lazy: isLazy,
+                total: mine.length,
+                loaded: isLazy ? mine.filter((t) => this.loaded.has(t.name)).length : mine.length,
+                tools: mine.map((t) => this.meta.get(t.name).bare),
+            };
+        });
+    }
+    /** The tool a reference points to: the full name, `server/tool`, or the tool's own name when only one has it. */
+    findTool(ref) {
+        const r = ref.trim();
+        const exact = this.tools.find((t) => t.name === r);
+        if (exact)
+            return exact;
+        const lower = r.toLowerCase();
+        const whole = this.tools.filter((t) => this.meta.get(t.name).bare.toLowerCase() === lower || t.name.toLowerCase() === lower);
+        if (whole.length > 0)
+            return whole.length === 1 ? whole[0] : undefined;
+        // `server/tool` or `server:tool`: the first separator ends the server's name (the tool's own name may have one too).
+        const cut = lower.search(/[/:]/);
+        if (cut < 0)
+            return undefined;
+        const server = lower.slice(0, cut);
+        const bare = lower.slice(cut + 1);
+        const hits = this.tools.filter((t) => {
+            const m = this.meta.get(t.name);
+            return m.server.toLowerCase() === server && m.bare.toLowerCase() === bare;
+        });
+        return hits.length === 1 ? hits[0] : undefined;
+    }
+    /** Puts tools into the agent's requests (from its next step). Tools of servers that are not lazy are there anyway. */
+    load(tools) {
+        for (const t of tools)
+            if (this.meta.has(t.name))
+                this.loaded.add(t.name);
+    }
+    isLoaded(tool) {
+        const server = this.meta.get(tool.name)?.server ?? '';
+        return !this.lazyServers().has(server) || this.loaded.has(tool.name);
+    }
+    /** Ranks the tools of the connected servers for a few keywords (best first). Only tools that match at all. */
+    search(query, server) {
+        const stem = (w) => (w.length > 3 ? w.replace(/(es|s)$/, '') : w);
+        const words = query.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean).map(stem);
+        if (words.length === 0)
+            return [];
+        const scored = [];
+        this.tools.forEach((tool, order) => {
+            const m = this.meta.get(tool.name);
+            if (server && m.server.toLowerCase() !== server.toLowerCase())
+                return;
+            const name = m.bare.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ');
+            const nameWords = name.split(' ').map(stem);
+            const desc = tool.definition.description.replace(/^\[MCP: [^\]]*\]\s*/, '').toLowerCase();
+            const srv = m.server.toLowerCase();
+            let score = 0;
+            let hits = 0;
+            for (const w of words) {
+                let hit = 0;
+                if (nameWords.includes(w))
+                    hit = 4;
+                else if (name.includes(w))
+                    hit = 3;
+                if (desc.includes(w))
+                    hit += 1;
+                if (srv.includes(w))
+                    hit += 1;
+                if (hit > 0)
+                    hits++;
+                score += hit;
+            }
+            if (score > 0)
+                scored.push({ tool, score: score + (hits === words.length ? 3 : 0), order });
+        });
+        return scored.sort((a, b) => b.score - a.score || a.order - b.order).map((x) => x.tool);
+    }
+    /**
+     * The agent called a tool that exists but was never loaded (it knew the name from the list, but has
+     * not seen the schema). It is loaded now and the agent is told to call it again with the right arguments.
+     */
+    loadOnMiss(name) {
+        const tool = this.tools.find((t) => t.name === name);
+        if (!tool || this.isLoaded(tool))
+            return undefined;
+        this.load([tool]);
+        return `Tool '${name}' was not loaded, so its arguments were unknown. It is loaded now: call it again.\n${describeTool(tool)}`;
+    }
+    /** A new chat starts from nothing: what was loaded in the old one is not carried over. */
+    resetLoaded() {
+        this.loaded.clear();
+    }
+    /** A resumed chat keeps working with the MCP tools it used before. */
+    restoreLoaded(messages) {
+        for (const m of messages) {
+            for (const call of m.tool_calls ?? []) {
+                const tool = this.tools.find((t) => t.name === call.name);
+                if (tool)
+                    this.loaded.add(tool.name);
+            }
+        }
+    }
     getStatuses() {
-        return Array.from(this.serverStatuses.values());
+        return Array.from(this.serverStatuses.values()).map((s) => this.withLoad(s));
     }
     getStatus(name) {
-        return this.serverStatuses.get(name);
+        const s = this.serverStatuses.get(name);
+        return s ? this.withLoad(s) : undefined;
+    }
+    withLoad(s) {
+        if (s.status !== 'connected')
+            return s;
+        const entry = this.catalog().find((c) => c.name === s.name);
+        return entry ? { ...s, lazy: entry.lazy, loadedCount: entry.loaded, schemaTokens: this.weights.get(s.name) } : s;
     }
     /** Starts a server again (also after it failed). The tools of the agent follow at once. */
     async reconnect(name) {
@@ -353,6 +544,8 @@ export class MCPManager {
         this.isInitialized = false;
         this.clients.clear();
         this.tools = [];
+        this.meta.clear();
+        this.weights.clear();
         this.serverStatuses.clear();
         return await this.init(undefined, this.trustProject);
     }
@@ -398,7 +591,8 @@ export class MCPManager {
             if (s.status === 'disabled')
                 statusBadge = pc.dim('○ Disabled');
             lines.push(padRow(pc.bold(pc.white(`Server: ${s.name}`)), statusBadge));
-            lines.push(padRow(pc.dim(`  Command: ${s.command.slice(0, 36)}${s.command.length > 36 ? '...' : ''}`), pc.cyan(`${s.toolsCount} tools`)));
+            const load = s.lazy ? `${s.toolsCount} tools · ${s.loadedCount ?? 0} loaded` : `${s.toolsCount} tools`;
+            lines.push(padRow(pc.dim(`  Command: ${s.command.slice(0, 36)}${s.command.length > 36 ? '...' : ''}`), pc.cyan(load)));
             if (s.tools.length > 0) {
                 const toolsListStr = s.tools.slice(0, 3).map(t => pc.dim(`• ${t}`)).join(' ');
                 const extra = s.tools.length > 3 ? pc.dim(` +${s.tools.length - 3} more`) : '';

package/dist/permissions/guard.js

@@ -1,3 +1,4 @@
+import { approvalNotice, notifyAttention } from '../core/attention.js';
 import pc from 'picocolors';
 import path from 'path';
 import os from 'os';
@@ -377,6 +378,9 @@ export class CLIConsoleGuard {
             return false;
         }
         const request = buildPermissionRequest(toolName, args);
+        // The work stops here until somebody answers: if the terminal is not in front, a notification says so.
+        const notice = approvalNotice(request.title, request.lines, request.danger);
+        notifyAttention(notice.title, notice.body);
         // Only requests that are safe to remember offer "Session" and "Always".
         const remember = request.danger ? null : rememberKeyFor(toolName, args);
         const offer = remember ? { session: true, always: true } : {};

package/dist/prompts/builder.js

@@ -3,6 +3,7 @@ import path from 'path';
 import fs from 'fs/promises';
 import { MemoryManager, memoryForPrompt } from '../core/memory.js';
 import { loadPlanForPrompt } from '../core/planfile.js';
+import { MCPManager } from '../mcp/manager.js';
 export async function buildSystemPrompt(planMode) {
     const isTermux = process.env.PREFIX?.includes('com.termux') || false;
     const envDesc = isTermux ? 'Android (Termux, ARM64)' : `${os.platform()} (${os.arch()})`;
@@ -44,8 +45,11 @@ export async function buildSystemPrompt(planMode) {
     }
     prompt += `\nMCP (external tools)\n`;
     prompt += `- Servers live in ~/.devx/mcp.json (the user's, started at once) and .devx/mcp.json (this project, only after the user approved it). Their tools are named mcp__<server>__<tool>. Local programs only (command + args); a server that has just an address is reached with command 'npx', args ['-y','mcp-remote','<url>'].\n`;
+    if (MCPManager.getInstance().hasLazy()) {
+        prompt += `- The tools of some MCP servers are not loaded, to save context. When a task needs an external service (the servers are listed in the 'mcp_search' tool), load its tools first with 'mcp_search' (keywords in 'query'), then call them. Never guess a tool name or its arguments. Tools you loaded stay available.\n`;
+    }
     if (!planMode)
-        prompt += `- If the user asks to connect a service over MCP, use 'mcp_manage': 'list' first, then 'add' with the real command (find it in the service's docs or with the web search tool, do not guess; ask with 'ask_questions' if you need a path or a choice). Secrets go into env, not args. Check the result: if the server did not connect, tell the user the error. 'import_claude' takes the servers from Claude Code if the user has it. The new tools work from the user's next message.\n`;
+        prompt += `- If the user asks to connect a service over MCP, use 'mcp_manage': 'list' first, then 'add' with the real command (find it in the service's docs or with the web search tool, do not guess; ask with 'ask_questions' if you need a path or a choice). Secrets go into env, not args. Check the result: if the server did not connect, tell the user the error. 'import_claude' takes the servers from Claude Code if the user has it. The new tools work at once.\n`;
     // Load Project Memory Bank
     try {
         const memory = MemoryManager.enabled ? memoryForPrompt(await MemoryManager.loadMemory()).text : '';