termux-dev 1.8.2 → 1.9.0

package/dist/cli/ui.js

@@ -36,9 +36,12 @@ export const palette = {
     accent: (s) => tokens().accent(s),
     bold: (s) => (colorOn() ? `\x1b[1m${s}\x1b[22m` : s),
 };
-export function resolveMode(planMode, yolo) {
+/** `extra` is YOLO without the safety net (nothing is asked); it only counts while YOLO is on. */
+export function resolveMode(planMode, yolo, extra = false) {
     if (planMode)
         return 'plan';
+    if (yolo && extra)
+        return 'extra';
     return yolo ? 'yolo' : 'agent';
 }
 export function modeStyle(mode) {
@@ -47,6 +50,8 @@ export function modeStyle(mode) {
             return { label: 'plan', glyph: '◆', color: palette.plan };
         case 'yolo':
             return { label: 'yolo', glyph: '▲', color: palette.yolo };
+        case 'extra':
+            return { label: 'extra', glyph: '▲', color: palette.err };
         default:
             return { label: 'agent', glyph: '●', color: palette.accent };
     }
@@ -136,7 +141,7 @@ function brand(version) {
 }
 export function renderHeader(info, cols) {
     const W = contentWidth(cols);
-    const modePill = info.yolo ? palette.yolo(palette.bold('▲ auto-approve')) : '';
+    const modePill = info.extra ? palette.err(palette.bold('▲ extra: nothing asked')) : info.yolo ? palette.yolo(palette.bold('▲ auto-approve')) : '';
     const branch = info.branch
         ? `${palette.faint('git:')}${palette.muted(info.branch)}${info.dirty ? palette.warn('*') : ''}`
         : '';
@@ -146,7 +151,7 @@ export function renderHeader(info, cols) {
         const limit = Math.max(8, cols - 1);
         const room = Math.max(6, cols - 3);
         const titleOptions = info.yolo
-            ? [`${brand(info.version)}  ${modePill}`, `${brand(info.version)}  ${palette.yolo('▲ yolo')}`, `${brand(info.version)} ${palette.yolo('▲')}`, brand(info.version)]
+            ? [`${brand(info.version)}  ${modePill}`, `${brand(info.version)}  ${info.extra ? palette.err('▲ extra') : palette.yolo('▲ yolo')}`, `${brand(info.version)} ${info.extra ? palette.err('▲') : palette.yolo('▲')}`, brand(info.version)]
             : [brand(info.version)];
         lines.push(titleOptions.find((t) => displayWidth(t) <= limit) ?? truncateWidth(stripAnsi(brand(info.version)), limit));
         lines.push(`  ${palette.text(truncateWidth(info.model, room))}`);
@@ -258,6 +263,8 @@ export function inputCells(cols) {
     const W = frameWidth(cols);
     return Math.max(4, isCompact(cols) ? W - 4 : W - 6);
 }
+/** Control characters but the line break (`\n` is a real break in the input, it is laid out, not shown). */
+const CONTROL_EXCEPT_NEWLINE = /[\x00-\x09\x0b-\x1f\x7f]/g;
 /** Rows the input may take before it scrolls: a quarter of the terminal, at most 8. */
 export function maxInputRows(termRows = process.stdout.rows || 24) {
     return Math.max(1, Math.min(8, Math.floor(termRows / 4)));
@@ -291,7 +298,14 @@ export function wrapInput(input, cells) {
         const start = i;
         let used = 0;
         let afterSpace = -1;
+        let hardBreak = false;
         while (i < cps.length) {
+            // A line break ends the row; it stays at the end of that row, so the cursor behind it is on the next one.
+            if (cps[i] === '\n') {
+                i++;
+                hardBreak = true;
+                break;
+            }
             let next = atoms.get(i) ?? i + 1;
             let w = widths.slice(i, next).reduce((a, b) => a + b, 0);
             if (next > i + 1 && w > cells) {
@@ -305,12 +319,17 @@ export function wrapInput(input, cells) {
             if (cps[i - 1] === ' ')
                 afterSpace = i;
         }
-        if (i < cps.length && cps[i] !== ' ' && afterSpace > start)
-            i = afterSpace; // break between words
-        if (i === start)
-            i = start + 1; // a cell wider than the row
+        if (!hardBreak) {
+            if (i < cps.length && cps[i] !== ' ' && afterSpace > start)
+                i = afterSpace; // break between words
+            if (i === start)
+                i = start + 1; // a cell wider than the row
+        }
         rows.push({ start, end: i });
     }
+    // Text that ends with a line break: the cursor waits on a new, empty row.
+    if (cps[cps.length - 1] === '\n')
+        rows.push({ start: cps.length, end: cps.length });
     return rows;
 }
 function layoutInput(input, cursorPos, cells) {
@@ -335,7 +354,7 @@ function layoutInput(input, cursorPos, cells) {
  * (the arrow keys then walk the prompt history as before). Returns a UTF-16 index.
  */
 export function moveCursorRow(input, cursorPos, cols, dir) {
-    const clean = input.replace(/[\x00-\x1f\x7f]/g, ' ');
+    const clean = input.replace(CONTROL_EXCEPT_NEWLINE, ' ');
     const { cps, rows, widths, cursorRow, cursorCell } = layoutInput(clean, cursorPos, inputCells(cols));
     const target = rows[cursorRow + dir];
     if (!target)
@@ -358,7 +377,7 @@ function inputRows(f, cells) {
     const { cps, rows, cursorRow, cursorCell } = layoutInput(f.input, f.cursorPos, cells);
     const limit = f.maxInputRows ?? maxInputRows();
     const firstRow = rows.length <= limit ? 0 : Math.max(0, Math.min(cursorRow - limit + 1, rows.length - limit));
-    const shown = rows.slice(firstRow, firstRow + limit).map((r) => formatBadges(cps.slice(r.start, r.end).join('')));
+    const shown = rows.slice(firstRow, firstRow + limit).map((r) => formatBadges(cps.slice(r.start, r.end).join('').replace(/\n$/, '')));
     return { rows: shown, firstRow, cursorRow: cursorRow - firstRow, cursorCol: cursorCell };
 }
 function keyHints(cols, mode) {
@@ -398,8 +417,9 @@ export function fitModelLabel(label, max) {
 }
 export function buildPromptFrame(input) {
     // Control characters would move the cursor and tear the frame apart. They are shown as
-    // spaces; one character stays one character, so cursor positions keep matching.
-    const f = { ...input, input: input.input.replace(/[\x00-\x1f\x7f]/g, ' ') };
+    // spaces; one character stays one character, so cursor positions keep matching. A line break
+    // is kept: it starts a new row of the input.
+    const f = { ...input, input: input.input.replace(CONTROL_EXCEPT_NEWLINE, ' ') };
     if (isCompact(f.cols))
         return buildCompactFrame(f);
     const W = frameWidth(f.cols);
@@ -997,7 +1017,7 @@ export function easeToward(current, target, dtMs, tauMs = 400) {
     return current + distance * (1 - Math.exp(-dtMs / tauMs));
 }
 /**
- * The working line:  `  ⠹ Read src/x.ts  (12s · ↓ 364 tokens · ctrl+c to stop)`.
+ * The working line:  `  ⠹ Read src/x.ts  (12s · ↓ 364 tokens · esc to stop)`.
  * On a narrow screen the details are dropped step by step, the label is cut last.
  */
 export function renderStatusLine({ label: rawLabel, elapsedMs, meta = '', frame, columns }) {
@@ -1026,7 +1046,7 @@ export function renderStatusLine({ label: rawLabel, elapsedMs, meta = '', frame,
     return `  ${glyph} ${palette.text(text)}${' '.repeat(GAP)}${suffix}`;
 }
 /**
- * Animated "working" line:  `  ⠹ Read src/x.ts  (12s · 1.2k tok · ctrl+c to stop)`.
+ * Animated "working" line:  `  ⠹ Read src/x.ts  (12s · 1.2k tok · esc to stop)`.
  * Same start / message / stop API as the clack spinner it replaces.
  */
 let activeSpinner = null;

package/dist/cli/usage-panel.js

@@ -128,10 +128,23 @@ function buildRows(d, iw, detail) {
     const note = costNote(s);
     if (note && detail === 'full')
         line('  ' + palette.faint(truncateWidth(note, iw - 2)));
+    if (s.restoredCost && detail === 'full') {
+        line('  ' + palette.faint(truncateWidth(`Includes ${formatMoney(s.restoredCost, { estimated: s.costState.estimated })} from before this chat was resumed; the lines below count only since devx started.`, iw - 2)));
+    }
     const tokens = iw >= 40 ? `${fmtTokens(s.promptTokens)} in · ${fmtTokens(s.completionTokens)} out` : `${fmtTokens(s.promptTokens)}/${fmtTokens(s.completionTokens)}`;
     pair('Tokens', palette.text(tokens));
-    if (s.cacheReadTokens > 0 && detail !== 'min')
-        pair('Cached input', palette.text(fmtTokens(s.cacheReadTokens)));
+    if (detail !== 'min') {
+        // What the money was paid for. Every request resends the whole conversation, so the input
+        // is usually the biggest part, and the cache is what makes it cheaper.
+        const money = (v) => s.costParts && v !== undefined && iw >= 40 ? palette.faint('  ' + formatMoney(v, { estimated: s.costState.estimated })) : '';
+        const paid = (label, tokens, v) => pair(label, palette.text(fmtTokens(tokens)) + money(v));
+        paid('  Input', s.uncachedTokens, s.costParts?.input);
+        if (s.cacheReadTokens > 0)
+            paid('  Cached input', s.cacheReadTokens, s.costParts?.cacheRead);
+        if (s.cacheWriteTokens > 0)
+            paid('  Cache writes', s.cacheWriteTokens, s.costParts?.cacheWrite);
+        paid('  Output', s.completionTokens, s.costParts?.output);
+    }
     pair('Requests', palette.text(String(s.requestsCount)));
     // ── traffic
     if (detail === 'full') {
@@ -221,7 +234,7 @@ export function runUsagePanel(data, options = {}) {
                 return;
             closed = true;
             input.off('data', onData);
-            output.off?.('resize', draw);
+            stopWatching();
             block.erase();
             if (!wasRaw)
                 input.setRawMode?.(false);
@@ -236,7 +249,7 @@ export function runUsagePanel(data, options = {}) {
             }
         };
         input.on('data', onData);
-        output.on?.('resize', draw);
+        const stopWatching = block.watchResize(draw);
         draw();
     });
 }

package/dist/cli/width.js

@@ -176,3 +176,21 @@ export function wrapText(text, width) {
     const unbreakable = text.split(/\s+/).some((word) => displayWidth(word) > width);
     return unbreakable ? wrapWidth(text, width) : wrapWords(text, width);
 }
+/**
+ * How many rows up the top of a block is from the cursor, once the terminal is `cols` wide.
+ *
+ * A block drawn at one width is re-wrapped by the terminal when the window is resized: a line that
+ * was as wide as the old window now takes several rows, so counting the lines of the block is not
+ * enough to get back to its top (the top stays on screen and the block shows up twice).
+ *
+ * @param lineWidths visible width of each line of the block as it was drawn
+ * @param cursorRow  the line the cursor is on
+ * @param cursorCol  the column of the cursor in that line
+ */
+export function rowsToTop(lineWidths, cursorRow, cursorCol, cols) {
+    const width = Math.max(1, cols);
+    let rows = 0;
+    for (let i = 0; i < cursorRow && i < lineWidths.length; i++)
+        rows += Math.max(1, Math.ceil(lineWidths[i] / width));
+    return rows + Math.floor(Math.max(0, cursorCol) / width);
+}

package/dist/core/background.js

@@ -236,8 +236,22 @@ export class BackgroundManager extends EventEmitter {
             return '';
         const text = this.notes.map((n) => n.text).join('\n\n');
         this.notes = [];
+        // What the prompt frame shows about unreported news is gone now: let it redraw.
+        this.emit('change');
         return `[devx · background tasks]\n${text}`;
     }
+    /**
+     * Tasks that ended badly and whose news the model has not received yet. The prompt frame shows
+     * this number: it goes away once devx has told the model about the failure.
+     */
+    unreportedFailures() {
+        const ids = new Set();
+        for (const note of this.notes) {
+            if (note.kind === 'exit' && this.tasks.get(note.taskId)?.info.status === 'failed')
+                ids.add(note.taskId);
+        }
+        return ids.size;
+    }
     // ───────────────────────── internals ─────────────────────────
     must(id) {
         const task = this.tasks.get(String(id));

package/dist/core/context-stats.js

@@ -23,6 +23,7 @@ export function contextBreakdown(messages, definitions, limit) {
         user, assistant, toolResults,
         images, imageCount,
         total,
+        inUse: messages.some((m) => m.role !== 'system') ? total : 0,
         compactAt: Math.floor(limit * CONTEXT_USAGE_RATIO),
         free: Math.max(0, limit - total),
     };

package/dist/core/cost.js

@@ -12,8 +12,8 @@
  */
 const PER_MILLION = 1_000_000;
 const finite = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0;
-/** The cost of the tokens at the given rates. */
-export function computeCost(rates, usage) {
+/** The cost of the tokens at the given rates, split by what was paid for. */
+export function costParts(rates, usage) {
     const prompt = Math.max(0, usage.promptTokens || 0);
     const tier = rates.tier && prompt > rates.tier.over ? rates.tier : null;
     const input = tier?.input ?? rates.input;
@@ -23,17 +23,31 @@ export function computeCost(rates, usage) {
     const read = Math.min(prompt, Math.max(0, usage.cacheReadTokens || 0));
     const written = Math.min(prompt - read, Math.max(0, usage.cacheWriteTokens || 0));
     const plain = prompt - read - written;
-    // Without a cache price the cached tokens cost as much as ordinary input.
-    let cost = plain * input + read * (cacheRead ?? input) + written * (cacheWrite ?? input);
     const completion = Math.max(0, usage.completionTokens || 0);
     const reasoning = Math.min(completion, Math.max(0, usage.reasoningTokens || 0));
-    if (rates.reasoning !== undefined && reasoning > 0) {
-        cost += (completion - reasoning) * output + reasoning * rates.reasoning;
-    }
-    else {
-        cost += completion * output;
-    }
-    return cost / PER_MILLION;
+    const out = rates.reasoning !== undefined && reasoning > 0
+        ? (completion - reasoning) * output + reasoning * rates.reasoning
+        : completion * output;
+    // Without a cache price the cached tokens cost as much as ordinary input.
+    return {
+        input: (plain * input) / PER_MILLION,
+        cacheRead: (read * (cacheRead ?? input)) / PER_MILLION,
+        cacheWrite: (written * (cacheWrite ?? input)) / PER_MILLION,
+        output: out / PER_MILLION,
+    };
+}
+/** The cost of the tokens at the given rates. */
+export function computeCost(rates, usage) {
+    const p = costParts(rates, usage);
+    return p.input + p.cacheRead + p.cacheWrite + p.output;
+}
+/** The same parts scaled so that they add up to `total` (the cost the provider reported). */
+export function scaleParts(parts, total) {
+    const sum = parts.input + parts.cacheRead + parts.cacheWrite + parts.output;
+    if (!(sum > 0) || !Number.isFinite(total))
+        return undefined;
+    const k = total / sum;
+    return { input: parts.input * k, cacheRead: parts.cacheRead * k, cacheWrite: parts.cacheWrite * k, output: parts.output * k };
 }
 /** A price as the OpenRouter list writes it: USD per token, often a string. */
 function perToken(value) {

package/dist/core/custom-providers.js

@@ -0,0 +1,161 @@
+import { isLocalBaseUrl } from './cost.js';
+/** The key stored for a server that needs none (a local one): the OpenAI client wants some value and falls back to $OPENAI_API_KEY for an empty one. */
+export const NO_KEY = 'no-key';
+/** The id the old single "Custom" entry of the provider list had. */
+const LEGACY_ID = 'custom';
+const MAX_NAME = 40;
+export function customProviders(config) {
+    const own = config.customProviders;
+    return own && typeof own === 'object' && !Array.isArray(own) ? own : {};
+}
+/** The saved providers, in the order they were added. */
+export function listCustomProviders(config) {
+    return Object.entries(customProviders(config))
+        .filter(([, p]) => p && typeof p.baseUrl === 'string')
+        .map(([id, p]) => ({ id, name: String(p.name || id), baseUrl: p.baseUrl, apiKey: config.apiKeys?.[id] ?? '' }));
+}
+export function isCustomProvider(config, id) {
+    return !!id && !!customProviders(config)[id];
+}
+/** The name to show for a provider id: the user's name for a custom one, the label of a listed one, else the id. */
+export function providerDisplayName(config, id, listed = []) {
+    if (!id)
+        return '';
+    const own = customProviders(config)[id];
+    if (own?.name)
+        return own.name;
+    return listed.find((p) => p.value === id)?.label ?? id;
+}
+/**
+ * The single "Custom" entry older versions had becomes a saved provider named Custom, so that
+ * whoever used it finds it in the list (with its address and key). Returns true when it did.
+ */
+export function migrateLegacyCustom(config) {
+    if (customProviders(config)[LEGACY_ID])
+        return false;
+    const url = config.baseUrls?.[LEGACY_ID] || (config.provider === LEGACY_ID ? config.baseUrl : '');
+    if (!url)
+        return false;
+    config.customProviders = { ...customProviders(config), [LEGACY_ID]: { name: 'Custom', baseUrl: url } };
+    return true;
+}
+/** Is this name usable? A name must be unique (without regard to case), but a provider may keep its own. */
+export function nameProblem(config, name, exceptId) {
+    const clean = name.trim();
+    if (!clean)
+        return 'empty';
+    if (Array.from(clean).length > MAX_NAME)
+        return 'long';
+    const taken = listCustomProviders(config).some((p) => p.id !== exceptId && p.name.trim().toLowerCase() === clean.toLowerCase());
+    return taken ? 'taken' : null;
+}
+/** An address of an API: http(s), with a host. The path stays as typed (`/v1`), only a trailing slash goes. */
+export function checkBaseUrl(input) {
+    const text = input.trim();
+    if (!text)
+        return { ok: false, reason: 'empty' };
+    let url;
+    try {
+        url = new URL(text);
+    }
+    catch {
+        return { ok: false, reason: 'invalid' };
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:')
+        return { ok: false, reason: 'scheme' };
+    if (!url.hostname)
+        return { ok: false, reason: 'invalid' };
+    return { ok: true, url: text.replace(/\/+$/, '') };
+}
+/** A server on this machine or on the home network usually needs no key. */
+export function usuallyNeedsNoKey(baseUrl) {
+    return isLocalBaseUrl(baseUrl);
+}
+/** `api.example.com` for the list. */
+export const hostOfUrl = (url) => url.replace(/^https?:\/\//, '').replace(/\/.*$/, '');
+/** The key as the list shows it. */
+export function keyHint(key) {
+    if (!key)
+        return '';
+    if (key === NO_KEY)
+        return 'no key';
+    if (key.length <= 8)
+        return '****';
+    return `${key.slice(0, 4)}...${key.slice(-4)}`;
+}
+// ───────────────────────── changing the saved providers ─────────────────────────
+/** An id from the name that no listed and no saved provider has: `custom-my-gateway`, `custom-my-gateway-2`. */
+export function newProviderId(config, name, listedIds = []) {
+    const slug = name
+        .toLowerCase()
+        .normalize('NFC')
+        .replace(/[^\p{L}\p{N}]+/gu, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 30) || 'provider';
+    const taken = new Set([...listedIds, ...Object.keys(customProviders(config))]);
+    let id = `custom-${slug}`;
+    for (let n = 2; taken.has(id); n++)
+        id = `custom-${slug}-${n}`;
+    return id;
+}
+function ensureMaps(config) {
+    const own = config.customProviders;
+    if (!own || typeof own !== 'object' || Array.isArray(own))
+        config.customProviders = {};
+    config.apiKeys = config.apiKeys || {};
+    config.baseUrls = config.baseUrls || {};
+}
+/** Adds a provider and returns its id. The name and address are expected to have been checked. */
+export function addCustomProvider(config, input, listedIds = []) {
+    ensureMaps(config);
+    const id = newProviderId(config, input.name, listedIds);
+    config.customProviders[id] = { name: input.name.trim(), baseUrl: input.baseUrl };
+    config.baseUrls[id] = input.baseUrl;
+    config.apiKeys[id] = input.apiKey;
+    return id;
+}
+/**
+ * Changes the name, the address or the key of a saved provider. When it is the provider in use,
+ * the settings of the running session follow at once.
+ */
+export function updateCustomProvider(config, id, patch) {
+    const own = customProviders(config)[id];
+    if (!own)
+        return false;
+    ensureMaps(config);
+    if (patch.name !== undefined)
+        config.customProviders[id] = { ...config.customProviders[id], name: patch.name.trim() };
+    if (patch.baseUrl !== undefined) {
+        config.customProviders[id] = { ...config.customProviders[id], baseUrl: patch.baseUrl };
+        config.baseUrls[id] = patch.baseUrl;
+        if (config.provider === id)
+            config.baseUrl = patch.baseUrl;
+    }
+    if (patch.apiKey !== undefined) {
+        config.apiKeys[id] = patch.apiKey;
+        if (config.provider === id)
+            config.apiKey = patch.apiKey;
+    }
+    return true;
+}
+/**
+ * Forgets a saved provider with its key. The provider in use keeps working until another is chosen
+ * (its address and key stay in the running settings) but it is no longer a provider of the list:
+ * the config forgets its id, so that saving does not write the key and the address back;
+ * `wasActive` tells the caller to say so.
+ */
+export function removeCustomProvider(config, id) {
+    if (!customProviders(config)[id])
+        return { removed: false, wasActive: false };
+    const rest = { ...config.customProviders };
+    delete rest[id];
+    config.customProviders = rest;
+    if (config.apiKeys)
+        delete config.apiKeys[id];
+    if (config.baseUrls)
+        delete config.baseUrls[id];
+    const wasActive = config.provider === id;
+    if (wasActive)
+        delete config.provider;
+    return { removed: true, wasActive };
+}

package/dist/core/images.js

@@ -0,0 +1,46 @@
+/**
+ * Images the model can be shown: which files count as images, how big they may be, and a check
+ * that the bytes really are an image. A file the API refuses (a text file named .png, an
+ * oversized photo) would stay in the history and make every following request fail, so it is
+ * checked before it is sent.
+ */
+// Formats the image APIs accept (SVG is text, not an image for a model).
+export const IMAGE_EXTS = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.gif': 'image/gif'
+};
+/** Above this an API usually refuses the image (Anthropic: 5 MB). */
+export const IMAGE_WARN_BYTES = 5 * 1024 * 1024;
+/** Above this the image is not sent at all. */
+export const IMAGE_MAX_BYTES = 20 * 1024 * 1024;
+/** The media type for a file name, when its extension is one of an image. */
+export function imageMimeForPath(file) {
+    const dot = file.lastIndexOf('.');
+    if (dot === -1)
+        return undefined;
+    return IMAGE_EXTS[file.slice(dot).toLowerCase()];
+}
+/** The media type the first bytes say, or undefined when they are not PNG, JPEG, GIF or WebP. */
+export function sniffImageMime(buf) {
+    const at = (i) => buf[i];
+    if (buf.length >= 8 && at(0) === 0x89 && at(1) === 0x50 && at(2) === 0x4e && at(3) === 0x47 && at(4) === 0x0d && at(5) === 0x0a && at(6) === 0x1a && at(7) === 0x0a) {
+        return 'image/png';
+    }
+    if (buf.length >= 3 && at(0) === 0xff && at(1) === 0xd8 && at(2) === 0xff)
+        return 'image/jpeg';
+    if (buf.length >= 6) {
+        const head = String.fromCharCode(at(0), at(1), at(2), at(3), at(4), at(5));
+        if (head === 'GIF87a' || head === 'GIF89a')
+            return 'image/gif';
+    }
+    if (buf.length >= 12) {
+        const riff = String.fromCharCode(at(0), at(1), at(2), at(3));
+        const webp = String.fromCharCode(at(8), at(9), at(10), at(11));
+        if (riff === 'RIFF' && webp === 'WEBP')
+            return 'image/webp';
+    }
+    return undefined;
+}

package/dist/core/local-config.js

@@ -51,9 +51,10 @@ export function applyLocalConfig(target, local, trusted) {
  * Settings that last for one run only and are never written to ~/.devxrc.json.
  *  - `autoApprove` (YOLO): switched on in the settings or with `--yolo`, it is off again the
  *    next time devx starts. A mode that skips confirmations should not stay on by accident.
+ *  - `autoApproveAll` (Extra): YOLO without the safety net, the same.
  *  - `projectMcpTrusted`, `effortOverride`: runtime flags.
  */
-export const SESSION_ONLY_SETTINGS = ['autoApprove', 'projectMcpTrusted', 'effortOverride'];
+export const SESSION_ONLY_SETTINGS = ['autoApprove', 'autoApproveAll', 'projectMcpTrusted', 'effortOverride'];
 /** The config as it goes to disk: without the settings that last for one run only. */
 export function persistedConfig(config) {
     const out = { ...config };
@@ -65,5 +66,6 @@ export function persistedConfig(config) {
 export function withoutSessionOnlySettings(config) {
     const out = { ...config };
     delete out.autoApprove;
+    delete out.autoApproveAll;
     return out;
 }

package/dist/core/locales/de.js

@@ -20,25 +20,23 @@ export const de = {
     'conn.classicRestored': '✓ Verbindung wiederhergestellt! Die Generierung wird fortgesetzt...',
     'stop.connection': 'Verbindung abgebrochen',
     'stop.stopped': 'gestoppt',
-    'stop.interrupted': 'unterbrochen, deine Nachricht wird gesendet',
     'stop.classicConnection': 'Verbindung abgebrochen (Strg+C).',
     'stop.classicStopped': 'Generierung gestoppt (Strg+C).',
-    'stop.classicInterrupted': 'Unterbrochen: deine Nachricht wird gesendet.',
     'status.waiting': 'Warte auf das Modell',
     'status.thinking': 'Denkt nach',
     'status.writing': 'Schreibt',
     'status.running': 'Läuft',
     'status.reconnecting': 'Neuverbindung',
-    'status.stop': 'ctrl+c zum Stoppen',
+    'status.stop': 'esc zum Stoppen',
     'status.thinkingLine': 'denkt nach',
     'status.thoughtFor': 'nachgedacht: {sec} s',
     'composer.placeholder': 'Aufgabe beschreiben oder etwas fragen…',
     'composer.queued': 'in der Warteschlange',
     'composer.queuedMany': '{n} in der Warteschlange',
-    'composer.queuedHint': 'ctrl+enter sendet sofort · ↓ bearbeiten',
-    'composer.hint1': 'enter reiht ein · ctrl+c stoppt',
+    'composer.queuedHint': '↓ bearbeiten',
+    'composer.hint1': 'enter reiht ein · esc stoppt',
     'composer.hint2': 'enter reiht ein',
-    'composer.hint3': 'enter reiht ein · ctrl+c stoppt',
+    'composer.hint3': 'enter reiht ein · esc stoppt',
     'composer.hint4': 'enter reiht ein',
     'summary.toolOne': '{n} Werkzeug',
     'summary.toolMany': '{n} Werkzeuge',
@@ -54,6 +52,7 @@ export const de = {
     'settings.row.layout': 'Oberfläche',
     'settings.row.pureBlack': 'Schwarzer Hintergrund',
     'settings.row.autoApprove': 'Auto-Freigabe (YOLO)',
+    'settings.row.extra': 'Extra (fragt nichts)',
     'settings.row.maxIterations': 'Max. Schritte',
     'settings.row.memory': 'Projektgedächtnis',
     'settings.row.updates': 'Updateprüfung',
@@ -63,6 +62,7 @@ export const de = {
     'settings.short.layout': 'Oberfläche',
     'settings.short.pureBlack': 'Schwarz',
     'settings.short.autoApprove': 'YOLO',
+    'settings.short.extra': 'Extra',
     'settings.short.maxIterations': 'Schritte',
     'settings.short.memory': 'Gedächtnis',
     'settings.short.updates': 'Updates',
@@ -78,12 +78,15 @@ export const de = {
     'settings.hint.layout': 'Schlicht: Eingabe im Rahmen, Karten und ruhige Werkzeugzeilen. Klassisch: das ursprüngliche ASCII-Layout.',
     'settings.hint.pureBlack': 'Setzt den Terminalhintergrund auf tiefes OLED-Schwarz (#0a0a0c). Aus behält deinen eigenen Hintergrund.',
     'settings.hint.autoApprove': 'Überspringt übliche Rückfragen. Gefährliche Befehle und Dateien mit Zugangsdaten fragen weiterhin nach. Gilt nur für diese Sitzung: Beim nächsten Start von devx ist es wieder aus.',
+    'settings.hint.extra': 'Führt JEDEN Befehl ohne Rückfrage aus: auch zerstörerische (rm -rf, sudo, git push --force), heruntergeladene Skripte, das Lesen von Schlüsseln und Geheimnissen, neue MCP-Server. Hier gibt es keine Sandbox. Gilt nur für diese Sitzung.',
     'settings.hint.maxIterations': 'Wie viele Werkzeugschritte (Dateiänderungen, Befehle) der Agent pro Anfrage ausführen darf.',
     'settings.hint.memory': 'Lädt die Regeln aus .devx/memory.md in jede Sitzung.',
     'settings.hint.updates': 'Sucht beim Start auf GitHub nach einer neuen devx-Version. /update funktioniert in jedem Fall.',
     'settings.hint.language': 'Sprache der Oberfläche: Meldungen, Einstellungen und Hinweise. Code und Werkzeugnamen bleiben englisch.',
     'settings.hint.about': 'KI-Coding-Agent für das Terminal von ApvCode. MIT-Lizenz. github.com/apvcode/Termux-Dev',
     'settings.warnYolo': 'An: Der Agent führt Befehle aus und ändert Dateien ohne Rückfrage.',
+    'settings.warnExtra': 'Achtung: nichts wird gefragt. Nur wo alles verloren sein darf.',
+    'settings.extraEnabled': 'Extra ist an: Der Agent führt jeden Befehl ohne Rückfrage aus, auch gefährliche. Beim nächsten Start von devx ist es wieder aus.',
     'settings.keys.move': 'wählen',
     'settings.keys.change': 'ändern',
     'settings.keys.toggle': 'umschalten',
@@ -219,9 +222,35 @@ export const de = {
     'onboard.language.note': 'Du kannst sie später in /settings ändern.',
     'onboard.provider.title': 'anbieter',
     'onboard.provider.placeholder': 'tippen, um einen Anbieter zu finden',
-    'onboard.provider.note': 'Der Dienst, der dir die Modelle liefert. Nicht in der Liste? Wähle eigene Adresse.',
+    'onboard.provider.note': 'Der Dienst, der dir die Modelle gibt. Nicht in der Liste? Füge deinen eigenen mit „Anbieter hinzufügen“ hinzu.',
     'onboard.custom': 'Eigene Adresse',
     'onboard.customDetail': 'Jede OpenAI-kompatible Adresse',
+    'provider.add': 'Anbieter hinzufügen',
+    'provider.addDetail': 'Jede OpenAI- oder Anthropic-kompatible Adresse',
+    'provider.customTag': 'eigen',
+    'provider.new': 'neuer Anbieter',
+    'provider.name.label': 'Name des Anbieters',
+    'provider.name.placeholder': 'Mein Gateway',
+    'provider.name.empty': 'Gib einen Namen ein.',
+    'provider.name.long': 'Der Name ist zu lang (höchstens 40 Zeichen).',
+    'provider.name.taken': 'Ein Anbieter mit diesem Namen gibt es schon.',
+    'provider.url.note': 'Die Adresse bis /chat/completions oder /messages, zum Beispiel https://api.example.com/v1.',
+    'provider.url.invalid': 'Das ist keine Adresse. Beispiel: https://api.example.com/v1',
+    'provider.url.scheme': 'Die Adresse muss mit http:// oder https:// beginnen.',
+    'provider.key.none': 'Kein Schlüssel nötig',
+    'provider.key.noneDetail': 'Ein Server auf diesem Rechner oder in diesem Netz',
+    'provider.key.enter': 'Schlüssel eingeben',
+    'provider.menu.use': 'Diesen Anbieter verwenden',
+    'provider.menu.rename': 'Namen ändern',
+    'provider.menu.url': 'Adresse ändern',
+    'provider.menu.key': 'Schlüssel ändern',
+    'provider.menu.delete': 'Löschen',
+    'provider.menu.deleteDetail': 'Entfernt ihn samt Schlüssel',
+    'provider.delete.question': 'Anbieter {name} und seinen Schlüssel löschen?',
+    'provider.delete.active': 'Das ist der aktuelle Anbieter: Er arbeitet weiter, bis du einen anderen wählst.',
+    'provider.saved': 'Anbieter {name} gespeichert',
+    'provider.updated': 'Anbieter {name} aktualisiert',
+    'provider.deleted': 'Anbieter {name} gelöscht',
     'onboard.baseUrl.title': 'adresse',
     'onboard.baseUrl.label': 'Basis-URL der API',
     'onboard.baseUrl.placeholder': 'https://api.example.com/v1',