termux-dev 1.6.0 → 1.8.1

package/dist/cli/index.js

@@ -1,6 +1,5 @@
 import { Command } from 'commander';
 import * as p from '@clack/prompts';
-import { search, password, input, select } from '@inquirer/prompts';
 import pc from 'picocolors';
 import os from 'os';
 import path from 'path';
@@ -13,14 +12,21 @@ 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 { CLIConsoleGuard } from '../permissions/guard.js';
+import { CLIConsoleGuard, newPermissionMemory } from '../permissions/guard.js';
 import { globalSnapshotManager } from '../core/snapshot.js';
-import { MemoryManager } from '../core/memory.js';
+import { MemoryManager, memoryForPrompt } from '../core/memory.js';
 import { startServer, stopServer, displayServerBanner } from './server.js';
-import { notifyDevice, acquireWakeLock } from '../core/notify.js';
+import { notifyDevice, acquireWakeLock, isTermux, notificationBody, sendDesktopNotification } from '../core/notify.js';
+import { copyToClipboard } from './clipboard-write.js';
+import { REWIND_CURRENT, messageDraft, rewindItems, userEntries } from './rewind.js';
+import { runPicker } from './picker.js';
+import { runFinder, runTextInput } from './finder.js';
+import { renderWelcome } from './welcome.js';
+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 { getModelContextLimit } from '../core/models.js';
+import { getModelContextInfo, getModelContextLimit } from '../core/models.js';
 import { SessionManager } from '../core/session.js';
 import { MarkdownStreamer, renderMarkdown } from './markdown.js';
 import { SmoothStreamer } from './smooth.js';
@@ -31,12 +37,36 @@ import { setActiveTheme, getCurrentTheme, listThemes, findTheme } from './theme.
 import { runHeadlessMode } from './headless.js';
 import { CustomCommandManager } from '../core/commands.js';
 import { UsageTracker } from '../core/usage.js';
+import { CostLedger } from '../core/cost.js';
 import { SessionExporter } from './export.js';
-import { MCPManager } from '../mcp/manager.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 { LiveTelemetryTracker } from './telemetry.js';
-import { renderCleanStatus, renderPowerlineStatus, GitStatusCache } from './statusline.js';
+import { renderPowerlineStatus, GitStatusCache } from './statusline.js';
 import { formatDiffBox } from './diff.js';
 import { drawBanner } from './banner.js';
