termux-dev 1.9.3 → 1.9.7

package/README.md

@@ -67,6 +67,10 @@ 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>`.
+- **Notifications when devx waits for you:**  
+  When the agent needs an approval or asks you a question (`◆ Clarify`) and the terminal is not in front, you get a notification (kitty's own protocol, `notify-send` on Linux, `osascript` on macOS; on Termux an Android notification with a short vibration). A finished task is announced too, with the start of the answer. The terminal has to report focus changes (most modern ones do); when devx cannot tell whether you are looking, it stays quiet instead of popping up in front of you.
+- **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`):**  
@@ -90,6 +94,33 @@ The terminal interface is built around a framed prompt that carries the status i
 - **Node.js**: `v20.0.0` or higher
 - **npm**, **pnpm**, or **yarn**
 
+### Installing Node.js and npm
+
+devx needs Node.js 20 or newer (npm comes with it). Pick your system:
+
+```bash
+# Windows (PowerShell)
+winget install OpenJS.NodeJS.LTS
+
+# macOS (Homebrew)
+brew install node
+
+# Ubuntu / Debian (NodeSource: the version in the distribution's own repository is often older than 20)
+curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
+sudo apt-get install -y nodejs
+
+# Fedora
+sudo dnf install -y nodejs
+
+# Arch Linux
+sudo pacman -S nodejs npm
+
+# Android (Termux)
+pkg update && pkg install -y nodejs-lts
+```
+
+Reopen the terminal and check: `node -v` (should be `v20` or higher) and `npm -v`. Any system: the installer at [nodejs.org](https://nodejs.org/en/download) or [nvm](https://github.com/nvm-sh/nvm).
+
 ### Fast Global Install (Recommended)
 
 ```bash
@@ -374,6 +405,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.3</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.7</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.3</text>
+  <text x="112.0" y="62.0" class="t" fill="#5f6b7a">v1.9.7</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,12 +11,13 @@ 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';
 import { startServer, stopServer, displayServerBanner } from './server.js';
 import { notifyDevice, acquireWakeLock, isTermux, notificationBody, sendDesktopNotification } from '../core/notify.js';
+import { isTerminalFocused, setFocusTracking, setTerminalFocused } from '../core/attention.js';
 import { copyToClipboard } from './clipboard-write.js';
 import { REWIND_CURRENT, messageDraft, rewindItems, userEntries } from './rewind.js';
 import { runPicker } from './picker.js';
@@ -930,12 +931,17 @@ 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);
+    history.addMessage({ role: 'system', content: await buildSystemPrompt(planMode) });
+    // The servers start while the prompt is already there (starting them takes seconds: `npx` and the
+    // network). What needs them waits for `mcpReady`: the first request, and /mcp. When they are up the
+    // prompt is written again, so that it says how the agent reaches the tools that wait to be loaded.
+    const mcpReady = MCPManager.getInstance()
+        .init(undefined, config.projectMcpTrusted === true)
+        .then(async () => { history.updateSystemPrompt(await buildSystemPrompt(planMode)); })
+        .catch(() => undefined);
     // 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();
@@ -988,7 +994,6 @@ export async function main() {
     // The name of the chat: in the title of the terminal window (`◈ Short title`) and in the list of sessions.
     let windowTitle = '';
     let titleAttempts = 0;
-    let terminalFocused = true; // updated by the terminal's focus reports while a task runs
     const setWindowTitle = (title) => {
         windowTitle = title;
         if (process.stdout.isTTY)
@@ -1018,6 +1023,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 +1342,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;
@@ -1855,6 +1863,7 @@ export async function main() {
                 continue;
             }
             if (cmd === '/mcp') {
+                await mcpReady;
                 const sub = (parts[1] || '').toLowerCase();
                 if (sub === 'reload' || sub === 'restart' || sub === 'r') {
                     const s = new UiSpinner();
@@ -2106,8 +2115,10 @@ export async function main() {
         });
         // The format of the gateway is learned once (cached); the first request waits for it.
         await refreshFormats(config).catch(() => null);
+        // The MCP servers may still be starting (see mcpReady): the request goes out with their tools.
+        await mcpReady;
         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 +2146,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 +2262,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 +2293,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. */
@@ -2417,7 +2432,7 @@ export async function main() {
             let text = (Buffer.isBuffer(data) ? data : Buffer.from(String(data))).toString('utf8');
             // Focus reports: ESC [ I (got the focus) and ESC [ O (lost it). They are not keys.
             if (text.includes('\x1b[I') || text.includes('\x1b[O')) {
-                terminalFocused = text.lastIndexOf('\x1b[I') > text.lastIndexOf('\x1b[O');
+                setTerminalFocused(text.lastIndexOf('\x1b[I') > text.lastIndexOf('\x1b[O'));
                 text = text.replace(/\x1b\[[IO]/g, '');
                 if (!text)
                     return;
@@ -2461,6 +2476,7 @@ export async function main() {
                     process.stdout.on('resize', onResize);
                     uiSpinner?.mute(true);
                     process.stdout.write('\x1b[?1004h'); // the terminal tells when it loses or gets the focus
+                    setFocusTracking(true); // approval cards and questions notify when it is not in front
                 }
             }
             catch { }
@@ -2497,12 +2513,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();
                 }
@@ -2832,7 +2852,7 @@ export async function main() {
                     if (shouldNotify)
                         notifyDevice(heading, preview || `Task completed in ${secs}s!`);
                 }
-                else if (!terminalFocused) {
+                else if (!isTerminalFocused()) {
                     // The terminal is not in front: a notification with the start of the answer.
                     if (sendDesktopNotification(heading, preview || `Task completed in ${secs}s`) === 'none' && shouldNotify)
                         notifyDevice(heading, preview || `Task completed in ${secs}s!`);
@@ -2921,6 +2941,7 @@ export async function main() {
             const unsent = composer.stop();
             if (process.stdout.isTTY)
                 process.stdout.write('\x1b[?1004l');
+            setFocusTracking(false);
             releasePauseHook();
             process.stdout.removeListener('resize', onResize);
             if (!currentDraft && (unsent.draft || unsent.queued.length > 0)) {

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/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/update-screen.js

@@ -4,7 +4,7 @@ import { runPicker } from './picker.js';
 import { palette, renderNotice } from './ui.js';
 import { displayWidth, truncateWidth } from './width.js';
 import { getLanguage, t } from '../core/i18n.js';
-import { UpdateError, buildUpdateSteps, checkForUpdates, detectInstallMethod, getCurrentVersion, restartDevx, runUpdateSteps, } from './updater.js';
+import { UpdateError, buildUpdateSteps, checkForUpdates, checkForUpdatesRemembered, detectInstallMethod, readCachedCheck, getCurrentVersion, restartDevx, runUpdateSteps, } from './updater.js';
 /**
  * The update screens, in the style of the rest of devx:
  *
@@ -344,7 +344,9 @@ export async function runStartupUpdateCheck(config, deps = {}) {
     if (!out.isTTY)
         return;
     const current = await getCurrentVersion();
-    const result = await withCheckingLine(out, current, () => (deps.check ?? checkForUpdates)(6000));
+    // A recent answer is used as it is: no network, no "checking" line, no wait before the prompt.
+    const cached = deps.check ? undefined : await readCachedCheck();
+    const result = cached ?? await withCheckingLine(out, current, () => (deps.check ?? checkForUpdatesRemembered)(6000));
     if (result.updateAvailable) {
         if (config.skippedUpdate === result.latestVersion)
             return;
@@ -359,6 +361,8 @@ export async function runStartupUpdateCheck(config, deps = {}) {
     }
     if (result.error)
         return; // offline at start-up is not worth a word
+    if (cached)
+        return; // up to date, as the last check said: nothing to show
     // Up to date: a short line that goes away by itself.
     out.write(`  ${palette.ok('✓')} ${palette.muted(t('update.upToDate', { version: result.currentVersion }))}\n`);
     await sleep(deps.tickMs !== undefined ? 0 : 450);

package/dist/cli/updater.js

@@ -1,5 +1,6 @@
 import { spawn } from 'child_process';
 import path from 'path';
+import os from 'os';
 import fs from 'fs/promises';
 import { fileURLToPath } from 'url';
 const GITHUB_REPO_URL = 'https://github.com/apvcode/Termux-Dev';
@@ -40,6 +41,12 @@ export async function checkForUpdates(timeoutMs = 10000) {
     // mobile connection a stalled second request used to block devx at startup forever.
     const signal = AbortSignal.timeout(timeoutMs);
     try {
+        // The release is asked at the same time as the package.json, not after it: the check takes as long
+        // as the slower of the two, not both. A failure of the release request is not an error of the check.
+        const releaseRequest = fetch(`${REMOTE_RELEASE_URL}?t=${Date.now()}`, {
+            signal,
+            headers: { 'User-Agent': 'devx-updater' }
+        }).catch(() => null);
         // 1. Try fetching latest package.json with cache-busting timestamp
         const cacheBusterUrl = `${REMOTE_PKG_URL}?t=${Date.now()}`;
         const res = await fetch(cacheBusterUrl, {
@@ -59,11 +66,8 @@ export async function checkForUpdates(timeoutMs = 10000) {
         }
         // 2. Also check latest GitHub release tag
         try {
-            const relRes = await fetch(`${REMOTE_RELEASE_URL}?t=${Date.now()}`, {
-                signal,
-                headers: { 'User-Agent': 'devx-updater' }
-            });
-            if (relRes.ok) {
+            const relRes = await releaseRequest;
+            if (relRes?.ok) {
                 const relData = await relRes.json();
                 const relTag = (relData.tag_name || relData.name || '').replace(/^v/, '').trim();
                 if (relTag && (!latestVersion || isNewerVersion(relTag, latestVersion))) {
@@ -99,6 +103,56 @@ export async function checkForUpdates(timeoutMs = 10000) {
         };
     }
 }
+// ───────────────────────── remembering the check ─────────────────────────
+/** An answer is good for this long; after it devx asks again. */
+const CHECK_FRESH_MS = 6 * 60 * 60 * 1000;
+/** A failed check (offline, a stalled connection) is not repeated at every start: that would stall every start. */
+const CHECK_FAILED_MS = 30 * 60 * 1000;
+const checkFile = () => path.join(os.homedir(), '.devx', 'update-check.json');
+/** The last check, when it is recent enough to be trusted at start-up; undefined when devx has to ask again. */
+export async function readCachedCheck(now = Date.now()) {
+    try {
+        const saved = JSON.parse(await fs.readFile(checkFile(), 'utf8'));
+        const age = now - Number(saved.checkedAt);
+        // A clock that went backwards makes the age negative: such an answer is not trusted.
+        if (!Number.isFinite(age) || age < 0)
+            return undefined;
+        const currentVersion = await getCurrentVersion();
+        if (saved.error) {
+            return age < CHECK_FAILED_MS ? { updateAvailable: false, currentVersion, latestVersion: currentVersion, error: saved.error } : undefined;
+        }
+        if (age >= CHECK_FRESH_MS || !saved.latestVersion)
+            return undefined;
+        // Judged against the version that runs now: after an update the old answer no longer says "update".
+        return {
+            updateAvailable: isNewerVersion(saved.latestVersion, currentVersion),
+            currentVersion,
+            latestVersion: saved.latestVersion,
+            releaseNotes: saved.releaseNotes || undefined,
+            publishedAt: saved.publishedAt || undefined,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Keeps the answer of a check for the next start-ups. Never throws: this is only a shortcut. */
+export async function rememberCheck(result, now = Date.now()) {
+    try {
+        const saved = result.error
+            ? { checkedAt: now, error: result.error }
+            : { checkedAt: now, latestVersion: result.latestVersion, releaseNotes: result.releaseNotes, publishedAt: result.publishedAt };
+        await fs.mkdir(path.dirname(checkFile()), { recursive: true, mode: 0o700 });
+        await fs.writeFile(checkFile(), JSON.stringify(saved));
+    }
+    catch { }
+}
+/** `checkForUpdates`, and the answer is kept for the next start-ups (the start-up check reads it, see readCachedCheck). */
+export async function checkForUpdatesRemembered(timeoutMs = 10000) {
+    const result = await checkForUpdates(timeoutMs);
+    await rememberCheck(result);
+    return result;
+}
 /** How this devx was installed: from the npm package, or from a git clone (a developer's copy). */
 export async function detectInstallMethod() {
     const here = fileURLToPath(import.meta.url);

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/attention.js

@@ -0,0 +1,63 @@
+import { isTermux, notificationBody, notifyDevice, sendDesktopNotification } from './notify.js';
+/**
+ * "devx is waiting for you": a notification when the agent needs an answer (an approval card, a
+ * question) and the person is not looking at the terminal. A finished task is announced elsewhere
+ * (the end of a turn); this is for the moments when the work is stopped until someone answers.
+ */
+let tracking = false;
+let focused = true;
+/**
+ * The terminal reports when it loses and gets the focus (while a task runs). Without those reports
+ * devx cannot tell whether anybody is looking, and a notification that pops up in front of someone who is
+ * typing in the terminal is worse than none, so nothing is sent then.
+ */
+export function setFocusTracking(on) {
+    tracking = on;
+    // A task starts because the person just pressed Enter here.
+    if (on)
+        focused = true;
+}
+export function setTerminalFocused(value) {
+    focused = value;
+}
+export function isTerminalFocused() {
+    return focused;
+}
+/**
+ * Tells the person that devx waits for them. Returns whether something was sent. Never throws.
+ * On Termux (Android) a notification always goes out: the person is most likely in another app, and
+ * the phone cannot tell devx. On a desktop it goes out only when the terminal is not in front.
+ */
+export function notifyAttention(title, body, deps = {}) {
+    try {
+        const text = notificationBody(body, 140) || title;
+        if (deps.termux ?? isTermux()) {
+            (deps.device ?? notifyDevice)(title, text);
+            return true;
+        }
+        if (!tracking || focused)
+            return false;
+        const via = (deps.desktop ?? sendDesktopNotification)(title, text);
+        // No desktop notification service: the terminal bell at least marks the window as asking for attention.
+        if (via === 'none')
+            (deps.device ?? notifyDevice)(title, text);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** What an approval card asks, in a line for a notification: `bash: npm test`. */
+export function approvalNotice(title, lines, danger) {
+    const first = (lines.find((l) => l.trim()) ?? '').trim();
+    return {
+        title: danger ? 'devx · dangerous action, approval needed' : 'devx · approval needed',
+        body: first ? `${title}: ${first}` : title,
+    };
+}
+/** The question the agent asks, for a notification (and how many more follow). */
+export function questionNotice(questions) {
+    const first = String(questions[0]?.question ?? '').trim();
+    const more = questions.length > 1 ? ` (+${questions.length - 1} more)` : '';
+    return { title: 'devx · question for you', body: `${first || 'The agent has a question'}${more}` };
+}