talos-code 0.0.1 → 0.2.0

package/dist/config/load.js

@@ -0,0 +1,382 @@
+import { mkdir, open, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { projectId } from "../paths.js";
+import { CREDENTIAL_STORES, CURRENT_UI_THEMES, DEFAULT_CONFIG, MODEL_WINDOW_MAX, MODEL_WINDOW_MIN, REASONING_EFFORTS, UI_BUSY_INPUTS, UI_EXIT_OUTPUTS, UI_REASONING_MODES } from "./types.js";
+import { CURRENT_CONFIG_VERSION, migrateConfigValue } from "./migrations.js";
+const ALLOWED = new Set(['version', 'model', 'reasoningEffort', 'permissionMode', 'outputFormat', 'updateChannel', 'providerRuntime', 'permissions', 'ui', 'extensions', 'credentials', 'models', 'catalog']); /* R5b: catalog.modelsDev */
+/*
+ * R5a lane R (Q-R5-3): `models` holds a person's override of a model's window, keyed `provider:model` (a bare OpenRouter id
+ * has no prefix). Each value is an object with `contextWindow` and optionally `maxOutputTokens`, whole numbers between
+ * MODEL_WINDOW_MIN and MODEL_WINDOW_MAX, the output below the window. Anything else is refused by name: a window typed as
+ * "128k", a negative or a fraction would otherwise switch the Context Engine on a number nobody meant.
+ */
+const MODEL_KEY = /^[A-Za-z0-9][A-Za-z0-9._\-/:@+]{0,255}$/u;
+function validModelTokens(value) { return Number.isSafeInteger(value) && Number(value) >= MODEL_WINDOW_MIN && Number(value) <= MODEL_WINDOW_MAX; }
+function validateModels(models) {
+    if (!isObj(models))
+        throw new Error('CONFIG_INVALID_MODELS');
+    for (const [id, row] of Object.entries(models)) {
+        if (!MODEL_KEY.test(id) || !isObj(row) || Object.keys(row).some(key => key !== 'contextWindow' && key !== 'maxOutputTokens'))
+            throw new Error('CONFIG_INVALID_MODELS');
+        if (row.contextWindow !== undefined && !validModelTokens(row.contextWindow))
+            throw new Error('CONFIG_INVALID_MODEL_WINDOW');
+        if (row.maxOutputTokens !== undefined && (!Number.isSafeInteger(row.maxOutputTokens) || Number(row.maxOutputTokens) < 1 || Number(row.maxOutputTokens) > MODEL_WINDOW_MAX))
+            throw new Error('CONFIG_INVALID_MODEL_WINDOW');
+        if (row.contextWindow !== undefined && row.maxOutputTokens !== undefined && Number(row.maxOutputTokens) >= Number(row.contextWindow))
+            throw new Error('CONFIG_INVALID_MODEL_WINDOW');
+    }
+}
+const SECRET_KEY = /^(?:api[-_]?key|token|secret|password|authorization)$/iu;
+function isObj(x) { return !!x && typeof x === 'object' && !Array.isArray(x); }
+export function assertNoSecrets(value, path = 'config') {
+    if (Array.isArray(value)) {
+        value.forEach((v, i) => assertNoSecrets(v, `${path}[${i}]`));
+        return;
+    }
+    if (!isObj(value))
+        return;
+    for (const [k, v] of Object.entries(value)) {
+        if (SECRET_KEY.test(k))
+            throw new Error(`SECRET_FIELD_FORBIDDEN:${path}.${k}`);
+        assertNoSecrets(v, `${path}.${k}`);
+    }
+}
+function validate(obj) {
+    if (!isObj(obj))
+        throw new Error('CONFIG_INVALID');
+    assertNoSecrets(obj);
+    for (const k of Object.keys(obj))
+        if (!ALLOWED.has(k))
+            throw new Error(`CONFIG_UNKNOWN_KEY:${k}`);
+    const out = structuredClone(obj);
+    if (out.version !== undefined && out.version !== CURRENT_CONFIG_VERSION)
+        throw new Error('CONFIG_VERSION_INVALID');
+    if (out.permissionMode && !['default', 'acceptEdits', 'plan', 'auto', 'dontAsk', 'bypassPermissions'].includes(out.permissionMode))
+        throw new Error('CONFIG_INVALID_PERMISSION_MODE');
+    if (out.outputFormat && !['text', 'json', 'stream-json'].includes(out.outputFormat))
+        throw new Error('CONFIG_INVALID_OUTPUT_FORMAT');
+    if (out.reasoningEffort !== undefined && !REASONING_EFFORTS.includes(out.reasoningEffort))
+        throw new Error('CONFIG_INVALID_REASONING_EFFORT');
+    /* R2 (gate E13): `credentials.store` is `system` or `memory`, nothing else; the key names the store, never holds a secret. */
+    const credentials = out.credentials;
+    if (credentials !== undefined) {
+        if (!isObj(credentials) || Object.keys(credentials).some(key => key !== 'store'))
+            throw new Error('CONFIG_INVALID_CREDENTIALS');
+        if (credentials.store !== undefined && !CREDENTIAL_STORES.includes(credentials.store))
+            throw new Error('CONFIG_INVALID_CREDENTIAL_STORE');
+    }
+    /* R5b: the models.dev switch (catalog.modelsDev, a boolean). */
+    const catalog = out.catalog;
+    if (catalog !== undefined && (!isObj(catalog) || Object.keys(catalog).some(key => key !== 'modelsDev') || (catalog.modelsDev !== undefined && typeof catalog.modelsDev !== 'boolean')))
+        throw new Error('CONFIG_INVALID_CATALOG');
+    const ui = out.ui;
+    if (ui !== undefined) {
+        if (!isObj(ui))
+            throw new Error('CONFIG_INVALID_UI');
+        if (ui.theme !== undefined && (!CURRENT_UI_THEMES.includes(ui.theme)))
+            throw new Error('CONFIG_INVALID_THEME');
+        if (ui.exitOutput !== undefined && !UI_EXIT_OUTPUTS.includes(ui.exitOutput))
+            throw new Error('CONFIG_INVALID_EXIT_OUTPUT');
+        /* R5a lane R (Q-R5-7, Q-R5-9): the busy-input mode and how reasoning is shown. */
+        if (ui.busyInput !== undefined && !UI_BUSY_INPUTS.includes(ui.busyInput))
+            throw new Error('CONFIG_INVALID_BUSY_INPUT');
+        if (ui.reasoning !== undefined && !UI_REASONING_MODES.includes(ui.reasoning))
+            throw new Error('CONFIG_INVALID_REASONING_DISPLAY');
+        /* R5a (owner 2026-09-24): the busy-input tip is shown once per install, then this is true. */
+        if (ui.busyTipSeen !== undefined && typeof ui.busyTipSeen !== 'boolean')
+            throw new Error('CONFIG_INVALID_UI');
+        /* R5b D5 (Q-R5-15): `ui.history.persist` turns the kept prompt history off. */
+        if (ui.history !== undefined && (!isObj(ui.history) || Object.keys(ui.history).some(key => key !== 'persist') || (ui.history.persist !== undefined && typeof ui.history.persist !== 'boolean')))
+            throw new Error('CONFIG_INVALID_UI');
+        const keymap = ui.keymap;
+        if (keymap !== undefined) {
+            if (!isObj(keymap))
+                throw new Error('CONFIG_INVALID_KEYMAP');
+            for (const [id, value] of Object.entries(keymap)) {
+                if (!id || !Array.isArray(value) || !value.every(chord => typeof chord === 'string'))
+                    throw new Error('CONFIG_INVALID_KEYMAP');
+            }
+        }
+    }
+    const models = out.models;
+    if (models !== undefined)
+        validateModels(models);
+    return out;
+}
+async function readJson(file) { try {
+    const parsed = JSON.parse(await readFile(file, 'utf8'));
+    return validate(migrateConfigValue(parsed).value);
+}
+catch (e) {
+    if (e?.code === 'ENOENT')
+        return {};
+    throw e;
+} }
+/*
+ * ⛔ R0 (forensics B row 8, never green since `27d699a2b`): an origin is recorded for the key a layer sets AND for every path beneath
+ *   it, after dropping what an earlier layer recorded beneath it. Before, a subtree that first appeared in a layer (the user's
+ *   `ui.keymap`) recorded only its root, so `talos config origins` reported the user's own keymap overrides as `default`.
+ */
+function recordOrigin(origins, key, value, origin) {
+    for (const known of [...origins.keys()])
+        if (known.startsWith(`${key}.`))
+            origins.delete(known);
+    origins.set(key, origin);
+    if (isObj(value))
+        for (const [k, v] of Object.entries(value))
+            recordOrigin(origins, `${key}.${k}`, v, origin);
+}
+function deepMerge(base, overlay, origin, origins, prefix = '') {
+    const out = { ...base };
+    for (const [k, v] of Object.entries(overlay)) {
+        const key = prefix ? `${prefix}.${k}` : k;
+        if (isObj(v) && isObj(out[k]))
+            out[k] = deepMerge(out[k], v, origin, origins, key);
+        else {
+            out[k] = structuredClone(v);
+            recordOrigin(origins, key, v, origin);
+        }
+    }
+    return out;
+}
+function files(paths, projectRoot) { return { user: join(paths.configRoot, 'config.json'), project: join(projectRoot, '.talos-cli', 'config.json'), projectUser: join(paths.projectOverridesRoot, projectId(projectRoot), 'config.json') }; }
+const PERMISSION_LISTS = ['allow', 'ask', 'deny'];
+/*
+ * B1 slice 23 — EVERY SCOPE ADDS PERMISSION RULES; NO SCOPE REMOVES ONE.
+ *
+ * Measured at 5e05de8e: a list or a `null` in a later file replaced the earlier value, so a project's
+ * `.talos-cli/config.json` setting `permissions.deny` (even to `[]`) switched off the person's own deny rules, a
+ * project-user file written before slice 21 (`deny: []`) switched off the project's, and `permissions: null` became
+ * three empty lists in main.ts. `cat secrets.txt`, denied in the user file, ran.
+ *
+ * Primary source, Claude Code documentation read through Context7 (`/websites/code_claude`) on 2026-09-17: "Arrays
+ * merge across layers; scalars at a higher layer override lower ones" (glossary, Settings layers); "If a tool is
+ * denied at any level, no other level can allow it" (permissions, Settings precedence).
+ *
+ * So `allow`, `ask` and `deny` are each the union of every scope's list, an entry listed twice is kept once, and
+ * each entry keeps every scope that lists it, for `talos config origins`. An absent or `null` value holds no rule and
+ * contributes nothing.
+ * ⛔ A MALFORMED value is not dropped: slice 21 refuses to build the engine on it, by name, because a skipped deny
+ * rule allows what it denied. It is handed on unchanged — a whole `permissions` that is not an object, or one list
+ * that is not a list, the highest-precedence one first — and the engine stops the start. No valid rule is allowed
+ * in its place.
+ * Entries are ordered highest precedence first (project-user, project, user): `locate` in security/persist.ts names
+ * the file of an unreadable entry by its index in the highest-precedence file that defines the list.
+ * Writing a scope (`writeConfigScope`, `replaceConfigScope`, the slice 21 writer) keeps its per-file semantics:
+ * only the reading side merges.
+ */
+function mergePermissions(layers, origins) {
+    const byPrecedence = [...layers].reverse();
+    const entries = { allow: new Map(), ask: new Map(), deny: new Map() };
+    const badList = {};
+    let badListRank = Infinity;
+    let whole = null;
+    for (const [rank, layer] of byPrecedence.entries()) {
+        const permissions = layer.value.permissions;
+        if (permissions === undefined || permissions === null)
+            continue;
+        if (!isObj(permissions)) {
+            whole ??= { value: permissions, origin: layer.origin, rank };
+            continue;
+        }
+        for (const list of PERMISSION_LISTS) {
+            const values = permissions[list];
+            if (values === undefined || values === null)
+                continue;
+            if (!Array.isArray(values)) {
+                if (!badList[list]) {
+                    badList[list] = { value: values, origin: layer.origin };
+                    badListRank = Math.min(badListRank, rank);
+                }
+                continue;
+            }
+            for (const value of values) {
+                const key = typeof value === 'string' ? `rule:${value}` : `json:${JSON.stringify(value)}`;
+                const known = entries[list].get(key);
+                if (!known)
+                    entries[list].set(key, { value: structuredClone(value), origin: layer.origin, scopes: [layer.origin] });
+                else if (!known.scopes.includes(layer.origin))
+                    known.scopes.push(layer.origin);
+            }
+        }
+    }
+    if (whole && whole.rank < badListRank) {
+        recordOrigin(origins, 'permissions', whole.value, whole.origin);
+        return structuredClone(whole.value);
+    }
+    // Keys other than the three lists are not rules; they keep the scalar precedence of every other key.
+    let merged = {};
+    for (const layer of layers) {
+        const permissions = layer.value.permissions;
+        if (!isObj(permissions))
+            continue;
+        merged = deepMerge(merged, Object.fromEntries(Object.entries(permissions).filter(([key]) => !PERMISSION_LISTS.includes(key))), layer.origin, origins, 'permissions');
+    }
+    for (const list of PERMISSION_LISTS) {
+        const bad = badList[list];
+        if (bad) {
+            merged[list] = structuredClone(bad.value);
+            origins.set(`permissions.${list}`, bad.origin);
+            continue;
+        }
+        const kept = [...entries[list].values()];
+        merged[list] = kept.map(entry => structuredClone(entry.value));
+        origins.set(`permissions.${list}`, kept);
+    }
+    return merged;
+}
+/*
+ * B1 slice 23 — A REPOSITORY CANNOT SWITCH THE PERMISSION BOUNDARY OFF.
+ *
+ * Measured at 5e05de8e: `permissionMode: "bypassPermissions"` in a project's `.talos-cli/config.json` was the mode
+ * of every run started in it. That file is part of the repository; the project-user file lives in the person's
+ * profile and keeps its effect, as do the user file and `--permission-mode`.
+ *
+ * Primary source, Claude Code documentation via Context7 (`/websites/code_claude`), 2026-09-17, settings reference,
+ * `permissions.defaultMode`: "`auto` and `bypassPermissions` don't take effect from project or local settings … Before
+ * v2.1.257, `bypassPermissions` took effect from any file." Measured in the Claude Code 2.1.274 binary on this host on
+ * the same day: it writes `settings defaultMode "bypassPermissions" ignored — only policy/user/flag settings may grant
+ * bypass mode (projectSettings and localSettings are repo-controllable)` to its debug log only. TALOS says it where
+ * the person looks (contract of slice 23): main.ts prints it before the screen starts and puts it in a
+ * non-interactive result. The wording follows Claude Code's own "Ignoring 2 permissions.allow entries from
+ * .claude/settings.local.json: …" (errors reference, same Context7 read).
+ *
+ * The value is dropped from the project layer, so the run uses the next scope's value. It is reported only when it
+ * would otherwise have been the effective one: a project-user value or the command line decides regardless.
+ */
+const REPOSITORY_CANNOT_SELECT = new Set(['bypassPermissions', 'auto']);
+function describeOrigin(origin, userFile) { return origin === 'user' ? `the user configuration ${userFile}` : 'the built-in default'; }
+export async function loadEffectiveConfig({ paths, projectRoot, cli = {} }) {
+    const f = files(paths, projectRoot);
+    const origins = new Map();
+    const layers = [
+        { origin: 'default', file: null, value: structuredClone(DEFAULT_CONFIG) },
+        { origin: 'user', file: f.user, value: await readJson(f.user) },
+        { origin: 'project', file: f.project, value: await readJson(f.project) },
+        { origin: 'project-user', file: f.projectUser, value: await readJson(f.projectUser) },
+        { origin: 'cli', file: null, value: validate(cli) },
+    ];
+    let held = null;
+    let projectReasoning = null;
+    let projectKeymap = null;
+    let projectStore = null;
+    let projectModels = null;
+    let value = {};
+    for (const layer of layers) {
+        const rest = { ...layer.value };
+        // The defaults keep `permissions` so the key keeps its place; its value is replaced by the union below.
+        if (layer.origin !== 'default')
+            delete rest.permissions;
+        if (layer.origin === 'project' && typeof rest.permissionMode === 'string' && REPOSITORY_CANNOT_SELECT.has(rest.permissionMode)) {
+            held = { value: rest.permissionMode, file: layer.file };
+            delete rest.permissionMode;
+        }
+        if (layer.origin === 'project' && typeof rest.reasoningEffort === 'string') {
+            projectReasoning = { value: rest.reasoningEffort, file: layer.file };
+            delete rest.reasoningEffort;
+        }
+        if (layer.origin === 'project' && isObj(rest.ui) && Object.hasOwn(rest.ui, 'keymap')) {
+            const ui = { ...rest.ui };
+            projectKeymap = { value: structuredClone(ui.keymap), file: layer.file };
+            delete ui.keymap;
+            if (Object.keys(ui).length)
+                rest.ui = ui;
+            else
+                delete rest.ui;
+        }
+        /* R2 owner decision 2026-09-24 (gate E13): a repository cannot choose where TALOS keeps the person's keys; the user
+           file, the project-user file (in the person's profile) and TALOS_CREDENTIAL_STORE can. Same shape as ui.keymap. */
+        if (layer.origin === 'project' && isObj(rest.credentials) && Object.hasOwn(rest.credentials, 'store')) {
+            const credentials = { ...rest.credentials };
+            projectStore = { value: credentials.store, file: layer.file };
+            delete credentials.store;
+            if (Object.keys(credentials).length)
+                rest.credentials = credentials;
+            else
+                delete rest.credentials;
+        }
+        /* R5a lane R (Q-R5-3): a model's window decides when the Context Engine compacts and how much every request may carry, so,
+           like reasoningEffort, a repository cannot set it for the person; the user and project-user files can. */
+        if (layer.origin === 'project' && Object.hasOwn(rest, 'models')) {
+            projectModels = { value: structuredClone(rest.models), file: layer.file };
+            delete rest.models;
+        }
+        value = deepMerge(value, rest, layer.origin, origins);
+    }
+    value.permissions = mergePermissions(layers, origins);
+    const ignored = [];
+    if (projectKeymap)
+        ignored.push({
+            code: 'PROJECT_KEYMAP_IGNORED', path: 'ui.keymap', value: projectKeymap.value, origin: 'project', file: projectKeymap.file,
+            message: `Ignoring ui.keymap from ${projectKeymap.file}: repository configuration cannot remap keyboard controls; use user or project-user configuration.`,
+        });
+    if (projectStore)
+        ignored.push({
+            code: 'PROJECT_CREDENTIAL_STORE_IGNORED', path: 'credentials.store', value: projectStore.value, origin: 'project', file: projectStore.file,
+            message: `Ignoring credentials.store from ${projectStore.file}: repository configuration cannot choose where TALOS keeps your keys; use user or project-user configuration, or TALOS_CREDENTIAL_STORE.`,
+        });
+    if (projectModels)
+        ignored.push({
+            code: 'PROJECT_MODELS_IGNORED', path: 'models', value: projectModels.value, origin: 'project', file: projectModels.file,
+            message: `Ignoring models from ${projectModels.file}: repository configuration cannot set a model's context window; use user or project-user configuration.`,
+        });
+    if (projectReasoning)
+        ignored.push({
+            code: 'PROJECT_REASONING_EFFORT_IGNORED', path: 'reasoningEffort', value: projectReasoning.value, origin: 'project', file: projectReasoning.file,
+            message: `Ignoring reasoningEffort "${projectReasoning.value}" from ${projectReasoning.file}: repository configuration cannot force reasoning spend; use user, project-user, or an explicit session choice.`,
+        });
+    const modeOrigin = origins.get('permissionMode');
+    if (held && (modeOrigin === 'default' || modeOrigin === 'user')) {
+        const used = typeof value.permissionMode === 'string' ? value.permissionMode : 'default';
+        ignored.push({ code: 'PERMISSION_MODE_IGNORED', path: 'permissionMode', value: held.value, origin: 'project', file: held.file,
+            message: `Ignoring permissionMode "${held.value}" from ${held.file}: a project file is part of the repository, so it cannot select "bypassPermissions" or "auto" (the user configuration, the project-user configuration or --permission-mode can). This run uses "${used}" from ${describeOrigin(modeOrigin, f.user)}.` });
+    }
+    return { value: value, origins, ignored };
+}
+async function atomicWriteText(file, text) { await mkdir(dirname(file), { recursive: true, mode: 0o700 }); const tmp = `${file}.tmp-${process.pid}-${Date.now()}`; await writeFile(tmp, text, { encoding: 'utf8', mode: 0o600 }); const h = await open(tmp, 'r+'); try {
+    await h.sync();
+}
+finally {
+    await h.close();
+} await rename(tmp, file); }
+async function atomicWrite(file, value) { const current = validate(migrateConfigValue(value).value); await atomicWriteText(file, `${JSON.stringify(current, null, 2)}\n`); }
+export async function writeConfigScope({ paths, projectRoot, scope, patch }) { assertNoSecrets(patch); const f = files(paths, projectRoot); const file = scope === 'user' ? f.user : scope === 'project' ? f.project : f.projectUser; const current = await readJson(file); const origins = new Map(); const merged = deepMerge(current, validate(patch), scope === 'project-user' ? 'project-user' : scope, origins); await atomicWrite(file, merged); }
+export async function readConfigScope({ paths, projectRoot, scope }) { const f = files(paths, projectRoot); return readJson(scope === 'user' ? f.user : scope === 'project' ? f.project : f.projectUser); }
+export async function replaceConfigScope({ paths, projectRoot, scope, value }) { const f = files(paths, projectRoot); const file = scope === 'user' ? f.user : scope === 'project' ? f.project : f.projectUser; await atomicWrite(file, value); }
+function scopeFile(paths, projectRoot, scope) { const f = files(paths, projectRoot); return scope === 'user' ? f.user : scope === 'project' ? f.project : f.projectUser; }
+export async function migrateConfigScope({ paths, projectRoot, scope }) {
+    const file = scopeFile(paths, projectRoot, scope);
+    let raw;
+    try {
+        raw = await readFile(file, 'utf8');
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            raw = '{}\n';
+        else
+            throw error;
+    }
+    const result = migrateConfigValue(JSON.parse(raw));
+    const backupFile = `${file}.migration-backup`;
+    if (result.changed) {
+        await atomicWriteText(backupFile, raw);
+        await atomicWrite(file, result.value);
+    }
+    return { ...result, file, backupFile: result.changed ? backupFile : null };
+}
+export async function rollbackConfigMigration({ paths, projectRoot, scope }) {
+    const file = scopeFile(paths, projectRoot, scope);
+    const backupFile = `${file}.migration-backup`;
+    let raw;
+    try {
+        raw = await readFile(backupFile, 'utf8');
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            throw Object.assign(new Error('CONFIG_MIGRATION_BACKUP_NOT_FOUND'), { code: 'CONFIG_MIGRATION_BACKUP_NOT_FOUND' });
+        throw error;
+    }
+    JSON.parse(raw);
+    await atomicWriteText(file, raw);
+    return { restored: true, file, backupFile };
+}

package/dist/config/migrations.js

@@ -0,0 +1,48 @@
+export const CURRENT_CONFIG_VERSION = 2;
+const V1_THEMES = new Set(['calm', 'ember', 'coral', 'rose', 'violet', 'indigo', 'azure', 'cyan', 'teal', 'jade', 'mono']);
+const LEGACY_THEME = new Map([['auto', 'calm'], ['dark', 'calm'], ['light', 'calm'], ['mono', 'mono']]);
+/* R5b D4 (owner decision Q-R5-14): v2 themes are the product's ten dark themes; each CLI-only accent of v1 moves to the
+   nearest official one by hue (coral #FB7185 -> signal #ff6f61, rose #F472B6 -> ember #ff5c62, indigo #818CF8 -> violet
+   #b794f6, azure #60A5FA and cyan #22D3EE -> telemetry #6ad4d4, teal #2DD4BF -> aurora #42e7c7, jade #34D399 -> terminal
+   #63f08e); calm, ember, violet and mono keep their ids. */
+const V1_TO_V2_THEME = new Map([['coral', 'signal'], ['rose', 'ember'], ['indigo', 'violet'], ['azure', 'telemetry'], ['cyan', 'telemetry'], ['teal', 'aurora'], ['jade', 'terminal']]);
+const V2_THEMES = new Set(['calm', 'forge', 'terminal', 'aurora', 'ember', 'atlas', 'noir', 'signal', 'violet', 'telemetry', 'mono']);
+function objectValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function fail(code) { throw Object.assign(new Error(code), { code }); }
+export function migrateConfigValue(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        fail('CONFIG_INVALID');
+    const source = structuredClone(input);
+    const rawVersion = source.version;
+    const fromVersion = rawVersion === undefined ? 0 : typeof rawVersion === 'number' && Number.isInteger(rawVersion) ? rawVersion : fail('CONFIG_VERSION_INVALID');
+    if (fromVersion > CURRENT_CONFIG_VERSION)
+        fail('CONFIG_VERSION_UNSUPPORTED');
+    if (fromVersion < 0)
+        fail('CONFIG_VERSION_INVALID');
+    if (fromVersion === CURRENT_CONFIG_VERSION)
+        return { value: source, fromVersion, toVersion: CURRENT_CONFIG_VERSION, changed: false, steps: [] };
+    const next = structuredClone(source);
+    const steps = [];
+    const withTheme = (change) => {
+        const ui = objectValue(next.ui);
+        if (next.ui !== undefined || Object.keys(ui).length) {
+            const raw = ui.theme;
+            if (typeof raw === 'string') {
+                const migrated = change(raw);
+                if (migrated)
+                    ui.theme = migrated;
+            }
+            next.ui = ui;
+        }
+    };
+    if (fromVersion === 0) {
+        withTheme(raw => LEGACY_THEME.get(raw) ?? (V1_THEMES.has(raw) ? raw : null));
+        steps.push('v0-to-v1');
+    }
+    withTheme(raw => V1_TO_V2_THEME.get(raw) ?? (V2_THEMES.has(raw) ? raw : null));
+    steps.push('v1-to-v2');
+    next.version = CURRENT_CONFIG_VERSION;
+    return { value: next, fromVersion, toVersion: CURRENT_CONFIG_VERSION, changed: true, steps };
+}

package/dist/config/types.js

@@ -0,0 +1,11 @@
+export const CURRENT_UI_THEMES = Object.freeze(['calm', 'forge', 'terminal', 'aurora', 'ember', 'atlas', 'noir', 'signal', 'violet', 'telemetry', 'mono']);
+export const UI_EXIT_OUTPUTS = Object.freeze(['transcript', 'resume']);
+export const CREDENTIAL_STORES = Object.freeze(['system', 'memory']);
+/* R5a lane R: the values config/load.ts accepts, and the owner's defaults (Q-R5-7 queue, Q-R5-9 collapsed). */
+export const UI_BUSY_INPUTS = Object.freeze(['queue', 'steer', 'interrupt']);
+export const UI_REASONING_MODES = Object.freeze(['collapsed', 'visible']);
+/** R5a lane R (Q-R5-3): the bounds of a person's model override; outside them the value is refused by name, never clamped. */
+export const MODEL_WINDOW_MIN = 1_024;
+export const MODEL_WINDOW_MAX = 10_000_000;
+export const REASONING_EFFORTS = Object.freeze(['low', 'medium', 'high', 'xhigh', 'max']);
+export const DEFAULT_CONFIG = { version: 2, permissionMode: 'default', outputFormat: 'text', updateChannel: 'stable', permissions: { allow: [], ask: [], deny: [] }, ui: { theme: 'forge', markdown: true, exitOutput: 'transcript', busyInput: 'queue', reasoning: 'collapsed' }, extensions: { enabled: [] } };

package/dist/diagnostics/development-log.js

@@ -0,0 +1,154 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRedactor, secretValuesFromEnvironment } from "./redact.js";
+import { CLI_VERSION } from "../version.js";
+const MAX_FILE_BYTES = 8 * 1024 * 1024;
+const MAX_STRING = 16 * 1024;
+const MAX_ARRAY = 128;
+const MAX_KEYS = 128;
+let state = null;
+let hooksInstalled = false;
+function sha256(value) { return createHash('sha256').update(value).digest('hex'); }
+export function developmentTextEvidence(value) { const text = String(value ?? ''); return { length: text.length, bytes: Buffer.byteLength(text, 'utf8'), sha256: sha256(text) }; }
+function truncate(value) { const text = typeof value === 'string' ? value : String(value); if (text.length <= MAX_STRING)
+    return text; return `${text.slice(0, MAX_STRING)}…[truncated:${text.length - MAX_STRING}]`; }
+/*
+ * ⛔ R0 (forensics B row 4): logging is TOTAL — it never throws, whatever it is handed. `50601493c` put
+ *   `developmentLogError` first in `main`'s catch; a thrown value with a throwing getter made `Object.entries` throw there, so the
+ *   catch itself threw and no error envelope was written. Every read of a foreign value goes through `readField`, and a value that
+ *   cannot be read at all is logged as `[UNREADABLE]` instead of breaking the caller.
+ */
+const UNREADABLE = '[UNREADABLE]';
+function readField(value, key) { try {
+    return value[key];
+}
+catch {
+    return UNREADABLE;
+} }
+function safeValue(value, depth = 0, seen = new WeakSet()) {
+    try {
+        if (depth > 6)
+            return '[DEPTH_LIMIT]';
+        if (value === null || typeof value === 'number' || typeof value === 'boolean')
+            return value;
+        if (typeof value === 'bigint')
+            return value.toString();
+        if (typeof value === 'string')
+            return truncate(value);
+        if (typeof value === 'function')
+            return `[Function:${readField(value, 'name') || 'anonymous'}]`;
+        if (typeof value !== 'object')
+            return String(value);
+        if (seen.has(value))
+            return '[CIRCULAR]';
+        seen.add(value);
+        if (value instanceof Error)
+            return serializeError(value, depth + 1, seen);
+        if (Array.isArray(value))
+            return value.slice(0, MAX_ARRAY).map(item => safeValue(item, depth + 1, seen));
+        const out = {};
+        for (const key of Object.keys(value).slice(0, MAX_KEYS)) {
+            const item = readField(value, key);
+            if (/^(?:prompt|text|testo|consegna|consegnaCorta|content|delta|messages|input|output|command|comando)$/iu.test(key) && typeof item === 'string')
+                out[key + 'Evidence'] = developmentTextEvidence(item);
+            else
+                out[key] = safeValue(item, depth + 1, seen);
+        }
+        return out;
+    }
+    catch {
+        return UNREADABLE;
+    }
+}
+function serializeError(error, depth = 0, seen = new WeakSet()) {
+    try {
+        if (!(error instanceof Error))
+            return { value: safeValue(error, depth + 1, seen) };
+        const name = readField(error, 'name');
+        if (seen.has(error))
+            return { name, message: '[CIRCULAR_ERROR]' };
+        seen.add(error);
+        const code = readField(error, 'code'), retryable = readField(error, 'retryable'), details = readField(error, 'details'), cause = readField(error, 'cause');
+        return { name, message: truncate(readField(error, 'message')), stack: truncate(readField(error, 'stack') ?? ''), ...(typeof code === 'string' ? { code } : {}), ...(typeof retryable === 'boolean' ? { retryable } : {}), ...(details !== undefined ? { details: safeValue(details, depth + 1, seen) } : {}), ...(cause !== undefined ? { cause: serializeError(cause, depth + 1, seen) } : {}) };
+    }
+    catch {
+        return { value: UNREADABLE };
+    }
+}
+function dependencySnapshot() {
+    try {
+        const root = fileURLToPath(new URL('../../', import.meta.url));
+        const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+        const lock = JSON.parse(readFileSync(join(root, 'package-lock.json'), 'utf8'));
+        const packages = lock?.packages ?? {};
+        const version = (name) => packages[`node_modules/${name}`]?.version ?? pkg.dependencies?.[name] ?? pkg.devDependencies?.[name] ?? null;
+        return { packageRoot: root, packageVersion: pkg.version ?? CLI_VERSION, typescript: version('typescript'), react: version('react'), ink: version('ink'), mxc: version('@microsoft/mxc-sdk') };
+    }
+    catch (error) {
+        return { unavailable: true, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function environmentSnapshot() {
+    const names = ['TERM', 'COLORTERM', 'CI', 'GITHUB_ACTIONS', 'WT_SESSION', 'TERM_PROGRAM', 'COMSPEC', 'PSModulePath', 'TALOS_CLI_INSPECTION_SNAPSHOT', 'TALOS_CLI_DEV_LOG_DIR', 'TALOS_REDUCED_MOTION'];
+    return Object.fromEntries(names.filter(name => process.env[name] !== undefined).map(name => [name, process.env[name]]));
+}
+function nextPath(s) { return join(s.dir, `${s.base}${s.part === 1 ? '' : `.part-${s.part}`}.jsonl`); }
+function rotateIfNeeded(s) { try {
+    if (existsSync(s.path) && statSync(s.path).size >= MAX_FILE_BYTES) {
+        s.part += 1;
+        s.path = nextPath(s);
+    }
+}
+catch { /* best effort */ } }
+function write(record) { const s = state; if (!s || s.closed)
+    return; try {
+    rotateIfNeeded(s);
+    const redacted = s.redactor.value(safeValue(record));
+    appendFileSync(s.path, JSON.stringify(redacted) + '\n', { encoding: 'utf8', mode: 0o600 });
+}
+catch { /* logging must never break TALOS */ } }
+function installProcessHooks() {
+    if (hooksInstalled)
+        return;
+    hooksInstalled = true;
+    process.on('warning', warning => developmentLog('process.warning', { error: serializeError(warning) }, 'warning', 'process'));
+    process.on('unhandledRejection', reason => developmentLog('process.unhandledRejection', { error: serializeError(reason) }, 'error', 'process'));
+    process.on('uncaughtExceptionMonitor', error => developmentLog('process.uncaughtExceptionMonitor', { error: serializeError(error) }, 'fatal', 'process'));
+}
+export function initializeDevelopmentLogging(input = {}) {
+    if (state && !state.closed) {
+        developmentLog('logger.context_update', { projectRoot: input.projectRoot, paths: input.paths, argv: input.argv?.map(developmentTextEvidence), extra: input.extra }, 'debug', input.component ?? state.component);
+        return state.path;
+    }
+    const dir = resolve(input.logDir ?? process.env.TALOS_CLI_DEV_LOG_DIR ?? (input.paths ? join(input.paths.logsRoot, 'development') : ''));
+    if (!dir || dir === resolve('.'))
+        return null;
+    try {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    catch {
+        return null;
+    }
+    const started = performance.now(), correlationId = randomUUID(), stamp = new Date().toISOString().replace(/[:.]/gu, '-');
+    const s = { dir, base: `talos-dev-${stamp}-${process.pid}-${correlationId.slice(0, 8)}`, part: 1, path: '', started, correlationId, redactor: createRedactor(secretValuesFromEnvironment(process.env)), component: input.component ?? 'cli', closed: false };
+    s.path = nextPath(s);
+    state = s;
+    installProcessHooks();
+    developmentLog('process.start', { cliVersion: CLI_VERSION, node: process.version, versions: process.versions, platform: process.platform, arch: process.arch, pid: process.pid, ppid: process.ppid, cwd: process.cwd(), execPath: process.execPath, argv: (input.argv ?? process.argv.slice(2)).map(developmentTextEvidence), projectRoot: input.projectRoot ?? null, terminal: { stdinTTY: Boolean(process.stdin.isTTY), stdoutTTY: Boolean(process.stdout.isTTY), columns: process.stdout.columns ?? null, rows: process.stdout.rows ?? null }, paths: input.paths ?? null, environment: environmentSnapshot(), dependencies: dependencySnapshot(), extra: input.extra ?? null }, 'info', 'process');
+    return s.path;
+}
+export function developmentLog(event, data = {}, severity = 'info', component) { const s = state; if (!s || s.closed)
+    return; try {
+    write({ schema: 'talos.cli.development-log.v1', ts: new Date().toISOString(), elapsedMs: Math.round((performance.now() - s.started) * 1000) / 1000, pid: process.pid, correlationId: s.correlationId, severity, component: component ?? s.component, event, data });
+}
+catch { /* logging must never break TALOS */ } }
+export function developmentLogError(event, error, data = {}, component) { if (!state || state.closed)
+    return; try {
+    developmentLog(event, { ...data, error: serializeError(error) }, 'error', component);
+}
+catch { /* logging must never break TALOS */ } }
+export function developmentLogPath() { return state?.path ?? null; }
+export function closeDevelopmentLogging(extra = {}) { if (!state || state.closed)
+    return; developmentLog('process.stop', extra, 'info', 'process'); state.closed = true; }