+import { reportRuntimeError } from './runtime_errors.js';
+import { GutterWriter, UiSpinner, formatCost, formatTokens as formatTokensShort, palette, pickTip, renderHeader, renderNotice, renderResultBlock, renderToolLine, renderTurnSummary, registerPauseHook, easeToward, renderStatusLine, renderUserEcho, resolveMode, } from './ui.js';
+import { runSettings } from './settings.js';
+import { runMcpPanel } from './mcp-panel.js';
+import { renderResumedMessages } from './resume.js';
+import { askConfirm, askPlanDecision, printFarewell } from './confirm.js';
+import { createCheckpoint, diffCheckpoint, restoreCheckpoint } from '../core/checkpoint.js';
+import { log, note } from './log.js';
+import { displayWidth, tailWidth } from './width.js';
+import { COMPACT_MARK, collapsedThoughtLine, renderItem, messagesToItems, renderTranscript, toolResultRows } from './transcript.js';
+import { chooseEffort, effortCommand } from './effort.js';
+import { effectiveReasoning, parseEffortArg, detectRoute, thinkLabel } from '../core/reasoning.js';
+import { catalogInfo, installCapabilities, refreshCapabilities, refreshCatalog } from '../core/capabilities.js';
+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 { LANGUAGES, getLanguage, setLanguage, t } from '../core/i18n.js';
+import { anthropicOnlyModels, formatFromBaseUrl, refreshFormats } from '../core/formats.js';
+import { providerFormat } from '../providers/index.js';
 const CONFIG_PATH = path.join(os.homedir(), '.devxrc.json');
 function maskApiKey(key) {
     if (!key)
@@ -54,14 +84,24 @@ async function saveConfig(config) {
     if (config.provider && config.baseUrl) {
         config.baseUrls[config.provider] = config.baseUrl;
     }
-    await fs.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf8');
+    // 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));
 }
 async function fetchModels(baseUrl, apiKey) {
     try {
         const url = baseUrl.endsWith('/') ? `${baseUrl}models` : `${baseUrl}/models`;
         const headers = {};
-        if (apiKey && apiKey !== 'ollama')
+        if (formatFromBaseUrl(baseUrl) === 'anthropic') {
+            // Anthropic's own API wants x-api-key and a version, not a Bearer token.
+            headers['anthropic-version'] = '2023-06-01';
+            if (apiKey)
+                headers['x-api-key'] = apiKey;
+        }
+        else if (apiKey && apiKey !== 'ollama') {
             headers['Authorization'] = `Bearer ${apiKey}`;
+        }
         const res = await fetch(url, { headers });
         if (!res.ok) {
             if (res.status === 401 || res.status === 403) {
@@ -73,7 +113,7 @@ async function fetchModels(baseUrl, apiKey) {
         if (data && data.data && Array.isArray(data.data)) {
             const list = data.data.map((m) => ({
                 id: m.id,
-                name: m.name || m.id,
+                name: m.name || m.display_name || m.id,
                 contextLength: m.context_length || m.max_context_length || m.limit?.context || m.limit?.input
             }));
             return { ok: true, status: res.status, models: list };
@@ -84,6 +124,12 @@ async function fetchModels(baseUrl, apiKey) {
         return { ok: false, status: 0, models: [], error: e.message || 'Network error' };
     }
 }
+/** Asks the endpoint what the model can do and which wire formats it speaks (cached for a day). */
+function refreshEndpoint(config, options) {
+    return Promise.all([refreshCapabilities(config, options), refreshFormats(config, options)]).then(([record]) => record);
+}
+/** `"probeEndpoints": false` in the config: devx asks nothing but the plain model list. */
+let probeEndpointsAllowed = true;
 const POPULAR_PROVIDER_MODELS = {
     google: ['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-1.5-flash', 'gemini-1.5-pro'],
     openai: ['gpt-4o', 'gpt-4o-mini', 'o3-mini', 'o1', 'gpt-4-turbo'],
@@ -93,10 +139,21 @@ const POPULAR_PROVIDER_MODELS = {
     groq: ['llama-3.3-70b-versatile', 'llama-3.1-8b-instant', 'mixtral-8x7b-32768'],
     mistral: ['mistral-large-latest', 'mistral-small-latest', 'codestral-latest'],
 };
-async function selectModel(baseUrl, apiKey, currentModel, providerId = '', allowCancel = true) {
-    const s = p.spinner();
-    s.start('Fetching available models from provider...');
+const formatContext = (n) => (n >= 1_000_000 ? `${(n / 1_000_000).toFixed(1)}M` : `${Math.round(n / 1000)}k`);
+/** `step` is "3/4" during the first run, so the card says where in the setup you are. */
+async function selectModel(baseUrl, apiKey, currentModel, providerId = '', _allowCancel = true, step) {
+    const s = new UiSpinner();
+    s.start(t('onboard.model.fetching'));
     const result = await fetchModels(baseUrl, apiKey);
+    // The same gateway may list more models (Claude) in its Anthropic format, with the same key.
+    if (result.ok && probeEndpointsAllowed) {
+        await refreshFormats({ baseUrl, apiKey }, { force: true }).catch(() => null);
+        const known = new Set(result.models.map(m => m.id.toLowerCase()));
+        for (const id of anthropicOnlyModels(baseUrl)) {
+            if (!known.has(id.toLowerCase()))
+                result.models.push({ id, name: id, viaAnthropic: true, contextLength: getModelContextLimit(id) });
+        }
+    }
     s.stop();
     let models = result.models;
     if (models.length === 0 && providerId && POPULAR_PROVIDER_MODELS[providerId]) {
@@ -106,201 +163,152 @@ async function selectModel(baseUrl, apiKey, currentModel, providerId = '', allow
             contextLength: getModelContextLimit(id)
         }));
     }
-    let modelChoice;
-    if (models.length > 0) {
-        try {
-            modelChoice = await search({
-                message: `Select a model (${models.length} available, type to filter):`,
-                source: async (term) => {
-                    const q = (term || '').trim().toLowerCase();
-                    const list = [];
-                    if (allowCancel) {
-                        list.push({ name: pc.yellow('⬅️  Back / Cancel'), value: '__cancel__', description: 'Keep current model' });
-                    }
-                    list.push({ name: pc.yellow('✏️  Type a custom model name...'), value: 'custom_input', description: 'Enter any model ID manually' });
-                    for (const m of models) {
-                        const isCurrent = m.id === currentModel;
-                        const prefix = isCurrent ? pc.cyan('› ') : '  ';
-                        const nameStr = isCurrent ? pc.bold(pc.cyan(m.id + ' (current)')) : m.id;
-                        const ctxStr = m.contextLength ? `${m.contextLength >= 1_000_000 ? (m.contextLength / 1_000_000).toFixed(1) + 'M' : Math.round(m.contextLength / 1000) + 'k'} context` : '';
-                        list.push({
-                            name: prefix + nameStr,
-                            value: m.id,
-                            description: ctxStr
-                        });
-                    }
-                    if (!q)
-                        return list;
-                    return list.filter(item => item.value.toLowerCase().includes(q) || item.name.toLowerCase().includes(q));
-                },
-                pageSize: 10
-            });
-        }
-        catch {
-            return null;
-        }
-        if (modelChoice === '__cancel__') {
-            return null;
-        }
-        if (modelChoice === 'custom_input') {
-            try {
-                const customModel = await input({
-                    message: 'Type the model name (e.g. gpt-4o or claude-3-7-sonnet):',
-                });
-                if (!customModel || !customModel.trim())
-                    return null;
-                const name = customModel.trim();
-                return { model: name, contextLimit: getModelContextLimit(name) };
-            }
-            catch {
-                return null;
-            }
-        }
-        const found = models.find(m => m.id === modelChoice);
-        const limit = (found && found.contextLength) || getModelContextLimit(modelChoice);
-        return { model: modelChoice, contextLimit: limit };
-    }
-    else {
-        p.log.warn('Could not fetch models automatically.');
-        try {
-            const typedModel = await input({
-                message: 'Type the model name you want to use (e.g. gpt-4o):',
-                default: currentModel || ''
-            });
-            if (!typedModel || !typedModel.trim())
-                return null;
-            const name = typedModel.trim();
-            return { model: name, contextLimit: getModelContextLimit(name) };
-        }
-        catch {
+    const typeName = async (note) => {
+        const name = await runTextInput({
+            title: t('onboard.model.title'),
+            subtitle: step,
+            label: t('onboard.model.label'),
+            initial: models.length === 0 ? currentModel : '',
+            notes: note ? [note] : undefined,
+        });
+        return name ? { model: name, contextLimit: getModelContextLimit(name) } : null;
+    };
+    if (models.length === 0)
+        return typeName(t('onboard.model.manual'));
+    const CUSTOM = '__custom__';
+    for (;;) {
+        const choice = await runFinder({
+            title: t('onboard.model.title'),
+            subtitle: step ?? `${models.length}`,
+            placeholder: t('onboard.model.placeholder'),
+            current: currentModel,
+            items: [
+                { value: CUSTOM, label: t('onboard.model.custom'), detail: t('onboard.model.customDetail'), pinned: true },
+                ...models.map((m) => ({
+                    value: m.id,
+                    label: m.id,
+                    detail: [m.viaAnthropic ? t('onboard.model.anthropic') : '', m.contextLength ? t('onboard.model.context', { n: formatContext(m.contextLength) }) : ''].filter(Boolean).join(', '),
+                })),
+            ],
+        });
+        if (choice === undefined)
             return null;
+        if (choice === CUSTOM) {
+            const typed = await typeName();
+            if (typed)
+                return typed;
+            continue; // Esc in the field: back to the list
         }
+        const found = models.find(m => m.id === choice);
+        return { model: choice, contextLimit: (found && found.contextLength) || getModelContextLimit(choice) };
     }
 }
+/** 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 || {};
     if (currentConfig.provider && currentConfig.apiKey) {
         apiKeys[currentConfig.provider] = currentConfig.apiKey;
     }
-    let providerId;
-    try {
-        providerId = await search({
-            message: 'Select AI Provider (type to filter, Esc to cancel):',
-            source: async (term) => {
-                const q = (term || '').trim().toLowerCase();
-                const filtered = q
-                    ? ALL_PROVIDERS.filter(pr => pr.label.toLowerCase().includes(q) || pr.value.toLowerCase().includes(q))
-                    : ALL_PROVIDERS;
-                const list = filtered.map(pr => {
-                    const isCurrent = pr.value === currentConfig.provider;
-                    const labelStr = isCurrent ? pc.bold(pc.cyan(pr.label + ' (current)')) : pr.label;
-                    const hasKey = apiKeys[pr.value] ? `[Key: ${maskApiKey(apiKeys[pr.value])}] ` : '';
-                    return {
-                        name: `${isCurrent ? pc.cyan('› ') : '  '}${labelStr}`,
-                        value: pr.value,
-                        description: `${hasKey}${pr.baseUrl || 'Custom endpoint'}`
-                    };
-                });
-                if (allowCancel) {
-                    list.unshift({
-                        name: pc.yellow('⬅️  Back / Cancel'),
-                        value: '__cancel__',
-                        description: 'Keep current provider'
-                    });
-                }
-                return list;
-            },
-            pageSize: 10
-        });
-    }
-    catch {
-        return null;
-    }
-    if (providerId === '__cancel__') {
-        return null;
-    }
-    const selectedProvider = ALL_PROVIDERS.find(pr => pr.value === providerId) || { baseUrl: '', label: providerId };
-    let baseUrl = baseUrls[providerId] || selectedProvider.baseUrl;
-    if (providerId === 'custom' || !baseUrl) {
-        try {
-            const customUrl = await input({
-                message: 'Enter Base URL (e.g. https://api.openai.com/v1):',
-                default: baseUrl || ''
+    const firstRun = !allowCancel;
+    const stepOf = (n) => (firstRun ? `${n}/5` : undefined);
+    let providerId = '';
+    let baseUrl = '';
+    let apiKey = '';
+    let stage = 'provider';
+    let modelRes = null;
+    while (!modelRes) {
+        if (stage === 'provider') {
+            const choice = await runFinder({
+                title: t('onboard.provider.title'),
+                subtitle: stepOf(3),
+                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',
+                })),
             });
-            if (!customUrl || !customUrl.trim())
-                return null;
-            baseUrl = customUrl.trim();
-            baseUrls[providerId] = baseUrl;
+            if (choice === undefined)
+                return null; // Esc on the first step leaves the whole setup
+            providerId = choice;
+            const known = ALL_PROVIDERS.find(pr => pr.value === providerId);
+            baseUrl = baseUrls[providerId] || known?.baseUrl || '';
+            stage = providerId === 'custom' || !baseUrl ? 'url' : 'key';
         }
-        catch {
-            return null;
+        else if (stage === 'url') {
+            const url = await runTextInput({
+                title: t('onboard.baseUrl.title'),
+                subtitle: stepOf(3),
+                label: t('onboard.baseUrl.label'),
+                initial: baseUrl,
+                placeholder: t('onboard.baseUrl.placeholder'),
+            });
+            if (url === undefined) {
+                stage = 'provider';
+                continue;
+            }
+            baseUrl = url;
+            baseUrls[providerId] = baseUrl;
+            stage = 'key';
         }
-    }
-    let apiKey = '';
-    if (providerId === 'ollama') {
-        apiKey = 'ollama';
-    }
-    else {
-        const savedKey = apiKeys[providerId];
-        if (savedKey) {
-            let keyChoice;
-            try {
-                keyChoice = await search({
-                    message: `API key found for ${selectedProvider.label} (${maskApiKey(savedKey)}):`,
-                    source: async () => [
-                        { name: `🟢 Continue with saved API key (${maskApiKey(savedKey)})`, value: 'use_saved' },
-                        { name: '✏️  Enter a new API key', value: 'new_key' },
-                        { name: pc.yellow('⬅️  Cancel'), value: '__cancel__' }
+        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';
+            if (providerId === 'ollama') {
+                apiKey = 'ollama';
+                stage = 'model';
+                continue;
+            }
+            const saved = apiKeys[providerId];
+            let useSaved = false;
+            if (saved) {
+                const choice = await runPicker({
+                    title: t('onboard.key.title'),
+                    subtitle: label,
+                    items: [
+                        { value: 'saved', label: t('onboard.key.useSaved'), detail: maskApiKey(saved) },
+                        { value: 'new', label: t('onboard.key.enterNew') },
                     ],
-                    pageSize: 5
+                    notes: [t('onboard.key.savedTitle', { provider: label })],
                 });
+                if (choice === undefined) {
+                    stage = back;
+                    continue;
+                }
+                useSaved = choice === 'saved';
             }
-            catch {
-                return null;
-            }
-            if (keyChoice === '__cancel__')
-                return null;
-            if (keyChoice === 'use_saved') {
-                apiKey = savedKey;
+            if (useSaved) {
+                apiKey = saved;
             }
             else {
-                try {
-                    const key = await password({
-                        message: `Enter new API Key for ${selectedProvider.label}:`,
-                        mask: '•'
-                    });
-                    if (!key || !key.trim())
-                        return null;
-                    apiKey = key.trim();
-                    apiKeys[providerId] = apiKey;
-                }
-                catch {
-                    return null;
+                const key = await runTextInput({
+                    title: t('onboard.key.title'),
+                    subtitle: stepOf(4) ?? label,
+                    label: t('onboard.key.label', { provider: label }),
+                    secret: true,
+                    notes: [t('onboard.key.note')],
+                });
+                if (key === undefined) {
+                    stage = back;
+                    continue;
                 }
+                apiKey = key;
+                apiKeys[providerId] = apiKey;
             }
+            stage = 'model';
         }
         else {
-            try {
-                const key = await password({
-                    message: `Enter API Key for ${selectedProvider.label} (or press Esc to cancel):`,
-                    mask: '•'
-                });
-                if (!key || !key.trim())
-                    return null;
-                apiKey = key.trim();
-                apiKeys[providerId] = apiKey;
-            }
-            catch {
-                return null;
-            }
+            modelRes = await selectModel(baseUrl, apiKey, currentConfig.model || '', providerId, allowCancel, stepOf(5));
+            if (!modelRes)
+                stage = apiKey === 'ollama' ? 'provider' : 'key';
         }
     }
-    // Pick a model for this provider
-    const modelRes = await selectModel(baseUrl, apiKey, currentConfig.model || '', providerId, allowCancel);
-    if (!modelRes) {
-        return null;
-    }
     const updatedConfig = {
         ...currentConfig,
         provider: providerId,
@@ -315,25 +323,82 @@ async function selectProvider(currentConfig, allowCancel = true) {
     await saveConfig(updatedConfig);
     return updatedConfig;
 }
+/** The themes as a list; the interface takes the colours of the focused one at once, so you see what you pick. */
+async function chooseTheme(current, step) {
+    const before = current ?? getCurrentTheme().id;
+    const picked = await runPicker({
+        title: t('onboard.theme.title'),
+        subtitle: step,
+        items: listThemes().map((th) => ({ value: th.id, label: th.name, detail: th.desc })),
+        current: before,
+        labelWidth: 20,
+        notes: [t('onboard.theme.note')],
+        onFocus: (id) => { setActiveTheme(id); },
+    });
+    setActiveTheme(picked ?? before);
+    return picked;
+}
+/** First run: the welcome card, the language, then provider, key and model, each on its own small card. */
 async function runOnboarding() {
-    console.clear();
-    p.intro(pc.bgCyan(pc.black(' Welcome to devx ')));
-    p.note('No configuration found. Let\'s set up your AI provider.', 'Setup');
-    const res = await selectProvider({ apiKeys: {}, baseUrls: {} }, false);
+    const cols = () => process.stdout.columns || 80;
+    const show = (done) => {
+        process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
+        console.log();
+        for (const line of renderWelcome(DEVX_VERSION, cols(), done))
+            console.log(line);
+        console.log();
+    };
+    show(0);
+    const language = await runPicker({
+        title: t('onboard.language.title'),
+        subtitle: '1/5',
+        items: LANGUAGES.map((l) => ({ value: l.id, label: l.name })),
+        current: getLanguage(),
+        notes: [t('onboard.language.note')],
+        labelWidth: 14,
+    });
+    if (language === undefined) {
+        process.exit(0);
+    }
+    setLanguage(language);
+    show(1);
+    const theme = await chooseTheme(undefined, '2/5');
+    show(2);
+    const res = await selectProvider({ apiKeys: {}, baseUrls: {}, language, ...(theme ? { theme } : {}), onboarded: true }, false);
     if (!res) {
         process.exit(0);
     }
-    p.outro(pc.green('Setup complete! Configuration saved to ~/.devxrc.json'));
+    show(5);
+    console.log(renderNotice('ok', t('onboard.done')));
+    console.log();
     return res;
 }
+/**
+ * The context window to use for the model of this config: a number the user wrote into
+ * `contextLimits`, else the catalogue's (the maker's own number), else what was saved when the
+ * model was chosen, else devx's table, rules and default.
+ */
+function resolveContextLimit(config) {
+    const own = config.contextLimits?.[config.model];
+    if (typeof own === 'number' && own >= 1024)
+        return { limit: own, source: 'config' };
+    const info = getModelContextInfo(config.model);
+    if (info.source === 'catalogue')
+        return info;
+    if (typeof config.maxContextTokens === 'number' && config.maxContextTokens > 0) {
+        return config.maxContextTokens === info.limit ? info : { limit: config.maxContextTokens, source: 'saved' };
+    }
+    return info;
+}
 async function loadConfig(interactive = true) {
     let globalConfig = {};
     try {
         const data = await fs.readFile(CONFIG_PATH, 'utf8');
-        globalConfig = JSON.parse(data);
+        globalConfig = withoutSessionOnlySettings(JSON.parse(data));
+        setLanguage(globalConfig.language); // the questions below are asked in the chosen language
         if (!globalConfig.model || !globalConfig.baseUrl)
             throw new Error('Invalid config');
-        globalConfig.maxContextTokens = globalConfig.maxContextTokens || getModelContextLimit(globalConfig.model);
+        globalConfig.maxContextTokens = resolveContextLimit(globalConfig).limit;
         globalConfig.apiKeys = globalConfig.apiKeys || {};
         globalConfig.baseUrls = globalConfig.baseUrls || {};
         globalConfig.trustedProjects = globalConfig.trustedProjects || {};
@@ -371,59 +436,57 @@ async function loadConfig(interactive = true) {
     // Workspace & Project Trust Check on first time opening this directory
     if (isTrusted === undefined) {
         if (interactive) {
-            console.log('');
-            p.log.warn(pc.bold(pc.yellow(`🛡️  [WORKSPACE TRUST] First time opening this workspace:`)));
-            console.log(pc.dim(`   Directory: ${cwd}`));
-            if (localConfig) {
-                if (localConfig.autoApprove === true) {
-                    console.log(pc.yellow(`   • Local .devx.json requests Auto-approval (YOLO mode)`));
-                }
-                if (localConfig.bashAllowlist) {
-                    console.log(pc.yellow(`   • Local .devx.json requests Bash allowlist: ${localConfig.bashAllowlist.join(', ')}`));
-                }
-            }
-            const answer = await p.confirm({
-                message: 'Do you trust this workspace and allow agent operations?',
-                initialValue: true
+            const trusted = await askConfirm({
+                title: t('trust.title'),
+                question: t('trust.question'),
+                details: [cwd, ...(localConfig?.autoApprove === true ? [t('trust.wantsYolo')] : []), ...(localConfig?.bashAllowlist ? [t('trust.wantsAllowlist', { list: localConfig.bashAllowlist.join(', ') })] : [])],
+                yes: t('trust.yes'),
+                no: t('trust.no'),
             });
-            if (p.isCancel(answer) || answer !== true) {
+            if (!trusted) {
                 resetTerminalTheme();
-                p.outro(pc.yellow('Workspace not trusted. Exiting devx.'));
+                printFarewell(t('trust.exiting'), 'warn');
                 process.exit(0);
             }
             globalConfig.trustedProjects = globalConfig.trustedProjects || {};
             globalConfig.trustedProjects[cwd] = true;
             await saveConfig(globalConfig);
-            p.log.success(pc.green('Workspace marked as trusted. Full capabilities enabled.'));
+            isTrusted = true;
+            log.success(pc.green('Workspace marked as trusted. Full capabilities enabled.'));
         }
         else {
             isTrusted = false; // Never auto-trust in non-interactive headless mode
         }
     }
-    if (localConfig && typeof localConfig === 'object') {
-        // Apply safe configuration overrides
-        if (localConfig.model)
-            effectiveConfig.model = localConfig.model;
-        if (localConfig.provider)
-            effectiveConfig.provider = localConfig.provider;
-        if (localConfig.apiKey)
-            effectiveConfig.apiKey = localConfig.apiKey;
-        if (localConfig.baseUrl)
-            effectiveConfig.baseUrl = localConfig.baseUrl;
-        if (localConfig.maxIterations)
-            effectiveConfig.maxIterations = localConfig.maxIterations;
-        if (localConfig.maxContextTokens)
-            effectiveConfig.maxContextTokens = localConfig.maxContextTokens;
-        if (localConfig.dataSaverLimitMB)
-            effectiveConfig.dataSaverLimitMB = localConfig.dataSaverLimitMB;
-        if (localConfig.pureBlackTheme !== undefined)
-            effectiveConfig.pureBlackTheme = localConfig.pureBlackTheme;
-        // Apply elevated permissions only if explicitly trusted
-        if (isTrusted) {
-            if (localConfig.autoApprove !== undefined)
-                effectiveConfig.autoApprove = localConfig.autoApprove;
-            if (Array.isArray(localConfig.bashAllowlist))
-                effectiveConfig.bashAllowlist = localConfig.bashAllowlist;
+    // Provider / API key / permission settings from the repository only count in a trusted workspace.
+    const ignoredLocalSettings = applyLocalConfig(effectiveConfig, localConfig, isTrusted === true);
+    if (ignoredLocalSettings.length > 0) {
+        console.error(pc.yellow(`Ignored ${ignoredLocalSettings.join(', ')} from the local project config: this workspace is not trusted.`));
+    }
+    // MCP servers declared by the project are arbitrary commands. They run only if the
+    // user approved exactly this set of commands (re-asked whenever the files change).
+    effectiveConfig.projectMcpTrusted = false;
+    const projectMcpServers = discoverProjectMcpServers(cwd);
+    if (projectMcpServers.length > 0) {
+        const fingerprint = hashProjectMcpServers(projectMcpServers);
+        globalConfig.trustedMcp = globalConfig.trustedMcp || {};
+        if (globalConfig.trustedMcp[cwd] === fingerprint) {
+            effectiveConfig.projectMcpTrusted = true;
+        }
+        else if (interactive) {
+            const listing = projectMcpServers.map((srv) => `${srv.name}  (${srv.file})  ${`${srv.config.command} ${(srv.config.args || []).join(' ')}`.trim()}`);
+            const allow = await askConfirm({ title: 'mcp', question: t('trust.mcpQuestion'), details: listing });
+            if (allow) {
+                globalConfig.trustedMcp[cwd] = fingerprint;
+                await saveConfig(globalConfig);
+                effectiveConfig.projectMcpTrusted = true;
+            }
+            else {
+                console.log(renderNotice('info', 'Project MCP servers skipped. Your own servers still start.'));
+            }
+        }
+        else {
+            console.error(pc.yellow(`Skipped ${projectMcpServers.length} project MCP server(s): not approved yet. Run devx interactively in this folder once to review and approve them.`));
         }
     }
     // Configure Data Saver threshold
@@ -452,7 +515,8 @@ process.on('exit', () => {
     if (process.stdin.isTTY) {
         process.stdin.setRawMode(false);
     }
-    process.stdout.write('\x1B[?25h');
+    if (process.stdout.isTTY)
+        process.stdout.write(EXTENDED_KEYS_OFF + '\x1B[?1004l' + RESTORE_TERMINAL_TITLE + '\x1B[?25h');
     resetTerminalTheme();
 });
 process.on('SIGINT', () => {
@@ -464,7 +528,7 @@ process.on('SIGINT', () => {
             process.stdin.setRawMode(false);
             process.stdin.pause();
         }
-        process.stdout.write('\x1B[?25h'); // restore cursor
+        process.stdout.write(EXTENDED_KEYS_OFF + '\x1B[?1004l' + RESTORE_TERMINAL_TITLE + '\x1B[?25h'); // restore cursor
         resetTerminalTheme();
         process.exit(0);
     }
@@ -478,9 +542,24 @@ function clearTerminalScreen() {
         console.clear();
     }
 }
+/** The model name and its reasoning setting: "o3 · think high", "mimo-v2.6-flash · think auto". */
+function modelLabel(config) {
+    const think = thinkLabel(config);
+    return think ? `${config.model} · ${think}` : config.model;
+}
+// Registered by main() once the config exists; lets every screen redraw show the live
+// model / mode / folder in the header card.
+let headerProvider = null;
 function drawLogo(bannerMode = 'full') {
     const cols = process.stdout.columns || 80;
     clearTerminalScreen();
+    if (bannerMode === 'clean' && headerProvider) {
+        console.log();
+        for (const line of renderHeader(headerProvider(), cols))
+            console.log(line);
+        console.log();
+        return;
+    }
     drawBanner(bannerMode, DEVX_VERSION, cols);
 }
 function formatSessionTime(timestamp) {
@@ -523,58 +602,42 @@ function formatToolGeneratingLabel(name, targetHint) {
         return `→ Clarifying questions...`;
     return `→ ${name}${target}...`;
 }
+/** `#ab526 · 2h ago · 12 msgs`: what tells two sessions with the same title apart. */
+function sessionDetail(s) {
+    const count = s.messages.filter((m) => m.role !== 'system').length;
+    return `#${s.id.split('_').pop()} · ${formatSessionTime(s.updatedAt)} · ${t('resume.msgs', { n: count })}`;
+}
 async function handleSessionDelete(bannerMode) {
     while (true) {
         const sessions = await SessionManager.listSessions();
         if (sessions.length === 0) {
             drawLogo(bannerMode);
-            p.log.warn('No saved sessions found.');
-            break;
-        }
-        let chosenSessionId;
-        try {
-            chosenSessionId = await search({
-                message: `Select session to DELETE (${sessions.length} sessions, Esc to finish):`,
-                source: async (term) => {
-                    const q = (term || '').trim().toLowerCase();
-                    const list = [
-                        { name: pc.yellow('⬅️  Done / Cancel'), value: '__cancel__', description: 'Return to chat' },
-                        { name: pc.red('🗑️  Delete ALL sessions'), value: '__all__', description: `Remove all ${sessions.length} saved sessions` }
-                    ];
-                    for (const s of sessions) {
-                        const timeStr = formatSessionTime(s.updatedAt);
-                        const msgCount = s.messages.filter(m => m.role !== 'system').length;
-                        const shortId = s.id.split('_').pop();
-                        list.push({
-                            name: `${pc.red('🗑️ ')} ${pc.dim(`[#${shortId}]`)} ${s.title}`,
-                            value: s.id,
-                            description: `${timeStr} • ${msgCount} msgs • ${s.model || 'default'}`
-                        });
-                    }
-                    if (!q)
-                        return list;
-                    return list.filter(item => item.name.toLowerCase().includes(q) || item.value.toLowerCase().includes(q));
-                },
-                pageSize: 10
-            });
-        }
-        catch {
+            log.warn('No saved sessions found.');
             break;
         }
+        const DELETE_ALL = '__all__';
+        const chosen = await runFinder({
+            title: t('sessions.deleteTitle'),
+            subtitle: `${sessions.length}`,
+            placeholder: t('resume.placeholder'),
+            labelWidth: 36,
+            items: [
+                { value: DELETE_ALL, label: t('sessions.deleteAll', { n: sessions.length }), pinned: true },
+                ...sessions.map((s) => ({ value: s.id, label: s.title, detail: sessionDetail(s), keywords: `${s.id} ${s.model || ''}` })),
+            ],
+        });
+        const chosenSessionId = chosen ?? '__cancel__';
         if (!chosenSessionId || chosenSessionId === '__cancel__') {
             drawLogo(bannerMode);
-            p.log.info('Session deletion finished.');
+            log.info('Session deletion finished.');
             break;
         }
         if (chosenSessionId === '__all__') {
-            const confirmAll = await p.confirm({
-                message: `Are you sure you want to delete ALL ${sessions.length} saved sessions?`,
-                initialValue: false
-            });
-            if (!p.isCancel(confirmAll) && confirmAll) {
+            const confirmAll = await askConfirm({ title: 'sessions', question: t('confirm.deleteAll', { n: sessions.length }) });
+            if (confirmAll) {
                 const count = await SessionManager.deleteAllSessions();
                 drawLogo(bannerMode);
-                p.log.success(`Deleted all ${count} sessions.`);
+                log.success(`Deleted all ${count} sessions.`);
                 break;
             }
             continue;
@@ -584,173 +647,68 @@ async function handleSessionDelete(bannerMode) {
         const ok = await SessionManager.deleteSession(chosenSessionId);
         drawLogo(bannerMode);
         if (ok) {
-            p.log.success(`Deleted session: "${title}"`);
+            log.success(`Deleted session: "${title}"`);
         }
         else {
-            p.log.error(`Failed to delete session: "${title}"`);
+            log.error(`Failed to delete session: "${title}"`);
         }
     }
 }
 async function handleThemeSelect(config) {
-    const currentTh = getCurrentTheme();
-    const themeChoices = listThemes().map(t => ({
-        name: `${t.emoji} ${t.boldFn(t.name.padEnd(18))} ${pc.dim(t.desc)} ${t.id === currentTh.id ? pc.green('(Active)') : ''}`,
-        value: t.id,
-        description: `Apply ${t.name} color palette (${t.hex}) to banners, prompts, and actions`
-    }));
-    try {
-        const selected = await select({
-            message: `${pc.bold('🎨 Select UI Theme / Выберите цветовую тему:')}`,
-            choices: themeChoices
-        });
-        if (selected) {
-            config.theme = selected;
-            await saveConfig(config);
-            const th = setActiveTheme(selected);
-            drawLogo(config.banner || 'full');
-            p.log.success(th.boldFn(`🎨 Theme switched to ${th.emoji} ${th.name}!`));
-        }
+    const selected = await chooseTheme(config.theme);
+    if (selected) {
+        config.theme = selected;
+        await saveConfig(config);
+        const th = setActiveTheme(selected);
+        // No redraw of the screen: that would wipe the conversation. New output uses the new colours.
+        if (config.ui?.layout === 'classic')
+            log.success(th.boldFn(`Theme switched to ${th.colorFn(th.symbol)} ${th.name}!`));
+        else
+            console.log(renderNotice('ok', `theme ${th.name}`));
     }
-    catch { }
 }
 async function handleSettings(config) {
-    while (true) {
-        try {
-            const maxIter = config.maxIterations || 100;
-            const maxIterLabel = maxIter >= 9999 ? 'Unlimited' : `${maxIter} steps`;
-            const currentTh = getCurrentTheme();
-            const choice = await select({
-                message: `${pc.bold('⚙️  Settings')} ${pc.dim(`(devx v${DEVX_VERSION} • theme: ${currentTh.name})`)}`,
-                choices: [
-                    {
-                        name: `🎨 Color Theme: ${currentTh.emoji} ${currentTh.name}`,
-                        value: 'change_theme',
-                        description: `Switch UI accent colors (${currentTh.desc})`
-                    },
-                    {
-                        name: `Interface: ${config.ui?.layout === 'classic' ? 'Classic' : 'Clean'}`,
-                        value: 'toggle_layout',
-                        description: 'Switch between the compact layout and the original terminal UI'
-                    },
-                    {
-                        name: `${config.pureBlackTheme !== false ? pc.green('🖤 Pure Black Background: ON') : pc.yellow('🖤 Pure Black Background: OFF')}`,
-                        value: 'toggle_black_theme',
-                        description: config.pureBlackTheme !== false
-                            ? 'Apply deep OLED obsidian black background (#0a0a0c) like OpenCode'
-                            : 'Use standard system terminal background color'
-                    },
-                    {
-                        name: `${config.autoApprove ? pc.green('⚡ Auto-Approve (YOLO Mode): ON') : pc.yellow('🛡️  Auto-Approve (YOLO Mode): OFF')}`,
-                        value: 'toggle_auto_approve',
-                        description: config.autoApprove
-                            ? 'Permissions are automatically granted (no confirmation prompts for commands/files)'
-                            : 'Agent asks for confirmation before executing bash commands or writing files'
-                    },
-                    {
-                        name: `${config.enableMemory !== false ? pc.green('🧠 Project Memory Bank: ON') : pc.yellow('🧠 Project Memory Bank: OFF')}`,
-                        value: 'toggle_memory',
-                        description: config.enableMemory !== false
-                            ? 'Load persistent project rules and preferences from .devx/memory.md into AI context'
-                            : 'Start sessions with a clean state without loading project memory'
-                    },
-                    {
-                        name: `${config.checkUpdates !== false ? pc.green('🔔 Check for Updates on Startup: ON') : pc.yellow('🔔 Check for Updates on Startup: OFF')}`,
-                        value: 'toggle_check_updates',
-                        description: config.checkUpdates !== false
-                            ? 'Automatically check for updates from GitHub repository when launching devx'
-                            : 'Disable update checking on startup (run /update manually instead)'
-                    },
-                    {
-                        name: `🔄 Max Agent Iterations: ${currentTh.colorFn(maxIterLabel)}`,
-                        value: 'change_max_iterations',
-                        description: 'Limit how many tool steps (file edits, terminal commands) agent can do per request'
-                    },
-                    {
-                        name: `${currentTh.colorFn('✨ About devx')} ${pc.dim(`(v${DEVX_VERSION} by ApvCode)`)}`,
-                        value: 'about',
-                        description: 'Terminal-Native AI Coding Agent created by ApvCode (https://github.com/apvcode/Termux-Dev)'
-                    },
-                    {
-                        name: '⬅️ Back / Save',
-                        value: 'back',
-                        description: 'Return to chat'
-                    }
-                ]
-            });
-            if (choice === 'change_theme') {
-                await handleThemeSelect(config);
-                continue;
-            }
-            if (choice === 'toggle_layout') {
-                config.ui = config.ui || {};
-                config.ui.layout = config.ui.layout === 'classic' ? 'clean' : 'classic';
-                config.banner = config.ui.layout === 'clean' ? 'clean' : 'full';
-                await saveConfig(config);
-                drawLogo(config.banner);
-                continue;
-            }
-            if (choice === 'about') {
-                p.note(`⚡ devx v${DEVX_VERSION} — Terminal-Native AI Coding Agent\n` +
-                    `🎨 Theme: ${currentTh.emoji} ${currentTh.name}\n` +
-                    `👤 Author: ApvCode (https://github.com/apvcode)\n` +
-                    `🌟 Repository: https://github.com/apvcode/Termux-Dev\n` +
-                    `📜 License: MIT License (2026)\n` +
-                    `Built for Android Termux, Windows, macOS, and Linux.`, 'About devx');
-                continue;
-            }
-            if (choice === 'toggle_black_theme') {
-                config.pureBlackTheme = config.pureBlackTheme === false ? true : false;
-                await saveConfig(config);
-                if (config.pureBlackTheme) {
+    const initial = {
+        themeId: getCurrentTheme().id,
+        layout: config.ui?.layout === 'classic' ? 'classic' : 'clean',
+        pureBlack: config.pureBlackTheme !== false,
+        autoApprove: !!config.autoApprove,
+        maxIterations: config.maxIterations || 100,
+        memory: config.enableMemory !== false,
+        updates: config.checkUpdates !== false,
+        costLimit: Number(config.maxCostPerSession) || 0,
+        language: getLanguage(),
+    };
+    // One panel, redrawn in place; every change is visible at once and saved when it closes.
+    const final = await runSettings(initial, {
+        version: DEVX_VERSION,
+        onChange: (key, state) => {
+            if (key === 'theme')
+                setActiveTheme(state.themeId);
+            if (key === 'language')
+                setLanguage(state.language);
+            if (key === 'memory')
+                MemoryManager.enabled = state.memory;
+            if (key === 'pureBlack') {
+                if (state.pureBlack)
                     enableDarkTheme(true);
-                }
-                else {
+                else
                     resetTerminalTheme();
-                }
-                drawLogo(config.banner || 'full');
-                p.log.success(`Pure Black background: ${config.pureBlackTheme ? pc.bold(pc.green('ON (Deep Black)')) : pc.bold(pc.yellow('OFF (System Default)'))}`);
-                continue;
-            }
-            if (choice === 'toggle_auto_approve') {
-                config.autoApprove = !config.autoApprove;
-                await saveConfig(config);
-                p.log.success(`Auto-approve permissions: ${config.autoApprove ? pc.bold(pc.green('ON (Automatic Yes)')) : pc.bold(pc.yellow('OFF (Ask every time)'))}`);
-                continue;
-            }
-            if (choice === 'toggle_memory') {
-                config.enableMemory = config.enableMemory === false ? true : false;
-                await saveConfig(config);
-                p.log.success(`Project memory bank: ${config.enableMemory !== false ? pc.bold(pc.green('ON (Persistent .devx/memory.md)')) : pc.bold(pc.yellow('OFF'))}`);
-                continue;
             }
-            if (choice === 'toggle_check_updates') {
-                config.checkUpdates = config.checkUpdates === false ? true : false;
-                await saveConfig(config);
-                p.log.success(`Check for updates: ${config.checkUpdates !== false ? pc.bold(pc.green('ON (Checked on startup)')) : pc.bold(pc.yellow('OFF (Manual only)'))}`);
-                continue;
-            }
-            if (choice === 'change_max_iterations') {
-                const val = await select({
-                    message: 'Select maximum iterations limit per prompt:',
-                    choices: [
-                        { name: '30 steps (Strict / Safe)', value: 30 },
-                        { name: '50 steps (Moderate)', value: 50 },
-                        { name: '100 steps (Recommended / Default)', value: 100 },
-                        { name: '200 steps (Very large refactors)', value: 200 },
-                        { name: 'Unlimited (No limit)', value: 9999 }
-                    ]
-                });
-                config.maxIterations = val;
-                await saveConfig(config);
-                p.log.success(`Max iterations updated to: ${pc.bold(val >= 9999 ? 'Unlimited' : `${val} steps`)}`);
-                continue;
-            }
-            break;
-        }
-        catch {
-            break;
-        }
-    }
+        },
+    });
+    config.theme = final.themeId;
+    config.ui = config.ui || {};
+    config.ui.layout = final.layout;
+    config.banner = final.layout === 'clean' ? (config.banner === 'off' ? 'off' : 'clean') : 'full';
+    config.pureBlackTheme = final.pureBlack;
+    config.autoApprove = final.autoApprove;
+    config.maxIterations = final.maxIterations;
+    config.enableMemory = final.memory;
+    config.checkUpdates = final.updates;
+    config.language = final.language;
+    config.maxCostPerSession = final.costLimit;
+    await saveConfig(config);
     process.stdin.resume();
     return config;
 }
@@ -776,10 +734,10 @@ export async function main() {
         const isIgnorableIo = err.code === 'EIO' || err.code === 'EPIPE' || err.code === 'ERR_STREAM_DESTROYED';
         if (isIgnorableIo)
             return;
-        console.error('\n[devx runtime error]:', err.message);
+        reportRuntimeError(err, activeAbortHandler);
     });
     process.on('unhandledRejection', (reason) => {
-        // Prevent Node.js crash from unhandled network promise rejections
+        reportRuntimeError(reason, activeAbortHandler);
     });
     acquireWakeLock();
     const program = new Command();
@@ -793,59 +751,82 @@ export async function main() {
         .option('-q, --quiet', 'Quiet output in headless mode (suppress banners and tool logs)')
         .option('--json', 'Output structured JSON in headless mode')
         .option('--plan', 'Start in plan mode (architect & planner)')
+        .option('-e, --effort <level>', 'Reasoning effort for this run: off, low, normal, high, xhigh, max, or auto')
         .parse(process.argv);
     const options = program.opts();
     const planModeInitial = !!options.plan;
     const isHeadless = !!options.prompt;
     let config = await loadConfig(!isHeadless);
+    setLanguage(config.language);
+    // What each model offers for reasoning: the stored answers of the endpoint and the catalogue.
+    installCapabilities();
+    probeEndpointsAllowed = config.probeEndpoints !== false;
     config.banner = config.ui?.layout === 'classic'
         ? config.banner || 'full'
         : config.banner === 'off' ? 'off' : 'clean';
     if (options.model) {
         config.model = options.model;
-        config.maxContextTokens = getModelContextLimit(options.model);
+        config.maxContextTokens = resolveContextLimit({ ...config, maxContextTokens: 0 }).limit;
     }
     if (options.yolo) {
         config.autoApprove = 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).
+        await refreshEndpoint(config).catch(() => null);
+        const parsed = parseEffortArg(String(options.effort));
+        const { caps } = effectiveReasoning({ ...config, effortOverride: undefined });
+        if (parsed.kind === 'invalid') {
+            console.error(pc.yellow(`--effort: unknown level "${parsed.text}". Use off, low, normal, high, xhigh, max or auto.`));
+        }
+        else if (parsed.kind === 'auto') {
+            config.effortOverride = '';
+        }
+        else if (!caps.supported) {
+            console.error(pc.yellow(`--effort ignored: ${config.model} has no reasoning setting.`));
+        }
+        else if (!caps.levels.includes(parsed.level)) {
+            console.error(pc.yellow(`--effort ignored: ${config.model} does not offer "${parsed.level}" (it offers ${caps.levels.join(', ')}).`));
+        }
+        else {
+            config.effortOverride = parsed.level;
+        }
+    }
     // If -p / --prompt is provided, execute one-shot headless mode and exit!
     if (isHeadless) {
+        const abortController = new AbortController();
+        activeAbortHandler = () => abortController.abort();
         const exitCode = await runHeadlessMode(options.prompt, config, {
             planMode: planModeInitial,
             yolo: !!options.yolo,
             quiet: !!options.quiet,
-            json: !!options.json
+            json: !!options.json,
+            signal: abortController.signal
         });
+        activeAbortHandler = null;
         process.exit(exitCode);
     }
     let planMode = planModeInitial;
+    headerProvider = () => {
+        const git = GitStatusCache.getStatus(true);
+        return {
+            version: DEVX_VERSION,
+            model: modelLabel(config),
+            provider: config.provider,
+            cwd: process.cwd(),
+            branch: git?.branch,
+            dirty: git?.isDirty,
+            yolo: !!config.autoApprove,
+            tip: pickTip(),
+        };
+    };
     if (!config.onboarded) {
-        const cols = Math.min(process.stdout.columns || 40, 42);
-        const fill = Math.max(2, cols - 16);
-        const topBorder = '┌─ preview.ts ' + '─'.repeat(fill) + '┐';
-        const bottomBorder = '└' + '─'.repeat(cols - 2) + '┘';
-        const themeChoices = listThemes().map(t => {
-            const addLine = t.diffAddBg(` + 1 | const theme = "${t.id}";`.padEnd(cols - 2));
-            const remLine = t.diffRemoveBg(` - 2 | const theme = "none";`.padEnd(cols - 2));
-            const preview = `${t.colorFn(topBorder)}\n${addLine}\n${remLine}\n${t.colorFn(bottomBorder)}\n\n${pc.dim('💡 You can change this anytime with /theme')}`;
-            return {
-                name: `${t.emoji} ${t.boldFn(t.name.padEnd(18))} ${pc.dim(t.desc)}`,
-                value: t.id,
-                description: preview
-            };
-        });
-        try {
-            clearTerminalScreen();
-            const selected = await search({
-                message: `${pc.bold('🎨 Pick a theme to personalize your workspace:')}`,
-                source: async () => themeChoices,
-                pageSize: 6
-            });
-            if (selected) {
-                config.theme = selected;
-            }
-        }
-        catch { }
+        // A config from before the first-run setup had a theme step: ask it once.
+        clearTerminalScreen();
+        const selected = await chooseTheme(config.theme);
+        if (selected)
+            config.theme = selected;
         config.onboarded = true;
         await saveConfig(config);
     }
@@ -854,19 +835,86 @@ 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);
-    await MCPManager.getInstance().init();
-    let totalSessionCost = 0;
+    await MCPManager.getInstance().init(undefined, config.projectMcpTrusted === true);
+    // 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();
+    const currentContext = () => contextBreakdown(history.getMessages(), getTools(planMode).map(t => t.definition), config.maxContextTokens || getModelContextLimit(config.model));
     let currentDraft = '';
     let autoTriggerPrompt = '';
+    // ctrl+p and ctrl+o while the agent works: reasoning and tool output, collapsed unless switched on.
+    let thinkingExpanded = false;
+    let outputExpanded = false;
+    // Everything said on screen so far, kept as items: ctrl+p and ctrl+o draw it again, folded or unfolded.
+    const transcript = [];
+    // Snapshots of the working folder before each turn of the agent (git): /undo puts back what changed, also by shell commands.
+    const checkpoints = [];
+    // What the user allowed on the approval card for this session ("Session"); "Always" goes to the config.
+    const permissionMemory = newPermissionMemory();
+    // 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;
+    const costLimit = () => costLimitRaised ?? (Number(config.maxCostPerSession) || 0);
+    for (const name of (config.allowedTools || []))
+        permissionMemory.tools.add(name);
+    // 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)
+            process.stdout.write(terminalTitleSequence(title));
+    };
+    if (process.stdout.isTTY)
+        process.stdout.write(SAVE_TERMINAL_TITLE);
+    /** Clears the screen and draws the whole conversation again, folded or unfolded as the switches say. */
+    const redrawChat = () => {
+        drawLogo(config.banner || 'full');
+        const rows = renderTranscript(transcript, { cols: process.stdout.columns || 80, thinkingExpanded, outputExpanded, diffColors: !!config.ui?.diffColors });
+        if (rows.length > 0)
+            console.log(rows.join('\n'));
+    };
+    // /clear and /new: leave the current conversation (it stays saved and can be resumed)
+    // and start from a clean slate: history, cost, usage counters, undo stack, screen.
+    const startFreshSession = async () => {
+        sessionManager.startNewSession(config.model, planMode);
+        transcript.length = 0;
+        checkpoints.length = 0;
+        windowTitle = '';
+        titleAttempts = 0;
+        if (process.stdout.isTTY)
+            process.stdout.write(RESTORE_TERMINAL_TITLE + SAVE_TERMINAL_TITLE);
+        history = new History();
+        history.addMessage({ role: 'system', content: await buildSystemPrompt(planMode) });
+        sessionCost.reset();
+        costLimitRaised = null;
+        costWarned = false;
+        currentDraft = '';
+        UsageTracker.getInstance().reset();
+        globalSnapshotManager.reset();
+        GitStatusCache.invalidate();
+        drawLogo(config.banner || 'full');
+    };
+    const announce = (message) => {
+        if (config.ui?.layout === 'classic')
+            log.success(message);
+        else
+            console.log(renderNotice('ok', message));
+    };
     while (true) {
-        const currentTokens = history.getConversationTokens();
         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.
+        const ctxNow = currentContext();
+        const currentTokens = ctxNow.total - ctxNow.system - ctxNow.tools;
         const usagePercent = Math.min(100, Math.round((currentTokens / maxTokens) * 100));
         const formatTokens = (n) => {
             if (n >= 1_000_000)
@@ -875,21 +923,13 @@ export async function main() {
                 return `${(n / 1000).toFixed(1)}k`;
             return `${n}`;
         };
-        const costStr = totalSessionCost > 0 ? `Cost: $${totalSessionCost.toFixed(4)}` : 'Cost: $0.0000';
+        const costStr = `Cost: ${sessionCost.format()}`;
         const tokenStats = `Context: ${formatTokens(currentTokens)} / ${formatTokens(maxTokens)} (${usagePercent}%) • ${costStr}`;
         const cols = process.stdout.columns || 80;
         const modeName = planMode ? 'PLAN' : 'AGENT';
         const theme = getCurrentTheme();
         if (config.ui?.layout !== 'classic') {
-            console.log(renderCleanStatus({
-                mode: modeName,
-                model: config.model,
-                currentTokens,
-                maxTokens,
-                cost: totalSessionCost,
-                cols,
-                isYolo: !!config.autoApprove
-            }) + '\n');
+            // Clean layout: mode, model, context and cost live in the borders of the prompt frame.
         }
         else if (config.ui?.powerlineStatus) {
             const statusLine = renderPowerlineStatus({
@@ -897,7 +937,7 @@ export async function main() {
                 model: config.model,
                 currentTokens,
                 maxTokens,
-                cost: totalSessionCost,
+                cost: sessionCost.total,
                 cols,
                 maxCostUSD: config.maxCostUSD,
                 isYolo: !!config.autoApprove
@@ -930,38 +970,53 @@ export async function main() {
             autoTriggerPrompt = '';
             console.log(config.ui?.layout === 'classic'
                 ? theme.colorFn('◆') + '  ' + pc.bold(pc.white(answer))
-                : pc.cyan('›') + ' ' + answer);
+                : renderUserEcho(answer, cols).join('\n'));
         }
         else {
             const inputStr = await askPrompt({
                 message: 'Ask anything...',
                 placeholder: config.ui?.layout === 'classic'
                     ? 'Fix a TODO, type /help, or press Tab to switch mode'
-                    : 'Ask or describe a task…',
+                    : t('composer.placeholder'),
                 initialValue: currentDraft,
+                // Between turns the same keys work at the prompt: the chat above is drawn again.
+                onViewToggle: (kind) => {
+                    if (kind === 'thinking')
+                        thinkingExpanded = !thinkingExpanded;
+                    else
+                        outputExpanded = !outputExpanded;
+                    redrawChat();
+                },
                 planMode,
                 isYolo: !!config.autoApprove,
-                ui: config.ui
+                ui: config.ui,
+                model: modelLabel(config),
+                cwd: process.cwd(),
+                branch: GitStatusCache.getStatus()?.branch,
+                dirty: GitStatusCache.getStatus()?.isDirty,
+                contextPercent: usagePercent,
+                cost: sessionCost.total,
+                costState: sessionCost.state()
             });
             if (inputStr.startsWith('__TOGGLE_MODE__:')) {
                 currentDraft = inputStr.slice('__TOGGLE_MODE__:'.length);
                 planMode = !planMode;
                 const newSys = await buildSystemPrompt(planMode);
                 history.updateSystemPrompt(newSys);
-                p.log.info(planMode
-                    ? pc.bold(pc.cyan('🔄 Mode: PLAN (Architect & Planner) — Press Tab to switch to AGENT'))
-                    : pc.bold(pc.green('🔄 Mode: AGENT (Coder & Executor) — Press Tab to switch to PLAN')));
+                // Clean layout: the prompt frame changes colour and label, no extra line needed.
+                if (config.ui?.layout === 'classic') {
+                    log.info(planMode
+                        ? pc.bold(pc.cyan('Mode: PLAN (Architect & Planner) — Press Tab to switch to AGENT'))
+                        : pc.bold(pc.green('Mode: AGENT (Coder & Executor) — Press Tab to switch to PLAN')));
+                }
                 continue;
             }
             currentDraft = '';
             if (inputStr === '__CANCEL__') {
-                const confirmExit = await p.confirm({
-                    message: 'Are you sure you want to exit devx?',
-                    initialValue: false
-                });
-                if (!p.isCancel(confirmExit) && confirmExit === true) {
+                const confirmExit = await askConfirm({ title: t('confirm.exitTitle'), question: t('confirm.exit'), record: false });
+                if (confirmExit) {
                     resetTerminalTheme();
-                    p.outro('Goodbye!');
+                    printFarewell(t('confirm.goodbye'));
                     break;
                 }
                 else {
@@ -981,16 +1036,16 @@ export async function main() {
                 const cmdArgs = answer.slice(cmd.length).trim();
                 const expandedPrompt = CustomCommandManager.expandTemplate(customCmd.promptTemplate, cmdArgs);
                 answer = expandedPrompt;
-                p.log.info(pc.cyan(`⚡ Executing custom command: ${pc.bold(customCmd.cmd)} (${customCmd.desc})`));
+                log.info(pc.cyan(`Executing custom command: ${pc.bold(customCmd.cmd)} (${customCmd.desc})`));
             }
             else {
                 const VALID_COMMANDS = [
                     '/new', '/reset', '/resume', '/session', '/sessions', '/history',
                     '/theme', '/themes', '/usage', '/export', '/mcp',
                     '/settings', '/update', '/model', '/provider', '/providers',
-                    '/plan', '/agent', '/image', '/serve', '/memory', '/undo',
+                    '/plan', '/agent', '/image', '/serve', '/memory', '/permissions', '/copy', '/rename', '/title', '/rewind', '/undo',
                     '/diff', '/commit', '/status', '/compact', '/init', '/doctor',
-                    '/config', '/clear', '/exit', '/quit', '/help'
+                    '/config', '/clear', '/exit', '/quit', '/help', '/effort'
                 ];
                 if (!VALID_COMMANDS.includes(cmd)) {
                     const customList = await CustomCommandManager.listCommands();
@@ -1010,38 +1065,39 @@ export async function main() {
                         { name: '/settings     - Configure permissions & auto-approval', value: '/settings' },
                         { name: '/update       - Check and install updates from GitHub', value: '/update' },
                         { name: '/model        - Switch model for current provider', value: '/model' },
+                        { name: '/effort       - Set the reasoning effort for the current model', value: '/effort' },
                         { name: '/provider     - Change AI provider (Google, OpenRouter...)', value: '/provider' },
                         { 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: '/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' },
+                        { name: '/rename       - Rename the chat', value: '/rename' },
+                        { name: '/rewind       - Go back to one of your messages', value: '/rewind' },
                         { name: '/undo         - Revert last file changes made by AI', value: '/undo' },
                         { name: '/diff         - Show git diff of modified files', value: '/diff' },
                         { name: '/commit       - AI-generated git commit message', value: '/commit' },
                         { name: '/status       - Show git repository status', value: '/status' },
                         { name: '/compact      - Compact conversation context', value: '/compact' },
                         { name: '/config       - View current configuration', value: '/config' },
-                        { name: '/clear        - Clear message history', value: '/clear' },
+                        { name: '/clear        - Clear context and start a new session', value: '/clear' },
                         { name: '/help         - Show commands overview', value: '/help' },
                         { name: '/exit         - Exit devx', value: '/exit' },
                         ...customSlashItems
                     ];
                     try {
-                        const picked = await search({
-                            message: 'Commands (type to search or select):',
-                            source: async (term) => {
-                                const q = (term || '').trim().toLowerCase();
-                                const list = [
-                                    { name: pc.yellow('⬅️  Cancel'), value: '__cancel__' },
-                                    ...SLASH_COMMANDS
-                                ];
-                                if (!q)
-                                    return list;
-                                return list.filter(item => item.name.toLowerCase().includes(q) || item.value.toLowerCase().includes(q));
-                            },
-                            pageSize: 12
+                        const picked = await runFinder({
+                            title: t('commands.title'),
+                            subtitle: `${SLASH_COMMANDS.length}`,
+                            placeholder: t('commands.placeholder'),
+                            labelWidth: 14,
+                            items: SLASH_COMMANDS.map((c) => {
+                                const [name, ...rest] = c.name.split(/\s+-\s+/);
+                                return { value: c.value, label: name.trim(), detail: rest.join(' - ') };
+                            }),
                         });
-                        if (!picked || picked === '__cancel__') {
+                        if (!picked) {
                             continue;
                         }
                         if (picked === '/session del') {
@@ -1056,55 +1112,53 @@ export async function main() {
                 }
             }
             if (cmd === '/settings') {
+                // The panel erases itself; the conversation above it stays where it is.
                 config = await handleSettings(config);
-                drawLogo(config.banner || 'full');
+                costLimitRaised = null;
+                costWarned = false;
+                // The project memory switch changes what the system prompt contains.
+                history.updateSystemPrompt(await buildSystemPrompt(planMode));
                 continue;
             }
             if (cmd === '/update') {
-                const s = p.spinner();
+                const s = new UiSpinner();
                 s.start('Checking for updates from https://github.com/apvcode/Termux-Dev...');
                 const res = await checkForUpdates(10000);
                 s.stop();
                 if (res.updateAvailable) {
-                    p.log.info(pc.bold(pc.yellow(`🚀 Update available: v${res.currentVersion} ➔ v${res.latestVersion}`)));
-                    const doUpdate = await p.confirm({
-                        message: `Do you want to update devx to v${res.latestVersion} now?`,
-                        initialValue: true
-                    });
-                    if (!p.isCancel(doUpdate) && doUpdate) {
+                    log.info(pc.bold(pc.yellow(`Update available: v${res.currentVersion} → v${res.latestVersion}`)));
+                    const doUpdate = await askConfirm({ title: 'update', question: t('confirm.update', { version: res.latestVersion }), initial: true });
+                    if (doUpdate) {
                         await performSelfUpdate(res.latestVersion);
                     }
                 }
                 else {
-                    p.log.success(pc.green(`devx is up to date! (v${res.currentVersion})`));
+                    log.success(pc.green(`devx is up to date! (v${res.currentVersion})`));
                 }
                 continue;
             }
             if (cmd === '/help') {
-                p.note('/settings - Configure permissions (Auto-Approve / Ask every time)\n/resume - Resume previous chat session\n/session del - Select and delete saved sessions\n/new - Start a new chat session (or /new <prompt>)\n/model - Switch model for current provider\n/provider - Switch AI provider (with saved keys)\n/config - View configuration\n/plan - Switch to plan mode\n/agent - Switch to agent mode\n/clear - Clear history\n/exit - Exit', 'Commands');
+                note('/settings - Configure permissions (Auto-Approve / Ask every time)\n/resume - Resume previous chat session\n/session del - Select and delete saved sessions\n/new - Start a new chat session (or /new <prompt>)\n/model - Switch model for current provider\n/effort - Set the reasoning effort (only levels the model supports)\n/provider - Switch AI provider (with saved keys)\n/config - View configuration\n/plan - Switch to plan mode\n/agent - Switch to agent mode\n/clear - Clear context and start a new session\n/exit - Exit', 'Commands');
                 continue;
             }
             if (cmd === '/exit') {
-                p.outro('Goodbye!');
+                printFarewell(t('confirm.goodbye'));
                 break;
             }
             if (cmd === '/clear') {
-                drawLogo(config.banner || 'full');
+                await startFreshSession();
+                announce('new session · context cleared');
                 continue;
             }
             if (cmd === '/new' || cmd === '/reset') {
-                sessionManager.startNewSession(config.model, planMode);
-                history = new History();
-                history.addMessage({ role: 'system', content: await buildSystemPrompt(planMode) });
-                totalSessionCost = 0;
-                drawLogo(config.banner || 'full');
+                await startFreshSession();
                 const initialPrompt = parts.slice(1).join(' ').trim();
                 if (initialPrompt) {
-                    p.log.success('Started new session with prompt.');
+                    announce('new session · starting with your prompt');
                     answer = initialPrompt;
                 }
                 else {
-                    p.log.success('Started a new chat session.');
+                    announce('new session started');
                     continue;
                 }
             }
@@ -1116,46 +1170,24 @@ export async function main() {
                 }
                 const sessions = await SessionManager.listSessions();
                 if (sessions.length === 0) {
-                    p.log.warn('No saved sessions found.');
-                    continue;
-                }
-                let chosenSessionId;
-                try {
-                    chosenSessionId = await search({
-                        message: 'Select a session to resume (type to filter, Esc to cancel):',
-                        source: async (term) => {
-                            const q = (term || '').trim().toLowerCase();
-                            const list = [
-                                { name: pc.yellow('⬅️  Back / Cancel'), value: '__cancel__', description: 'Return to chat' },
-                                { name: pc.red('🗑️  Delete sessions... (/session del)'), value: '__delete_mode__', description: 'Selectively delete saved sessions' }
-                            ];
-                            for (const s of sessions) {
-                                const timeStr = formatSessionTime(s.updatedAt);
-                                const msgCount = s.messages.filter(m => m.role !== 'system').length;
-                                const shortId = s.id.split('_').pop();
-                                list.push({
-                                    name: `${pc.dim(`[#${shortId}]`)} ${s.title}`,
-                                    value: s.id,
-                                    description: `${timeStr} • ${msgCount} msgs • ${s.model || 'default'}`
-                                });
-                            }
-                            if (!q)
-                                return list;
-                            return list.filter(item => item.name.toLowerCase().includes(q) || item.value.toLowerCase().includes(q));
-                        },
-                        pageSize: 10
-                    });
-                }
-                catch {
-                    continue;
-                }
-                if (chosenSessionId === '__cancel__') {
+                    log.warn('No saved sessions found.');
                     continue;
                 }
-                if (chosenSessionId === '__delete_mode__') {
-                    await handleSessionDelete(config.banner || 'full');
+                const picked = await runFinder({
+                    title: t('resume.title'),
+                    subtitle: `${sessions.length}`,
+                    placeholder: t('resume.placeholder'),
+                    labelWidth: 36,
+                    items: sessions.map((s) => ({
+                        value: s.id,
+                        label: s.title,
+                        detail: sessionDetail(s),
+                        keywords: `${s.id} ${s.model || ''}`,
+                    })),
+                });
+                if (picked === undefined)
                     continue;
-                }
+                const chosenSessionId = picked;
                 const loaded = await SessionManager.loadSession(chosenSessionId);
                 if (loaded) {
                     sessionManager.setLoadedSession(loaded);
@@ -1165,57 +1197,34 @@ export async function main() {
                     }
                     if (loaded.model) {
                         config.model = loaded.model;
-                        config.maxContextTokens = getModelContextLimit(loaded.model);
+                        config.maxContextTokens = resolveContextLimit({ ...config, maxContextTokens: 0 }).limit;
                     }
                     if (loaded.planMode !== undefined) {
                         planMode = loaded.planMode;
                     }
-                    totalSessionCost = loaded.totalCost || 0;
+                    sessionCost.restore(loaded.totalCost || 0, loaded.costEstimated === true);
                     drawLogo(config.banner || 'full');
                     const nonSysMessages = loaded.messages.filter(m => m.role !== 'system');
                     const totalMsgs = nonSysMessages.length;
                     const displayLimit = 20;
                     const recentMessages = nonSysMessages.slice(-displayLimit);
                     const shownCount = recentMessages.length;
-                    // Header banner showing messages loaded
-                    const countInfo = totalMsgs > displayLimit
-                        ? `Loaded recent ${shownCount} messages of ${totalMsgs}`
-                        : `Loaded all ${totalMsgs} messages`;
-                    console.log('\n' + pc.bold(pc.cyan(`─── 📜 ${countInfo} (Session: "${loaded.title}") ───`)) + '\n');
-                    // Render each message in chronological order
-                    for (const msg of recentMessages) {
-                        if (msg.role === 'user') {
-                            console.log(pc.cyan('◆') + '  ' + pc.bold(pc.white(msg.content)));
-                            if (msg.images && msg.images.length > 0) {
-                                console.log(pc.magenta(`  [🖼️ ${msg.images.map(i => i.path).join(', ')}]`));
-                            }
-                            console.log();
-                        }
-                        else if (msg.role === 'assistant') {
-                            if (msg.content) {
-                                console.log(renderMarkdown(msg.content));
-                            }
-                            if (msg.tool_calls && msg.tool_calls.length > 0) {
-                                for (const tc of msg.tool_calls) {
-                                    console.log(pc.dim(`  ⚡ ${tc.name}`));
-                                }
-                            }
-                            console.log();
-                        }
-                        else if (msg.role === 'tool') {
-                            if (msg.content) {
-                                const firstLine = msg.content.trim().split('\n')[0];
-                                if (firstLine.includes('+') || firstLine.includes('lines') || firstLine.includes('Successfully')) {
-                                    console.log(pc.green(`  └─ ${firstLine}`));
-                                }
-                            }
-                        }
-                    }
-                    console.log(pc.bold(pc.cyan(`────────────────────────────────────────────────────────────────────────\n`)));
-                    p.log.success(`Resumed session: "${loaded.title}" (${totalMsgs} total messages in history)`);
+                    transcript.length = 0;
+                    titleAttempts = 0;
+                    if (loaded.title && loaded.title !== 'New Session')
+                        setWindowTitle(loaded.title);
+                    transcript.push(...messagesToItems(recentMessages));
+                    console.log(renderResumedMessages(recentMessages, {
+                        title: loaded.title,
+                        shown: shownCount,
+                        total: totalMsgs,
+                        cols: process.stdout.columns || 80,
+                        thinkingExpanded,
+                        outputExpanded,
+                    }).join('\n'));
                 }
                 else {
-                    p.log.error('Failed to load session.');
+                    log.error('Failed to load session.');
                 }
                 continue;
             }
@@ -1223,37 +1232,63 @@ export async function main() {
                 planMode = true;
                 const newSys = await buildSystemPrompt(true);
                 history.updateSystemPrompt(newSys);
-                drawLogo(config.banner || 'full');
-                p.log.success(pc.cyan('Switched to PLAN mode (Architect & Planner). Modifying tools are disabled.'));
+                announce('plan mode · designs and asks questions, does not touch files');
                 continue;
             }
             if (cmd === '/agent') {
                 planMode = false;
                 const newSys = await buildSystemPrompt(false);
                 history.updateSystemPrompt(newSys);
-                drawLogo(config.banner || 'full');
-                p.log.success(pc.green('Switched to AGENT mode (Coder & Executor). Full tools enabled.'));
+                announce('agent mode · edits files and runs commands');
                 continue;
             }
             if (cmd === '/undo') {
-                const { revertedFiles, count } = await globalSnapshotManager.undoLastTurn();
-                if (count === 0) {
-                    p.log.warn('No changes to undo.');
+                // With git: the whole folder goes back to how it was before the last turn, shell commands included.
+                const cp = checkpoints[checkpoints.length - 1];
+                const diff = cp ? await diffCheckpoint(cp).catch(() => null) : null;
+                if (cp && diff && diff.modified.length + diff.created.length + diff.deleted.length > 0) {
+                    const list = [
+                        ...diff.modified.map((f) => `changed  ${f}`),
+                        ...diff.deleted.map((f) => `deleted  ${f}`),
+                        ...diff.created.map((f) => `new      ${f}`),
+                    ];
+                    const shown = list.slice(0, 12);
+                    if (list.length > shown.length)
+                        shown.push(`… +${list.length - shown.length} more`);
+                    const ok = await askConfirm({
+                        title: 'undo',
+                        question: t('undo.question', { n: list.length }),
+                        details: [...shown, t('undo.note')],
+                        initial: true,
+                    });
+                    if (ok) {
+                        await restoreCheckpoint(cp, diff);
+                        checkpoints.pop();
+                        await globalSnapshotManager.undoLastTurn().catch(() => null);
+                        history.popLastTurn();
+                        log.success(t('undo.done', { n: list.length }));
+                    }
                 }
                 else {
-                    history.popLastTurn();
-                    p.log.success(pc.bold(pc.green(`⏪ Successfully reverted changes in ${count} file(s):`)));
-                    for (const f of revertedFiles) {
-                        console.log(pc.cyan(`  • ${f}`));
+                    const { revertedFiles, count } = await globalSnapshotManager.undoLastTurn();
+                    if (count === 0) {
+                        log.warn('No changes to undo.');
+                    }
+                    else {
+                        history.popLastTurn();
+                        log.success(`Reverted changes in ${count} file(s)`);
+                        for (const f of revertedFiles)
+                            console.log(pc.cyan(`  • ${f}`));
+                        console.log(pc.dim('  Note: without git only edits made with the file tools are reverted, not those of shell commands.'));
                     }
                 }
                 continue;
             }
             if (cmd === '/diff') {
                 try {
-                    const diffOutput = execSync('git diff', { encoding: 'utf8' });
+                    const diffOutput = execSync('git diff', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
                     if (!diffOutput.trim()) {
-                        p.log.info('No uncommitted changes in git repository.');
+                        log.info('No uncommitted changes in git repository.');
                     }
                     else {
                         console.log('\n' + pc.bold(pc.cyan('─── Git Diff ─────────────────────────')));
@@ -1275,15 +1310,15 @@ export async function main() {
                     }
                 }
                 catch {
-                    p.log.warn('Git is not available or current directory is not a git repo.');
+                    log.warn('Git is not available or current directory is not a git repo.');
                 }
                 continue;
             }
             if (cmd === '/status') {
                 try {
-                    const statusOutput = execSync('git status --short', { encoding: 'utf8' });
+                    const statusOutput = execSync('git status --short', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
                     if (!statusOutput.trim()) {
-                        p.log.success('Working directory clean, no modified files.');
+                        log.success('Working directory clean, no modified files.');
                     }
                     else {
                         console.log('\n' + pc.bold(pc.cyan('─── Git Status ───────────────────────')));
@@ -1307,23 +1342,24 @@ export async function main() {
                     }
                 }
                 catch {
-                    p.log.warn('Git is not available or current directory is not a git repo.');
+                    log.warn('Git is not available or current directory is not a git repo.');
                 }
                 continue;
             }
             if (cmd === '/commit') {
                 try {
-                    const status = execSync('git status --short', { encoding: 'utf8' });
+                    const status = execSync('git status --short', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
                     if (!status.trim()) {
-                        p.log.info('No changes to commit.');
+                        log.info('No changes to commit.');
                         continue;
                     }
-                    const diff = execSync('git diff', { encoding: 'utf8' });
+                    const diff = execSync('git diff', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
                     const userMsg = parts.slice(1).join(' ').trim();
                     let commitMsg = userMsg;
                     if (!commitMsg) {
-                        const s = p.spinner();
+                        const s = new UiSpinner();
                         s.start('Generating conventional commit message with AI...');
+                        await refreshFormats(config).catch(() => null);
                         const provider = createProvider(config);
                         const promptReq = {
                             messages: [
@@ -1341,57 +1377,66 @@ export async function main() {
                         s.stop();
                         commitMsg = (genRes.content || 'chore: update project files').trim().replace(/^["'`]|["'`]$/g, '').split('\n')[0];
                     }
-                    const confirmed = await p.confirm({
-                        message: `Commit changes with message:\n"${pc.bold(pc.green(commitMsg))}"?`,
-                        initialValue: true
-                    });
-                    if (!p.isCancel(confirmed) && confirmed) {
+                    const confirmed = await askConfirm({ title: 'commit', question: t('confirm.commit'), details: [commitMsg], initial: true });
+                    if (confirmed) {
                         execFileSync('git', ['add', '-A'], { stdio: 'ignore' });
                         execFileSync('git', ['commit', '-m', commitMsg], { stdio: 'ignore' });
-                        p.log.success(pc.bold(pc.green(`✅ Committed: ${commitMsg}`)));
+                        log.success(pc.bold(pc.green(`Committed: ${commitMsg}`)));
                     }
                     else {
-                        p.log.info('Commit cancelled.');
+                        log.info('Commit cancelled.');
                     }
                 }
                 catch (err) {
-                    p.log.error(`Git commit failed: ${err.message}`);
+                    log.error(`Git commit failed: ${err.message}`);
                 }
                 continue;
             }
             if (cmd === '/compact') {
                 const msgs = history.getMessages();
                 if (msgs.length <= 2) {
-                    p.log.info('Conversation is already short, no compaction needed.');
+                    log.info('Conversation is already short, no compaction needed.');
                     continue;
                 }
-                const s = p.spinner();
+                const s = new UiSpinner();
                 s.start('Compacting conversation context with AI...');
                 try {
+                    await refreshFormats(config).catch(() => null);
                     const provider = createProvider(config);
+                    // The request itself must fit the window: shorten a copy of the history first.
+                    const forSummary = new History();
+                    for (const m of msgs)
+                        forSummary.addMessage({ ...m, images: undefined });
+                    forSummary.pruneToLimit(Math.floor((config.maxContextTokens || 100000) * 0.7));
                     const compactPrompt = {
                         messages: [
-                            ...msgs,
+                            ...forSummary.getMessages(),
                             {
                                 role: 'user',
-                                content: 'Please create a clear, comprehensive, and structured summary of our conversation so far, including all established requirements, decisions, modified files, and remaining tasks. Be concise and precise.'
+                                content: 'Write a short, structured summary of our conversation so far: what the user wants, decisions made, files created or changed, and what is left to do. Plain text, no filler.'
                             }
                         ]
                     };
                     const res = await provider.chat(compactPrompt);
                     s.stop();
+                    if (!res.content || !res.content.trim())
+                        throw new Error('the model returned an empty summary');
                     const sysPrompt = await buildSystemPrompt(planMode);
                     history.clear();
                     history.addMessage({ role: 'system', content: sysPrompt });
+                    // A user message, not an assistant one: the Anthropic format cannot start with the assistant.
                     history.addMessage({
-                        role: 'assistant',
-                        content: `[CONVERSATION COMPACTED]\n${res.content || ''}`
+                        role: 'user',
+                        content: `${COMPACT_MARK} Summary of our conversation so far:\n${res.content}`
                     });
-                    p.log.success(pc.bold(pc.green('🗜️ Context successfully compacted! Freed up tokens while retaining task summary.')));
+                    const item = { kind: 'compact', summary: res.content };
+                    transcript.push(item);
+                    console.log();
+                    console.log(renderItem(item, { cols: process.stdout.columns || 80, thinkingExpanded, outputExpanded }).join('\n'));
                 }
                 catch (err) {
                     s.stop();
-                    p.log.error(`Compaction failed: ${err.message}`);
+                    log.error(`Compaction failed: ${err.message}`);
                 }
                 continue;
             }
@@ -1399,13 +1444,13 @@ export async function main() {
                 const cur = sessionManager.getSession();
                 const nonSys = history.getMessages().filter(m => m.role !== 'system');
                 const shortId = cur.id.split('_').pop();
-                console.log('\n' + pc.bold(pc.cyan('─── 🆔 Active Session Information ───')));
+                console.log('\n' + pc.bold(pc.cyan('─── Active Session Information ───')));
                 console.log(`  ${pc.bold('ID:')}        ${pc.cyan(cur.id)} ${pc.dim(`(#${shortId})`)}`);
                 console.log(`  ${pc.bold('Title:')}     "${cur.title}"`);
                 console.log(`  ${pc.bold('Model:')}     ${config.model}`);
                 console.log(`  ${pc.bold('Mode:')}      ${planMode ? pc.cyan('PLAN') : pc.green('AGENT')}`);
                 console.log(`  ${pc.bold('Messages:')}  ${nonSys.length} messages`);
-                console.log(`  ${pc.bold('Cost:')}      $${totalSessionCost.toFixed(4)}`);
+                console.log(`  ${pc.bold('Cost:')}      ${sessionCost.format()}`);
                 console.log(`  ${pc.bold('File:')}      ~/.devx/sessions/${cur.id}.json`);
                 console.log(pc.bold(pc.cyan('──────────────────────────────────────\n')));
                 continue;
@@ -1413,12 +1458,12 @@ export async function main() {
             if (cmd === '/init') {
                 const agentsPath = path.join(process.cwd(), 'AGENTS.md');
                 if (fsSync.existsSync(agentsPath)) {
-                    p.log.warn('AGENTS.md already exists in current workspace.');
+                    log.warn('AGENTS.md already exists in current workspace.');
                 }
                 else {
                     const template = `# Project Developer Instructions (AGENTS.md)\n\n## Overview\nProject description and goals.\n\n## Tech Stack\n- TypeScript / Node.js\n\n## Coding Guidelines\n- Clean, modular code\n- Verify changes after editing\n`;
                     await fs.writeFile(agentsPath, template, 'utf8');
-                    p.log.success(`Created ${pc.bold('AGENTS.md')} in project root! Customize it to give devx persistent instructions.`);
+                    log.success(`Created ${pc.bold('AGENTS.md')} in project root! Customize it to give devx persistent instructions.`);
                 }
                 continue;
             }
@@ -1430,10 +1475,10 @@ export async function main() {
                 const sub = parts[1]?.toLowerCase();
                 if (sub === 'stop') {
                     if (stopServer()) {
-                        p.log.success('Web server stopped.');
+                        log.success('Web server stopped.');
                     }
                     else {
-                        p.log.info('No web server is currently running.');
+                        log.info('No web server is currently running.');
                     }
                 }
                 else {
@@ -1443,7 +1488,7 @@ export async function main() {
                         await displayServerBanner(localUrl, networkUrl);
                     }
                     catch (err) {
-                        p.log.error(`Failed to start web server: ${err.message}`);
+                        log.error(`Failed to start web server: ${err.message}`);
                     }
                 }
                 continue;
@@ -1456,12 +1501,11 @@ export async function main() {
                         config.theme = matched.id;
                         await saveConfig(config);
                         const th = setActiveTheme(matched.id);
-                        drawLogo(config.banner || 'full');
-                        p.log.success(th.boldFn(`🎨 Theme switched to ${th.emoji} ${th.name}!`));
+                        announce(`theme ${th.name}`);
                     }
                     else {
                         const themes = listThemes();
-                        p.log.warn(`Unknown theme: "${themeArg}". Available themes: ${themes.map(t => `${t.emoji} ${t.id}`).join(', ')}`);
+                        log.warn(`Unknown theme: "${themeArg}". Available themes: ${themes.map(t => `${t.colorFn(t.symbol)} ${t.id}`).join(', ')}`);
                     }
                 }
                 else {
@@ -1469,59 +1513,250 @@ export async function main() {
                 }
                 continue;
             }
+            if (cmd === '/rewind') {
+                const msgs = history.getMessages();
+                const entries = userEntries(msgs);
+                if (entries.length === 0) {
+                    log.warn(t('rewind.none'));
+                    continue;
+                }
+                const chosen = await runPicker({
+                    title: t('rewind.title'),
+                    subtitle: t('rewind.count', { n: entries.length }),
+                    items: rewindItems(msgs),
+                    current: REWIND_CURRENT,
+                    labelWidth: 54,
+                });
+                if (chosen === undefined || chosen === REWIND_CURRENT)
+                    continue;
+                const target = msgs[chosen];
+                // The folder can go back too, to how it was before that message.
+                const cpIndex = target.checkpoint ? checkpoints.findIndex((c) => c.sha === target.checkpoint) : -1;
+                if (cpIndex >= 0) {
+                    const diff = await diffCheckpoint(checkpoints[cpIndex]).catch(() => null);
+                    const total = diff ? diff.modified.length + diff.created.length + diff.deleted.length : 0;
+                    if (diff && total > 0) {
+                        const list = [...diff.modified.map((f) => `changed  ${f}`), ...diff.deleted.map((f) => `deleted  ${f}`), ...diff.created.map((f) => `new      ${f}`)];
+                        const shown = list.slice(0, 10);
+                        if (list.length > shown.length)
+                            shown.push(`… +${list.length - shown.length} more`);
+                        const restore = await askConfirm({ title: t('rewind.title'), question: t('rewind.filesQuestion', { n: total }), details: shown, yes: t('rewind.filesYes'), no: t('rewind.filesNo') });
+                        if (restore)
+                            await restoreCheckpoint(checkpoints[cpIndex], diff);
+                    }
+                    checkpoints.length = cpIndex;
+                }
+                else if (target.checkpoint) {
+                    checkpoints.length = 0;
+                }
+                // The conversation after the message is burned: the model forgets it as well.
+                history.rewindBefore(chosen);
+                const kept = history.getMessages().filter((m) => m.role !== 'system');
+                transcript.length = 0;
+                transcript.push(...messagesToItems(kept));
+                await sessionManager.save(history.getMessages(), sessionCost.total, config.model, planMode, sessionCost.estimated);
+                currentDraft = messageDraft(target.content);
+                redrawChat();
+                log.info(t((target.images && target.images.length > 0) ? 'rewind.doneImages' : 'rewind.done'));
+                continue;
+            }
+            if (cmd === '/copy') {
+                const last = [...history.getMessages()].reverse().find((m) => m.role === 'assistant' && m.content && m.content.trim());
+                if (!last) {
+                    log.warn(t('copy.none'));
+                }
+                else {
+                    const method = await copyToClipboard(last.content);
+                    if (method === 'none')
+                        log.error(t('copy.failed'));
+                    else
+                        log.success(t('copy.done', { n: Array.from(last.content).length }));
+                }
+                continue;
+            }
+            if (cmd === '/rename' || cmd === '/title') {
+                const name = cleanTitle(parts.slice(1).join(' '));
+                if (name) {
+                    sessionManager.setTitle(name);
+                    setWindowTitle(name);
+                    await sessionManager.save(history.getMessages(), sessionCost.total, config.model, planMode, sessionCost.estimated);
+                    log.success(t('rename.done', { name }));
+                }
+                else {
+                    // Without a name the model names the chat again.
+                    const msgs = history.getMessages();
+                    const firstUser = msgs.find((m) => m.role === 'user')?.content ?? '';
+                    const reply = [...msgs].reverse().find((m) => m.role === 'assistant' && m.content && m.content.trim())?.content ?? '';
+                    if (!firstUser.trim() || !reply.trim()) {
+                        log.warn(t('rename.usage'));
+                    }
+                    else {
+                        const generated = await generateChatTitle(createProvider(config), firstUser.split('\n\n--- Attached Files ---')[0], reply);
+                        if (!generated)
+                            log.error(t('rename.failed'));
+                        else {
+                            sessionManager.setTitle(generated);
+                            setWindowTitle(generated);
+                            await sessionManager.save(history.getMessages(), sessionCost.total, config.model, planMode, sessionCost.estimated);
+                            log.success(t('rename.done', { name: generated }));
+                        }
+                    }
+                }
+                continue;
+            }
+            if (cmd === '/permissions') {
+                if ((parts[1] || '').toLowerCase() === 'clear') {
+                    config.bashAllowlist = [];
+                    config.allowedTools = [];
+                    permissionMemory.bash.clear();
+                    permissionMemory.tools.clear();
+                    await saveConfig(config);
+                    log.success(t('permissions.cleared'));
+                }
+                else {
+                    const bash = Array.from(new Set([...(config.bashAllowlist || []), ...permissionMemory.bash]));
+                    const tools = Array.from(permissionMemory.tools);
+                    const rows = [
+                        ...bash.map((k) => `command   ${k}`),
+                        ...tools.map((k) => `tool      ${k}`),
+                    ];
+                    if (rows.length === 0)
+                        log.info(t('permissions.none'));
+                    else
+                        note(rows.join('\n'), t('permissions.title'));
+                    if (rows.length > 0)
+                        log.info(t('permissions.hint'));
+                }
+                continue;
+            }
             if (cmd === '/memory') {
                 const sub = parts[1]?.toLowerCase();
                 if (sub === 'clear') {
                     await MemoryManager.clearMemory();
-                    p.log.success('Cleared project memory bank (.devx/memory.md).');
+                    history.updateSystemPrompt(await buildSystemPrompt(planMode));
+                    log.success('Cleared project memory bank (.devx/memory.md).');
+                }
+                else if (sub === 'remove' || sub === 'rm') {
+                    const name = parts[2];
+                    if (!name) {
+                        console.log(renderNotice('warn', t('mcp.removeUsage')));
+                    }
+                    else if (!removeUserServer(name)) {
+                        console.log(renderNotice('warn', t('mcp.removeNotFound', { name })));
+                    }
+                    else {
+                        const sp = new UiSpinner();
+                        sp.start('Reloading MCP servers...');
+                        await MCPManager.getInstance().reload();
+                        sp.stop();
+                        console.log(renderNotice('ok', t('mcp.removed', { name })));
+                    }
                 }
                 else if (sub === 'add') {
                     const fact = parts.slice(2).join(' ').trim();
                     if (!fact) {
-                        p.log.warn('Usage: /memory add <fact or rule to remember>');
+                        log.warn('Usage: /memory add <fact or rule to remember>');
                     }
                     else {
                         await MemoryManager.addFact(fact);
-                        p.log.success(`Saved to memory: "${fact}"`);
+                        // The model sees the new rule from the next message on, not only after a restart.
+                        history.updateSystemPrompt(await buildSystemPrompt(planMode));
+                        log.success(`Saved to memory: "${fact}"`);
                     }
                 }
                 else {
                     const mem = await MemoryManager.loadMemory();
                     if (!mem.trim()) {
-                        p.log.info('Project memory is empty. AI will remember facts as you work, or use /memory add <fact>.');
+                        log.info('Project memory is empty. AI will remember facts as you work, or use /memory add <fact>.');
                     }
                     else {
-                        p.note(mem, '🧠 Project Memory Bank (.devx/memory.md)');
+                        note(mem, 'Project Memory Bank (.devx/memory.md)');
+                        const capped = memoryForPrompt(mem);
+                        if (capped.omitted > 0)
+                            log.warn(t('memory.capped', { n: capped.omitted }));
                         console.log(pc.dim('Commands: /memory add <text> | /memory clear\n'));
                     }
                 }
                 continue;
             }
             if (cmd === '/usage') {
-                const card = UsageTracker.getInstance().renderUsageCard();
-                console.log('\n' + card);
+                await runUsagePanel({
+                    model: config.model,
+                    format: providerFormat(config),
+                    effort: thinkLabel(config) || undefined,
+                    context: currentContext(),
+                    compactions: history.compactions,
+                    dropped: history.droppedMessages,
+                    session: UsageTracker.getInstance().getSummary(),
+                    noVision: modelAcceptsImages(config.model) === false,
+                    limitSource: resolveContextLimit(config).source,
+                });
+                process.stdin.resume();
                 continue;
             }
             if (cmd === '/export') {
                 const targetName = parts.slice(1).join(' ').trim();
                 const res = await SessionExporter.exportToMarkdown(history.getMessages(), config.model, targetName || undefined);
                 if (res.success) {
-                    p.log.success(pc.bold(pc.green(`📄 Session exported to: ${res.filePath}`)));
+                    log.success(pc.bold(pc.green(`Session exported to: ${res.filePath}`)));
                 }
                 else {
-                    p.log.error(`Failed to export session: ${res.error}`);
+                    log.error(`Failed to export session: ${res.error}`);
                 }
                 continue;
             }
             if (cmd === '/mcp') {
                 const sub = (parts[1] || '').toLowerCase();
                 if (sub === 'reload' || sub === 'restart' || sub === 'r') {
-                    const s = p.spinner();
+                    const s = new UiSpinner();
                     s.start('Reloading MCP servers...');
                     await MCPManager.getInstance().reload();
                     s.stop();
                     console.log('\n' + MCPManager.getInstance().renderStatusCard());
                 }
+                else if (sub === 'import') {
+                    // The servers that Claude Code already knows (~/.claude.json) become devx servers.
+                    const found = readClaudeServers();
+                    if (Object.keys(found).length === 0) {
+                        console.log(renderNotice('warn', 'No servers found in ~/.claude.json'));
+                    }
+                    else {
+                        const added = saveUserServers(found);
+                        const skipped = Object.keys(found).filter((n) => !added.includes(n));
+                        const s = new UiSpinner();
+                        s.start('Starting MCP servers...');
+                        await MCPManager.getInstance().reload();
+                        s.stop();
+                        console.log(renderNotice('ok', added.length ? `imported: ${added.join(', ')} (saved to ~/.devx/mcp.json)` : 'nothing new to import'));
+                        if (skipped.length)
+                            console.log(renderNotice('info', `already in devx: ${skipped.join(', ')}`));
+                        console.log('\n' + MCPManager.getInstance().renderStatusCard());
+                    }
+                }
+                else if (sub === 'add') {
+                    // /mcp add <name> <command> [args...]
+                    const [name, command, ...rest] = parts.slice(2);
+                    if (!name || !command) {
+                        console.log(renderNotice('warn', 'Usage: /mcp add <name> <command|url> [args...]   e.g. /mcp add notion npx -y mcp-remote https://mcp.notion.com/mcp'));
+                    }
+                    else {
+                        // An address is a remote server (over HTTP); anything else is a program to start.
+                        saveUserServers({ [name]: /^https?:\/\//i.test(command) ? { url: command } : { command, ...(rest.length ? { args: rest } : {}) } }, true);
+                        const s = new UiSpinner();
+                        s.start(`Starting ${name}...`);
+                        await MCPManager.getInstance().reload();
+                        s.stop();
+                        const st = MCPManager.getInstance().getStatus(name);
+                        console.log(st?.status === 'connected'
+                            ? renderNotice('ok', `${name} connected, ${st.toolsCount} tools (saved to ~/.devx/mcp.json)`)
+                            : renderNotice('error', `${name}: ${st?.error || st?.status || 'not started'}`));
+                    }
+                }
+                else if (process.stdin.isTTY && process.stdout.isTTY) {
+                    // The panel erases itself when it is closed; the conversation above it stays where it is.
+                    await runMcpPanel(MCPManager.getInstance());
+                    process.stdin.resume();
+                }
                 else {
                     console.log('\n' + MCPManager.getInstance().renderStatusCard());
                 }
@@ -1537,32 +1772,90 @@ export async function main() {
                         masked.apiKeys[k] = maskApiKey(masked.apiKeys[k]);
                     }
                 }
-                p.note(JSON.stringify(masked, null, 2), 'Configuration (Secrets Masked)');
+                note(JSON.stringify(masked, null, 2), 'Configuration (Secrets Masked)');
                 continue;
             }
             if (cmd === '/model') {
                 const res = await selectModel(config.baseUrl, config.apiKey, config.model, config.provider || '', true);
-                drawLogo(config.banner || 'full');
                 if (res) {
                     config.model = res.model;
-                    config.maxContextTokens = res.contextLimit;
+                    config.maxContextTokens = config.contextLimits?.[config.model] ?? res.contextLimit;
                     await saveConfig(config);
-                    p.log.success(`Switched model to: ${pc.bold(config.model)}`);
+                    await refreshEndpoint(config).catch(() => null);
+                    announce(`model ${config.model}${providerFormat(config) === 'anthropic' ? ' (Anthropic format)' : ''}`);
                 }
                 else {
-                    p.log.info('Model selection cancelled.');
+                    log.info('Model selection cancelled.');
+                }
+                continue;
+            }
+            if (cmd === '/effort') {
+                const showSay = (say) => {
+                    if (config.ui?.layout === 'classic') {
+                        const text = say.detail ? `${say.text}\n${say.detail}` : say.text;
+                        if (say.kind === 'ok')
+                            log.success(text);
+                        else if (say.kind === 'warn')
+                            log.warn(text);
+                        else
+                            log.info(text);
+                    }
+                    else {
+                        console.log(renderNotice(say.kind, say.text));
+                        if (say.detail)
+                            console.log(renderResultBlock(say.detail, 'muted', process.stdout.columns || 80));
+                    }
+                };
+                const argText = parts.slice(1).join(' ').trim();
+                if (/^(refresh|update)$/i.test(argText)) {
+                    showSay({ kind: 'info', text: 'asking models.dev and the endpoint...' });
+                    try {
+                        const result = await refreshCatalog();
+                        showSay({ kind: 'ok', text: `catalogue updated: ${result.models} models from ${result.providers} providers, ${result.priced} prices`, detail: `models.dev, ${result.generated}` });
+                    }
+                    catch (e) {
+                        const info = catalogInfo();
+                        showSay({ kind: 'warn', text: 'could not download the catalogue.', detail: `${String(e?.message || e)}. Using the ${info.downloaded ? 'downloaded' : 'built-in'} one (${info.models} models, ${info.generated}).` });
+                    }
+                    const route = detectRoute(config.baseUrl);
+                    if (route === 'generic' || route === 'openrouter') {
+                        const record = await refreshEndpoint(config, { force: true }).catch(() => null);
+                        showSay(record?.data
+                            ? { kind: 'ok', text: `the endpoint described ${config.model}` }
+                            : { kind: 'info', text: `the endpoint says nothing about ${config.model}`, detail: 'levels come from the catalogue or from the model name' });
+                    }
+                    continue;
+                }
+                // A custom endpoint is asked about this model first (cached, a few seconds at most).
+                await refreshEndpoint(config).catch(() => null);
+                const outcome = effortCommand(config, argText);
+                if (outcome.type === 'say') {
+                    if (outcome.say.kind === 'ok')
+                        await saveConfig(config);
+                    showSay(outcome.say);
+                }
+                else {
+                    const choice = await runPicker(outcome.picker);
+                    if (choice === undefined) {
+                        showSay({ kind: 'info', text: 'effort unchanged' });
+                    }
+                    else {
+                        const say = chooseEffort(config, choice);
+                        await saveConfig(config);
+                        showSay(say);
+                    }
                 }
                 continue;
             }
             if (cmd === '/provider' || cmd === '/providers') {
                 const newConfig = await selectProvider(config, true);
-                drawLogo(config.banner || 'full');
                 if (newConfig) {
                     config = newConfig;
-                    p.log.success(`Switched provider to: ${pc.bold(config.provider || 'custom')} (${config.model})`);
+                    await refreshEndpoint(config).catch(() => null);
+                    announce(`provider ${config.provider || 'custom'} · ${config.model}${providerFormat(config) === 'anthropic' ? ' (Anthropic format)' : ''}`);
                 }
                 else {
-                    p.log.info('Provider selection cancelled.');
+                    log.info('Provider selection cancelled.');
                 }
                 continue;
             }
@@ -1598,36 +1891,85 @@ export async function main() {
                         planMode = false;
                         const newSys = await buildSystemPrompt(false);
                         history.updateSystemPrompt(newSys);
-                        p.log.success(pc.bold(pc.green('⚡ Plan approved! Auto-switched to AGENT mode. Starting execution...')));
+                        log.success(pc.bold(pc.green('Plan approved! Auto-switched to AGENT mode. Starting execution...')));
                     }
                 }
             }
         }
         // Resolve @file and @image mentions
-        const { text: cleanAnswer, attachments, images } = await resolveAtMentions(answer);
+        const { text: cleanAnswer, attachments, images, warnings: attachWarnings } = await resolveAtMentions(answer);
+        for (const warning of attachWarnings)
+            log.warn(warning);
         let finalContent = cleanAnswer;
         if (attachments.length > 0) {
             const attachBlocks = attachments.map(a => `[Attached file: ${a.path}]\n\`\`\`\n${a.content}\n\`\`\``).join('\n\n');
             finalContent = `${cleanAnswer}\n\n--- Attached Files ---\n${attachBlocks}`;
-            p.log.info(pc.cyan(`📎 Attached ${attachments.length} file(s): ${attachments.map(a => a.path).join(', ')}`));
+            log.info(pc.cyan(`Attached ${attachments.length} file(s): ${attachments.map(a => a.path).join(', ')}`));
         }
         if (images.length > 0) {
-            p.log.info(pc.cyan(`🖼️  Attached ${images.length} image(s): ${images.map(i => i.path).join(', ')}`));
+            if (modelAcceptsImages(config.model) === false) {
+                log.warn(`${config.model} cannot read images: ${images.length === 1 ? 'the image' : 'the images'} will not be sent. Switch to a model with vision (/model).`);
+            }
+            else {
+                log.info(pc.cyan(`Attached ${images.length} image(s): ${images.map(i => path.basename(i.path)).join(', ')}`));
+            }
+        }
+        // The session is over its cost limit: ask before spending more.
+        if (costLimit() > 0 && sessionCost.total >= costLimit()) {
+            const proceed = await askConfirm({
+                title: t('cost.title'),
+                question: t('cost.reached', { spent: formatCost(sessionCost.total), limit: formatCost(costLimit()) }),
+                details: [t('cost.raise', { limit: formatCost(costLimit() * 2) })],
+                yes: t('cost.continue'),
+                no: t('cost.cancel'),
+            });
+            if (!proceed) {
+                log.info(t('cost.cancelled'));
+                currentDraft = answer;
+                continue;
+            }
+            costLimitRaised = costLimit() * 2;
+            costWarned = false;
         }
         globalSnapshotManager.beginTurn();
+        let turnCheckpoint = null;
+        if (!planMode) {
+            turnCheckpoint = await createCheckpoint(process.cwd(), checkpoints[checkpoints.length - 1]?.sha);
+            if (turnCheckpoint)
+                checkpoints.push(turnCheckpoint);
+        }
+        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)
+            setWindowTitle(provisionalTitle(answer));
         history.addMessage({
             role: 'user',
             content: finalContent,
-            images: images.length > 0 ? images : undefined
+            images: images.length > 0 ? images : undefined,
+            at: Date.now(),
+            checkpoint: turnCheckpoint?.sha,
         });
+        // The format of the gateway is learned once (cached); the first request waits for it.
+        await refreshFormats(config).catch(() => null);
         const provider = createProvider(config);
         const tools = getTools(planMode);
-        const guard = new CLIConsoleGuard(config.autoApprove, config.bashAllowlist || []);
+        const guard = new CLIConsoleGuard(config.autoApprove, [...(config.bashAllowlist || [])], {
+            memory: permissionMemory,
+            // "Always": kept in the config for the next sessions (`/permissions` lists and clears them).
+            onAlways: (r) => {
+                if (r.kind === 'bash')
+                    config.bashAllowlist = Array.from(new Set([...(config.bashAllowlist || []), r.key]));
+                else
+                    config.allowedTools = Array.from(new Set([...(config.allowedTools || []), r.key]));
+                void saveConfig(config).catch(() => null);
+            },
+        });
         const agentConfig = {
             maxContextTokens: config.maxContextTokens || 100000,
             maxIterations: config.maxIterations || 100,
             autoApprove: config.autoApprove,
-            bashAllowlist: config.bashAllowlist
+            bashAllowlist: config.bashAllowlist,
+            hooks: config.hooks,
         };
         const agent = new Agent(agentConfig, provider, tools, history, guard);
         const taskStartTime = Date.now();
@@ -1637,30 +1979,217 @@ export async function main() {
         let spinnerActive = false;
         let thinkingActive = false;
         let thinkingStartTime = 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 = '';
+        let thoughtPrinted = 0;
+        let liveShown = 0; // how much of the reasoning the live line has flowed through
+        let liveAt = 0;
+        // The same for commands and their output (ctrl+o).
         let textActive = false;
-        const s = p.spinner();
+        let assistantBuf = '';
+        // The last finished reasoning waits for the reply it belongs to, to be saved with it.
+        let pendingReasoning = null;
+        let pendingRedraw = false;
+        let gapBeforeTool = false;
+        const cleanUi = config.ui?.layout !== 'classic';
+        const s = (cleanUi ? new UiSpinner() : p.spinner());
+        const uiSpinner = cleanUi ? s : null;
+        const assistantGutter = new GutterWriter(palette.accent('●') + ' ', '  ');
+        const thoughtGutter = new GutterWriter(palette.faint('  │ '), palette.faint('  │ '));
         const streamer = new MarkdownStreamer();
+        if (cleanUi)
+            streamer.setSink((text) => assistantGutter.write(text));
         const thoughtStreamer = new SmoothStreamer((chunk) => {
-            process.stdout.write(pc.dim(chunk));
+            if (cleanUi)
+                thoughtGutter.write(palette.muted(chunk));
+            else
+                process.stdout.write(pc.dim(chunk));
         });
+        let turnOutputTokens = 0;
+        // Live token counter of this turn: exact numbers of finished requests plus an estimate for
+        // the request in flight: what the model has written for the user's request so far (↓).
+        let turnInputTokens = 0;
+        let requestOutEstimate = 0;
+        let toolArgsEstimate = 0;
+        // The shown number eases toward the real one: it climbs fast, then slows down, instead of jumping.
+        let shownOutput = 0;
+        let shownAt = Date.now();
+        const liveTokens = () => {
+            const target = turnOutputTokens + requestOutEstimate + toolArgsEstimate;
+            const now = Date.now();
+            shownOutput = easeToward(shownOutput, target, now - shownAt);
+            shownAt = now;
+            return `↓ ${formatTokensShort(Math.round(shownOutput))} tokens`;
+        };
+        const costAtTurnStart = sessionCost.total;
+        const turnCost = { estimated: false, unpriced: 0, priced: 0 };
+        let spacerBeforeText = false;
+        // Tool results in the clean layout: a quiet "╰ summary" line, a diff box for edits.
+        const renderCleanToolResult = (name, result) => {
+            const rows = toolResultRows(name, result, { cols: process.stdout.columns || 80, expanded: outputExpanded, diffColors: !!config.ui?.diffColors });
+            if (rows.length > 0)
+                console.log(rows.join('\n'));
+        };
         const telemetry = new LiveTelemetryTracker();
         telemetry.start('connecting');
+        uiSpinner?.setMetaProvider(liveTokens);
+        // Only a text that is being written holds it back (its line cannot be cut in the middle).
+        /** The reasoning goes into the saved session with the reply it came before. */
+        const attachReasoning = () => {
+            if (!pendingReasoning)
+                return;
+            const messages = history.getMessages();
+            for (let i = messages.length - 1; i >= 0; i--) {
+                if (messages[i].role === 'assistant') {
+                    if (!messages[i].reasoning) {
+                        messages[i].reasoning = pendingReasoning;
+                        pendingReasoning = null;
+                    }
+                    return;
+                }
+                if (messages[i].role === 'user')
+                    return; // the reply is not written yet
+            }
+        };
+        const safeToRedraw = () => !textActive;
+        /** Clears the screen and draws the whole conversation again, folded or unfolded as the switches say. */
+        const redraw = () => {
+            composer.suspend();
+            // A reasoning that was being printed in full is part of the screen that is wiped: it starts again.
+            if (thinkingActive) {
+                thinkingActive = false;
+                thoughtPrinted = 0;
+                thoughtStreamer.reset();
+                thoughtGutter.reset();
+            }
+            redrawChat();
+            composer.resume();
+        };
+        const runPendingRedraw = () => {
+            if (pendingRedraw && safeToRedraw()) {
+                pendingRedraw = false;
+                redraw();
+            }
+        };
+        /** The assistant's text is complete: close its line and keep it in the conversation. */
+        const endText = () => {
+            if (textActive) {
+                process.stdout.write('\n');
+                textActive = false;
+            }
+            if (assistantBuf.trim())
+                transcript.push({ kind: 'assistant', text: assistantBuf });
+            assistantBuf = '';
+            runPendingRedraw();
+        };
         const finishThinking = (extraNewline = true) => {
-            if (!thinkingActive)
+            if (!thinkingActive && !thinkingStreaming)
                 return;
-            thoughtStreamer.flush();
+            if (thinkingActive) {
+                thoughtStreamer.flush();
+                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 width = Math.min(process.stdout.columns || 40, 52);
-            const label = `─── Thought for ${elapsedSec}s${teleStats} `;
-            const fillLen = Math.max(2, width - label.length);
-            process.stdout.write('\n\n' + pc.dim(label + '─'.repeat(fillLen)) + (extraNewline ? '\n\n' : '\n'));
+            if (cleanUi && !thinkingActive) {
+                // Folded: one quiet line instead of the whole reasoning.
+                if (spacerBeforeText)
+                    process.stdout.write('\n');
+                process.stdout.write(collapsedThoughtLine(`${t('status.thoughtFor', { sec: elapsedSec })}${teleStats}`, !!thoughtBuffer.trim(), process.stdout.columns || 80) + '\n');
+                spacerBeforeText = true;
+            }
+            else if (cleanUi) {
+                process.stdout.write('\n' + palette.faint(`  ╰ ${t('status.thoughtFor', { sec: elapsedSec })}${teleStats}`) + '\n');
+                thoughtGutter.reset();
+                spacerBeforeText = true;
+            }
+            else {
+                const width = Math.min(process.stdout.columns || 40, 52);
+                const label = `─── Thought for ${elapsedSec}s${teleStats} `;
+                const fillLen = Math.max(2, width - label.length);
+                process.stdout.write('\n\n' + pc.dim(label + '─'.repeat(fillLen)) + (extraNewline ? '\n\n' : '\n'));
+            }
+            if (cleanUi) {
+                transcript.push({ kind: 'thought', text: thoughtBuffer, sec: elapsedSec, stats: teleStats });
+                gapBeforeTool = true;
+            }
+            if (thoughtBuffer.trim())
+                pendingReasoning = { text: thoughtBuffer.trim(), sec: elapsedSec, stats: teleStats };
+            thoughtBuffer = '';
+            thoughtPrinted = 0;
+            liveShown = 0;
             thinkingActive = false;
+            thinkingStreaming = false;
             thinkingStartTime = 0;
+            runPendingRedraw();
         };
-        const stopGeneration = () => {
+        /** Prints the header of the reasoning block (once) and what has not been written of it yet. */
+        const showThought = () => {
+            if (!thinkingActive) {
+                process.stdout.write((cleanUi ? (spacerBeforeText ? '\n' : '') : '\n') + (cleanUi ? palette.muted(`  ∴ ${t('status.thinkingLine')}`) : pc.bold(pc.white('› Thought:'))) + '\n');
+                if (cleanUi)
+                    spacerBeforeText = false;
+                thinkingActive = true;
+            }
+            if (thoughtBuffer.length > thoughtPrinted) {
+                thoughtStreamer.push(thoughtBuffer.slice(thoughtPrinted));
+                thoughtPrinted = thoughtBuffer.length;
+            }
+        };
+        /**
+         * The newest words of the reasoning on one line while it is folded: half the width of the
+         * screen, the oldest words fading out on the left, an ellipsis at the end. The text flows
+         * in a few characters at a time (faster the further it is behind) instead of jumping with
+         * every chunk the model sends.
+         */
+        const liveThought = () => {
+            if (!cleanUi || !thinkingStreaming || thinkingActive)
+                return '';
+            const text = thoughtBuffer.replace(/\s+/g, ' ').trimStart();
+            const now = Date.now();
+            const lag = text.length - liveShown;
+            if (lag > 0)
+                liveShown = Math.min(text.length, liveShown + Math.max(1, Math.ceil((now - liveAt) * Math.max(0.12, lag / 220))));
+            else
+                liveShown = text.length;
+            liveAt = now;
+            const cols = process.stdout.columns || 80;
+            const hint = `  (${t('view.expandThought')})`;
+            const width = Math.max(16, Math.min(Math.floor(cols / 2) - 2, cols - 8 - displayWidth(hint)));
+            const tail = Array.from(tailWidth(text.slice(0, liveShown), width));
+            if (tail.length === 0)
+                return '';
+            const third = Math.ceil(tail.length / 3);
+            const old = tail.slice(0, third).join('');
+            const mid = tail.slice(third, third * 2).join('');
+            const fresh = tail.slice(third * 2).join('');
+            return '  ' + palette.faint('∴') + ' ' + palette.faint(old) + palette.muted(mid) + palette.text(fresh) + palette.faint('…' + hint);
+        };
+        /** ctrl+p / ctrl+o: fold or unfold the reasoning / the tool output of the whole chat, also what is already above. */
+        const toggleView = (kind) => {
+            if (!cleanUi)
+                return;
+            if (kind === 'thinking')
+                thinkingExpanded = !thinkingExpanded;
+            else
+                outputExpanded = !outputExpanded;
+            composer.refresh();
+            if (safeToRedraw()) {
+                redraw();
+                // A thought that is being written goes on in full from its beginning.
+                if (thinkingExpanded && thinkingStreaming)
+                    showThought();
+            }
+            else {
+                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) => {
             if (aborted)
                 return;
             aborted = true;
@@ -1673,24 +2202,100 @@ export async function main() {
             thoughtStreamer.reset();
             finishThinking(true);
             streamer.finish();
-            if (textActive) {
-                process.stdout.write('\n');
-            }
-            if (isConnecting) {
-                console.log(pc.yellow('\n⏹  Подключение отменено / Connection cancelled (Ctrl+C).'));
+            endText();
+            if (reason) {
+                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();
+            }
+            else if (isConnecting) {
+                console.log(pc.yellow('\n' + t('stop.classicConnection')));
             }
             else {
-                console.log(pc.yellow('\n⏹  Generation stopped / Ответ остановлен (Ctrl+C).'));
+                console.log(pc.yellow('\n' + t('stop.classicStopped')));
             }
         };
         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.
+        let statusLabel = t('status.waiting');
+        let statusFrame = 0;
+        const statusStartedAt = Date.now();
+        const statusLine = () => renderStatusLine({
+            label: statusLabel,
+            elapsedMs: Date.now() - statusStartedAt,
+            meta: liveTokens(),
+            frame: statusFrame++,
+            columns: process.stdout.columns || 80,
+        });
+        const composer = new TurnComposer(process.stdout, () => {
+            const ctx = currentContext();
+            const used = ctx.total - ctx.system - ctx.tools;
+            const git = GitStatusCache.getStatus();
+            return {
+                mode: resolveMode(planMode, !!config.autoApprove),
+                model: modelLabel(config),
+                cwd: process.cwd(),
+                branch: git?.branch,
+                dirty: git?.isDirty,
+                contextPercent: Math.min(100, Math.round((used / (config.maxContextTokens || getModelContextLimit(config.model))) * 100)),
+                cost: sessionCost.total,
+                costState: sessionCost.state(),
+            };
+        }, undefined, statusLine, sendQueuedNow);
+        composer.live = liveThought;
+        composer.onToggle = toggleView;
+        const releasePauseHook = registerPauseHook(() => {
+            composer.suspend();
+            return () => composer.resume();
+        });
         const onRawData = (data) => {
-            const buf = Buffer.isBuffer(data) ? data : Buffer.from(String(data));
-            if (buf.includes(3) || buf.includes(0x03) || data === '\x03') {
+            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');
+                text = text.replace(/\x1b\[[IO]/g, '');
+                if (!text)
+                    return;
+            }
+            // Ctrl+C is 0x03, or `CSI 99;5u` while the extended keyboard modes are on.
+            if (text.includes('\x03') || splitKeys(text).some((k) => normalizeKey(k) === '\x03')) {
                 stopGeneration();
+                return;
             }
+            composer.handleData(text);
+        };
+        const onResize = () => composer.onResize();
+        /** What a queued message becomes in the conversation: its @files and images are attached like in a normal prompt. */
+        const queuedToMessage = async (text) => {
+            const resolved = await resolveAtMentions(text);
+            let content = resolved.text;
+            if (resolved.attachments.length > 0) {
+                const blocks = resolved.attachments.map(a => `[Attached file: ${a.path}]\n\`\`\`\n${a.content}\n\`\`\``).join('\n\n');
+                content = `${resolved.text}\n\n--- Attached Files ---\n${blocks}`;
+            }
+            return { role: 'user', content, images: resolved.images.length > 0 ? resolved.images : undefined };
         };
         activeAbortHandler = stopGeneration;
         process.on('SIGINT', onSigInt);
@@ -1699,36 +2304,53 @@ export async function main() {
                 process.stdin.resume();
                 process.stdin.setRawMode(true);
                 process.stdin.on('data', onRawData);
+                if (cleanUi && config.ui?.typeAhead !== false && composer.start()) {
+                    process.stdout.on('resize', onResize);
+                    uiSpinner?.mute(true);
+                    process.stdout.write('\x1b[?1004h'); // the terminal tells when it loses or gets the focus
+                }
             }
             catch { }
         }
-        s.start('Connecting...');
+        s.start(cleanUi ? t('status.waiting') : 'Connecting...');
         spinnerActive = true;
         const turnStartTime = Date.now();
         let toolsExecutedCount = 0;
         try {
-            for await (const event of agent.run(abortController.signal)) {
+            for await (const event of agent.run(abortController.signal, {
+                takePending: async () => Promise.all(composer.takeQueued().map(queuedToMessage)),
+                hasPending: () => composer.hasQueued(),
+            })) {
                 if (aborted)
                     break;
                 if (event.type === 'reasoning_delta') {
                     isConnecting = false;
                     telemetry.setPhase('thinking');
+                    statusLabel = t('status.thinking');
                     telemetry.recordTokens(telemetry.estimateTokensFromText(event.delta));
+                    requestOutEstimate += telemetry.estimateTokensFromText(event.delta);
                     if (spinnerActive) {
                         s.stop();
                         spinnerActive = false;
                     }
-                    if (!thinkingActive) {
+                    if (!thinkingStreaming) {
+                        thinkingStreaming = true;
                         thinkingStartTime = Date.now();
-                        process.stdout.write('\n' + pc.bold(pc.white('› Thought:')) + '\n');
-                        thinkingActive = true;
+                        thoughtBuffer = '';
+                        thoughtPrinted = 0;
+                        liveShown = 0;
+                        liveAt = Date.now();
                     }
-                    thoughtStreamer.push(event.delta);
+                    thoughtBuffer += event.delta;
+                    if (!cleanUi || thinkingExpanded)
+                        showThought();
                 }
                 else if (event.type === 'text_delta') {
                     isConnecting = false;
                     telemetry.setPhase('generating');
+                    statusLabel = t('status.writing');
                     telemetry.recordTokens(telemetry.estimateTokensFromText(event.delta));
+                    requestOutEstimate += telemetry.estimateTokensFromText(event.delta);
                     if (spinnerActive) {
                         s.stop();
                         spinnerActive = false;
@@ -1736,7 +2358,15 @@ export async function main() {
                     finishThinking(true);
                     if (!textActive) {
                         textActive = true;
+                        if (cleanUi) {
+                            if (spacerBeforeText)
+                                process.stdout.write('\n');
+                            spacerBeforeText = false;
+                            assistantGutter.reset();
+                        }
                     }
+                    assistantBuf += event.delta;
+                    gapBeforeTool = false;
                     streamer.push(event.delta);
                 }
                 else if (event.type === 'text') {
@@ -1747,7 +2377,18 @@ export async function main() {
                     }
                     finishThinking(true);
                     if (!textActive) {
-                        console.log('\n' + renderMarkdown(event.content) + '\n');
+                        if (cleanUi) {
+                            if (spacerBeforeText)
+                                console.log();
+                            spacerBeforeText = false;
+                            assistantGutter.reset();
+                            assistantGutter.write(renderMarkdown(event.content) + '\n');
+                            console.log();
+                            transcript.push({ kind: 'assistant', text: event.content });
+                        }
+                        else {
+                            console.log('\n' + renderMarkdown(event.content) + '\n');
+                        }
                     }
                 }
                 else if (event.type === 'tool_generating') {
@@ -1755,47 +2396,102 @@ export async function main() {
                     telemetry.setPhase('tool');
                     const theme = getCurrentTheme();
                     const label = formatToolGeneratingLabel(event.name, event.targetHint);
+                    statusLabel = label;
                     const teleStats = telemetry.getTotalTokens() > 0
                         ? ` · ${LiveTelemetryTracker.formatTokenCount(telemetry.getTotalTokens())} tok · ${telemetry.getTokensPerSecond()} tok/s`
                         : '';
                     const telemetrySuffix = config.ui?.liveTelemetry ? ` ${pc.dim(`(${telemetry.getElapsedSeconds()}s${teleStats})`)}` : '';
+                    // The model has started on a tool call: its text is complete. (A long write can take minutes, and
+                    // ctrl+p / ctrl+o must work meanwhile: they wait only for a text that is still being written.)
+                    if (textActive) {
+                        streamer.finish();
+                        endText();
+                    }
                     if (!spinnerActive) {
                         streamer.finish();
                         finishThinking(false);
-                        s.start(theme.boldFn(label) + telemetrySuffix);
+                        s.start(cleanUi ? label : theme.boldFn(label) + telemetrySuffix);
                         spinnerActive = true;
                     }
                     else {
-                        s.message(theme.boldFn(label) + telemetrySuffix);
+                        s.message(cleanUi ? label : theme.boldFn(label) + telemetrySuffix);
+                    }
+                    // The arguments written so far (about 3 bytes per token), on top of the text before them.
+                    toolArgsEstimate = Math.max(toolArgsEstimate, Math.round(event.bytes / 3));
+                }
+                else if (event.type === 'user_message') {
+                    // The message typed during the work reached the model: show it in the chat like any prompt.
+                    if (spinnerActive) {
+                        s.stop();
+                        spinnerActive = false;
                     }
+                    finishThinking(true);
+                    streamer.finish();
+                    endText();
+                    statusLabel = t('status.waiting');
+                    const typed = event.content.split('\n\n--- Attached Files ---')[0];
+                    transcript.push({ kind: 'user', text: typed });
+                    console.log();
+                    console.log(renderUserEcho(typed, process.stdout.columns || 80).join('\n'));
+                    console.log();
+                    s.start(cleanUi ? t('status.waiting') : 'Connecting...');
+                    spinnerActive = true;
                 }
                 else if (event.type === 'tool_start') {
+                    attachReasoning();
                     isConnecting = false;
                     telemetry.reset();
+                    statusLabel = event.actionDesc || event.name;
+                    // A question to the user takes over the keyboard: the typing line steps aside.
+                    if (event.name === 'ask_questions')
+                        composer.suspend();
                     if (spinnerActive) {
                         s.stop();
                         spinnerActive = false;
                     }
                     streamer.finish();
                     finishThinking(false);
-                    if (textActive) {
-                        process.stdout.write('\n');
-                        textActive = false;
+                    endText();
+                    if (cleanUi) {
+                        if (gapBeforeTool)
+                            console.log();
+                        gapBeforeTool = false;
+                        transcript.push({ kind: 'tool', name: event.name, desc: event.actionDesc || event.name });
+                        console.log(renderToolLine(event.actionDesc, process.stdout.columns || 80, outputExpanded));
+                        assistantGutter.reset();
+                    }
+                    else {
+                        console.log('\n' + pc.bold(pc.white(event.actionDesc)));
                     }
-                    console.log('\n' + pc.bold(pc.white(event.actionDesc)));
                     if (event.name !== 'ask_questions' && event.name !== 'todo_list') {
-                        s.start('Executing...');
+                        s.start(cleanUi ? t('status.running') : 'Executing...');
                         spinnerActive = true;
                     }
                 }
                 else if (event.type === 'tool_end') {
+                    for (let i = transcript.length - 1; i >= 0; i--) {
+                        const it = transcript[i];
+                        if (it.kind === 'tool' && it.result === undefined) {
+                            it.result = event.result || '';
+                            break;
+                        }
+                    }
+                    if (event.name === 'ask_questions')
+                        composer.resume();
+                    statusLabel = t('status.waiting');
+                    composer.refresh();
                     toolsExecutedCount++;
                     GitStatusCache.invalidate();
                     if (spinnerActive) {
                         s.stop();
                         spinnerActive = false;
                     }
-                    if (event.result) {
+                    if (cleanUi) {
+                        if (event.result)
+                            renderCleanToolResult(event.name, event.result);
+                        spacerBeforeText = true;
+                    }
+                    else if (event.result) {
                         try {
                             const parsed = JSON.parse(event.result);
                             if (parsed.type === 'todo_list' && parsed.displayCard) {
@@ -1824,36 +2520,71 @@ export async function main() {
                     }
                 }
                 else if (event.type === 'usage') {
-                    totalSessionCost += event.usage.cost || 0;
+                    attachReasoning();
+                    sessionCost.add(event.usage);
+                    // The cost limit: a warning at 80%, the task is stopped at 100%.
+                    const limit = costLimit();
+                    if (limit > 0 && !aborted) {
+                        if (sessionCost.total >= limit) {
+                            stopGeneration(false, t('cost.stopped', { limit: formatCost(limit) }));
+                        }
+                        else if (!costWarned && sessionCost.total >= limit * 0.8) {
+                            costWarned = true;
+                            console.log(renderNotice('warn', t('cost.warn', { spent: formatCost(sessionCost.total), limit: formatCost(limit) })));
+                        }
+                    }
+                    composer.refresh();
+                    if (typeof event.usage.cost === 'number') {
+                        turnCost.priced = (turnCost.priced ?? 0) + 1;
+                        if (event.usage.costSource === 'estimated')
+                            turnCost.estimated = true;
+                    }
+                    else {
+                        turnCost.unpriced = (turnCost.unpriced ?? 0) + 1;
+                    }
+                    turnOutputTokens += event.usage.completionTokens || 0;
+                    turnInputTokens += event.usage.promptTokens || 0;
+                    requestOutEstimate = 0;
+                    toolArgsEstimate = 0;
                 }
                 else if (event.type === 'reconnecting') {
+                    statusLabel = t('status.reconnecting');
                     telemetry.reset();
                     if (spinnerActive) {
                         s.stop();
                         spinnerActive = false;
                     }
-                    if (thinkingActive) {
+                    if (thinkingActive || thinkingStreaming) {
                         finishThinking(false);
                     }
-                    if (textActive) {
-                        process.stdout.write('\n');
-                        textActive = false;
-                    }
+                    endText();
                     streamer.reset();
-                    console.log();
-                    console.log(pc.bold(pc.yellow(`⚠️  Интернет-соединение нестабильно (${event.reason})`)));
-                    console.log(pc.cyan(`🔄 Попытка переподключения [${event.attempt}/${event.maxAttempts}] (пауза ${(event.delayMs / 1000).toFixed(1)}с)...`));
-                    s.start(pc.cyan(`Ожидание сети [${event.attempt}/${event.maxAttempts}]...`));
+                    if (cleanUi) {
+                        console.log(renderNotice('warn', t('conn.unstable', { reason: event.reason })));
+                        s.start(t('conn.reconnecting', { attempt: event.attempt, max: event.maxAttempts, delay: (event.delayMs / 1000).toFixed(1) }));
+                    }
+                    else {
+                        console.log();
+                        console.log(pc.bold(pc.yellow(t('conn.classicUnstable', { reason: event.reason }))));
+                        console.log(pc.cyan(t('conn.classicRetry', { attempt: event.attempt, max: event.maxAttempts, delay: (event.delayMs / 1000).toFixed(1) })));
+                        s.start(pc.cyan(t('conn.classicWaiting', { attempt: event.attempt, max: event.maxAttempts })));
+                    }
                     spinnerActive = true;
                 }
                 else if (event.type === 'reconnected') {
+                    statusLabel = t('status.waiting');
                     if (spinnerActive) {
                         s.stop();
                         spinnerActive = false;
                     }
-                    console.log(pc.bold(pc.green(`✔ Соединение восстановлено! Возобновляем генерацию...`)));
-                    console.log();
-                    s.start('Connecting...');
+                    if (cleanUi) {
+                        console.log(renderNotice('ok', t('conn.restored')));
+                    }
+                    else {
+                        console.log(pc.bold(pc.green(t('conn.classicRestored'))));
+                        console.log();
+                    }
+                    s.start(cleanUi ? t('status.waiting') : 'Connecting...');
                     spinnerActive = true;
                 }
                 else if (event.type === 'error') {
@@ -1863,14 +2594,20 @@ export async function main() {
                     }
                     finishThinking(true);
                     streamer.finish();
-                    p.log.error(pc.bold(pc.red(`❌ ${event.message}`)));
+                    if (cleanUi)
+                        console.log(renderNotice('error', event.message));
+                    else
+                        log.error(pc.bold(pc.red(`${event.message}`)));
                 }
                 else if (event.type === 'system') {
                     if (spinnerActive) {
                         s.stop();
                         spinnerActive = false;
                     }
-                    p.log.info(event.message);
+                    if (cleanUi)
+                        console.log(renderNotice('info', event.message));
+                    else
+                        log.info(event.message);
                 }
             }
             finishThinking(true);
@@ -1879,59 +2616,113 @@ export async function main() {
                 s.stop();
                 spinnerActive = false;
             }
-            if (textActive) {
-                process.stdout.write('\n');
+            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.
+            const leftover = composer.stop();
+            if (interruptPrompt) {
+                autoTriggerPrompt = interruptPrompt;
+                if (leftover.draft)
+                    currentDraft = leftover.draft;
+            }
+            else if (leftover.queued.length > 0) {
+                if (aborted)
+                    currentDraft = [...leftover.queued, leftover.draft].filter(Boolean).join(' ');
+                else
+                    autoTriggerPrompt = leftover.queued.join('\n');
+            }
+            else if (leftover.draft) {
+                currentDraft = leftover.draft;
             }
+            attachReasoning();
             const turnElapsedMs = Date.now() - turnStartTime;
+            if (cleanUi && !aborted) {
+                const summaryRow = renderTurnSummary({
+                    ms: turnElapsedMs,
+                    tools: toolsExecutedCount,
+                    outputTokens: turnOutputTokens,
+                    inputTokens: turnInputTokens,
+                    cost: sessionCost.total - costAtTurnStart,
+                    costState: turnCost
+                });
+                console.log(summaryRow);
+                console.log();
+                transcript.push({ kind: 'raw', rows: [summaryRow] });
+            }
             const shouldNotify = (turnElapsedMs >= 15000) || (toolsExecutedCount > 0) || (planMode && lastPlanReady !== null);
-            if (shouldNotify && !aborted) {
+            if (!aborted) {
                 const secs = Math.round(turnElapsedMs / 1000);
-                notifyDevice('devx', `Task completed in ${secs}s!`);
+                const lastReply = [...history.getMessages()].reverse().find((m) => m.role === 'assistant' && m.content && m.content.trim());
+                const preview = notificationBody(lastReply?.content ?? '');
+                const heading = windowTitle || BASE_TITLE;
+                if (isTermux()) {
+                    if (shouldNotify)
+                        notifyDevice(heading, preview || `Task completed in ${secs}s!`);
+                }
+                else if (!terminalFocused) {
+                    // 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!`);
+                }
+                else if (shouldNotify) {
+                    notifyDevice(heading, `Task completed in ${secs}s!`);
+                }
             }
             // Auto-save session
-            await sessionManager.save(history.getMessages(), totalSessionCost, config.model, planMode);
+            await sessionManager.save(history.getMessages(), sessionCost.total, config.model, planMode, sessionCost.estimated);
+            // The first exchange names the chat. It runs in the background and never holds the prompt back.
+            if (!aborted && !sessionManager.hasGeneratedTitle && titleAttempts < 2) {
+                titleAttempts++;
+                const msgs = history.getMessages();
+                const firstUser = msgs.find((m) => m.role === 'user')?.content ?? '';
+                const reply = [...msgs].reverse().find((m) => m.role === 'assistant' && m.content && m.content.trim())?.content ?? '';
+                if (firstUser.trim() && reply.trim()) {
+                    const forSession = sessionManager.getSession().id;
+                    void (async () => {
+                        try {
+                            const title = await generateChatTitle(createProvider(config), firstUser.split('\n\n--- Attached Files ---')[0], reply);
+                            // The user may have started another chat meanwhile.
+                            if (!title || sessionManager.getSession().id !== forSession)
+                                return;
+                            sessionManager.setTitle(title);
+                            setWindowTitle(title);
+                            await sessionManager.save(history.getMessages(), sessionCost.total, config.model, planMode, sessionCost.estimated);
+                        }
+                        catch { }
+                    })();
+                }
+            }
             // Check if plan was finalized in PLAN mode
             if (planMode && !aborted) {
                 const lastMsg = history.getMessages().slice(-1)[0];
                 const hasPlanReadyTool = lastPlanReady !== null;
-                const hasPlanText = lastMsg && lastMsg.role === 'assistant' && (lastMsg.content.includes('🎯 Цель') ||
-                    lastMsg.content.includes('📁 Пошаговый') ||
+                const hasPlanText = lastMsg && lastMsg.role === 'assistant' && (lastMsg.content.includes('Цель и архитектурный обзор') ||
+                    lastMsg.content.includes('Goal and architecture') ||
+                    lastMsg.content.includes('Step-by-step changes') ||
+                    lastMsg.content.includes('Пошаговый список изменений') ||
                     lastMsg.content.includes('FINAL PLAN') ||
                     lastMsg.content.includes('План готов') ||
                     lastMsg.content.includes('Архитектурный план') ||
                     lastMsg.content.includes('план готов'));
                 if (hasPlanReadyTool || hasPlanText) {
+                    const approvedPlan = lastPlanReady ? { summary: lastPlanReady.summary, files: lastPlanReady.files, steps: lastPlanReady.steps } : (hasPlanText && lastMsg ? lastMsg.content : null);
                     resetPlanReady();
                     console.log();
-                    let choice = '';
-                    try {
-                        choice = await select({
-                            message: pc.bold(pc.cyan('📋 Plan is ready! What would you like to do?')),
-                            choices: [
-                                {
-                                    name: pc.bold(pc.green('🚀 Go (Switch to AGENT mode and start execution)')),
-                                    value: 'go',
-                                    description: 'Automatically switch to AGENT mode and start implementing the plan immediately'
-                                },
-                                {
-                                    name: pc.bold(pc.yellow('✏️  Other (Modify, add details, or ask questions)')),
-                                    value: 'other',
-                                    description: 'Stay in PLAN mode and open prompt to type adjustments or additions'
-                                }
-                            ]
-                        });
-                    }
-                    catch { }
+                    const choice = await askPlanDecision();
                     if (choice === 'go') {
                         planMode = false;
+                        // The approved plan is kept in the project: it survives /clear and a restart.
+                        if (approvedPlan)
+                            await savePlanFile(process.cwd(), approvedPlan).catch(() => null);
                         const newSys = await buildSystemPrompt(false);
                         history.updateSystemPrompt(newSys);
-                        p.log.success(pc.bold(pc.green('🚀 Switched to AGENT mode! Starting execution of approved plan...')));
+                        log.success(t('plan.started'));
                         currentDraft = '';
                         autoTriggerPrompt = 'Go!';
                         continue;
                     }
                     else {
+                        log.info(t('plan.editHint'));
                         currentDraft = '';
                         continue;
                     }
@@ -1946,10 +2737,23 @@ export async function main() {
                 spinnerActive = false;
             }
             if (!aborted && err.name !== 'AbortError' && !err.message?.includes('aborted')) {
-                p.log.error(pc.bold(pc.red(`❌ ${err.message}`)));
+                if (cleanUi)
+                    console.log(renderNotice('error', err.message));
+                else
+                    log.error(pc.bold(pc.red(`${err.message}`)));
             }
         }
         finally {
+            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)) {
+                currentDraft = [...unsent.queued, unsent.draft].filter(Boolean).join(' ');
+            }
             globalSnapshotManager.finishTurn();
             activeAbortHandler = null;
             process.removeListener('SIGINT', onSigInt);
@@ -1960,6 +2764,15 @@ export async function main() {
         }
     }
     MCPManager.getInstance().stopAll();
+    // The cards leave stdin resumed; nothing else keeps devx alive after the main loop, so end it here.
+    if (process.stdin.isTTY) {
+        try {
+            process.stdin.setRawMode(false);
+        }
+        catch { }
+    }
+    process.stdin.pause();
+    process.exit(0);
 }
 process.on('exit', () => {
     try {
@@ -1967,4 +2780,4 @@ process.on('exit', () => {
     }
     catch { }
 });
-main().catch(console.error);
+main().catch((err) => reportRuntimeError(err, activeAbortHandler));