termux-dev 1.6.0 → 1.8.0

package/dist/core/reasoning.js

@@ -0,0 +1,393 @@
+/**
+ * Reasoning ("thinking") effort.
+ *
+ * Models differ a lot: OpenAI's o3 has low / medium / high and cannot switch reasoning off,
+ * Claude takes a thinking budget in tokens, Gemini 2.5 Pro cannot be switched off, DeepSeek-R1
+ * always reasons and has no setting at all. And every API wants the value in another
+ * parameter. This module answers two questions:
+ *
+ *   1. What can THIS model do?   -> `resolveReasoning(...).levels` (only these are offered)
+ *   2. How is a level sent?      -> `caps.build(level)` (the request parameters for this API)
+ *
+ * The first answer comes from, in this order: a profile in the config file, what the
+ * endpoint itself reports (OpenRouter-style metadata, Ollama, LiteLLM...), the models.dev
+ * catalogue, and finally rules by model name. The second comes from the route (by base URL).
+ * A model that nothing describes gets no levels instead of a guess.
+ */
+export const LEVELS = ['off', 'low', 'normal', 'high', 'xhigh', 'max'];
+export const isLevel = (value) => typeof value === 'string' && LEVELS.includes(value);
+// ───────────────────────── routes ─────────────────────────
+export function detectRoute(baseUrl = '') {
+    let host = baseUrl.toLowerCase();
+    try {
+        host = new URL(baseUrl).hostname.toLowerCase();
+    }
+    catch { }
+    if (host.endsWith('openrouter.ai'))
+        return 'openrouter';
+    if (host === 'api.openai.com')
+        return 'openai';
+    if (host === 'api.anthropic.com')
+        return 'anthropic';
+    if (host.endsWith('generativelanguage.googleapis.com'))
+        return 'google';
+    if (host.endsWith('aliyuncs.com'))
+        return 'dashscope';
+    if (host === 'api.z.ai' || host.endsWith('bigmodel.cn'))
+        return 'zai';
+    if (host.endsWith('deepseek.com'))
+        return 'deepseek';
+    return 'generic';
+}
+const ALWAYS_ON = [
+    /^deepseek-reasoner/, /^deepseek-r1/, /^r1-/, /-r1(-|$)/, /^qwq/, /^magistral/, /thinking(-\d+)?$/,
+    /^kimi-k2-thinking/, /^minimax-m2/, /^glm-z1/, /^sonar-reasoning/, /^grok-4/,
+];
+const OPENAI_EFFORT = { low: 'low', normal: 'medium', high: 'high' };
+function normalizeModel(model) {
+    const parts = model.toLowerCase().trim().split('/');
+    const name = (parts[parts.length - 1] || '').replace(/:.*$/, '');
+    return { vendor: parts.length > 1 ? parts[parts.length - 2] : '', name };
+}
+function familyFor(name) {
+    // Specific families first, the "always on" list last-but-one so that e.g. grok-3-mini wins over grok-4.
+    if (/^gpt-oss/.test(name)) {
+        return { id: 'gpt-oss', kind: 'effort', levels: ['low', 'normal', 'high'], confidence: 'known', effort: OPENAI_EFFORT };
+    }
+    if (/^o[1345](-mini|-pro|-preview)?(-\d{4}-\d{2}-\d{2})?$/.test(name) && !/^o1-(mini|preview)/.test(name)) {
+        if (/-pro/.test(name))
+            return { id: 'openai-o-pro', kind: 'effort', levels: ['high'], confidence: 'known', effort: { high: 'high' } };
+        return { id: 'openai-o', kind: 'effort', levels: ['low', 'normal', 'high'], confidence: 'known', effort: OPENAI_EFFORT };
+    }
+    const gpt5 = name.match(/^gpt-5(?:\.(\d+))?/);
+    if (gpt5) {
+        if (/chat/.test(name))
+            return null; // gpt-5-chat does not reason
+        const minor = gpt5[1] ? parseInt(gpt5[1], 10) : 0;
+        if (/-pro/.test(name))
+            return { id: 'gpt-5-pro', kind: 'effort', levels: ['high'], confidence: 'known', effort: { high: 'high' } };
+        const levels = ['off', 'low', 'normal', 'high'];
+        const effort = {
+            // gpt-5 itself cannot be switched off, "minimal" is the closest; 5.1 and later accept "none"
+            off: minor === 0 ? 'minimal' : 'none', low: 'low', normal: 'medium', high: 'high',
+        };
+        if (minor >= 2 || /codex-max/.test(name)) {
+            levels.push('xhigh');
+            effort.xhigh = 'xhigh';
+        }
+        return { id: minor === 0 ? 'gpt-5' : `gpt-5.${minor}`, kind: 'effort', levels, confidence: minor <= 2 ? 'known' : 'guess', effort };
+    }
+    if (/^grok-3-mini/.test(name)) {
+        return { id: 'grok-3-mini', kind: 'effort', levels: ['low', 'high'], confidence: 'known', effort: { low: 'low', high: 'high' } };
+    }
+    if (/^claude-/.test(name) && /claude-(3[-.]7|(opus|sonnet|haiku)-[4-9]|[4-9])/.test(name)) {
+        // Opus 4 / 4.1 can write at most 32k tokens, newer models 64k: that bounds the thinking budget.
+        const smallOutput = /opus-4(?![.-]?[5-9])/.test(name);
+        const levels = smallOutput ? ['off', 'low', 'normal', 'high', 'xhigh'] : ['off', 'low', 'normal', 'high', 'xhigh', 'max'];
+        return {
+            id: 'claude', kind: 'budget', levels, confidence: 'known',
+            budgets: { low: 2048, normal: 6144, high: 16000, xhigh: smallOutput ? 24000 : 32000, max: 63000 },
+        };
+    }
+    if (/^gemini-2\.5-pro/.test(name)) {
+        return {
+            id: 'gemini-2.5-pro', kind: 'budget', levels: ['low', 'normal', 'high', 'max'], confidence: 'known', defaultOn: true,
+            budgets: { low: 1024, normal: 8192, high: 24576, max: 32768 },
+        };
+    }
+    if (/^gemini-2\.5-flash/.test(name)) {
+        return {
+            id: 'gemini-2.5-flash', kind: 'budget', levels: ['off', 'low', 'normal', 'high', 'max'], confidence: 'known', defaultOn: true,
+            budgets: { off: 0, low: 1024, normal: 8192, high: 16384, max: 24576 },
+        };
+    }
+    if (/^gemini-3/.test(name)) {
+        return { id: 'gemini-3', kind: 'effort', levels: ['low', 'high'], confidence: 'guess', effort: { low: 'low', high: 'high' } };
+    }
+    if (/^qwen3/.test(name) && !/(thinking|instruct|coder)/.test(name)) {
+        return {
+            id: 'qwen3', kind: 'budget', levels: ['off', 'low', 'normal', 'high', 'max'], confidence: 'known', defaultOn: true,
+            budgets: { low: 1024, normal: 4096, high: 16384, max: 38912 },
+        };
+    }
+    if (/^deepseek-(v3\.[1-9]|v[4-9]|chat-v3\.[1-9])/.test(name)) {
+        return { id: 'deepseek-hybrid', kind: 'toggle', levels: ['off', 'normal'], confidence: 'guess' };
+    }
+    if (/^glm-(4\.[5-9]|[5-9])/.test(name)) {
+        return { id: 'glm', kind: 'toggle', levels: ['off', 'normal'], confidence: 'guess' };
+    }
+    if (ALWAYS_ON.some((re) => re.test(name)))
+        return 'always-on';
+    return null;
+}
+// ───────────────────────── wiring a level into a request ─────────────────────────
+const kTokens = (n) => (n >= 1000 ? `${Math.round(n / 1000)}k` : `${n}`);
+const LEVEL_MEANING = {
+    off: 'no reasoning',
+    low: 'light reasoning',
+    normal: 'balanced',
+    high: 'deep reasoning',
+    xhigh: 'very deep reasoning',
+    max: 'maximum reasoning',
+};
+function adapt(family, route, source) {
+    const caps = (levels, confidence, note, build, detail) => ({
+        family: family.id,
+        route,
+        supported: levels.length > 0,
+        levels,
+        confidence,
+        alwaysOn: !levels.includes('off'),
+        source,
+        note,
+        build,
+        describe: (l) => `${LEVEL_MEANING[l]}${detail(l) ? ` (${detail(l)})` : ''}`,
+    });
+    // ── effort families: a named effort per level
+    if (family.kind === 'effort') {
+        const effort = family.effort ?? {};
+        const param = (level) => {
+            const value = effort[level];
+            if (value === undefined)
+                return null;
+            return route === 'openrouter' ? { reasoning: { effort: value } } : { reasoning_effort: value };
+        };
+        return caps(family.levels, family.confidence, route === 'openrouter' ? 'Sent as reasoning.effort (OpenRouter).' : 'Sent as reasoning_effort.', param, (l) => `effort: ${effort[l]}`);
+    }
+    // ── toggle families: thinking on or off
+    if (family.kind === 'toggle') {
+        const on = (level) => level !== 'off';
+        if (route === 'openrouter') {
+            return caps(family.levels, family.confidence, 'Sent as reasoning.enabled (OpenRouter).', (l) => ({ reasoning: { enabled: on(l) } }), () => '');
+        }
+        if (route === 'zai' || route === 'deepseek') {
+            return caps(family.levels, 'guess', 'Sent as thinking.type.', (l) => ({ thinking: { type: on(l) ? 'enabled' : 'disabled' } }), () => '');
+        }
+        return caps(family.levels, 'guess', 'Sent as reasoning_effort; devx retries without it if the endpoint rejects it.', (l) => ({ reasoning_effort: on(l) ? 'medium' : 'none' }), () => '');
+    }
+    // ── budget families: a number of thinking tokens
+    const budgets = family.budgets ?? {};
+    const budgetOf = (l) => budgets[l] ?? 0;
+    const detail = (l) => (l === 'off' ? '' : `~${kTokens(budgetOf(l))} thinking tokens`);
+    if (route === 'anthropic') {
+        return caps(family.levels, 'known', 'Sent as thinking.budget_tokens (Anthropic).', (l) => l === 'off' ? null : { thinking: { type: 'enabled', budget_tokens: budgetOf(l) }, max_tokens: budgetOf(l) + 16000 }, detail);
+    }
+    if (route === 'openrouter') {
+        return caps(family.levels, 'known', 'Sent as reasoning.max_tokens (OpenRouter).', (l) => {
+            if (l === 'off')
+                return family.defaultOn ? { reasoning: { enabled: false } } : null;
+            return { reasoning: { max_tokens: budgetOf(l) } };
+        }, detail);
+    }
+    if (route === 'google') {
+        return caps(family.levels, 'known', 'Sent as google.thinking_config.thinking_budget.', (l) => ({
+            extra_body: { google: { thinking_config: { thinking_budget: budgetOf(l), include_thoughts: true } } },
+        }), detail);
+    }
+    if (route === 'dashscope') {
+        return caps(family.levels, 'known', 'Sent as enable_thinking / thinking_budget (DashScope).', (l) => l === 'off' ? { enable_thinking: false } : { enable_thinking: true, thinking_budget: budgetOf(l) }, detail);
+    }
+    // Any other endpoint: only the widely understood reasoning_effort, with three coarse steps.
+    const generic = family.levels.filter((l) => l === 'low' || l === 'normal' || l === 'high' || l === 'off');
+    const mapping = { off: 'none', low: 'low', normal: 'medium', high: 'high' };
+    return caps(generic, 'guess', 'Sent as reasoning_effort; devx retries without it if the endpoint rejects it.', (l) => (mapping[l] ? { reasoning_effort: mapping[l] } : null), (l) => `effort: ${mapping[l]}`);
+}
+const NONE = (route, family, note, alwaysOn, source = 'none') => ({
+    supported: false, levels: [], family, route, confidence: 'none', alwaysOn, source, note,
+    build: () => null,
+    describe: () => '',
+});
+function fromProfile(profile, route) {
+    const levels = LEVELS.filter((l) => profile.levels.includes(l));
+    return {
+        supported: levels.length > 0,
+        levels,
+        family: 'custom',
+        route,
+        confidence: 'custom',
+        alwaysOn: !levels.includes('off'),
+        source: 'profile',
+        note: `From your config (reasoningProfiles): ${profile.param}.`,
+        build: (level) => {
+            const value = profile.values[level];
+            if (value === undefined)
+                return null;
+            const path = profile.param.split('.');
+            return path.reduceRight((inner, key) => ({ [key]: inner }), value);
+        },
+        describe: (l) => `${LEVEL_MEANING[l]} (${profile.param}: ${String(profile.values[l])})`,
+    };
+}
+// ───────────────────────── from source data to a family ─────────────────────────
+const without = (family, level) => ({
+    ...family,
+    levels: family.levels.filter((l) => l !== level),
+});
+/** Effort values of an API -> our levels. "minimal" stands in for "off" where nothing is lower. */
+function effortFamily(efforts) {
+    const has = (e) => efforts.includes(e);
+    const effort = {};
+    if (has('none'))
+        effort.off = 'none';
+    else if (has('minimal'))
+        effort.off = 'minimal';
+    if (has('low'))
+        effort.low = 'low';
+    if (has('medium'))
+        effort.normal = 'medium';
+    if (has('high'))
+        effort.high = 'high';
+    if (has('xhigh'))
+        effort.xhigh = 'xhigh';
+    if (has('max'))
+        effort.max = 'max';
+    const levels = LEVELS.filter((l) => effort[l] !== undefined);
+    return levels.length > 0 ? { id: 'catalog-effort', kind: 'effort', levels, confidence: 'known', effort } : null;
+}
+/** A token budget range -> five budgets, each clamped into the range the source allows. */
+function budgetFamily(budget, toggle, mandatory) {
+    const min = Math.max(0, budget.min ?? 0);
+    const max = budget.max && budget.max > 0 ? budget.max : 32768;
+    const clamp = (n) => Math.min(max, Math.max(min || 1, n));
+    const wanted = [
+        ['low', 2048], ['normal', 8192], ['high', 16384], ['xhigh', 24576], ['max', max],
+    ];
+    const budgets = {};
+    const levels = [];
+    const seen = new Set();
+    for (const [level, value] of wanted) {
+        const v = clamp(value);
+        if (seen.has(v))
+            continue; // two levels with the same budget would be one choice
+        seen.add(v);
+        budgets[level] = v;
+        levels.push(level);
+    }
+    if (!mandatory && (toggle || min === 0)) {
+        budgets.off = 0;
+        levels.unshift('off');
+    }
+    return { id: 'catalog-budget', kind: 'budget', levels, confidence: 'known', budgets, defaultOn: true };
+}
+/**
+ * Turns what a source reports into a family. The source is authoritative for effort values
+ * (they change with every model generation); for budgets and toggles the hand-written rule
+ * is kept when there is one, because it knows vendor limits that sources leave out.
+ */
+function familyFromData(data, rule) {
+    const efforts = data.efforts ?? [];
+    const hasEffort = efforts.length > 0;
+    const hasBudget = !!data.budget;
+    const mandatory = data.mandatory === true;
+    const ruleKept = (f) => (mandatory ? without(f, 'off') : f);
+    if (hasEffort && !hasBudget)
+        return effortFamily(efforts);
+    if (hasBudget)
+        return rule && rule.kind === 'budget' ? ruleKept(rule) : budgetFamily(data.budget, !!data.toggle, mandatory);
+    // Only "it can be switched" or "it reasons", without details.
+    if (rule)
+        return ruleKept(rule);
+    if (data.toggle)
+        return { id: 'catalog-toggle', kind: 'toggle', levels: mandatory ? ['normal'] : ['off', 'normal'], confidence: 'known' };
+    const levels = mandatory ? ['low', 'normal', 'high'] : ['off', 'low', 'normal', 'high'];
+    return {
+        id: 'generic-effort', kind: 'effort', levels, confidence: 'guess',
+        effort: { off: 'none', low: 'low', normal: 'medium', high: 'high' },
+    };
+}
+const SOURCE_NAME = {
+    endpoint: 'The endpoint',
+    catalog: 'The models.dev catalogue',
+};
+/**
+ * What a model can do, and how it is sent over this route.
+ *
+ * @param data what the endpoint or the catalogue reports for this model (optional)
+ */
+export function resolveReasoning(model, baseUrl = '', profiles, data, 
+/** The wire format decides the route when it is not the one the host name suggests (Anthropic format on a gateway). */
+routeOverride) {
+    const route = routeOverride ?? detectRoute(baseUrl);
+    const profile = profiles?.[model.toLowerCase().trim()] ?? profiles?.[model];
+    if (profile && Array.isArray(profile.levels) && typeof profile.param === 'string' && profile.values) {
+        return fromProfile(profile, route);
+    }
+    const { name } = normalizeModel(model);
+    const found = familyFor(name);
+    const rule = found && found !== 'always-on' ? found : null;
+    if (data) {
+        if (data.none) {
+            return NONE(route, 'none-by-source', `${SOURCE_NAME[data.source]} reports that this model has no reasoning mode.`, false, data.source);
+        }
+        const family = familyFromData(data, rule);
+        if (family)
+            return adapt(family, route, data.source);
+    }
+    if (found === 'always-on') {
+        return NONE(route, 'always-on', 'This model always reasons and has no setting.', true, 'rules');
+    }
+    if (!found) {
+        return NONE(route, 'unknown', 'No reasoning setting is known for this model.', false);
+    }
+    return adapt(found, route, 'rules');
+}
+let dataLookup = null;
+/** Registers where the endpoint / catalogue data comes from (see capabilities.ts). */
+export function setReasoningDataLookup(lookup) {
+    dataLookup = lookup;
+}
+let routeResolver = null;
+/** Registers what decides the route besides the host name (see formats.ts). */
+export function setRouteResolver(resolver) {
+    routeResolver = resolver;
+}
+export function modelKey(model) {
+    return (model || '').toLowerCase().trim();
+}
+/**
+ * The level that applies to the current model: the saved choice, or the one-off override,
+ * but only if this model still offers it (switching models never sends a stale setting).
+ */
+export function effectiveReasoning(config, lookup = dataLookup) {
+    const data = lookup ? lookup(config) : undefined;
+    const caps = resolveReasoning(config.model || '', config.baseUrl || '', config.reasoningProfiles, data, routeResolver?.(config));
+    const raw = config.effortOverride ?? config.effort?.[modelKey(config.model)];
+    const level = isLevel(raw) && caps.supported && caps.levels.includes(raw) ? raw : undefined;
+    return { caps, level, params: level ? caps.build(level) : null };
+}
+/** Parses what the user typed after /effort. Accepts a few natural aliases. */
+export function parseEffortArg(arg) {
+    const text = arg.trim().toLowerCase();
+    if (['auto', 'default', 'reset', 'clear'].includes(text))
+        return { kind: 'auto' };
+    const aliases = {
+        off: 'off', none: 'off', no: 'off', disable: 'off', disabled: 'off', '0': 'off',
+        low: 'low', min: 'low', minimal: 'low', light: 'low',
+        normal: 'normal', medium: 'normal', med: 'normal', mid: 'normal',
+        high: 'high', hi: 'high',
+        xhigh: 'xhigh', 'x-high': 'xhigh', extra: 'xhigh', 'extra-high': 'xhigh',
+        max: 'max', maximum: 'max', ultra: 'max',
+    };
+    return aliases[text] ? { kind: 'level', level: aliases[text] } : { kind: 'invalid', text };
+}
+/** Stores (or clears, with null) the choice for a model. Returns a new effort map. */
+export function withEffort(effort, model, level) {
+    const next = { ...(effort || {}) };
+    if (level === null)
+        delete next[modelKey(model)];
+    else
+        next[modelKey(model)] = level;
+    return next;
+}
+/** Short label for the status line: "high", or nothing for the model default. */
+export function effortLabel(config) {
+    return effectiveReasoning(config).level ?? '';
+}
+/**
+ * What the status line says about reasoning next to the model name: "think high", "think auto"
+ * (the model's own default) or nothing when the model has no reasoning setting.
+ */
+export function thinkLabel(config) {
+    const { caps, level } = effectiveReasoning(config);
+    return caps.supported ? `think ${level ?? 'auto'}` : '';
+}

