termux-dev 1.9.5 → 1.9.8

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>`.
+- **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`):**  
@@ -92,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
@@ -206,7 +235,7 @@ Type `/` in the prompt to open the autocomplete command palette:
 - **`@filename`** — Fast fuzzy file autocomplete and full file embedding.
 - **`Backspace`** — Atomically deletes entire badges `[Pasted text #1]` and `[1.png 203kb]` in one press.
 - **`Ctrl+Backspace`** / **`Alt+Backspace`** — Erase the text word by word (also while the agent works).
-- **`Ctrl+Enter`** — While typing: start a new line (a new paragraph) instead of sending. `Alt+Enter` and `Shift+Enter` do the same where the terminal reports them; on a terminal that cannot tell them from `Enter` (a phone keyboard, for one) type `\` before `Enter`.
+- **`Ctrl+Enter`** — While typing: start a new line (a new paragraph) instead of sending. `Alt+Enter` and `Shift+Enter` do the same where the terminal reports them; on a terminal that cannot tell them from `Enter` (a phone keyboard, for one) type `\` before `Enter`. devx asks the terminal to tell them apart only where that is known to work (kitty, Ghostty, WezTerm, iTerm2, foot, Alacritty); Termux and other terminals that read that request as a cursor or style code never get it. `DEVX_EXTENDED_KEYS=1` (or `0`) forces it on (or off).
 - **`Ctrl+P`** / **`Ctrl+O`** — Unfold or fold the reasoning of the model (`Ctrl+P`) and the commands with their output (`Ctrl+O`) in the whole chat, also what is already above. Both are folded by default; works while the agent works and at the prompt.
 - **`Esc`** — Stop the current answer and whatever it started (a running command); what you typed waits in the next prompt. Esc also closes every list and card.
 - **`Ctrl+C`** — Stop current generation immediately or exit.

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.5</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.8</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.5</text>
+  <text x="112.0" y="62.0" class="t" fill="#5f6b7a">v1.9.8</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/index.js

@@ -17,6 +17,7 @@ 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';
@@ -68,7 +69,7 @@ import { modelAcceptsImages } from '../core/vision.js';
 import { contextBreakdown } from '../core/context-stats.js';
 import { runUsagePanel } from './usage-panel.js';
 import { TurnComposer } from './typeahead.js';
-import { EXTENDED_KEYS_OFF, normalizeKey, splitKeys } from './keys.js';
+import { extendedKeysOff, normalizeKey, splitKeys } from './keys.js';
 import { LANGUAGES, getLanguage, setLanguage, t } from '../core/i18n.js';
 import { anthropicOnlyModels, formatFromBaseUrl, refreshFormats } from '../core/formats.js';
 import { providerFormat } from '../providers/index.js';
@@ -593,7 +594,7 @@ process.on('exit', () => {
         process.stdin.setRawMode(false);
     }
     if (process.stdout.isTTY)
-        process.stdout.write(EXTENDED_KEYS_OFF + '\x1B[?1004l' + RESTORE_TERMINAL_TITLE + '\x1B[?25h');
+        process.stdout.write(extendedKeysOff() + '\x1B[?1004l' + RESTORE_TERMINAL_TITLE + '\x1B[?25h');
     resetTerminalTheme();
 });
 process.on('SIGINT', () => {
@@ -605,11 +606,18 @@ process.on('SIGINT', () => {
             process.stdin.setRawMode(false);
             process.stdin.pause();
         }
-        process.stdout.write(EXTENDED_KEYS_OFF + '\x1B[?1004l' + RESTORE_TERMINAL_TITLE + '\x1B[?25h'); // restore cursor
+        process.stdout.write(extendedKeysOff() + '\x1B[?1004l' + RESTORE_TERMINAL_TITLE + '\x1B[?25h'); // restore cursor
         resetTerminalTheme();
         process.exit(0);
     }
 });
+/**
+ * The new version has been started (it owns the terminal now) and this process ends when it ends.
+ * Nothing else may run here: a second prompt on the same terminal takes keys from the first.
+ */
+function waitForRestartedDevx() {
+    return new Promise(() => { });
+}
 function clearTerminalScreen() {
     if (process.stdout.isTTY) {
         // \x1b[2J: clear screen, \x1b[3J: clear scrollback buffer (crucial for Termux/xterm), \x1b[H: cursor to home
@@ -932,10 +940,16 @@ export async function main() {
     MemoryManager.enabled = config.enableMemory !== false;
     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.
+    if ((await runStartupUpdateCheck(config, { save: saveConfig })) === 'updated')
+        await waitForRestartedDevx();
     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 +1002,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)
@@ -1276,7 +1289,8 @@ export async function main() {
                 continue;
             }
             if (cmd === '/update') {
-                await runManualUpdate();
+                if ((await runManualUpdate()) === 'updated')
+                    await waitForRestartedDevx();
                 continue;
             }
             if (cmd === '/help') {
@@ -1858,6 +1872,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();
@@ -2109,6 +2124,8 @@ 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 = getToolSource(planMode);
         const guard = new CLIConsoleGuard(config.autoApprove, [...(config.bashAllowlist || [])], {
@@ -2424,7 +2441,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;
@@ -2468,6 +2485,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 { }
@@ -2843,7 +2861,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!`);
@@ -2932,6 +2950,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/keys.js

