@namzu/cli 35.0.0 → 36.0.0

package/dist/config/load.js

@@ -1,1208 +0,0 @@
-/**
- * Config cascade and runtime admission for @namzu/cli.
- *
- * Resolution order (highest priority first):
- *   1. CLI flags (handled by Commander, merged in `cli.ts`)
- *   2. Environment variables prefixed `NAMZU_`
- *   3. Project config: `./namzu.config.json` (TS variant added in a later
- *      milestone when a build step is justified)
- *   4. User config: `$NAMZU_HOME/config.yaml` (`~/.namzu/config.yaml` by default)
- *   5. Built-in defaults from `schema.ts`
- *
- * This module owns steps 2–5. CLI-flag merging happens in `cli.ts`, where
- * Commander knows what was explicitly set rather than merely defaulted.
- *
- * A file that is not there contributes nothing, and that is a default. A file
- * that IS there and cannot be read throws {@link ConfigLoadError} — this loader
- * has no way to say "some of your settings", and will not pretend the ones it
- * failed to read were never written.
- *
- * A source Namzu can parse but whose known key carries an invalid value throws
- * {@link ConfigValueError}. Absence, syntax failure, and semantic rejection are
- * three different states and none is represented by another.
- */
-import { readFileSync } from 'node:fs';
-import { basename, join, resolve } from 'node:path';
-import { RENAMED_PLUGIN_HOOK_EVENTS, SHELL_HOOK_EVENTS } from '@namzu/sdk';
-import { parse as yamlParse } from 'yaml';
-import { resolveNamzuHome } from '../integrations/state/home.js';
-import { isFormatName } from '../output/index.js';
-import { canonicalBrowserSiteKey, isBrowserSiteLevel, narrower, } from '../permissions/browser-sites.js';
-import { COMPOSER_TRIGGER_IDS, COMPOSER_TRIGGER_LANGUAGES, mergeComposerTriggers, } from './composer-triggers.js';
-import { configMetadataLiteral } from './debug.js';
-import { DEFAULT_CONFIG, } from './schema.js';
-import { TOOL_RESULT_SCREEN_NAMES, TOOL_RESULT_SCREEN_OPTION_KEYS, isToolResultScreenName, } from './tool-result-screens.js';
-/**
- * A machine-wide config that wins the cascade.
- *
- * It exists for the case where the person running namzu is not the person
- * deciding what it may do — a shared build machine, a managed workstation.
- * Applied LAST, so it beats the project file and the environment both, which
- * is the only ordering that makes it worth having.
- *
- * **Its guarantee is the file system's and nothing more.** namzu does not
- * verify a signature, does not check an owner, and cannot tell an
- * administrator's file from one the user wrote there. What stops a user
- * editing it is that the path needs privileges they do not have, on a machine
- * somebody configured that way. That is a real control and a narrow one, and
- * stating it precisely is the difference between a security boundary and the
- * appearance of one.
- *
- * Absent on almost every machine, which is the expected case and not an error.
- */
-export const MANAGED_CONFIG_PATH = process.platform === 'win32'
-    ? join(process.env.PROGRAMDATA ?? 'C:\\ProgramData', 'namzu', 'config.json')
-    : '/etc/namzu/config.json';
-/**
- * `loadConfig` plus the record of who won each key.
- *
- * A second entry point rather than widening `loadConfig` itself:
- * `loadConfig` is exported from `../index.js` for embedded consumers, and
- * `(opts?: LoadConfigOptions) => NamzuCliConfig` is a signature something out
- * there may already depend on. `loadConfig` below is now defined in terms of
- * this function precisely so the two cannot drift apart — there is one merge
- * to reason about, not two copies of the same precedence logic kept in sync
- * by hand.
- */
-export function loadConfigWithProvenance(opts = {}) {
-    return resolveConfigWithProvenance(opts, {
-        includeProject: true,
-        deferUnknownProfile: false,
-    });
-}
-/**
- * Resolve only process/user/managed authority before a project is trusted.
- *
- * Internal CLI seam: deliberately not re-exported from the package root. A
- * selected profile may be declared by the project layer, so an otherwise
- * unknown profile is deferred until the trusted, full resolution pass.
- */
-export function loadBootstrapConfigWithProvenance(opts = {}) {
-    return resolveConfigWithProvenance(opts, {
-        includeProject: false,
-        deferUnknownProfile: true,
-    });
-}
-function resolveConfigWithProvenance(opts, mode) {
-    const cwd = opts.cwd ?? process.cwd();
-    const env = opts.env ?? process.env;
-    const userPath = join(resolveNamzuHome({ ...(opts.home ? { home: opts.home } : {}), env }), 'config.yaml');
-    const projectPath = resolve(cwd, 'namzu.config.json');
-    const managedPath = opts.managedPath ?? MANAGED_CONFIG_PATH;
-    const userCfg = readYamlIfExists(userPath);
-    const projectCfg = mode.includeProject ? readJsonIfExists(projectPath) : {};
-    const managedCfg = readJsonIfExists(managedPath);
-    const { config: envCfg, variables: envVariables } = readEnv(env);
-    // The command line first, then the environment. A flag is this turn; a
-    // variable is this shell — so the narrower statement wins, the way it does
-    // everywhere else here.
-    const profileName = opts.profile ?? env.NAMZU_PROFILE;
-    const profiles = profileLayers(profileName, [
-        [userCfg, userPath],
-        [projectCfg, projectPath],
-        [managedCfg, managedPath],
-    ], mode.deferUnknownProfile);
-    return mergeConfigs(constantLayer(DEFAULT_CONFIG, { kind: 'default' }), constantLayer(userCfg, { kind: 'user-file', path: userPath }), constantLayer(projectCfg, { kind: 'project-file', path: projectPath }), 
-    // After both files and before the environment. A profile is a
-    // deliberate choice about a set of settings, so it beats the ambient
-    // values in the file it came from; a variable is a statement about this
-    // one shell, so it beats the profile.
-    ...profiles, {
-        config: envCfg,
-        sourceFor: (key) => {
-            const variable = envVariables[key];
-            // `readEnv` sets `variables[key]` in the same branch it sets
-            // `config[key]` — see `ENV_VARIABLE_NAMES` — so this is defined
-            // for every key this layer's config actually carries. Reaching
-            // `undefined` here means that pairing broke, which is a bug in
-            // this file, not a malformed environment.
-            if (variable === undefined) {
-                throw new Error(`no env variable recorded for config key '${key}'`);
-            }
-            return { kind: 'env', variable };
-        },
-    }, 
-    // Last, so it beats the project file and the environment both. That
-    // ordering is the whole of what a managed layer is.
-    constantLayer(managedCfg, { kind: 'managed', path: managedPath }));
-}
-/**
- * The `permissions` table of each file that declares one: user, project and
- * managed, in cascade order, each on its own.
- *
- * The merged config cannot answer "did ANY file deny this": a project that
- * writes `bash = "allow"` replaces a user's `bash = "deny"` under the same key.
- * A scheduled run takes its allows from its job alone and the denies from
- * every file, so it needs the layers apart. Validated as the cascade
- * validates them; a file that fails to parse throws the same error.
- */
-export function readPermissionLayers(opts = {}) {
-    const cwd = opts.cwd ?? process.cwd();
-    const env = opts.env ?? process.env;
-    const userPath = join(resolveNamzuHome({ ...(opts.home ? { home: opts.home } : {}), env }), 'config.yaml');
-    const projectPath = resolve(cwd, 'namzu.config.json');
-    const managedPath = opts.managedPath ?? MANAGED_CONFIG_PATH;
-    const layers = [];
-    for (const [source, path, config] of [
-        ['user-file', userPath, readYamlIfExists(userPath)],
-        ['project-file', projectPath, readJsonIfExists(projectPath)],
-        ['managed', managedPath, readJsonIfExists(managedPath)],
-    ]) {
-        const browserDenies = Object.entries(config.browser?.sites ?? {})
-            .filter(([site, level]) => site !== '*' && level === 'deny')
-            .map(([site]) => site);
-        if (config.permissions || browserDenies.length > 0)
-            layers.push({
-                source,
-                path,
-                permissions: config.permissions ?? {},
-                ...(browserDenies.length > 0 ? { browserDenies } : {}),
-            });
-    }
-    return layers;
-}
-/**
- * The selected profile, once per file that declares it.
- *
- * One layer per file rather than one merged layer, so provenance keeps naming
- * the file a value actually came from — a project profile overriding a user
- * profile of the same name is the ordinary case, and reporting both as "the
- * profile" would leave an operator opening the wrong file.
- *
- * Refuses a name nothing declares. The alternative is a turn under settings
- * nobody chose, reported as success.
- */
-function profileLayers(name, files, deferUnknown = false) {
-    if (name === undefined || name === '')
-        return [];
-    const layers = [];
-    const declared = new Set();
-    const declaringFiles = [];
-    for (const [config, path] of files) {
-        const profiles = config.profiles;
-        if (profiles === undefined)
-            continue;
-        declaringFiles.push(path);
-        for (const key of Object.keys(profiles))
-            declared.add(key);
-        if (!Object.hasOwn(profiles, name))
-            continue;
-        const selected = profiles[name];
-        // `Object.hasOwn` above is the declaration check. Direct indexing alone
-        // admits inherited `toString`, `constructor`, and `__proto__` as profiles
-        // a file never declared.
-        if (selected === undefined)
-            continue;
-        layers.push(constantLayer(selected, { kind: 'profile', name, path }));
-    }
-    if (layers.length === 0) {
-        if (deferUnknown)
-            return [];
-        const known = [...declared].sort();
-        // The path is where to go and fix it. A file that already declares
-        // profiles is the better answer than the one bound to this folder,
-        // because a misspelled name usually sits next to the right one — and
-        // when nothing declares any, the folder's own file is where the first
-        // one would go.
-        const where = declaringFiles[0] ?? files[1]?.[1] ?? '';
-        throw new ConfigLoadError(where, known.length === 0
-            ? `No profile named "${name}" — no config file declares any profiles.`
-            : `No profile named "${name}". Declared in ${declaringFiles.join(', ')}: ${known.join(', ')}.`);
-    }
-    return layers;
-}
-export function loadConfig(opts = {}) {
-    return loadConfigWithProvenance(opts).config;
-}
-/**
- * A config file namzu could not read.
- *
- * Its own class rather than a bare `Error` so `cli.ts` can print the message on
- * its own and exit `EXIT_BAD_CONFIG`, instead of the stack trace an internal
- * error deserves and an operator's typo does not.
- */
-export class ConfigLoadError extends Error {
-    /** The file whose contents could not be established. */
-    path;
-    constructor(path, message, options) {
-        super(message, options);
-        this.name = 'ConfigLoadError';
-        this.path = path;
-    }
-}
-/**
- * A known config key whose explicit value does not satisfy its public type.
- *
- * Kept distinct from {@link ConfigLoadError}: that class means a file could
- * not be read or parsed at all, while this one means the source was readable
- * and named a setting Namzu cannot honour. Public loaders throw both; the
- * standalone binary maps both to `EX_CONFIG`.
- */
-export class ConfigValueError extends Error {
-    source;
-    /** Dot/bracket path to the invalid known setting, without its source. */
-    settingPath;
-    constructor(source, settingPath, message) {
-        const origin = source.kind === 'file'
-            ? `config file ${configMetadataLiteral(source.path)}`
-            : `environment variable ${source.variable}`;
-        super(`${origin}: ${settingPath} ${message}`);
-        this.name = 'ConfigValueError';
-        this.source = source;
-        this.settingPath = settingPath;
-    }
-}
-function readYamlIfExists(path) {
-    const raw = readIfPresent(path);
-    if (raw === null)
-        return {};
-    let parsed;
-    try {
-        parsed = yamlParse(raw);
-    }
-    catch (cause) {
-        throw new ConfigLoadError(path, `${path} is not valid YAML: ${reasonOf(cause)}`, { cause });
-    }
-    return asConfigObject(path, parsed);
-}
-function readJsonIfExists(path) {
-    const raw = readIfPresent(path);
-    if (raw === null)
-        return {};
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (cause) {
-        throw new ConfigLoadError(path, `${path} is not valid JSON: ${reasonOf(cause)}`, { cause });
-    }
-    return asConfigObject(path, parsed);
-}
-/**
- * The file's text, or `null` when the file is genuinely not there.
- *
- * Absent and unreadable used to share one `catch`, and the shared answer was
- * `{}` — "no settings". For a file nobody wrote that is the right default. For
- * one that exists and could not be opened it is the wrong one, and wrong in the
- * direction that never announces itself: `permissions` is read from these files,
- * so an unreadable config becomes an empty rule table, and a headless run
- * resolves every call no rule covered to `auto`. The operator's deny list
- * becomes approval of the same calls, on the one path where nobody is watching.
- *
- * So only "the file is not there" reads as no settings. `ENOENT` is the file
- * itself missing; `ENOTDIR` is a parent that is not a directory, which means the
- * same thing — nothing was ever written at that path. A permission error, a
- * directory where a file belongs, or an I/O failure all mean the file exists and
- * its contents could not be established, and that is a refusal.
- *
- * See "an optional dependency may not degrade a check": the
- * degradation that matters is the one turning "I cannot establish this" into
- * "this is satisfied".
- */
-function readIfPresent(path) {
-    try {
-        return readFileSync(path, 'utf8');
-    }
-    catch (cause) {
-        const code = cause?.code;
-        if (code === 'ENOENT' || code === 'ENOTDIR')
-            return null;
-        throw new ConfigLoadError(path, `${path} could not be read: ${reasonOf(cause)}`, { cause });
-    }
-}
-/**
- * The parsed document as a config object, refusing anything that is not one.
- *
- * An empty file parses to `null`, and that is a genuine "no settings" — a file
- * someone emptied says nothing, which is what it looks like. A scalar or a list
- * is different: it is content namzu cannot read as settings, and admitting it as
- * `{}` is the same fail-open as the unreadable file one function up, reached by
- * a different route.
- */
-function asConfigObject(path, parsed) {
-    if (parsed === null || parsed === undefined)
-        return {};
-    if (typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new ConfigLoadError(path, `${path} must contain a mapping of settings, but its top level is ${describe(parsed)}`);
-    }
-    return sanitize(parsed, { kind: 'file', path });
-}
-function describe(value) {
-    return Array.isArray(value) ? 'a list' : `a ${typeof value}`;
-}
-function reasonOf(cause) {
-    return cause instanceof Error ? cause.message : String(cause);
-}
-const COMPOSER_TRIGGERS_KEYS = ['enabled', 'suggest', 'languages', 'builtin'];
-const SKILLS_CONFIG_KEYS = [
-    'builtin',
-    'disabled',
-    'suggest',
-    'suggestMinToolCalls',
-];
-const CONFIG_READERS = {
-    format: (v, context) => {
-        if (typeof v === 'string' && isFormatName(v))
-            return v;
-        return invalidConfigValue(context, [], 'must be one of "text", "json", or "yaml"');
-    },
-    quiet: (v, context) => {
-        if (typeof v === 'boolean')
-            return v;
-        return invalidConfigValue(context, [], 'must be a boolean');
-    },
-    modelCatalogueRefresh: (v, context) => {
-        if (typeof v === 'boolean')
-            return v;
-        return invalidConfigValue(context, [], 'must be a boolean');
-    },
-    // Shape only. Per-entry validation belongs to `compilePermissions`, which
-    // reports a bad effect or an unusable pattern as a diagnostic the user
-    // sees; dropping those entries here would silence it.
-    permissions: (v, context) => {
-        if (isConfigMapping(v))
-            return v;
-        return invalidConfigValue(context, [], 'must be a mapping of tool names');
-    },
-    // Shape only, like `permissions` and for the same reason: per-entry
-    // validation belongs to `verifyPermissionChecks`, which reports a bad
-    // check by index. Dropping a malformed one here would turn "your check is
-    // unreadable" into "your check passed".
-    permissionChecks: (v, context) => {
-        if (Array.isArray(v))
-            return v;
-        return invalidConfigValue(context, [], 'must be a list');
-    },
-    // Every declared profile is checked when its file loads, not only when it is
-    // selected. Typed config in a lower-precedence layer cannot become valid
-    // merely because another layer happens to win today. Unknown profile keys
-    // remain non-strict and are ignored by `sanitize`, like unknown base keys.
-    profiles: (v, context) => {
-        if (!isConfigMapping(v)) {
-            return invalidConfigValue(context, [], 'must be a mapping of profile names');
-        }
-        const profiles = {};
-        for (const name of Object.keys(v)) {
-            const entry = v[name];
-            if (!isConfigMapping(entry)) {
-                return invalidConfigValue(context, [name], 'must be a mapping of settings');
-            }
-            const parsed = sanitize(entry, context.source, [...context.path, name], false);
-            // Define rather than assign: `__proto__` is a valid own profile name,
-            // not permission to change this dictionary's prototype.
-            Object.defineProperty(profiles, name, {
-                value: parsed,
-                enumerable: true,
-                configurable: true,
-                writable: true,
-            });
-        }
-        return profiles;
-    },
-    // Shape only, for the same reason as `permissions`: an entry that names
-    // neither a command nor a url — or both — is reported by name when the
-    // connection is attempted. Dropping it here would turn a mistake the
-    // operator can see into a server that silently was never there.
-    mcpServers: (v, context) => {
-        if (isConfigMapping(v))
-            return v;
-        return invalidConfigValue(context, [], 'must be a mapping of server names');
-    },
-    memory: (v, context) => {
-        if (!isConfigMapping(v))
-            return invalidConfigValue(context, [], 'must be a mapping');
-        for (const key of Object.keys(v)) {
-            if (key !== 'recall' && key !== 'identifierGrounding')
-                return invalidConfigValue(context, [key], 'is not a memory key');
-        }
-        if (v.recall !== undefined && typeof v.recall !== 'boolean') {
-            return invalidConfigValue(context, ['recall'], 'must be true or false');
-        }
-        if (v.identifierGrounding !== undefined && typeof v.identifierGrounding !== 'boolean') {
-            return invalidConfigValue(context, ['identifierGrounding'], 'must be true or false');
-        }
-        return {
-            ...(v.recall === undefined ? {} : { recall: v.recall }),
-            ...(v.identifierGrounding === undefined
-                ? {}
-                : { identifierGrounding: v.identifierGrounding }),
-        };
-    },
-    compaction: (v, context) => {
-        if (!isConfigMapping(v))
-            return invalidConfigValue(context, [], 'must be a mapping');
-        const raw = v;
-        for (const key of Object.keys(v)) {
-            if (key !== 'strategy' &&
-                key !== 'contextWindowTokens' &&
-                key !== 'consolidate' &&
-                key !== 'recallEvidence' &&
-                key !== 'resolveEvidenceQueries' &&
-                key !== 'retainedToolPreviewChars' &&
-                key !== 'deduplicateObservations') {
-                return invalidConfigValue(context, [key], 'is not a compaction key');
-            }
-        }
-        if (raw.deduplicateObservations !== undefined &&
-            typeof raw.deduplicateObservations !== 'boolean') {
-            return invalidConfigValue(context, ['deduplicateObservations'], 'must be true or false');
-        }
-        if (raw.recallEvidence !== undefined && typeof raw.recallEvidence !== 'boolean')
-            return invalidConfigValue(context, ['recallEvidence'], 'must be true or false');
-        if (raw.resolveEvidenceQueries !== undefined && typeof raw.resolveEvidenceQueries !== 'boolean')
-            return invalidConfigValue(context, ['resolveEvidenceQueries'], 'must be true or false');
-        if (raw.consolidate !== undefined && typeof raw.consolidate !== 'boolean') {
-            return invalidConfigValue(context, ['consolidate'], 'must be true or false');
-        }
-        if (raw.retainedToolPreviewChars !== undefined &&
-            (typeof raw.retainedToolPreviewChars !== 'number' ||
-                !Number.isSafeInteger(raw.retainedToolPreviewChars) ||
-                raw.retainedToolPreviewChars < 0)) {
-            return invalidConfigValue(context, ['retainedToolPreviewChars'], 'must be a nonnegative safe integer');
-        }
-        if (raw.strategy !== undefined &&
-            raw.strategy !== 'structured' &&
-            raw.strategy !== 'salience') {
-            return invalidConfigValue(context, ['strategy'], 'must be `structured` or `salience`');
-        }
-        if (raw.contextWindowTokens !== undefined &&
-            (typeof raw.contextWindowTokens !== 'number' ||
-                !Number.isInteger(raw.contextWindowTokens) ||
-                raw.contextWindowTokens <= 0)) {
-            return invalidConfigValue(context, ['contextWindowTokens'], 'must be a positive integer');
-        }
-        return {
-            ...(raw.strategy !== undefined ? { strategy: raw.strategy } : {}),
-            ...(raw.contextWindowTokens !== undefined
-                ? { contextWindowTokens: raw.contextWindowTokens }
-                : {}),
-            ...(raw.consolidate !== undefined ? { consolidate: raw.consolidate } : {}),
-            ...(raw.recallEvidence !== undefined ? { recallEvidence: raw.recallEvidence } : {}),
-            ...(raw.resolveEvidenceQueries !== undefined
-                ? { resolveEvidenceQueries: raw.resolveEvidenceQueries }
-                : {}),
-            ...(raw.retainedToolPreviewChars !== undefined
-                ? { retainedToolPreviewChars: raw.retainedToolPreviewChars }
-                : {}),
-            ...(raw.deduplicateObservations !== undefined
-                ? { deduplicateObservations: raw.deduplicateObservations }
-                : {}),
-        };
-    },
-    additionalDirectories: (v, context) => {
-        if (!Array.isArray(v))
-            return invalidConfigValue(context, [], 'must be a list of directories');
-        for (const [index, entry] of v.entries()) {
-            if (typeof entry !== 'string' || entry.trim().length === 0) {
-                return invalidConfigValue(context, [index], 'must be a directory path');
-            }
-        }
-        return v;
-    },
-    toolResultScreens: (v, context) => {
-        if (!Array.isArray(v)) {
-            return invalidConfigValue(context, [], 'must be a list of screen names');
-        }
-        const names = TOOL_RESULT_SCREEN_NAMES.join(', ');
-        for (const [index, entry] of v.entries()) {
-            if (typeof entry === 'string') {
-                if (!isToolResultScreenName(entry)) {
-                    return invalidConfigValue(context, [index], `must be one of: ${names}`);
-                }
-                continue;
-            }
-            if (!isConfigMapping(entry)) {
-                return invalidConfigValue(context, [index], 'must be a screen name, or a mapping with a `name`');
-            }
-            const { name, ...options } = entry;
-            if (typeof name !== 'string' || !isToolResultScreenName(name)) {
-                return invalidConfigValue(context, [index, 'name'], `must be one of: ${names}`);
-            }
-            // An option the named screen does not read is refused rather than
-            // carried: `{ "name": "injection", "passthroughTools": [...] }`
-            // would otherwise install, parse, and exempt nothing, which reads
-            // to an operator as the exemption being in force.
-            for (const key of Object.keys(options)) {
-                if (!TOOL_RESULT_SCREEN_OPTION_KEYS[name].includes(key)) {
-                    return invalidConfigValue(context, [index, key], `is not an option of the "${name}" screen`);
-                }
-            }
-            const passthroughTools = entry.passthroughTools;
-            if (passthroughTools === undefined)
-                continue;
-            if (!Array.isArray(passthroughTools)) {
-                return invalidConfigValue(context, [index, 'passthroughTools'], 'must be a list of tool names');
-            }
-            for (const [position, toolName] of passthroughTools.entries()) {
-                if (typeof toolName !== 'string' || toolName.trim().length === 0) {
-                    return invalidConfigValue(context, [index, 'passthroughTools', position], 'must be a tool name');
-                }
-            }
-        }
-        return v;
-    },
-    hooks: (v, context) => {
-        if (!isConfigMapping(v))
-            return invalidConfigValue(context, [], 'must be a mapping of event → list');
-        const events = new Set(SHELL_HOOK_EVENTS);
-        const out = {};
-        for (const [event, entries] of Object.entries(v)) {
-            const renamed = Object.hasOwn(RENAMED_PLUGIN_HOOK_EVENTS, event)
-                ? RENAMED_PLUGIN_HOOK_EVENTS[event]
-                : undefined;
-            if (renamed !== undefined) {
-                return invalidConfigValue(context, [event], `was renamed; name it \`${renamed}\``);
-            }
-            if (!events.has(event)) {
-                return invalidConfigValue(context, [event], `is not a hook event (${SHELL_HOOK_EVENTS.join(', ')})`);
-            }
-            if (!Array.isArray(entries))
-                return invalidConfigValue(context, [event], 'must be a list of hooks');
-            const parsed = [];
-            for (const [index, entry] of entries.entries()) {
-                if (!isConfigMapping(entry)) {
-                    return invalidConfigValue(context, [event, index], 'must be a mapping with a `command`');
-                }
-                const raw = entry;
-                for (const key of Object.keys(entry)) {
-                    if (key !== 'command' && key !== 'matcher' && key !== 'timeoutMs') {
-                        return invalidConfigValue(context, [event, index, key], 'is not a recognized hook setting');
-                    }
-                }
-                if (typeof raw.command !== 'string' || raw.command.trim().length === 0) {
-                    return invalidConfigValue(context, [event, index, 'command'], 'must be a non-empty string');
-                }
-                if (raw.matcher !== undefined && typeof raw.matcher !== 'string') {
-                    return invalidConfigValue(context, [event, index, 'matcher'], 'must be a string');
-                }
-                if (raw.timeoutMs !== undefined &&
-                    (typeof raw.timeoutMs !== 'number' ||
-                        !Number.isInteger(raw.timeoutMs) ||
-                        raw.timeoutMs <= 0)) {
-                    return invalidConfigValue(context, [event, index, 'timeoutMs'], 'must be a positive integer');
-                }
-                parsed.push({
-                    command: raw.command,
-                    ...(raw.matcher !== undefined ? { matcher: raw.matcher } : {}),
-                    ...(raw.timeoutMs !== undefined ? { timeoutMs: raw.timeoutMs } : {}),
-                });
-            }
-            out[event] = parsed;
-        }
-        return out;
-    },
-    browser: (v, context) => readBrowserConfig(v, context),
-    web: (v, context) => {
-        if (!isConfigMapping(v))
-            return invalidConfigValue(context, [], 'must be a mapping');
-        for (const key of Object.keys(v)) {
-            if (key !== 'fetch' && key !== 'search' && key !== 'backend')
-                return invalidConfigValue(context, [key], 'is not a recognized web setting');
-        }
-        const raw = v;
-        if (raw.backend !== undefined &&
-            raw.backend !== 'auto' &&
-            raw.backend !== 'exa' &&
-            raw.backend !== 'native')
-            return invalidConfigValue(context, ['backend'], 'must be auto, exa or native');
-        if (raw.search === 'cached' && raw.backend === 'exa')
-            return invalidConfigValue(context, ['backend'], 'cached search requires native');
-        if (raw.search !== undefined &&
-            (typeof raw.search !== 'string' || !['off', 'cached', 'live'].includes(raw.search))) {
-            return invalidConfigValue(context, ['search'], 'must be off, cached, or live');
-        }
-        if (raw.fetch !== undefined && typeof raw.fetch !== 'boolean') {
-            return invalidConfigValue(context, ['fetch'], 'must be a boolean');
-        }
-        return raw;
-    },
-    limits: (v, context) => {
-        if (!isConfigMapping(v))
-            return invalidConfigValue(context, [], 'must be a mapping');
-        for (const key of Object.keys(v)) {
-            if (!['maxIterations', 'tokenBudget', 'timeoutMs', 'waitForProviderMs'].includes(key))
-                return invalidConfigValue(context, [key], 'is not a limit (maxIterations, tokenBudget, timeoutMs, waitForProviderMs)');
-            const value = v[key];
-            const minimum = key === 'waitForProviderMs' ? 1 : 0;
-            if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < minimum)
-                return invalidConfigValue(context, [key], `must be a safe whole number at least ${minimum}`);
-            if (key === 'timeoutMs' && value > 2_147_483_647)
-                return invalidConfigValue(context, [key], 'must be at most 2147483647 milliseconds; use 0 for unlimited');
-        }
-        return v;
-    },
-    plugins: (v, context) => {
-        if (!isConfigMapping(v))
-            return invalidConfigValue(context, [], 'must be a mapping');
-        const known = new Set(['enabled', 'autoDiscovery', 'allowedScopes', 'hookTimeoutMs']);
-        for (const key of Object.keys(v)) {
-            if (!known.has(key)) {
-                return invalidConfigValue(context, [key], 'is not a recognized plugin setting');
-            }
-        }
-        const raw = v;
-        if (raw.enabled !== undefined && typeof raw.enabled !== 'boolean') {
-            return invalidConfigValue(context, ['enabled'], 'must be a boolean');
-        }
-        if (raw.autoDiscovery !== undefined && typeof raw.autoDiscovery !== 'boolean') {
-            return invalidConfigValue(context, ['autoDiscovery'], 'must be a boolean');
-        }
-        let allowedScopes;
-        if (raw.allowedScopes !== undefined) {
-            if (!Array.isArray(raw.allowedScopes)) {
-                return invalidConfigValue(context, ['allowedScopes'], 'must be a list');
-            }
-            const invalidIndex = raw.allowedScopes.findIndex((scope) => scope !== 'project' && scope !== 'user');
-            if (invalidIndex >= 0) {
-                return invalidConfigValue(context, ['allowedScopes', invalidIndex], 'must be one of "project" or "user"');
-            }
-            if (new Set(raw.allowedScopes).size !== raw.allowedScopes.length) {
-                return invalidConfigValue(context, ['allowedScopes'], 'must not contain duplicates');
-            }
-            allowedScopes = raw.allowedScopes;
-        }
-        if (raw.hookTimeoutMs !== undefined &&
-            (!Number.isInteger(raw.hookTimeoutMs) ||
-                raw.hookTimeoutMs <= 0 ||
-                raw.hookTimeoutMs > 2_147_483_647)) {
-            return invalidConfigValue(context, ['hookTimeoutMs'], 'must be an integer from 1 to 2147483647');
-        }
-        return {
-            ...(raw.enabled !== undefined ? { enabled: raw.enabled } : {}),
-            ...(raw.autoDiscovery !== undefined ? { autoDiscovery: raw.autoDiscovery } : {}),
-            ...(allowedScopes !== undefined ? { allowedScopes } : {}),
-            ...(raw.hookTimeoutMs !== undefined ? { hookTimeoutMs: raw.hookTimeoutMs } : {}),
-        };
-    },
-    // Read field by field rather than shape-only, unlike the two above.
-    // Those hand their entries to a compiler that reports a bad one by name;
-    // this one is consumed directly, and a misspelled `require_isolation` or
-    // a string where a list belongs would otherwise become "no requirement"
-    // — a security control silently downgraded by a typo, which is the
-    // failure this whole change exists to remove.
-    sandbox: (v, context) => {
-        if (!isConfigMapping(v))
-            return invalidConfigValue(context, [], 'must be a mapping');
-        const raw = v;
-        for (const key of ['enabled', 'allowEscape', 'allowUnattendedEscape']) {
-            if (raw[key] !== undefined && typeof raw[key] !== 'boolean') {
-                return invalidConfigValue(context, [key], 'must be a boolean');
-            }
-        }
-        if (raw.requireIsolation !== undefined && !Array.isArray(raw.requireIsolation)) {
-            return invalidConfigValue(context, ['requireIsolation'], 'must be a list');
-        }
-        const requireIsolation = raw.requireIsolation;
-        const invalidIndex = requireIsolation?.findIndex((value) => value !== 'filesystem' && value !== 'network' && value !== 'process');
-        if (invalidIndex !== undefined && invalidIndex >= 0) {
-            return invalidConfigValue(context, ['requireIsolation', invalidIndex], 'must be one of "filesystem", "network", or "process"');
-        }
-        if (raw.workspace !== undefined &&
-            raw.workspace !== 'working-directory' &&
-            raw.workspace !== 'ephemeral') {
-            return invalidConfigValue(context, ['workspace'], 'must be one of "working-directory" or "ephemeral"');
-        }
-        if (raw.teardownTimeoutMs !== undefined &&
-            (!Number.isInteger(raw.teardownTimeoutMs) ||
-                raw.teardownTimeoutMs < 0 ||
-                raw.teardownTimeoutMs > 2_147_483_647)) {
-            return invalidConfigValue(context, ['teardownTimeoutMs'], 'must be an integer from 0 to 2147483647');
-        }
-        return {
-            ...(raw.enabled !== undefined ? { enabled: raw.enabled } : {}),
-            ...(raw.allowEscape !== undefined ? { allowEscape: raw.allowEscape } : {}),
-            ...(raw.allowUnattendedEscape !== undefined
-                ? { allowUnattendedEscape: raw.allowUnattendedEscape }
-                : {}),
-            ...(requireIsolation !== undefined
-                ? {
-                    requireIsolation: requireIsolation,
-                }
-                : {}),
-            ...(raw.workspace !== undefined
-                ? { workspace: raw.workspace }
-                : {}),
-            ...(raw.teardownTimeoutMs !== undefined
-                ? { teardownTimeoutMs: raw.teardownTimeoutMs }
-                : {}),
-        };
-    },
-    // Field by field, for the same reason as `sandbox` and one stronger:
-    // this one decides whether conversation content leaves the machine. A
-    // misspelled `redacters` read shape-only could change the export's security
-    // posture while it still ran. A malformed known field therefore refuses the
-    // config rather than selecting either "off" or a different redactor set.
-    telemetry: (v, context) => {
-        if (!isConfigMapping(v))
-            return invalidConfigValue(context, [], 'must be a mapping');
-        const raw = v;
-        if (raw.sessionExport === undefined)
-            return {};
-        const se = raw.sessionExport;
-        if (!isConfigMapping(se)) {
-            return invalidConfigValue(context, ['sessionExport'], 'must be a mapping');
-        }
-        const entry = se;
-        // No destination, no export. There is nothing to fall back to and
-        // nothing safe to guess.
-        if (typeof entry.destination !== 'string' || entry.destination.length === 0) {
-            return invalidConfigValue(context, ['sessionExport', 'destination'], 'must be a non-empty string');
-        }
-        let eventTypes;
-        if (entry.eventTypes !== undefined) {
-            if (!Array.isArray(entry.eventTypes)) {
-                return invalidConfigValue(context, ['sessionExport', 'eventTypes'], 'must be a list');
-            }
-            const invalidIndex = entry.eventTypes.findIndex((event) => typeof event !== 'string');
-            if (invalidIndex >= 0) {
-                return invalidConfigValue(context, ['sessionExport', 'eventTypes', invalidIndex], 'must be a string');
-            }
-            eventTypes = entry.eventTypes;
-        }
-        let redactors;
-        if (entry.redactors !== undefined) {
-            if (!Array.isArray(entry.redactors)) {
-                return invalidConfigValue(context, ['sessionExport', 'redactors'], 'must be a list');
-            }
-            const invalidIndex = entry.redactors.findIndex((redactor) => redactor !== 'secrets');
-            if (invalidIndex >= 0) {
-                return invalidConfigValue(context, ['sessionExport', 'redactors', invalidIndex], 'must be "secrets"');
-            }
-            redactors = entry.redactors;
-        }
-        return {
-            sessionExport: {
-                destination: entry.destination,
-                ...(eventTypes !== undefined ? { eventTypes } : {}),
-                ...(redactors !== undefined ? { redactors } : {}),
-            },
-        };
-    },
-    // TUI notifications are terminal escape writes only. Invalid nested values
-    // refuse rather than silently selecting a different event/protocol or
-    // disabling the feature the operator explicitly configured.
-    skills: (v, context) => {
-        if (!isConfigMapping(v))
-            return invalidConfigValue(context, [], 'must be a mapping');
-        for (const key of Object.keys(v)) {
-            if (!SKILLS_CONFIG_KEYS.includes(key)) {
-                return invalidConfigValue(context, [key], `is not a skills setting (${SKILLS_CONFIG_KEYS.join(', ')})`);
-            }
-        }
-        const raw = v;
-        if (raw.builtin !== undefined && typeof raw.builtin !== 'boolean') {
-            return invalidConfigValue(context, ['builtin'], 'must be true or false');
-        }
-        if (raw.suggest !== undefined && typeof raw.suggest !== 'boolean') {
-            return invalidConfigValue(context, ['suggest'], 'must be true or false');
-        }
-        if (raw.suggestMinToolCalls !== undefined &&
-            (typeof raw.suggestMinToolCalls !== 'number' ||
-                !Number.isInteger(raw.suggestMinToolCalls) ||
-                raw.suggestMinToolCalls < 1)) {
-            return invalidConfigValue(context, ['suggestMinToolCalls'], 'must be a whole number of at least 1');
-        }
-        if (raw.disabled !== undefined &&
-            (!Array.isArray(raw.disabled) ||
-                raw.disabled.some((name) => typeof name !== 'string' || name.trim() === ''))) {
-            return invalidConfigValue(context, ['disabled'], 'must be a list of skill names');
-        }
-        return {
-            ...(raw.builtin !== undefined ? { builtin: raw.builtin } : {}),
-            ...(raw.disabled !== undefined
-                ? { disabled: raw.disabled.map((name) => name.trim()) }
-                : {}),
-            ...(raw.suggest !== undefined ? { suggest: raw.suggest } : {}),
-            ...(raw.suggestMinToolCalls !== undefined
-                ? { suggestMinToolCalls: raw.suggestMinToolCalls }
-                : {}),
-        };
-    },
-    schedule: (v, context) => {
-        if (!isConfigMapping(v))
-            return invalidConfigValue(context, [], 'must be a mapping');
-        for (const key of Object.keys(v)) {
-            if (key !== 'maxConcurrentRuns' && key !== 'notifications') {
-                return invalidConfigValue(context, [key], 'is not a schedule setting (maxConcurrentRuns, notifications)');
-            }
-        }
-        const raw = v;
-        if (raw.maxConcurrentRuns !== undefined &&
-            (typeof raw.maxConcurrentRuns !== 'number' ||
-                !Number.isSafeInteger(raw.maxConcurrentRuns) ||
-                raw.maxConcurrentRuns < 1 ||
-                raw.maxConcurrentRuns > 16)) {
-            return invalidConfigValue(context, ['maxConcurrentRuns'], 'must be a whole number from 1 to 16');
-        }
-        if (raw.notifications !== undefined && typeof raw.notifications !== 'boolean') {
-            return invalidConfigValue(context, ['notifications'], 'must be a boolean');
-        }
-        return {
-            ...(raw.maxConcurrentRuns !== undefined
-                ? { maxConcurrentRuns: raw.maxConcurrentRuns }
-                : {}),
-            ...(raw.notifications !== undefined ? { notifications: raw.notifications } : {}),
-        };
-    },
-    // Shape only: the words themselves are matched by the interactive
-    // terminal, which is the only reader. A wrong key or value still refuses,
-    // because an operator who wrote `enabled: flase` believes it is off.
-    composerTriggers: (v, context) => {
-        if (!isConfigMapping(v))
-            return invalidConfigValue(context, [], 'must be a mapping');
-        for (const key of Object.keys(v)) {
-            if (!COMPOSER_TRIGGERS_KEYS.includes(key)) {
-                return invalidConfigValue(context, [key], `is not a composerTriggers setting (${COMPOSER_TRIGGERS_KEYS.join(', ')})`);
-            }
-        }
-        const raw = v;
-        for (const key of ['enabled', 'suggest']) {
-            if (raw[key] !== undefined && typeof raw[key] !== 'boolean')
-                return invalidConfigValue(context, [key], 'must be true or false');
-        }
-        let languages;
-        if (raw.languages !== undefined) {
-            if (!Array.isArray(raw.languages))
-                return invalidConfigValue(context, ['languages'], 'must be a list: en, tr');
-            languages = [];
-            for (const [index, language] of raw.languages.entries()) {
-                if (!COMPOSER_TRIGGER_LANGUAGES.includes(language))
-                    return invalidConfigValue(context, ['languages', index], 'must be en or tr');
-                languages.push(language);
-            }
-        }
-        let builtin;
-        if (raw.builtin !== undefined) {
-            if (!isConfigMapping(raw.builtin))
-                return invalidConfigValue(context, ['builtin'], 'must be a mapping of trigger to arm, suggest or off');
-            builtin = {};
-            for (const [id, arming] of Object.entries(raw.builtin)) {
-                if (!COMPOSER_TRIGGER_IDS.includes(id))
-                    return invalidConfigValue(context, ['builtin', id], `is not a built-in trigger (${COMPOSER_TRIGGER_IDS.join(', ')})`);
-                if (arming !== 'arm' && arming !== 'suggest' && arming !== 'off')
-                    return invalidConfigValue(context, ['builtin', id], 'must be arm, suggest or off');
-                builtin[id] = arming;
-            }
-        }
-        return {
-            ...(raw.enabled !== undefined ? { enabled: raw.enabled } : {}),
-            ...(raw.suggest !== undefined ? { suggest: raw.suggest } : {}),
-            ...(languages !== undefined ? { languages } : {}),
-            ...(builtin !== undefined ? { builtin } : {}),
-        };
-    },
-    tui: (v, context) => {
-        if (!isConfigMapping(v))
-            return invalidConfigValue(context, [], 'must be a mapping');
-        const raw = v;
-        let notifications;
-        if (typeof raw.notifications === 'boolean')
-            notifications = raw.notifications;
-        else if (Array.isArray(raw.notifications)) {
-            const invalidIndex = raw.notifications.findIndex((event) => event !== 'turn-settled' && event !== 'approval-required');
-            if (invalidIndex >= 0) {
-                return invalidConfigValue(context, ['notifications', invalidIndex], 'must be one of "turn-settled" or "approval-required"');
-            }
-            notifications = raw.notifications;
-        }
-        else if (raw.notifications !== undefined) {
-            return invalidConfigValue(context, ['notifications'], 'must be a boolean or a list');
-        }
-        const method = raw.notificationMethod;
-        if (method !== undefined && method !== 'osc9' && method !== 'bel') {
-            return invalidConfigValue(context, ['notificationMethod'], 'must be "osc9" or "bel"');
-        }
-        return {
-            ...(notifications !== undefined ? { notifications } : {}),
-            ...(method !== undefined ? { notificationMethod: method } : {}),
-        };
-    },
-};
-export const ENV_VARIABLE_NAMES = {
-    format: 'NAMZU_FORMAT',
-    quiet: 'NAMZU_QUIET',
-    permissions: undefined,
-    // Deliberately not env-settable, and for a sharper reason than the rest:
-    // a variable that could replace the checks could also empty them, which
-    // would silence the one thing that says a policy stopped meaning what its
-    // author wrote — from a shell profile, with nothing in the config file to
-    // show for it.
-    permissionChecks: undefined,
-    // The SET of profiles is not env-settable — it is the thing being chosen
-    // BETWEEN, and a variable that could replace it could hand a shell a
-    // profile the files never declared. `NAMZU_PROFILE` selects one of the
-    // declared profiles and is read in the cascade rather than here, because
-    // it does not set a config field.
-    profiles: undefined,
-    mcpServers: undefined,
-    // Executable code must never be enabled by ambient shell state. The file
-    // and its provenance are the reviewable source of this authority.
-    plugins: undefined,
-    sandbox: undefined,
-    limits: undefined,
-    // Outbound reach is opted into in the file, never from the environment.
-    web: undefined,
-    // A browser signed in to the operator's sites, and which of them it may
-    // change: a file decision, never a shell's.
-    browser: undefined,
-    // A hook runs a command with the operator's authority; the file is the only
-    // place one may be declared.
-    hooks: undefined,
-    additionalDirectories: undefined,
-    // Absent here for the reason `additionalDirectories` is: the environment
-    // carries scalars, and a screen is a list of names whose meaning belongs
-    // where a project's runs are reviewed.
-    toolResultScreens: undefined,
-    // A strategy is a property of a project's runs, declared where they are reviewed.
-    compaction: undefined,
-    memory: undefined,
-    // Deliberately not env-settable. A `NAMZU_TELEMETRY_SESSION_EXPORT=/tmp/x`
-    // in a shell profile would start exporting conversation content with
-    // nothing in the config file to show for it — the disclosure would be
-    // honest and the *reason* would be invisible.
-    telemetry: undefined,
-    // Terminal notifications are an interactive UI choice. An environment
-    // variable in a shell profile must not start producing them invisibly.
-    tui: undefined,
-    // How many unattended runs a machine starts is the machine owner's to say,
-    // in a file; never a variable a profile could carry invisibly.
-    schedule: undefined,
-    // A list of names and a switch that decide what reaches the model's prompt;
-    // declared in a file, where a project's runs are reviewed.
-    skills: undefined,
-    // What typed words do in the operator's own composer: a file decision,
-    // never a variable a shell profile could carry invisibly.
-    composerTriggers: undefined,
-    // A scalar switch, and the one a CI job or a test harness needs to keep a
-    // launch off the network without writing a config file.
-    modelCatalogueRefresh: 'NAMZU_MODEL_CATALOGUE_REFRESH',
-};
-function readEnv(env) {
-    const config = {};
-    const variables = {};
-    const formatVar = ENV_VARIABLE_NAMES.format;
-    if (formatVar) {
-        const format = env[formatVar];
-        if (format !== undefined) {
-            if (!isFormatName(format)) {
-                throw new ConfigValueError({ kind: 'environment', variable: formatVar }, 'format', 'must be one of "text", "json", or "yaml"');
-            }
-            config.format = format;
-            variables.format = formatVar;
-        }
-    }
-    const quietVar = ENV_VARIABLE_NAMES.quiet;
-    if (quietVar) {
-        const quiet = env[quietVar];
-        if (quiet !== undefined) {
-            if (quiet !== '1' && quiet !== 'true' && quiet !== '0' && quiet !== 'false') {
-                throw new ConfigValueError({ kind: 'environment', variable: quietVar }, 'quiet', 'must be one of "1", "true", "0", or "false"');
-            }
-            config.quiet = quiet === '1' || quiet === 'true';
-            variables.quiet = quietVar;
-        }
-    }
-    const refreshVar = ENV_VARIABLE_NAMES.modelCatalogueRefresh;
-    if (refreshVar) {
-        const refresh = env[refreshVar];
-        if (refresh !== undefined) {
-            if (refresh !== '1' && refresh !== 'true' && refresh !== '0' && refresh !== 'false') {
-                throw new ConfigValueError({ kind: 'environment', variable: refreshVar }, 'modelCatalogueRefresh', 'must be one of "1", "true", "0", or "false"');
-            }
-            config.modelCatalogueRefresh = refresh === '1' || refresh === 'true';
-            variables.modelCatalogueRefresh = refreshVar;
-        }
-    }
-    return { config, variables };
-}
-function sanitize(value, source, prefix = [], allowProfiles = true) {
-    const v = value;
-    const out = {};
-    for (const key of Object.keys(CONFIG_READERS)) {
-        if (!Object.hasOwn(v, key))
-            continue;
-        if (!allowProfiles && (key === 'profiles' || key === 'plugins')) {
-            throw new ConfigValueError(source, formatSettingPath([...prefix, key]), key === 'plugins'
-                ? 'cannot be declared inside a profile because profiles may be selected by the environment'
-                : 'cannot be declared inside a profile');
-        }
-        const parsed = CONFIG_READERS[key](v[key], {
-            source,
-            path: [...prefix, key],
-        });
-        out[key] = parsed;
-    }
-    return out;
-}
-function isConfigMapping(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function invalidConfigValue(context, suffix, message) {
-    throw new ConfigValueError(context.source, formatSettingPath([...context.path, ...suffix]), message);
-}
-function formatSettingPath(segments) {
-    let out = '';
-    for (const segment of segments) {
-        if (typeof segment === 'number') {
-            out += `[${segment}]`;
-            continue;
-        }
-        if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(segment)) {
-            out += out === '' ? segment : `.${segment}`;
-            continue;
-        }
-        out += `[${configMetadataLiteral(segment)}]`;
-    }
-    return out;
-}
-function constantLayer(config, source) {
-    return { config, sourceFor: () => source };
-}
-/**
- * Merges cascade layers lowest-precedence first onto `MutableConfig`, with no
- * cast on the result — see that type's own doc comment for why the cast used
- * to be the bug this shape prevents. Still a per-key loop rather than
- * `Object.assign`, now for two reasons instead of one: the original reason (a
- * key `MutableConfig` cannot carry must fail to compile, not vanish) plus
- * recording `ConfigProvenance` in the same pass a key is written, so a key
- * can never land in one map and not the other.
- */
-function mergeConfigs(...layers) {
-    const out = {};
-    const provenance = {};
-    for (const layer of layers) {
-        for (const key of Object.keys(layer.config)) {
-            if (key === 'browser' && layer.config.browser) {
-                // Merged, not replaced: see `mergeBrowserConfig`.
-                out.browser = mergeBrowserConfig(out.browser, layer.config.browser, layer.sourceFor(key));
-                provenance[key] = layer.sourceFor(key);
-                continue;
-            }
-            if (key === 'composerTriggers' && layer.config.composerTriggers) {
-                // Merged per key; a project layer only lowers. See `mergeComposerTriggers`.
-                out.composerTriggers = mergeComposerTriggers(out.composerTriggers, layer.config.composerTriggers, isProjectSource(layer.sourceFor(key)));
-                provenance[key] = layer.sourceFor(key);
-                continue;
-            }
-            // Same widened-view assignment as `sanitize`: a cast on the target,
-            // not the value, is what lets a generic key write onto a
-            // heterogeneous mapped type without silently dropping a field this
-            // function cannot carry.
-            ;
-            out[key] = layer.config[key];
-            provenance[key] = layer.sourceFor(key);
-        }
-    }
-    return { config: out, provenance };
-}
-// ---------------------------------------------------------------------------
-// browser
-// ---------------------------------------------------------------------------
-const BROWSER_KEYS = new Set([
-    'enabled',
-    'defaultProfile',
-    'engine',
-    'headless',
-    'sites',
-    'keepOpen',
-]);
-/** `@namzu/browser`'s profile names, restated so reading config does not load Playwright. */
-const BROWSER_PROFILE_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-function readBrowserConfig(v, context) {
-    if (!isConfigMapping(v))
-        return invalidConfigValue(context, [], 'must be a mapping');
-    for (const key of Object.keys(v)) {
-        if (!BROWSER_KEYS.has(key)) {
-            return invalidConfigValue(context, [key], 'is not a browser setting (enabled, defaultProfile, engine, headless, sites, keepOpen)');
-        }
-    }
-    const raw = v;
-    for (const key of ['enabled', 'keepOpen']) {
-        if (raw[key] !== undefined && typeof raw[key] !== 'boolean')
-            return invalidConfigValue(context, [key], 'must be true or false');
-    }
-    if (raw.defaultProfile !== undefined &&
-        (typeof raw.defaultProfile !== 'string' ||
-            raw.defaultProfile.length > 64 ||
-            !BROWSER_PROFILE_NAME.test(raw.defaultProfile))) {
-        return invalidConfigValue(context, ['defaultProfile'], 'must be a profile name: lowercase letters, digits and single hyphens, at most 64 characters');
-    }
-    if (raw.engine !== undefined && !['auto', 'windows', 'local'].includes(raw.engine))
-        return invalidConfigValue(context, ['engine'], 'must be auto, windows or local');
-    if (raw.headless !== undefined && !['auto', 'always', 'never'].includes(raw.headless))
-        return invalidConfigValue(context, ['headless'], 'must be auto, always or never');
-    let sites;
-    if (raw.sites !== undefined) {
-        if (!isConfigMapping(raw.sites))
-            return invalidConfigValue(context, ['sites'], 'must be a mapping of site to level');
-        sites = {};
-        for (const [key, level] of Object.entries(raw.sites)) {
-            // Refused, not dropped: a site rule that silently vanished is a deny
-            // the operator believes in and the gate never sees.
-            if (!isBrowserSiteLevel(level))
-                return invalidConfigValue(context, ['sites', key], 'must be deny, read, ask or act');
-            const verdict = canonicalBrowserSiteKey(key);
-            if (!verdict.ok)
-                return invalidConfigValue(context, ['sites', key], verdict.reason);
-            const existing = sites[verdict.key];
-            sites[verdict.key] = existing === undefined ? level : narrower(existing, level);
-        }
-    }
-    return {
-        ...(raw.enabled !== undefined ? { enabled: raw.enabled } : {}),
-        ...(raw.defaultProfile !== undefined ? { defaultProfile: raw.defaultProfile } : {}),
-        ...(raw.engine !== undefined ? { engine: raw.engine } : {}),
-        ...(raw.headless !== undefined ? { headless: raw.headless } : {}),
-        ...(sites !== undefined ? { sites } : {}),
-        ...(raw.keepOpen !== undefined ? { keepOpen: raw.keepOpen } : {}),
-    };
-}
-function isProjectSource(source) {
-    return (source.kind === 'project-file' ||
-        (source.kind === 'profile' && basename(source.path) === 'namzu.config.json'));
-}
-/**
- * `browser` from one more layer, over what the layers below it said.
- *
- * Merged key by key, the later layer winning, with three exceptions, all in
- * the direction of less reach:
- *
- * - `enabled: false` in any file holds; a later file cannot switch it on.
- * - `sites` are merged per site. A site any file denies stays denied, and
- *   once a file has denied every other site (`"*": deny`), a later file's
- *   new sites are ignored: they would open what that file closed.
- * - `defaultProfile` is refused in a project file. A profile carries the
- *   operator's sign-ins, and a repository must not pick which ones its
- *   agent runs under.
- */
-export function mergeBrowserConfig(below, layer, source) {
-    if (layer.defaultProfile !== undefined && isProjectSource(source)) {
-        throw new ConfigValueError({ kind: 'file', path: 'path' in source ? source.path : 'namzu.config.json' }, 'browser.defaultProfile', 'cannot be set in a project file: a profile holds your sign-ins, so choose it in your user config or with /browser profile');
-    }
-    if (!below)
-        return layer;
-    let sites = below.sites;
-    if (layer.sites) {
-        const merged = { ...(below.sites ?? {}) };
-        const closed = below.sites?.['*'] === 'deny';
-        for (const [key, level] of Object.entries(layer.sites)) {
-            const existing = merged[key];
-            if (existing === undefined) {
-                if (closed && key !== '*')
-                    continue;
-                merged[key] = level;
-                continue;
-            }
-            merged[key] = existing === 'deny' ? 'deny' : level;
-        }
-        sites = merged;
-    }
-    const enabled = below.enabled === false || layer.enabled === false ? false : (layer.enabled ?? below.enabled);
-    return {
-        ...below,
-        ...layer,
-        ...(enabled !== undefined ? { enabled } : {}),
-        ...(sites !== undefined ? { sites } : {}),
-    };
-}
-//# sourceMappingURL=load.js.map