termux-dev 1.8.1 → 1.9.0

package/dist/cli/index.js

@@ -26,6 +26,8 @@ import { savePlanFile } from '../core/planfile.js';
 import { BASE_TITLE, RESTORE_TERMINAL_TITLE, SAVE_TERMINAL_TITLE, cleanTitle, generateChatTitle, provisionalTitle, terminalTitleSequence } from '../core/title.js';
 import { runDoctor } from './doctor.js';
 import { ALL_PROVIDERS } from './providers.js';
+import { addProviderFlow, manageProviderFlow } from './provider-manager.js';
+import { NO_KEY, hostOfUrl, isCustomProvider, keyHint, listCustomProviders, migrateLegacyCustom, providerDisplayName } from '../core/custom-providers.js';
 import { getModelContextInfo, getModelContextLimit } from '../core/models.js';
 import { SessionManager } from '../core/session.js';
 import { MarkdownStreamer, renderMarkdown } from './markdown.js';
@@ -42,6 +44,9 @@ import { SessionExporter } from './export.js';
 import { MCPManager, discoverProjectMcpServers, hashProjectMcpServers, readClaudeServers, removeUserServer, saveUserServers } from '../mcp/manager.js';
 import { writeSecureFile } from '../core/secure-file.js';
 import { applyLocalConfig, persistedConfig, withoutSessionOnlySettings } from '../core/local-config.js';
+import { cloneConfig, mergeConfigChanges } from '../core/config-merge.js';
+import { getBackgroundManager } from '../core/background.js';
+import { backgroundSummary, noteRows, runTasksCommand } from './background-ui.js';
 import { LiveTelemetryTracker } from './telemetry.js';
 import { renderPowerlineStatus, GitStatusCache } from './statusline.js';
 import { formatDiffBox } from './diff.js';
@@ -75,7 +80,18 @@ function maskApiKey(key) {
         return '****';
     return `${key.slice(0, 4)}...${key.slice(-4)}`;
 }