@@ -28,11 +28,50 @@ export function isNewlineKey(key) {
  * Asks the terminal to tell Ctrl+Enter and Shift+Enter apart from Enter (a plain terminal sends
  * the same byte for all of them). Two protocols are requested, a terminal answers the one it knows:
  * the kitty keyboard protocol (kitty, foot, ghostty, wezterm, alacritty, ...) and xterm's
- * modifyOtherKeys. Terminals that know neither ignore both, and Alt+Enter still works.
- * While on, the keys arrive as `CSI … u`: run them through `normalizeKey`.
+ * modifyOtherKeys. While on, the keys arrive as `CSI … u`: run them through `normalizeKey`.
+ *
+ * Only sent to terminals that are known to understand them (`extendedKeysSupported`): a terminal
+ * that does not parses `CSI > 1 u` as "restore the cursor" and `CSI > 4 ; 1 m` as "underline, bold",
+ * which throws the prompt to the top of the screen and draws lines under every row (Termux, UserLAnd).
+ */
+const EXTENDED_KEYS_ON_SEQ = '\x1b[>1u\x1b[>4;1m';
+const EXTENDED_KEYS_OFF_SEQ = '\x1b[<u\x1b[>4;0m';
+const KEYBOARD_PROTOCOL_PROGRAMS = new Set(['ghostty', 'wezterm', 'iterm.app', 'kitty', 'foot', 'alacritty', 'rio', 'contour']);
+/**
+ * Does this terminal understand the extended keyboard modes? Decided from the environment, and
+ * only for terminals known to: a wrong guess in the other direction costs Ctrl+Enter (Alt+Enter
+ * and a backslash before Enter still break the line), a wrong guess in this one wrecks the screen.
+ * `DEVX_EXTENDED_KEYS=1` forces it on, `DEVX_EXTENDED_KEYS=0` off.
  */
-export const EXTENDED_KEYS_ON = '\x1b[>1u\x1b[>4;1m';
-export const EXTENDED_KEYS_OFF = '\x1b[<u\x1b[>4;0m';
+export function extendedKeysSupported(env = process.env, platform = process.platform) {
+    const forced = (env.DEVX_EXTENDED_KEYS ?? '').trim().toLowerCase();
+    if (['1', 'on', 'true', 'yes'].includes(forced))
+        return true;
+    if (['0', 'off', 'false', 'no'].includes(forced))
+        return false;
+    // Android: Termux, UserLAnd and other terminals built on the same emulator.
+    if (platform === 'android' || env.TERMUX_VERSION || env.PREFIX?.includes('com.termux') || env.ANDROID_ROOT || env.ANDROID_DATA)
+        return false;
+    // Multiplexers sit between devx and the real terminal: they decide for themselves.
+    if (env.TMUX || env.STY)
+        return false;
+    const term = (env.TERM ?? '').toLowerCase();
+    if (term.startsWith('screen') || term.startsWith('tmux') || term === 'linux' || term === 'dumb')
+        return false;
+    if (env.KITTY_WINDOW_ID || env.GHOSTTY_RESOURCES_DIR || env.WEZTERM_EXECUTABLE)
+        return true;
+    if (/kitty|ghostty|foot|alacritty|wezterm/.test(term))
+        return true;
+    return KEYBOARD_PROTOCOL_PROGRAMS.has((env.TERM_PROGRAM ?? '').toLowerCase());
+}
+/** What to write to turn the extended keyboard modes on (nothing on a terminal that does not know them). */
+export function extendedKeysOn() {
+    return extendedKeysSupported() ? EXTENDED_KEYS_ON_SEQ : '';
+}
+/** What to write to turn them off again. */
+export function extendedKeysOff() {
+    return extendedKeysSupported() ? EXTENDED_KEYS_OFF_SEQ : '';
+}
 /**
  * Turns the extended encodings back into the keys the rest of the code knows:
  * `CSI 99;5u` and `CSI 27;5;99~` become Ctrl+C (0x03), `CSI 27u` becomes Esc, and every way

package/dist/cli/prompt.js

@@ -8,7 +8,7 @@ import { filterCommandPalette, estimatePromptTokens, formatPromptTokenBadge } fr
 import { PromptHistoryNavigator } from './history_search.js';
 import { buildPromptFrame, moveCursorRow, palette, renderUserEcho, resolveMode } from './ui.js';
 import { displayWidth, padEndWidth, rowsToTop, truncateWidth } from './width.js';
-import { EXTENDED_KEYS_OFF, EXTENDED_KEYS_ON, isNewlineKey, normalizeKey } from './keys.js';
+import { extendedKeysOff, extendedKeysOn, isNewlineKey, normalizeKey } from './keys.js';
 export const SLASH_COMMANDS = [
     { cmd: '/new', desc: 'Start a new clean chat session' },
     { cmd: '/resume', desc: 'Resume a previous chat session' },
@@ -99,7 +99,7 @@ export function askPrompt(opts = {}) {
             process.stdin.setRawMode(true);
             process.stdout.write('\x1b[?2004h'); // Enable bracketed paste mode
             // Lets the terminal tell Ctrl+Enter and Shift+Enter (a new paragraph) from Enter (send).
-            process.stdout.write(EXTENDED_KEYS_ON);
+            process.stdout.write(extendedKeysOn());
         }
         // ── framed prompt (clean layout) ──
         // The frame is a block of rows; the cursor rests on the input row. Redrawing moves up
@@ -552,7 +552,7 @@ export function askPrompt(opts = {}) {
             disposed = true;
             unsubscribeOwner?.();
             if (process.stdout.isTTY) {
-                process.stdout.write('\x1b[?2004l' + EXTENDED_KEYS_OFF);
+                process.stdout.write('\x1b[?2004l' + extendedKeysOff());
             }
             process.stdout.removeListener('resize', onResize);
             process.stdin.removeListener('data', onData);

package/dist/cli/typeahead.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
-import { EXTENDED_KEYS_OFF, EXTENDED_KEYS_ON, isNewlineKey, normalizeKey, splitKeys } from './keys.js';
+import { extendedKeysOff, extendedKeysOn, isNewlineKey, normalizeKey, splitKeys } from './keys.js';
 import { buildPromptFrame, palette } from './ui.js';
 import { displayWidth, truncateWidth } from './width.js';
 import { t } from '../core/i18n.js';
@@ -209,7 +209,7 @@ export class TurnComposer {
         this.shown = false;
         this.original = this.out.write.bind(this.out);
         this.out.write = ((chunk, encoding, cb) => this.through(chunk, encoding, cb));
-        this.write(EXTENDED_KEYS_ON + this.drawSeq());
+        this.write(extendedKeysOn() + this.drawSeq());
         // The working line animates: its time and counter are redrawn while the output is quiet.
         if (this.status) {
             this.timer = setInterval(() => this.tick(), 60);
@@ -225,7 +225,7 @@ export class TurnComposer {
             this.timer = null;
         }
         if (this.active) {
-            this.write(this.eraseSeq() + EXTENDED_KEYS_OFF + '\x1b[?25h');
+            this.write(this.eraseSeq() + extendedKeysOff() + '\x1b[?25h');
             if (this.original)
                 this.out.write = this.original;
             this.original = null;
@@ -241,14 +241,14 @@ export class TurnComposer {
         if (!this.active || this.suspended)
             return;
         // The card or question that takes over reads plain keys: the extended encodings go off for it.
-        this.write(this.eraseSeq() + EXTENDED_KEYS_OFF);
+        this.write(this.eraseSeq() + extendedKeysOff());
         this.suspended = true;
     }
     resume() {
         if (!this.active || !this.suspended)
             return;
         this.suspended = false;
-        this.write(EXTENDED_KEYS_ON + this.drawSeq());
+        this.write(extendedKeysOn() + this.drawSeq());
     }
     /** Builds the frame again (the context percentage or the cost changed) and draws it. */
     refresh() {
@@ -344,7 +344,9 @@ export class TurnComposer {
         if (!this.shown)
             return '';
         this.shown = false;
-        return '\x1b7\x1b[1B\r\x1b[J\x1b8';
+        // The erase starts from plain attributes: a style left on by the text above (an underline, a
+        // background) would be painted into every row it wipes (stripes across the screen).
+        return '\x1b7\x1b[0m\x1b[1B\r\x1b[J\x1b8';
     }
     /** Draws the frame under the cursor row and puts the cursor back where the text goes on. */
     drawSeq() {
@@ -358,7 +360,7 @@ export class TurnComposer {
         // ESC D moves down (scrolling at the bottom edge) and keeps the column; then back up.
         let seq = '\x1b[?25l' + '\x1bD'.repeat(n) + `\x1b[${n}A` + '\x1b7';
         for (const line of lines)
-            seq += `\x1b[1B\r\x1b[2K${line}\x1b[0m`;
+            seq += `\x1b[0m\x1b[1B\r\x1b[2K${line}\x1b[0m`;
         return seq + '\x1b8';
     }
 }

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,21 +344,24 @@ 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;
-        await presentUpdate(result, {
+        return presentUpdate(result, {
             offerSkip: true,
             save: async (version) => {
                 config.skippedUpdate = version;
                 await deps.save?.(config);
             },
         }, deps);
-        return;
     }
     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);
@@ -371,7 +374,7 @@ export async function runManualUpdate(deps = {}) {
     const result = await withCheckingLine(out, current, () => (deps.check ?? checkForUpdates)(10000));
     const cols = columnsOf(out);
     if (result.updateAvailable) {
-        await presentUpdate(result, { offerSkip: false }, deps);
+        return presentUpdate(result, { offerSkip: false }, deps);
     }
     else if (result.error) {
         out.write(renderNotice('warn', t('update.offline', { reason: result.error }), cols) + '\n');

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);
@@ -226,9 +280,26 @@ export async function runUpdateSteps(steps, events = {}, now = Date.now) {
     }
     return { ok: true };
 }
-/** Starts devx again, with the same arguments, and ends this process when the new one ends. */
+/**
+ * Starts devx again, with the same arguments, and ends this process when the new one ends.
+ *
+ * From here on this process only waits: the terminal belongs to the new one. It stops reading the
+ * keyboard (two programs reading one terminal take the keys from each other, and a typed line
+ * can end up in the shell) and no longer reacts to Ctrl+C itself (the new devx gets it).
+ */
 export function restartDevx() {
+    try {
+        process.stdin.pause();
+    }
+    catch { }
     const child = spawn(process.argv[0], process.argv.slice(1), { stdio: 'inherit' });
+    process.removeAllListeners('SIGINT');
+    process.on('SIGINT', () => { });
+    process.removeAllListeners('SIGTERM');
+    process.on('SIGTERM', () => { try {
+        child.kill('SIGTERM');
+    }
+    catch { } });
     child.on('exit', (code) => process.exit(code ?? 0));
     child.on('error', () => process.exit(0));
 }

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}` };
+}

package/dist/core/types.js

@@ -1 +1 @@
-export const DEVX_VERSION = '1.9.5';
+export const DEVX_VERSION = '1.9.8';

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/tools/questions.js

@@ -3,6 +3,7 @@ import { runPicker } from '../cli/picker.js';
 import { palette } from '../cli/ui.js';
 import { wrapWords } from '../cli/width.js';
 import { t } from '../core/i18n.js';
+import { notifyAttention, questionNotice } from '../core/attention.js';
 export const askQuestionsTool = {
     name: 'ask_questions',
     definition: {
@@ -45,6 +46,9 @@ export const askQuestionsTool = {
         if (!args.questions || !Array.isArray(args.questions) || args.questions.length === 0) {
             return 'No questions provided.';
         }
+        // The agent waits for the answer: if the terminal is not in front, a notification says so.
+        const notice = questionNotice(args.questions);
+        notifyAttention(notice.title, notice.body);
         const results = [];
         const total = args.questions.length;
         const cols = process.stdout.columns || 80;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termux-dev",
-  "version": "1.9.5",
+  "version": "1.9.8",
   "description": "Ultra-fast, terminal-native AI coding assistant and agent built for Android Termux, Windows, macOS, and Linux.",
   "main": "dist/cli/index.js",
   "type": "module",