package/dist/core/redact.js

@@ -0,0 +1,41 @@
+/**
+ * Hides secrets in the output of a tool before it reaches the model, the chat and the saved
+ * session: API keys, tokens and private keys that show up in a file, in `env` or in a log.
+ * It works on well-known shapes; a secret of an unknown shape can still get through, which is why
+ * reading credential files is also asked about (see the permission guard).
+ */
+const HIDDEN = '[hidden secret]';
+/** Keeps the first characters of a token (enough to recognise which key it is), hides the rest. */
+const keepHead = (value, keep) => `${value.slice(0, keep)}…${HIDDEN}`;
+const PATTERNS = [
+    // Private key blocks
+    { re: /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z0-9 ]*PRIVATE KEY-----|$)/g, replace: () => `[hidden private key]` },
+    // sk-..., sk-or-v1-..., sk-ant-... (OpenAI, OpenRouter, Anthropic and compatible gateways)
+    { re: /\bsk-[A-Za-z0-9][A-Za-z0-9_\-]{15,}/g, replace: (m) => keepHead(m, 5) },
+    // GitHub tokens
+    { re: /\b(?:gh[pousr]_[A-Za-z0-9]{30,}|github_pat_[A-Za-z0-9_]{30,})/g, replace: (m) => keepHead(m, 4) },
+    // Slack tokens
+    { re: /\bxox[abprs]-[A-Za-z0-9-]{10,}/g, replace: (m) => keepHead(m, 5) },
+    // AWS access key ids, Google API keys
+    { re: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g, replace: (m) => keepHead(m, 4) },
+    { re: /\bAIza[0-9A-Za-z_\-]{35}\b/g, replace: (m) => keepHead(m, 4) },
+    // Authorization headers
+    { re: /\b(Bearer|Basic)\s+[A-Za-z0-9._~+\/=\-]{16,}/g, replace: (_m, scheme) => `${scheme} ${HIDDEN}` },
+    // "apiKey": "value" and api_key=value style assignments (the name is kept, the value is hidden)
+    {
+        re: /((?:["']?)(?:api[_-]?key|apikey|secret|client[_-]?secret|access[_-]?token|auth[_-]?token|token|password|passwd)(?:["']?)\s*[:=]\s*["']?)([^\s"',}\]]{8,})(["']?)/gi,
+        replace: (_m, head, _value, tail) => `${head}${HIDDEN}${tail}`,
+    },
+];
+export function redactSecrets(text) {
+    if (!text || typeof text !== 'string')
+        return text;
+    let out = text;
+    for (const { re, replace } of PATTERNS)
+        out = out.replace(re, replace);
+    return out;
+}
+/** Whether a text holds something that looks like a secret (for tests and notices). */
+export function containsSecret(text) {
+    return redactSecrets(text) !== text;
+}

package/dist/core/secure-file.js

@@ -0,0 +1,22 @@
+import fs from 'fs/promises';
+/**
+ * Writes a file that may contain secrets (API keys, conversation transcripts).
+ * New files are created with mode 0600 and existing files are tightened to 0600,
+ * so credentials are never left readable by other local users.
+ * On platforms without POSIX permissions (Windows) the chmod is a harmless no-op.
+ */
+export async function writeSecureFile(filePath, data) {
+    await fs.writeFile(filePath, data, { encoding: 'utf8', mode: 0o600 });
+    try {
+        await fs.chmod(filePath, 0o600);
+    }
+    catch { }
+}
+/** Creates a private (0700) directory, tightening it if it already exists. */
+export async function ensureSecureDir(dirPath) {
+    await fs.mkdir(dirPath, { recursive: true, mode: 0o700 });
+    try {
+        await fs.chmod(dirPath, 0o700);
+    }
+    catch { }
+}

package/dist/core/session.js

@@ -2,6 +2,7 @@ import fs from 'fs/promises';
 import fsSync from 'fs';
 import path from 'path';
 import os from 'os';
+import { ensureSecureDir, writeSecureFile } from './secure-file.js';
 const SESSIONS_DIR = path.join(os.homedir(), '.devx', 'sessions');
 export class SessionManager {
     currentSession;
@@ -22,6 +23,14 @@ export class SessionManager {
             totalCost: 0
         };
     }
+    /** Names the chat (after the model made a title) and keeps it from being renamed by the first message again. */
+    setTitle(title) {
+        this.currentSession.title = title;
+        this.currentSession.titleGenerated = true;
+    }
+    get hasGeneratedTitle() {
+        return this.currentSession.titleGenerated === true;
+    }
     getSession() {
         return this.currentSession;
     }
@@ -29,12 +38,14 @@ export class SessionManager {
         this.currentSession = this.createEmptySession(model, planMode);
         return this.currentSession;
     }
-    async save(messages, totalCost, model, planMode) {
-        if (!fsSync.existsSync(SESSIONS_DIR)) {
-            await fs.mkdir(SESSIONS_DIR, { recursive: true });
-        }
+    async save(messages, totalCost, model, planMode, costEstimated) {
+        // Transcripts contain file contents and pasted images: keep them private to the user.
+        await ensureSecureDir(path.dirname(SESSIONS_DIR));
+        await ensureSecureDir(SESSIONS_DIR);
         this.currentSession.messages = messages;
         this.currentSession.totalCost = totalCost;
+        if (costEstimated !== undefined)
+            this.currentSession.costEstimated = costEstimated;
         this.currentSession.updatedAt = Date.now();
         if (model)
             this.currentSession.model = model;
@@ -51,7 +62,7 @@ export class SessionManager {
             }
         }
         const filePath = path.join(SESSIONS_DIR, `${this.currentSession.id}.json`);
-        await fs.writeFile(filePath, JSON.stringify(this.currentSession, null, 2), 'utf8');
+        await writeSecureFile(filePath, JSON.stringify(this.currentSession, null, 2));
     }
     static async listSessions() {
         if (!fsSync.existsSync(SESSIONS_DIR)) {

package/dist/core/snapshot.js

@@ -1,6 +1,13 @@
 import fs from 'fs/promises';
 import fsSync from 'fs';
 import path from 'path';
+/**
+ * Remembers the original state of every file changed through the file tools
+ * (write_file / edit_file) during a turn so that /undo can restore it.
+ *
+ * Limitations: snapshots live in memory only, and changes made by shell commands
+ * (the bash tool) are NOT tracked.
+ */
 export class SnapshotManager {
     history = [];
     currentTurn = null;
@@ -21,7 +28,7 @@ export class SnapshotManager {
         }
         try {
             if (fsSync.existsSync(resolved)) {
-                const content = await fs.readFile(resolved, 'utf8');
+                const content = await fs.readFile(resolved);
                 this.currentTurn.files.set(resolved, {
                     filePath: resolved,
                     existed: true,
@@ -60,7 +67,7 @@ export class SnapshotManager {
                     if (!fsSync.existsSync(parentDir)) {
                         await fs.mkdir(parentDir, { recursive: true });
                     }
-                    await fs.writeFile(filePath, snap.content, 'utf8');
+                    await fs.writeFile(filePath, snap.content);
                     revertedFiles.push(relPath);
                 }
                 else {
@@ -80,5 +87,10 @@ export class SnapshotManager {
     getUndoCount() {
         return this.history.length;
     }
+    /** Forgets every snapshot (a new session cannot undo the edits of the previous one). */
+    reset() {
+        this.history = [];
+        this.currentTurn = null;
+    }
 }
 export const globalSnapshotManager = new SnapshotManager();

package/dist/core/title.js

@@ -0,0 +1,61 @@
+/**
+ * The name of a chat: a few words made by the model from the first exchange, shown in the title of
+ * the terminal window and in the list of saved sessions. Everything here is a pure function except
+ * the one call to the model, which is given in (`chat`) so that it can be tested.
+ */
+export const TITLE_SYMBOL = '◈';
+export const BASE_TITLE = 'devx';
+const MAX_TITLE_CHARS = 40;
+/** What the model is asked: a short title in the language of the user, nothing else. */
+export const TITLE_SYSTEM_PROMPT = 'You name chats. Write a title of 2 to 5 words for the conversation below, in the language the user writes in. ' +
+    'No quotes, no trailing punctuation, no prefix such as "Title:". Output only the title.';
+/** Cleans what the model returned: one line, no quotes or markup, short. Empty when nothing usable is left. */
+export function cleanTitle(raw) {
+    let title = String(raw ?? '')
+        .replace(/<think>[\s\S]*?<\/think>/gi, '')
+        .split('\n')
+        .map((l) => l.trim())
+        .find((l) => l.length > 0) ?? '';
+    title = title
+        .replace(/^(?:title|название|заголовок)\s*[:：-]\s*/i, '')
+        .replace(/^[\s"'`«»“”„*#_>\-]+|[\s"'`«»“”„*_.:;!?…]+$/g, '')
+        .replace(/\s+/g, ' ');
+    if (Array.from(title).length > MAX_TITLE_CHARS) {
+        const cut = Array.from(title).slice(0, MAX_TITLE_CHARS).join('');
+        title = cut.replace(/\s+\S*$/, '') || cut;
+        title = title.replace(/[\s,;:.\-]+$/, '');
+    }
+    return title;
+}
+/** A stand-in until the model has named the chat: the start of the first message. */
+export function provisionalTitle(firstUserMessage) {
+    return cleanTitle(firstUserMessage.replace(/\s+/g, ' ').slice(0, 80));
+}
+/** Asks the model for the name. Never throws: on a failure or a timeout the answer is ''. */
+export async function generateChatTitle(provider, firstUser, firstReply, timeoutMs = 20000) {
+    const sample = `User: ${firstUser.slice(0, 600)}\n\nAssistant: ${firstReply.slice(0, 600)}`;
+    try {
+        const answer = await Promise.race([
+            provider.chat({
+                messages: [
+                    { role: 'system', content: TITLE_SYSTEM_PROMPT },
+                    { role: 'user', content: sample },
+                ],
+            }),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), timeoutMs).unref?.()),
+        ]);
+        return cleanTitle(answer.content);
+    }
+    catch {
+        return '';
+    }
+}
+// ───────────────────────── terminal window title ─────────────────────────
+/** The escape sequence that sets the title of the terminal window (OSC 0): `◈ Short title`. */
+export function terminalTitleSequence(title) {
+    const clean = title.replace(/[\x00-\x1f\x7f]/g, ' ').replace(/\s+/g, ' ').trim();
+    return `\x1b]0;${clean ? `${TITLE_SYMBOL} ${clean}` : BASE_TITLE}\x07`;
+}
+/** Remembers the title the terminal had (xterm title stack, also kitty, foot, wezterm), to give it back at exit. */
+export const SAVE_TERMINAL_TITLE = '\x1b[22;0t';
+export const RESTORE_TERMINAL_TITLE = '\x1b[23;0t';

package/dist/core/types.js

@@ -1 +1 @@
-export const DEVX_VERSION = '1.6.0';
+export const DEVX_VERSION = '1.8.0';