-async function saveConfig(config) {
+/**
+ * What this process last knew of the config file (its own settings after the start-up overrides,
+ * or what it wrote last). A save writes only the difference to it, see core/config-merge.ts.
+ */
+let configBaseline = null;
+let saveChain = Promise.resolve();
+/** Call once the start-up overrides (-m, project config) are applied: those are not saved by accident. */
+function markConfigBaseline(config) {
+    syncKeyMaps(config);
+    configBaseline = cloneConfig(persistedConfig(config));
+}
+function syncKeyMaps(config) {
     config.apiKeys = config.apiKeys || {};
     config.baseUrls = config.baseUrls || {};
     if (config.provider && config.apiKey) {
@@ -84,10 +100,38 @@ async function saveConfig(config) {
     if (config.provider && config.baseUrl) {
         config.baseUrls[config.provider] = config.baseUrl;
     }
+}
+async function writeConfigFile(config) {
+    syncKeyMaps(config);
     // Runtime-only flags and YOLO (one run only) must not end up in the user's config file.
-    const persisted = persistedConfig(config);
-    // The file holds API keys: owner-only permissions (0600).
-    await writeSecureFile(CONFIG_PATH, JSON.stringify(persisted, null, 2));
+    const mine = cloneConfig(persistedConfig(config));
+    // Another devx may have saved since we looked: write only our own changes on top of the file.
+    let disk = null;
+    try {
+        const parsed = JSON.parse(await fs.readFile(CONFIG_PATH, 'utf8'));
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+            disk = withoutSessionOnlySettings(parsed);
+    }
+    catch { }
+    const merged = disk ? mergeConfigChanges(configBaseline ?? {}, mine, disk) : mine;
+    // The file holds API keys: owner-only permissions (0600). Written aside and renamed, so a second
+    // process never reads half a file.
+    const tmp = `${CONFIG_PATH}.${process.pid}.tmp`;
+    try {
+        await writeSecureFile(tmp, JSON.stringify(merged, null, 2));
+        await fs.rename(tmp, CONFIG_PATH);
+    }
+    catch (err) {
+        await fs.rm(tmp, { force: true }).catch(() => null);
+        throw err;
+    }
+    configBaseline = mine;
+}
+async function saveConfig(config) {
+    // One save at a time inside this process; the read-merge-write of the next one sees the previous.
+    const run = saveChain.then(() => writeConfigFile(config));
+    saveChain = run.catch(() => undefined);
+    return run;
 }
 async function fetchModels(baseUrl, apiKey) {
     try {
@@ -99,7 +143,7 @@ async function fetchModels(baseUrl, apiKey) {
             if (apiKey)
                 headers['x-api-key'] = apiKey;
         }
-        else if (apiKey && apiKey !== 'ollama') {
+        else if (apiKey && apiKey !== 'ollama' && apiKey !== NO_KEY) {
             headers['Authorization'] = `Bearer ${apiKey}`;
         }
         const res = await fetch(url, { headers });
@@ -206,12 +250,21 @@ async function selectModel(baseUrl, apiKey, currentModel, providerId = '', _allo
 /** The host of an address, for the detail column: `api.openai.com`. */
 const hostOf = (url) => url.replace(/^https?:\/\//, '').replace(/\/.*$/, '');
 async function selectProvider(currentConfig, allowCancel = true) {
-    const apiKeys = currentConfig.apiKeys || {};
-    const baseUrls = currentConfig.baseUrls || {};
+    // The maps are shared with the config, so what the provider screens change is seen by both.
+    const apiKeys = (currentConfig.apiKeys = currentConfig.apiKeys || {});
+    const baseUrls = (currentConfig.baseUrls = currentConfig.baseUrls || {});
     if (currentConfig.provider && currentConfig.apiKey) {
         apiKeys[currentConfig.provider] = currentConfig.apiKey;
     }
+    // The single "Custom" of older versions becomes a saved provider with a name of its own.
+    migrateLegacyCustom(currentConfig);
     const firstRun = !allowCancel;
+    const providerFlow = {
+        // The first-run setup saves everything once, at its end.
+        save: firstRun ? undefined : saveConfig,
+        listedIds: ALL_PROVIDERS.map((pr) => pr.value),
+    };
+    const ADD = '__add__';
     const stepOf = (n) => (firstRun ? `${n}/5` : undefined);
     let providerId = '';
     let baseUrl = '';
@@ -226,20 +279,44 @@ async function selectProvider(currentConfig, allowCancel = true) {
                 placeholder: t('onboard.provider.placeholder'),
                 current: currentConfig.provider,
                 notes: firstRun ? [t('onboard.provider.note')] : undefined,
-                items: ALL_PROVIDERS.map((pr) => ({
-                    value: pr.value,
-                    label: pr.label,
-                    detail: `${apiKeys[pr.value] ? maskApiKey(apiKeys[pr.value]) + '  ' : ''}${hostOf(pr.baseUrl || '')}`.trim(),
-                    keywords: `${pr.value} ${hostOf(pr.baseUrl || '')}`,
-                    pinned: pr.value === 'custom',
-                })),
+                items: [
+                    { value: ADD, label: t('provider.add'), detail: t('provider.addDetail'), pinned: true },
+                    // The providers the user saved come first, then the long list of known ones.
+                    ...listCustomProviders(currentConfig).map((c) => ({
+                        value: c.id,
+                        label: c.name,
+                        detail: `${t('provider.customTag')} · ${[keyHint(c.apiKey), hostOfUrl(c.baseUrl)].filter(Boolean).join('  ')}`,
+                        keywords: `${c.id} ${hostOfUrl(c.baseUrl)} ${t('provider.customTag')}`,
+                    })),
+                    ...ALL_PROVIDERS.map((pr) => ({
+                        value: pr.value,
+                        label: pr.label,
+                        detail: `${apiKeys[pr.value] ? maskApiKey(apiKeys[pr.value]) + '  ' : ''}${hostOf(pr.baseUrl || '')}`.trim(),
+                        keywords: `${pr.value} ${hostOf(pr.baseUrl || '')}`,
+                    })),
+                ],
             });
             if (choice === undefined)
                 return null; // Esc on the first step leaves the whole setup
+            if (choice === ADD || isCustomProvider(currentConfig, choice)) {
+                // A provider of the user's own: add one, or use / change / delete a saved one.
+                let id = choice;
+                if (choice === ADD)
+                    id = await addProviderFlow(currentConfig, providerFlow);
+                else if ((await manageProviderFlow(currentConfig, choice, providerFlow)) !== 'use')
+                    id = null;
+                if (!id)
+                    continue; // back to the list (it shows the changes)
+                providerId = id;
+                baseUrl = currentConfig.customProviders[id].baseUrl;
+                apiKey = apiKeys[id] ?? '';
+                stage = apiKey ? 'model' : 'key';
+                continue;
+            }
             providerId = choice;
             const known = ALL_PROVIDERS.find(pr => pr.value === providerId);
             baseUrl = baseUrls[providerId] || known?.baseUrl || '';
-            stage = providerId === 'custom' || !baseUrl ? 'url' : 'key';
+            stage = !baseUrl ? 'url' : 'key';
         }
         else if (stage === 'url') {
             const url = await runTextInput({
@@ -258,8 +335,8 @@ async function selectProvider(currentConfig, allowCancel = true) {
             stage = 'key';
         }
         else if (stage === 'key') {
-            const label = ALL_PROVIDERS.find(pr => pr.value === providerId)?.label || providerId;
-            const back = providerId === 'custom' || !(ALL_PROVIDERS.find(pr => pr.value === providerId)?.baseUrl) ? 'url' : 'provider';
+            const label = providerDisplayName(currentConfig, providerId, ALL_PROVIDERS);
+            const back = isCustomProvider(currentConfig, providerId) ? 'provider' : !(ALL_PROVIDERS.find(pr => pr.value === providerId)?.baseUrl) ? 'url' : 'provider';
             if (providerId === 'ollama') {
                 apiKey = 'ollama';
                 stage = 'model';
@@ -306,7 +383,7 @@ async function selectProvider(currentConfig, allowCancel = true) {
         else {
             modelRes = await selectModel(baseUrl, apiKey, currentConfig.model || '', providerId, allowCancel, stepOf(5));
             if (!modelRes)
-                stage = apiKey === 'ollama' ? 'provider' : 'key';
+                stage = apiKey === 'ollama' || isCustomProvider(currentConfig, providerId) ? 'provider' : 'key';
         }
     }
     const updatedConfig = {
@@ -673,6 +750,7 @@ async function handleSettings(config) {
         layout: config.ui?.layout === 'classic' ? 'classic' : 'clean',
         pureBlack: config.pureBlackTheme !== false,
         autoApprove: !!config.autoApprove,
+        extra: !!config.autoApprove && !!config.autoApproveAll,
         maxIterations: config.maxIterations || 100,
         memory: config.enableMemory !== false,
         updates: config.checkUpdates !== false,
@@ -703,12 +781,20 @@ async function handleSettings(config) {
     config.banner = final.layout === 'clean' ? (config.banner === 'off' ? 'off' : 'clean') : 'full';
     config.pureBlackTheme = final.pureBlack;
     config.autoApprove = final.autoApprove;
+    // Extra goes with YOLO and, like YOLO, is never saved: it is off again at the next start.
+    const extraWasOn = !!initial.extra;
+    config.autoApproveAll = final.autoApprove && !!final.extra;
     config.maxIterations = final.maxIterations;
     config.enableMemory = final.memory;
     config.checkUpdates = final.updates;
     config.language = final.language;
     config.maxCostPerSession = final.costLimit;
     await saveConfig(config);
+    // Said once more where it cannot be missed, when the panel is closed with Extra newly switched on.
+    if (config.autoApproveAll && !extraWasOn) {
+        console.log(renderNotice('warn', t('settings.extraEnabled')));
+        console.log();
+    }
     process.stdin.resume();
     return config;
 }
@@ -747,6 +833,7 @@ export async function main() {
         .version(DEVX_VERSION)
         .option('-p, --prompt <task>', 'Run one-shot task non-interactively (headless mode)')
         .option('-y, --yolo', 'Automatically approve all tool executions without confirmation')
+        .option('--extra', 'Like --yolo, but nothing is asked at all: dangerous commands and credential files too (use only where you can afford to lose everything)')
         .option('-m, --model <model>', 'Specify AI model to use for this execution')
         .option('-q, --quiet', 'Quiet output in headless mode (suppress banners and tool logs)')
         .option('--json', 'Output structured JSON in headless mode')
@@ -768,9 +855,14 @@ export async function main() {
         config.model = options.model;
         config.maxContextTokens = resolveContextLimit({ ...config, maxContextTokens: 0 }).limit;
     }
-    if (options.yolo) {
+    // -m and the project config are for this run: only what changes from here on is saved.
+    markConfigBaseline(config);
+    if (options.yolo || options.extra) {
         config.autoApprove = true;
     }
+    if (options.extra) {
+        config.autoApproveAll = true;
+    }
     if (options.effort !== undefined) {
         // One run only (never saved). Anything the model does not offer is ignored with a warning.
         // A custom endpoint is asked about the model first (cached, a few seconds at most).
@@ -800,6 +892,7 @@ export async function main() {
         const exitCode = await runHeadlessMode(options.prompt, config, {
             planMode: planModeInitial,
             yolo: !!options.yolo,
+            extra: !!options.extra,
             quiet: !!options.quiet,
             json: !!options.json,
             signal: abortController.signal
@@ -813,11 +906,12 @@ export async function main() {
         return {
             version: DEVX_VERSION,
             model: modelLabel(config),
-            provider: config.provider,
+            provider: providerDisplayName(config, config.provider, ALL_PROVIDERS),
             cwd: process.cwd(),
             branch: git?.branch,
             dirty: git?.isDirty,
             yolo: !!config.autoApprove,
+            extra: !!config.autoApprove && !!config.autoApproveAll,
             tip: pickTip(),
         };
     };
@@ -845,6 +939,31 @@ export async function main() {
     // 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();
+    // For the small side jobs (chat title, commit message, summary): the lightest reasoning the model
+    // offers, and what they cost goes into the session total like everything else.
+    const sideProvider = () => {
+        const inner = createProvider(config, { light: true });
+        return {
+            id: inner.id,
+            chat: async (request) => {
+                try {
+                    const res = await inner.chat(request);
+                    if (res.usage)
+                        sessionCost.add(res.usage);
+                    return res;
+                }
+                catch (err) {
+                    // Timed out or cut off after the request went out: still billed, so it counts as an estimate.
+                    if (err?.status === undefined || err.status === 504 || err.status === 524) {
+                        const lost = inner.lostRequestUsage?.(new History().estimateTokens(request.messages), 0);
+                        if (lost)
+                            sessionCost.add(lost);
+                    }
+                    throw err;
+                }
+            },
+        };
+    };
     const currentContext = () => contextBreakdown(history.getMessages(), getTools(planMode).map(t => t.definition), config.maxContextTokens || getModelContextLimit(config.model));
     let currentDraft = '';
     let autoTriggerPrompt = '';
@@ -857,6 +976,9 @@ export async function main() {
     const checkpoints = [];
     // What the user allowed on the approval card for this session ("Session"); "Always" goes to the config.
     const permissionMemory = newPermissionMemory();
+    // Commands the agent keeps running in the background (servers, watchers): shown in the prompt frame, listed by /tasks.
+    const bg = getBackgroundManager();
+    const bgSummary = () => backgroundSummary(bg);
     // The most a session may cost (USD, 0 = no limit); "continue" at the limit raises it for this session only.
     let costLimitRaised = null;
     let costWarned = false;
@@ -885,6 +1007,10 @@ export async function main() {
     // and start from a clean slate: history, cost, usage counters, undo stack, screen.
     const startFreshSession = async () => {
         sessionManager.startNewSession(config.model, planMode);
+        // The tasks belonged to the conversation that is being left.
+        await bg.stopAll().catch(() => 0);
+        bg.clearFinished();
+        bg.takeNotes();
         transcript.length = 0;
         checkpoints.length = 0;
         windowTitle = '';
@@ -911,10 +1037,10 @@ export async function main() {
     while (true) {
         const maxTokens = config.maxContextTokens || getModelContextLimit(config.model);
         config.maxContextTokens = maxTokens;
-        // The conversation only: the system prompt and tool schemas are fixed overhead that every
-        // chat has, so an empty chat shows 0%. /usage shows the full picture.
+        // An empty chat shows 0; from the first message on, everything the next request carries
+        // is counted: the system prompt and the tool schemas too.
         const ctxNow = currentContext();
-        const currentTokens = ctxNow.total - ctxNow.system - ctxNow.tools;
+        const currentTokens = ctxNow.inUse;
         const usagePercent = Math.min(100, Math.round((currentTokens / maxTokens) * 100));
         const formatTokens = (n) => {
             if (n >= 1_000_000)
@@ -965,6 +1091,8 @@ export async function main() {
             }
         }
         let answer = '';
+        // Set when this turn starts by itself, from the news of a background task (not from the user).
+        let wakeNotes = '';
         if (autoTriggerPrompt) {
             answer = autoTriggerPrompt;
             autoTriggerPrompt = '';
@@ -989,6 +1117,7 @@ export async function main() {
                 },
                 planMode,
                 isYolo: !!config.autoApprove,
+                isExtra: !!config.autoApprove && !!config.autoApproveAll,
                 ui: config.ui,
                 model: modelLabel(config),
                 cwd: process.cwd(),
@@ -996,7 +1125,19 @@ export async function main() {
                 dirty: GitStatusCache.getStatus()?.isDirty,
                 contextPercent: usagePercent,
                 cost: sessionCost.total,
-                costState: sessionCost.state()
+                costState: sessionCost.state(),
+                background: bgSummary,
+                subscribe: (signal) => {
+                    const onChange = () => signal('redraw');
+                    // A task ended or printed what the agent asked to hear about: the agent takes it up by itself.
+                    const onNote = () => signal(config.backgroundAutoWake === false ? 'redraw' : 'wake');
+                    bg.on('change', onChange);
+                    bg.on('note', onNote);
+                    return () => {
+                        bg.off('change', onChange);
+                        bg.off('note', onNote);
+                    };
+                },
             });
             if (inputStr.startsWith('__TOGGLE_MODE__:')) {
                 currentDraft = inputStr.slice('__TOGGLE_MODE__:'.length);
@@ -1011,19 +1152,31 @@ export async function main() {
                 }
                 continue;
             }
-            currentDraft = '';
-            if (inputStr === '__CANCEL__') {
-                const confirmExit = await askConfirm({ title: t('confirm.exitTitle'), question: t('confirm.exit'), record: false });
-                if (confirmExit) {
-                    resetTerminalTheme();
-                    printFarewell(t('confirm.goodbye'));
-                    break;
-                }
-                else {
+            if (inputStr.startsWith('__WAKE__:')) {
+                // The prompt was closed by news from a background task: the agent answers it. What was typed stays.
+                currentDraft = inputStr.slice('__WAKE__:'.length);
+                wakeNotes = bg.takeNotes();
+                if (!wakeNotes)
                     continue;
+                console.log(noteRows(wakeNotes).map((r) => renderNotice('info', r)).join('\n'));
+                console.log();
+                answer = wakeNotes;
+            }
+            else {
+                currentDraft = '';
+                if (inputStr === '__CANCEL__') {
+                    const confirmExit = await askConfirm({ title: t('confirm.exitTitle'), question: t('confirm.exit'), record: false });
+                    if (confirmExit) {
+                        resetTerminalTheme();
+                        printFarewell(t('confirm.goodbye'));
+                        break;
+                    }
+                    else {
+                        continue;
+                    }
                 }
+                answer = inputStr.trim();
             }
-            answer = inputStr.trim();
         }
         if (!answer)
             continue;
@@ -1045,7 +1198,7 @@ export async function main() {
                     '/settings', '/update', '/model', '/provider', '/providers',
                     '/plan', '/agent', '/image', '/serve', '/memory', '/permissions', '/copy', '/rename', '/title', '/rewind', '/undo',
                     '/diff', '/commit', '/status', '/compact', '/init', '/doctor',
-                    '/config', '/clear', '/exit', '/quit', '/help', '/effort'
+                    '/config', '/clear', '/exit', '/quit', '/help', '/effort', '/tasks', '/bg', '/jobs'
                 ];
                 if (!VALID_COMMANDS.includes(cmd)) {
                     const customList = await CustomCommandManager.listCommands();
@@ -1070,6 +1223,7 @@ export async function main() {
                         { name: '/plan         - Switch to PLAN mode (architect)', value: '/plan' },
                         { name: '/agent        - Switch to AGENT mode (coder)', value: '/agent' },
                         { name: '/serve        - Start local web server for web preview', value: '/serve' },
+                        { name: '/tasks        - Background tasks (list, output, stop)', value: '/tasks' },
                         { name: '/memory       - View or edit project memory bank', value: '/memory' },
                         { name: '/permissions  - What is allowed without asking', value: '/permissions' },
                         { name: '/copy         - Copy the last answer to the clipboard', value: '/copy' },
@@ -1203,6 +1357,8 @@ export async function main() {
                         planMode = loaded.planMode;
                     }
                     sessionCost.restore(loaded.totalCost || 0, loaded.costEstimated === true);
+                    // /usage starts from the same total as the frame, and not from the chat that was open before.
+                    UsageTracker.getInstance().restoreCost(loaded.totalCost || 0, loaded.costEstimated === true);
                     drawLogo(config.banner || 'full');
                     const nonSysMessages = loaded.messages.filter(m => m.role !== 'system');
                     const totalMsgs = nonSysMessages.length;
@@ -1360,7 +1516,7 @@ export async function main() {
                         const s = new UiSpinner();
                         s.start('Generating conventional commit message with AI...');
                         await refreshFormats(config).catch(() => null);
-                        const provider = createProvider(config);
+                        const provider = sideProvider();
                         const promptReq = {
                             messages: [
                                 {
@@ -1402,7 +1558,7 @@ export async function main() {
                 s.start('Compacting conversation context with AI...');
                 try {
                     await refreshFormats(config).catch(() => null);
-                    const provider = createProvider(config);
+                    const provider = sideProvider();
                     // The request itself must fit the window: shorten a copy of the history first.
                     const forSummary = new History();
                     for (const m of msgs)
@@ -1471,6 +1627,12 @@ export async function main() {
                 await runDoctor(config);
                 continue;
             }
+            if (cmd === '/tasks' || cmd === '/bg' || cmd === '/jobs') {
+                const rows = await runTasksCommand(parts.slice(1).filter(Boolean), bg, process.stdout.columns || 80);
+                console.log(rows.join('\n'));
+                console.log();
+                continue;
+            }
             if (cmd === '/serve') {
                 const sub = parts[1]?.toLowerCase();
                 if (sub === 'stop') {
@@ -1591,7 +1753,7 @@ export async function main() {
                         log.warn(t('rename.usage'));
                     }
                     else {
-                        const generated = await generateChatTitle(createProvider(config), firstUser.split('\n\n--- Attached Files ---')[0], reply);
+                        const generated = await generateChatTitle(sideProvider(), firstUser.split('\n\n--- Attached Files ---')[0], reply);
                         if (!generated)
                             log.error(t('rename.failed'));
                         else {
@@ -1852,7 +2014,7 @@ export async function main() {
                 if (newConfig) {
                     config = newConfig;
                     await refreshEndpoint(config).catch(() => null);
-                    announce(`provider ${config.provider || 'custom'} · ${config.model}${providerFormat(config) === 'anthropic' ? ' (Anthropic format)' : ''}`);
+                    announce(`provider ${providerDisplayName(config, config.provider, ALL_PROVIDERS) || config.provider || 'custom'} · ${config.model}${providerFormat(config) === 'anthropic' ? ' (Anthropic format)' : ''}`);
                 }
                 else {
                     log.info('Provider selection cancelled.');
@@ -1897,7 +2059,10 @@ export async function main() {
             }
         }
         // Resolve @file and @image mentions
-        const { text: cleanAnswer, attachments, images, warnings: attachWarnings } = await resolveAtMentions(answer);
+        // News from a background task is output of a program, not a message of the user: no @file in it is read.
+        const { text: cleanAnswer, attachments, images, warnings: attachWarnings } = wakeNotes
+            ? { text: answer, attachments: [], images: [], warnings: [] }
+            : await resolveAtMentions(answer);
         for (const warning of attachWarnings)
             log.warn(warning);
         let finalContent = cleanAnswer;
@@ -1938,9 +2103,12 @@ export async function main() {
             if (turnCheckpoint)
                 checkpoints.push(turnCheckpoint);
         }
-        transcript.push({ kind: 'user', text: answer });
+        if (wakeNotes)
+            transcript.push({ kind: 'raw', rows: noteRows(wakeNotes).map((r) => renderNotice('info', r)) });
+        else
+            transcript.push({ kind: 'user', text: answer });
         // Until the model has named the chat, the start of the first message stands in for the name.
-        if (!windowTitle && !sessionManager.hasGeneratedTitle)
+        if (!wakeNotes && !windowTitle && !sessionManager.hasGeneratedTitle)
             setWindowTitle(provisionalTitle(answer));
         history.addMessage({
             role: 'user',
@@ -1954,6 +2122,7 @@ export async function main() {
         const provider = createProvider(config);
         const tools = getTools(planMode);
         const guard = new CLIConsoleGuard(config.autoApprove, [...(config.bashAllowlist || [])], {
+            extra: !!config.autoApproveAll,
             memory: permissionMemory,
             // "Always": kept in the config for the next sessions (`/permissions` lists and clears them).
             onAlways: (r) => {
@@ -2187,9 +2356,7 @@ export async function main() {
                 pendingRedraw = true;
             }
         };
-        // Ctrl+Enter: what the user typed goes to the agent right now, replacing the task it was on.
-        let interruptPrompt = '';
-        const stopGeneration = (quiet = false, reason) => {
+        const stopGeneration = (reason) => {
             if (aborted)
                 return;
             aborted = true;
@@ -2207,14 +2374,6 @@ export async function main() {
                 console.log(renderNotice('warn', reason));
                 console.log();
             }
-            else if (quiet) {
-                // The message that caused the stop is echoed by the next turn: only a quiet separator here.
-                if (cleanUi)
-                    console.log(renderNotice('info', t('stop.interrupted')));
-                else
-                    console.log(pc.yellow('\n' + t('stop.classicInterrupted')));
-                console.log();
-            }
             else if (cleanUi) {
                 console.log(renderNotice('warn', isConnecting ? t('stop.connection') : t('stop.stopped')));
                 console.log();
@@ -2229,13 +2388,6 @@ export async function main() {
         const onSigInt = () => {
             stopGeneration();
         };
-        const sendQueuedNow = () => {
-            if (aborted)
-                return;
-            interruptPrompt = composer.takeQueued().join('\n');
-            if (interruptPrompt)
-                stopGeneration(true);
-        };
         // The input line at the bottom while the agent works: what is typed there is queued and
         // reaches the model at its next step (see TurnComposer).
         // The working line (time and tokens) stays above the frame for the whole turn.
@@ -2251,10 +2403,10 @@ export async function main() {
         });
         const composer = new TurnComposer(process.stdout, () => {
             const ctx = currentContext();
-            const used = ctx.total - ctx.system - ctx.tools;
+            const used = ctx.inUse;
             const git = GitStatusCache.getStatus();
             return {
-                mode: resolveMode(planMode, !!config.autoApprove),
+                mode: resolveMode(planMode, !!config.autoApprove, !!config.autoApproveAll),
                 model: modelLabel(config),
                 cwd: process.cwd(),
                 branch: git?.branch,
@@ -2262,8 +2414,12 @@ export async function main() {
                 contextPercent: Math.min(100, Math.round((used / (config.maxContextTokens || getModelContextLimit(config.model))) * 100)),
                 cost: sessionCost.total,
                 costState: sessionCost.state(),
+                background: bgSummary(),
             };
-        }, undefined, statusLine, sendQueuedNow);
+        }, undefined, statusLine);
+        // A task started or ended during the turn: the frame shows the new count.
+        const onBgChange = () => composer.refresh();
+        bg.on('change', onBgChange);
         composer.live = liveThought;
         composer.onToggle = toggleView;
         const releasePauseHook = registerPauseHook(() => {
@@ -2284,6 +2440,16 @@ export async function main() {
                 stopGeneration();
                 return;
             }
+            // Esc stops the answer and whatever it started (a command that runs), like Ctrl+C. Not while a
+            // card has the keyboard: there Esc answers the card. A lone Esc comes in a chunk of its own;
+            // Esc followed by a character in one chunk is Alt+that character.
+            if (!composer.isSuspended) {
+                const keys = splitKeys(text);
+                if (keys.length === 1 && normalizeKey(keys[0]) === '\x1b') {
+                    stopGeneration();
+                    return;
+                }
+            }
             composer.handleData(text);
         };
         const onResize = () => composer.onResize();
@@ -2320,9 +2486,17 @@ export async function main() {
             for await (const event of agent.run(abortController.signal, {
                 takePending: async () => Promise.all(composer.takeQueued().map(queuedToMessage)),
                 hasPending: () => composer.hasQueued(),
+                takeNotes: () => bg.takeNotes(),
+                hasNotes: () => bg.hasNotes(),
             })) {
-                if (aborted)
+                if (aborted) {
+                    // The request that was cancelled is still billed by the provider: its estimate counts.
+                    if (event.type === 'usage') {
+                        sessionCost.add(event.usage);
+                        turnInputTokens += event.usage.promptTokens || 0;
+                    }
                     break;
+                }
                 if (event.type === 'reasoning_delta') {
                     isConnecting = false;
                     telemetry.setPhase('thinking');
@@ -2526,7 +2700,7 @@ export async function main() {
                     const limit = costLimit();
                     if (limit > 0 && !aborted) {
                         if (sessionCost.total >= limit) {
-                            stopGeneration(false, t('cost.stopped', { limit: formatCost(limit) }));
+                            stopGeneration(t('cost.stopped', { limit: formatCost(limit) }));
                         }
                         else if (!costWarned && sessionCost.total >= limit * 0.8) {
                             costWarned = true;
@@ -2609,6 +2783,22 @@ export async function main() {
                     else
                         log.info(event.message);
                 }
+                else if (event.type === 'background_note') {
+                    // A background task ended or printed what the agent asked to hear about.
+                    if (spinnerActive) {
+                        s.stop();
+                        spinnerActive = false;
+                    }
+                    finishThinking(true);
+                    streamer.finish();
+                    endText();
+                    const rows = noteRows(event.content);
+                    transcript.push({ kind: 'raw', rows: rows.map((r) => renderNotice('info', r)) });
+                    for (const row of rows)
+                        console.log(cleanUi ? renderNotice('info', row) : pc.dim(row));
+                    s.start(cleanUi ? t('status.waiting') : 'Connecting...');
+                    spinnerActive = true;
+                }
             }
             finishThinking(true);
             streamer.finish();
@@ -2619,13 +2809,9 @@ export async function main() {
             endText();
             // Hand the bottom of the screen back. Whatever was typed but not sent waits in the next prompt;
             // a message that arrived too late for the agent starts the next turn by itself.
+            bg.off('change', onBgChange);
             const leftover = composer.stop();
-            if (interruptPrompt) {
-                autoTriggerPrompt = interruptPrompt;
-                if (leftover.draft)
-                    currentDraft = leftover.draft;
-            }
-            else if (leftover.queued.length > 0) {
+            if (leftover.queued.length > 0) {
                 if (aborted)
                     currentDraft = [...leftover.queued, leftover.draft].filter(Boolean).join(' ');
                 else
@@ -2680,7 +2866,7 @@ export async function main() {
                     const forSession = sessionManager.getSession().id;
                     void (async () => {
                         try {
-                            const title = await generateChatTitle(createProvider(config), firstUser.split('\n\n--- Attached Files ---')[0], reply);
+                            const title = await generateChatTitle(sideProvider(), firstUser.split('\n\n--- Attached Files ---')[0], reply);
                             // The user may have started another chat meanwhile.
                             if (!title || sessionManager.getSession().id !== forSession)
                                 return;
@@ -2744,11 +2930,10 @@ export async function main() {
             }
         }
         finally {
+            bg.off('change', onBgChange);
             const unsent = composer.stop();
             if (process.stdout.isTTY)
                 process.stdout.write('\x1b[?1004l');
-            if (interruptPrompt && !autoTriggerPrompt)
-                autoTriggerPrompt = interruptPrompt;
             releasePauseHook();
             process.stdout.removeListener('resize', onResize);
             if (!currentDraft && (unsent.draft || unsent.queued.length > 0)) {