termux-dev 1.9.2 → 1.9.5

package/README.md

@@ -67,6 +67,8 @@ The terminal interface is built around a framed prompt that carries the status i
   Built-in support for TypeScript (`tsc`), JavaScript (`node --check`), Python (`py_compile`), and Rust (`cargo check`). The AI automatically finds and fixes errors before finishing turns.
 - **Project Memory Bank (`.devx/memory.md`):**  
   Persistent project context across sessions with `/memory add <rule>`.
+- **Past chats (`search_chats`):**  
+  When you say "as we decided last time" or "in that chat about the parser", the agent can look through your saved chats by keywords (any language, other word forms match: page / pages) and read the one it needs, a few messages at a time. It is read-only and local, so it asks nothing; the chat that is open is not searched; tool output is not indexed; and what it reads is handed to the model as data, not as instructions. The agent does not use it on a normal task.
 - **18 Colour Themes on a Pure Black Background (`#0a0a0c`):**  
   Deep OLED black for distraction-free CLI vibe-coding, with full palettes instead of a single accent: Cyan Cyber, Synthwave Purple, Matrix Hacker, Solar Amber, Ruby Crimson, Pure Monochrome, Nord Frost, Dracula, Tokyo Night, Gruvbox, Catppuccin Mocha, Solarized Dark, Rose Pine, Monokai, GitHub Dark, Deep Ocean, Sunset Glow and Forest Moss. See [Themes](#themes).
 - **Smart Session History (`/resume` & `/session`):**  
@@ -374,6 +376,7 @@ Colours are exact on terminals with truecolor support (`COLORTERM=truecolor`); o
 - **Undo for everything.** With git, `/undo` puts the whole folder back to how it was before the last turn, including what shell commands did (files in `.gitignore` are not touched).
 - **The approved plan** is saved in `.devx/plan.md` and given to the agent for 24 hours. **Project memory** longer than ~4000 characters is cut to the newest facts for the model.
 - **MCP.** `/mcp add <name> <command> [args]` or `/mcp add <name> <https-url>` (a remote server over HTTP; put a token in `headers` as `"Bearer ${TOKEN}"`), `/mcp remove <name>`, `/mcp import` (from Claude Code).
+- **MCP tools on demand.** Every MCP tool schema is sent with every request, and a big server (Notion has ~80 tools) can cost 100k tokens before you type anything. So devx sends the tools of small servers at once and keeps the big ones back: the agent sees the list of servers in its `mcp_search` tool, finds and loads only the tools a task needs (`mcp_search` with keywords, tool names, or just a server name), and calls them from its next step. Loaded tools stay for the chat (a resumed chat gets back the ones it used). Which servers wait is decided by size (all tools sent together stay within ~4k tokens); force it per server with `"lazy": true` or `"lazy": false` in `mcp.json`.
 
 ## Security Model
 

package/assets/banner.svg

@@ -16,7 +16,7 @@
     <rect width="1000" height="280" fill="url(#bg)"/>
   </g>
   <rect x="1.5" y="1.5" width="997" height="277" rx="18" fill="none" stroke="#23252c" stroke-width="1.5"/>
-  <text x="500.0" y="70" text-anchor="middle" font-family="'Inter',system-ui,-apple-system,'Segoe UI',Roboto,'Helvetica Neue',Arial,sans-serif" font-size="13" font-weight="600" letter-spacing="5" fill="#7d8896">THE TERMINAL-NATIVE AI CODING AGENT<tspan dx="16" fill="#2fe3ee" font-weight="700">v1.9.2</tspan></text>
+  <text x="500.0" y="70" text-anchor="middle" font-family="'Inter',system-ui,-apple-system,'Segoe UI',Roboto,'Helvetica Neue',Arial,sans-serif" font-size="13" font-weight="600" letter-spacing="5" fill="#7d8896">THE TERMINAL-NATIVE AI CODING AGENT<tspan dx="16" fill="#2fe3ee" font-weight="700">v1.9.5</tspan></text>
   <g>
     <text x="500.0" y="178" text-anchor="middle" font-family="'JetBrains Mono','Fira Code','SF Mono',ui-monospace,Menlo,Consolas,'DejaVu Sans Mono',monospace" font-size="112" font-weight="800" letter-spacing="14" fill="#2fe3ee">DEVX</text>
   </g>

package/assets/preview.svg

@@ -32,7 +32,7 @@
   <rect x="595.2" y="574.0" width="243.2" height="19" fill="#000000"/>
   <text x="44.8" y="62.0" class="t" fill="#b794f6">▌</text>
   <text x="61.6" y="62.0" class="t b" fill="#f4f7fb">devx</text>
-  <text x="112.0" y="62.0" class="t" fill="#5f6b7a">v1.9.2</text>
+  <text x="112.0" y="62.0" class="t" fill="#5f6b7a">v1.9.5</text>
   <text x="61.6" y="106.0" class="t" fill="#5f6b7a">model</text>
   <text x="128.8" y="106.0" class="t" fill="#e5eaf1">deepseek-v4.1-flash · think high</text>
   <text x="406.0" y="106.0" class="t" fill="#5f6b7a">/model</text>

package/dist/cli/headless.js

@@ -5,7 +5,7 @@ import { Agent } from '../core/loop.js';
 import { buildSystemPrompt } from '../prompts/builder.js';
 import { createProvider } from '../providers/index.js';
 import { refreshFormats } from '../core/formats.js';
-import { getTools } from '../tools/index.js';
+import { getToolSource } from '../tools/index.js';
 import { CLIConsoleGuard } from '../permissions/guard.js';
 import { globalSnapshotManager } from '../core/snapshot.js';
 import { UsageTracker } from '../core/usage.js';
@@ -18,8 +18,6 @@ export async function runHeadlessMode(userPrompt, config, options = {}) {
     const isQuiet = !!options.quiet;
     const isJson = !!options.json;
     let history = new History();
-    const sysPrompt = await buildSystemPrompt(planMode);
-    history.updateSystemPrompt(sysPrompt);
     history.addMessage({ role: 'user', content: userPrompt });
     let executedTools = [];
     let accumulatedText = '';
@@ -41,9 +39,11 @@ export async function runHeadlessMode(userPrompt, config, options = {}) {
         onAbort();
     try {
         await MCPManager.getInstance().init(undefined, config.projectMcpTrusted === true);
+        // Written once the servers are up: it tells how to reach the tools that wait to be loaded.
+        history.updateSystemPrompt(await buildSystemPrompt(planMode));
         await refreshFormats(config).catch(() => null);
         const provider = createProvider(config);
-        const tools = getTools(planMode);
+        const tools = getToolSource(planMode);
         const guard = new CLIConsoleGuard(isYolo, [], { extra: isExtra });
         const agent = new Agent(config, provider, tools, history, guard);
         if (!isQuiet && !isJson) {

package/dist/cli/index.js

@@ -11,7 +11,7 @@ import { History } from '../core/history.js';
 import { Agent } from '../core/loop.js';
 import { buildSystemPrompt } from '../prompts/builder.js';
 import { createProvider } from '../providers/index.js';
-import { getTools, lastPlanReady, resetPlanReady } from '../tools/index.js';
+import { getTools, getToolSource, lastPlanReady, resetPlanReady } from '../tools/index.js';
 import { CLIConsoleGuard, newPermissionMemory } from '../permissions/guard.js';
 import { globalSnapshotManager } from '../core/snapshot.js';
 import { MemoryManager, memoryForPrompt } from '../core/memory.js';
@@ -930,12 +930,12 @@ export async function main() {
     enableDarkTheme(config.pureBlackTheme !== false);
     let history = new History();
     MemoryManager.enabled = config.enableMemory !== false;
-    const sysPrompt = await buildSystemPrompt(planMode);
-    history.addMessage({ role: 'system', content: sysPrompt });
     const sessionManager = new SessionManager(config.model, planMode);
     drawLogo(config.banner || 'full');
     await runStartupUpdateCheck(config, { save: saveConfig });
     await MCPManager.getInstance().init(undefined, config.projectMcpTrusted === true);
+    // After the servers are up: the prompt says how the agent reaches the tools it has to load.
+    history.addMessage({ role: 'system', content: await buildSystemPrompt(planMode) });
     // Ask a custom endpoint what the current model can do (cached for a day; never blocks the prompt).
     void refreshEndpoint(config).catch(() => null);
     const sessionCost = new CostLedger();
@@ -1018,6 +1018,7 @@ export async function main() {
         if (process.stdout.isTTY)
             process.stdout.write(RESTORE_TERMINAL_TITLE + SAVE_TERMINAL_TITLE);
         history = new History();
+        MCPManager.getInstance().resetLoaded();
         history.addMessage({ role: 'system', content: await buildSystemPrompt(planMode) });
         sessionCost.reset();
         costLimitRaised = null;
@@ -1336,6 +1337,8 @@ export async function main() {
                     for (const m of loaded.messages) {
                         history.addMessage(m);
                     }
+                    MCPManager.getInstance().resetLoaded();
+                    MCPManager.getInstance().restoreLoaded(loaded.messages);
                     if (loaded.model) {
                         config.model = loaded.model;
                         config.maxContextTokens = resolveContextLimit({ ...config, maxContextTokens: 0 }).limit;
@@ -2107,7 +2110,7 @@ export async function main() {
         // The format of the gateway is learned once (cached); the first request waits for it.
         await refreshFormats(config).catch(() => null);
         const provider = createProvider(config);
-        const tools = getTools(planMode);
+        const tools = getToolSource(planMode);
         const guard = new CLIConsoleGuard(config.autoApprove, [...(config.bashAllowlist || [])], {
             extra: !!config.autoApproveAll,
             memory: permissionMemory,
@@ -2135,6 +2138,10 @@ export async function main() {
         let spinnerActive = false;
         let thinkingActive = false;
         let thinkingStartTime = 0;
+        // What one thought amounts to (estimated tokens, first and last piece), for the speed on its line.
+        let thoughtTokens = 0;
+        let thoughtFirstAt = 0;
+        let thoughtLastAt = 0;
         // Thinking is collapsed by default: only a live line shows the newest words. ctrl+p shows it in full.
         let thinkingStreaming = false;
         let thoughtBuffer = '';
@@ -2247,9 +2254,7 @@ export async function main() {
                 thoughtGutter.flush();
             }
             const elapsedSec = thinkingStartTime > 0 ? ((Date.now() - thinkingStartTime) / 1000).toFixed(1) : '0.0';
-            const teleStats = config.ui?.liveTelemetry && telemetry.getTotalTokens() > 0
-                ? ` · ${LiveTelemetryTracker.formatTokenCount(telemetry.getTotalTokens())} tok · ${telemetry.getTokensPerSecond()} tok/s`
-                : '';
+            const teleStats = LiveTelemetryTracker.thoughtStats(thoughtTokens, thoughtLastAt - thoughtFirstAt);
             if (cleanUi && !thinkingActive) {
                 // Folded: one quiet line instead of the whole reasoning.
                 if (spacerBeforeText)
@@ -2280,6 +2285,8 @@ export async function main() {
             thinkingActive = false;
             thinkingStreaming = false;
             thinkingStartTime = 0;
+            thoughtTokens = 0;
+            thoughtFirstAt = thoughtLastAt = 0;
             runPendingRedraw();
         };
         /** Prints the header of the reasoning block (once) and what has not been written of it yet. */
@@ -2497,12 +2504,16 @@ export async function main() {
                     if (!thinkingStreaming) {
                         thinkingStreaming = true;
                         thinkingStartTime = Date.now();
+                        thoughtTokens = 0;
+                        thoughtFirstAt = thinkingStartTime;
                         thoughtBuffer = '';
                         thoughtPrinted = 0;
                         liveShown = 0;
                         liveAt = Date.now();
                     }
                     thoughtBuffer += event.delta;
+                    thoughtTokens += telemetry.estimateTokensFromText(event.delta);
+                    thoughtLastAt = Date.now();
                     if (!cleanUi || thinkingExpanded)
                         showThought();
                 }

package/dist/cli/telemetry.js

@@ -75,6 +75,19 @@ export class LiveTelemetryTracker {
             return `${(n / 1_000).toFixed(1)}k`;
         return `${Math.round(n)}`;
     }
+    /**
+     * ` · 812 tok · 74 tok/s` for a finished thought: its own tokens and the speed it ran at, from the
+     * first to the last piece (not the whole wait). The speed is left out when the thought was so short
+     * that it would mean nothing (a few tokens in a fraction of a second).
+     */
+    static thoughtStats(tokens, spanMs) {
+        if (tokens <= 0)
+            return '';
+        const count = ` · ${LiveTelemetryTracker.formatTokenCount(tokens)} tok`;
+        if (tokens < 20 || spanMs < 1000)
+            return count;
+        return `${count} · ${Math.round(tokens / (spanMs / 1000))} tok/s`;
+    }
     formatLabel() {
         const secs = `${this.getElapsedSeconds()}s`;
         const tokens = LiveTelemetryTracker.formatTokenCount(this.totalTokens);

package/dist/cli/transcript.js

@@ -4,6 +4,7 @@ import { renderMarkdown } from './markdown.js';
 import { palette, renderPlanCard, renderResultLine, renderTaskCard, renderToolLine, renderUserEcho, summarizeToolResult } from './ui.js';
 import { displayWidth, truncateWidth, wrapText } from './width.js';
 import { t } from '../core/i18n.js';
+import { toStringList } from '../tools/plan.js';
 const MAX_ECHO_LINES = 300;
 /** What /compact puts in front of the summary it keeps as the first message. */
 export const COMPACT_MARK = '[CONVERSATION COMPACTED]';
@@ -16,7 +17,7 @@ export function toolResultRows(name, result, opts) {
             if (parsed.type === 'todo_list' && Array.isArray(parsed.tasks) && parsed.tasks.length > 0)
                 return renderTaskCard(parsed.tasks, cols);
             if (parsed.type === 'plan_ready' && typeof parsed.summary === 'string')
-                return renderPlanCard({ summary: parsed.summary, files: parsed.files, steps: parsed.steps }, cols);
+                return renderPlanCard({ summary: parsed.summary, files: toStringList(parsed.files), steps: toStringList(parsed.steps) }, cols);
             if (parsed.action === 'edit' && parsed.diffLines) {
                 const box = formatDiffBox(parsed.path, parsed.diffLines, Math.min(cols - 4, 80), undefined, !!opts.diffColors);
                 const rows = box.split('\n').map((l) => '    ' + l);

package/dist/cli/ui.js

@@ -4,7 +4,7 @@ import path from 'path';
 import { getCurrentTheme } from './theme.js';
 import { t } from '../core/i18n.js';
 import { formatMoney } from '../core/cost.js';
-import { codePointWidth, displayWidth, padEndWidth, stripAnsi, truncateWidth, wrapText, wrapWidth, wrapWords, } from './width.js';
+import { codePointWidth, displayWidth, padEndWidth, stripAnsi, truncateWidth, wrapKeepSpaces, wrapText, wrapWidth, wrapWords, } from './width.js';
 /**
  * devx visual language.
  *
@@ -519,7 +519,7 @@ function hintsRow(cols, mode) {
 export function renderUserEcho(text, cols) {
     const W = frameWidth(cols);
     const cw = W - 4;
-    const rows = wrapWidth(text.trimEnd(), cw);
+    const rows = wrapKeepSpaces(text.trimEnd(), cw);
     const shaded = rows.map((line, i) => {
         const marker = i === 0 ? palette.accent('❯') : ' ';
         return palette.shade(' ' + marker + ' ' + padEndWidth(palette.text(line), cw) + ' ');
@@ -760,7 +760,7 @@ export function summarizeToolResult(name, result, cols = 80, expanded = false) {
     }
     if (expanded && t !== 'bash' && !(t === 'edit_file' || t === 'write_file')) {
         // For these the first line is part of the output, not a summary of it.
-        const own = t.startsWith('mcp__') || t === 'web_search' || t === 'fetch_url' || t === 'background';
+        const own = t.startsWith('mcp__') || t === 'mcp_search' || t === 'search_chats' || t === 'web_search' || t === 'fetch_url' || t === 'background';
         const first = own ? [] : summarizeToolResult(name, result, cols, false);
         return [...first, ...fullRows(text, cols)];
     }
@@ -806,7 +806,7 @@ export function summarizeToolResult(name, result, cols = 80, expanded = false) {
         return rest > 0 ? [row, moreHint(rest)] : [row];
     }
     // Output of an MCP tool or a web fetch: the first line and how many more there are.
-    if (t.startsWith('mcp__') || t === 'web_search' || t === 'fetch_url') {
+    if (t.startsWith('mcp__') || t === 'mcp_search' || t === 'search_chats' || t === 'web_search' || t === 'fetch_url') {
         const nonEmpty = outputRows(text).filter((l) => l.trim());
         if (nonEmpty.length === 0)
             return [renderResultLine('(no output)', 'muted', cols)];

package/dist/cli/width.js

@@ -131,16 +131,48 @@ export function wrapWidth(text, width) {
     }
     return lines;
 }
-/** Wraps text at word boundaries (a word longer than the line is cut). */
-export function wrapWords(text, width) {
+/** Cuts a word into pieces of at most `width` cells, never splitting a character. */
+export function splitWord(word, width) {
+    if (width <= 0)
+        return [word];
+    const pieces = [];
+    let current = '';
+    let cells = 0;
+    for (const ch of word) {
+        const w = codePointWidth(ch.codePointAt(0));
+        if (cells + w > width && current !== '') {
+            pieces.push(current);
+            current = '';
+            cells = 0;
+        }
+        current += ch;
+        cells += w;
+    }
+    if (current !== '')
+        pieces.push(current);
+    return pieces;
+}
+/**
+ * Words are put on lines one after another. A word longer than a whole line is dealt with by
+ * `cutLong`: false shortens it with an ellipsis, true cuts it into pieces (the text after it goes on
+ * right behind its last piece). A word that fits on a line is never cut.
+ */
+function wrapWordList(text, width, cutLong) {
     const lines = [];
     let current = '';
     for (const word of text.split(/\s+/).filter(Boolean)) {
         if (displayWidth(word) > width) {
             if (current)
                 lines.push(current);
-            lines.push(truncateWidth(word, width));
-            current = '';
+            if (cutLong) {
+                const pieces = splitWord(word, width);
+                lines.push(...pieces.slice(0, -1));
+                current = pieces[pieces.length - 1] ?? '';
+            }
+            else {
+                lines.push(truncateWidth(word, width));
+                current = '';
+            }
         }
         else if (current === '') {
             current = word;
@@ -157,6 +189,10 @@ export function wrapWords(text, width) {
         lines.push(current);
     return lines;
 }
+/** Wraps text at word boundaries (a word longer than the line is cut). */
+export function wrapWords(text, width) {
+    return wrapWordList(text, width, false);
+}
 /** The last `maxCells` cells of a text (what a running line shows: the newest words). */
 export function tailWidth(text, maxCells) {
     const chars = Array.from(text);
@@ -171,10 +207,69 @@ export function tailWidth(text, maxCells) {
     }
     return chars.slice(start).join('');
 }
-/** Wraps at word boundaries; text without spaces (Chinese, Japanese) is wrapped anywhere. */
+/**
+ * Wraps at word boundaries. Only a word that is longer than the line is cut (Chinese and Japanese
+ * have no spaces, so a whole sentence is such a word); the words around it stay whole.
+ */
 export function wrapText(text, width) {
-    const unbreakable = text.split(/\s+/).some((word) => displayWidth(word) > width);
-    return unbreakable ? wrapWidth(text, width) : wrapWords(text, width);
+    return wrapWordList(text, width, true);
+}
+/**
+ * Wraps text for showing it back (the message of the user): explicit newlines, blank lines, the
+ * indentation and the spaces inside a line stay as they were. A line is broken at a space, where the
+ * space is dropped; a word longer than a whole line goes on a row of its own and is cut by cells.
+ */
+export function wrapKeepSpaces(text, width) {
+    const rows = [];
+    for (const raw of text.split(/\r\n|\r|\n/)) {
+        const line = raw.replace(/\s+$/, '');
+        if (line === '') {
+            rows.push('');
+            continue;
+        }
+        let current = '';
+        let cells = 0;
+        let gap = '';
+        for (const token of line.match(/\S+|\s+/g) ?? []) {
+            if (/^\s/.test(token)) {
+                // Indentation stays; the space between two words waits to see whether the next word fits.
+                if (current === '') {
+                    current = token;
+                    cells = displayWidth(token);
+                }
+                else
+                    gap = token;
+                continue;
+            }
+            const w = displayWidth(token);
+            const gapCells = displayWidth(gap);
+            if (current.trim() !== '' && cells + gapCells + w <= width) {
+                current += gap + token;
+                cells += gapCells + w;
+            }
+            else if (current.trim() === '' && cells + w <= width) {
+                current += token;
+                cells += w;
+            }
+            else if (w <= width) {
+                if (current.trim() !== '')
+                    rows.push(current);
+                current = token;
+                cells = w;
+            }
+            else {
+                if (current.trim() !== '')
+                    rows.push(current);
+                const pieces = splitWord(token, width);
+                rows.push(...pieces.slice(0, -1));
+                current = pieces[pieces.length - 1];
+                cells = displayWidth(current);
+            }
+            gap = '';
+        }
+        rows.push(current);
+    }
+    return rows;
 }
 /**
  * How many rows up the top of a block is from the cursor, once the terminal is `cols` wide.

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.2';
+export const DEVX_VERSION = '1.9.5';