@litfamily/litcodex 1.0.0

package/dist/config-migration/multi-agent-v2-guard.d.ts

@@ -0,0 +1,26 @@
+/** Ensure the reserved collaboration schema, hard concurrency 20, and depth-one topology. */
+export declare function ensureStableMultiAgent(config: string): string;
+/** True for a LitCodex marker or any enabled V2 table that installation must make schema-safe. */
+export declare function hasManagedMultiAgentGuard(config: string): boolean;
+/** Detect the request-layer 400 shape that strict TOML validation cannot catch. */
+export declare function hasReservedSpawnSchemaMismatch(config: string): boolean;
+/** Backward-compatible export for callers compiled against the prior name. */
+export declare const forceDisableMultiAgentV2: typeof ensureStableMultiAgent;
+/** Legacy keys written by older builds; Codex 0.144.0 does not accept them. */
+export declare const SUBAGENT_DEFAULT_MODEL_KEY = "default_subagent_model";
+export declare const SUBAGENT_DEFAULT_EFFORT_KEY = "default_subagent_reasoning_effort";
+/**
+ * Legacy serializer retained for callers that still need to inspect old state.
+ * Current migration never calls this: Codex 0.144.0 treats these scalar values
+ * as malformed agent-role tables and rejects the complete config.
+ */
+export declare function ensureSubagentDefaults(config: string, model: string, effort: string, options?: {
+    readonly overwrite?: boolean;
+}): string;
+/** Remove exactly the two legacy subagent-default keys from `[agents]`. */
+export declare function removeSubagentDefaults(config: string): string;
+/** Read the two legacy subagent-default keys from `[agents]`, when present. */
+export declare function readSubagentDefaults(config: string): {
+    readonly model?: string;
+    readonly effort?: string;
+};

package/dist/config-migration/multi-agent-v2-guard.js

@@ -0,0 +1,166 @@
+// Reserved-schema-safe multi-agent V2 guard for Codex 0.144.x.
+//
+// gpt-5.6 models reserve collaboration.spawn_agent and reject V2's extended
+// metadata schema. Hiding that metadata selects the model-owned schema while
+// retaining a hard 20-thread session cap and the host's depth-one guard.
+const MANAGED_COMMENT_MARKER = "Managed by LitCodex";
+const MANAGED_GUARD_COMMENT = [
+    `# ${MANAGED_COMMENT_MARKER}: reserved-schema-safe depth-one multi-agent, hard concurrency 20.`,
+    "# Opt out: LITCODEX_CONFIG_MIGRATION_DISABLED=1.",
+    "",
+].join("\n");
+/** Ensure the reserved collaboration schema, hard concurrency 20, and depth-one topology. */
+export function ensureStableMultiAgent(config) {
+    let result = removeEnabledFeaturesShorthand(config);
+    result = ensureSectionSetting(result, "[features]", "multi_agent", "true");
+    result = ensureSectionSetting(result, "[features.multi_agent_v2]", "enabled", "true");
+    result = ensureSectionSetting(result, "[features.multi_agent_v2]", "hide_spawn_agent_metadata", "true");
+    result = ensureSectionSetting(result, "[features.multi_agent_v2]", "max_concurrent_threads_per_session", "20");
+    result = removeSectionSetting(result, "[agents]", "max_threads");
+    result = ensureSectionSetting(result, "[agents]", "max_depth", "1");
+    return ensureManagedComment(result);
+}
+/** True for a LitCodex marker or any enabled V2 table that installation must make schema-safe. */
+export function hasManagedMultiAgentGuard(config) {
+    if (config.includes(MANAGED_COMMENT_MARKER))
+        return true;
+    const section = findSection(config, "[features.multi_agent_v2]");
+    if (section === null)
+        return false;
+    return hasSectionSetting(section.text, "enabled", "true");
+}
+/** Detect the request-layer 400 shape that strict TOML validation cannot catch. */
+export function hasReservedSpawnSchemaMismatch(config) {
+    const section = findSection(config, "[features.multi_agent_v2]");
+    return (section !== null &&
+        hasSectionSetting(section.text, "enabled", "true") &&
+        !hasSectionSetting(section.text, "hide_spawn_agent_metadata", "true"));
+}
+/** Backward-compatible export for callers compiled against the prior name. */
+export const forceDisableMultiAgentV2 = ensureStableMultiAgent;
+/** Legacy keys written by older builds; Codex 0.144.0 does not accept them. */
+export const SUBAGENT_DEFAULT_MODEL_KEY = "default_subagent_model";
+export const SUBAGENT_DEFAULT_EFFORT_KEY = "default_subagent_reasoning_effort";
+/**
+ * Legacy serializer retained for callers that still need to inspect old state.
+ * Current migration never calls this: Codex 0.144.0 treats these scalar values
+ * as malformed agent-role tables and rejects the complete config.
+ */
+export function ensureSubagentDefaults(config, model, effort, options = {}) {
+    let result = config;
+    for (const [key, value] of [
+        [SUBAGENT_DEFAULT_MODEL_KEY, model],
+        [SUBAGENT_DEFAULT_EFFORT_KEY, effort],
+    ]) {
+        if (options.overwrite === true || readSectionSetting(result, "[agents]", key) === null) {
+            result = ensureSectionSetting(result, "[agents]", key, JSON.stringify(value));
+        }
+    }
+    return result;
+}
+/** Remove exactly the two legacy subagent-default keys from `[agents]`. */
+export function removeSubagentDefaults(config) {
+    let result = removeSectionSetting(config, "[agents]", SUBAGENT_DEFAULT_MODEL_KEY);
+    result = removeSectionSetting(result, "[agents]", SUBAGENT_DEFAULT_EFFORT_KEY);
+    return result;
+}
+/** Read the two legacy subagent-default keys from `[agents]`, when present. */
+export function readSubagentDefaults(config) {
+    const model = readSectionSetting(config, "[agents]", SUBAGENT_DEFAULT_MODEL_KEY);
+    const effort = readSectionSetting(config, "[agents]", SUBAGENT_DEFAULT_EFFORT_KEY);
+    return { ...(model === null ? {} : { model }), ...(effort === null ? {} : { effort }) };
+}
+function readSectionSetting(config, header, key) {
+    const section = findSection(config, header);
+    if (section === null)
+        return null;
+    const match = section.text.match(new RegExp(`^\\s*${key}\\s*=\\s*"([^"\\n]*)"`, "m"));
+    return match?.[1] ?? null;
+}
+function ensureManagedComment(config) {
+    if (config.includes(MANAGED_COMMENT_MARKER)) {
+        return config.replace(/^# Managed by LitCodex:.*$/m, MANAGED_GUARD_COMMENT.split("\n")[0] ?? "");
+    }
+    const section = findSection(config, "[features.multi_agent_v2]");
+    if (section === null) {
+        return config;
+    }
+    return config.slice(0, section.start) + MANAGED_GUARD_COMMENT + config.slice(section.start);
+}
+function removeEnabledFeaturesShorthand(config) {
+    const section = findSection(config, "[features]");
+    if (section === null) {
+        return config;
+    }
+    const shorthandPattern = /^\s*multi_agent_v2\s*=\s*(?:true|false)[ \t]*(?:#[^\n]*)?[ \t]*\n?/m;
+    if (!shorthandPattern.test(section.text)) {
+        return config;
+    }
+    const patched = section.text.replace(shorthandPattern, "");
+    return config.slice(0, section.start) + patched + config.slice(section.end);
+}
+function appendSection(config, header, key, value) {
+    const trimmed = config.trimEnd();
+    const prefix = trimmed.length === 0 ? "" : `${trimmed}\n\n`;
+    return `${prefix}${header}\n${key} = ${value}\n`;
+}
+function ensureSectionSetting(config, header, key, value) {
+    const section = findSection(config, header);
+    if (section === null)
+        return appendSection(config, header, key, value);
+    const patched = replaceOrInsertSectionSetting(section.text, key, value);
+    return config.slice(0, section.start) + patched + config.slice(section.end);
+}
+function removeSectionSetting(config, header, key) {
+    const section = findSection(config, header);
+    if (section === null)
+        return config;
+    const pattern = new RegExp(`^\\s*${key}\\s*=.*(?:\\n|$)`, "m");
+    const patched = section.text.replace(pattern, "");
+    return config.slice(0, section.start) + patched + config.slice(section.end);
+}
+function replaceOrInsertSectionSetting(section, key, value) {
+    const pattern = new RegExp(`^(\\s*)${key}\\s*=.*$`, "m");
+    if (pattern.test(section)) {
+        return section.replace(pattern, (_match, indent) => `${indent}${key} = ${value}`);
+    }
+    const headerEnd = section.indexOf("\n");
+    const insertAt = headerEnd === -1 ? section.length : headerEnd + 1;
+    return `${section.slice(0, insertAt)}${headerEnd === -1 ? "\n" : ""}${key} = ${value}\n${section.slice(insertAt)}`;
+}
+function hasSectionSetting(section, key, value) {
+    const pattern = new RegExp(`^\\s*${key}\\s*=\\s*${value}\\s*(?:#[^\\n]*)?$`, "m");
+    return pattern.test(section);
+}
+/** Strip a trailing inline comment (best-effort; quoted keys with # out of scope). */
+function stripTrailingComment(line) {
+    const idx = line.indexOf("#");
+    return idx === -1 ? line : line.slice(0, idx).trim();
+}
+function findSection(config, headerLine) {
+    const lines = config.match(/[^\n]*\n?|$/g) ?? [];
+    let offset = 0;
+    let start = -1;
+    for (const line of lines) {
+        if (line.length === 0) {
+            break;
+        }
+        const trimmed = line.trim();
+        if (start === -1) {
+            if (stripTrailingComment(trimmed) === headerLine) {
+                start = offset;
+            }
+        }
+        else {
+            const bare = stripTrailingComment(trimmed);
+            if (bare.startsWith("[") && bare.endsWith("]")) {
+                return { start, end: offset, text: config.slice(start, offset) };
+            }
+        }
+        offset += line.length;
+    }
+    if (start === -1) {
+        return null;
+    }
+    return { start, end: config.length, text: config.slice(start) };
+}

package/dist/config-migration/native-default-route.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Keep omitted-agent dispatch on Codex's native default role.
+ *
+ * This is deliberately a nested `agents.default.config_file` setting. The host owns the
+ * dispatch semantics; LitCodex only supplies the role file and never invents a global scalar
+ * default-model key. Existing user-owned bindings are left byte-for-byte intact. Ambiguous native
+ * TOML shapes fail closed because a text rewrite cannot safely decide which binding the host uses.
+ */
+export declare function ensureNativeDefaultAgentConfig(config: string, configFile: string, configPath?: string | null): string;

package/dist/config-migration/native-default-route.js

@@ -0,0 +1,336 @@
+import { CodexConfigMigrationError } from "./errors.js";
+/**
+ * Keep omitted-agent dispatch on Codex's native default role.
+ *
+ * This is deliberately a nested `agents.default.config_file` setting. The host owns the
+ * dispatch semantics; LitCodex only supplies the role file and never invents a global scalar
+ * default-model key. Existing user-owned bindings are left byte-for-byte intact. Ambiguous native
+ * TOML shapes fail closed because a text rewrite cannot safely decide which binding the host uses.
+ */
+export function ensureNativeDefaultAgentConfig(config, configFile, configPath = null) {
+    const scan = scanDefaultBindings(config);
+    if (scan.ambiguous !== null) {
+        throw new CodexConfigMigrationError("CONFIG_MALFORMED", "Codex default-agent binding is ambiguous; refusing to rewrite it.", configPath, { reason: scan.ambiguous });
+    }
+    if (scan.bindingCount > 0 || scan.hasDefaultTable)
+        return config;
+    const prefix = config.trimEnd();
+    return `${prefix}${prefix.length === 0 ? "" : "\n\n"}[agents.default]\nconfig_file = ${JSON.stringify(configFile)}\n`;
+}
+/** Scan only enough TOML to distinguish a single native binding from unsafe alternatives. */
+function scanDefaultBindings(config) {
+    let section = null;
+    let multilineCloser = null;
+    let hasDefaultTable = false;
+    let bindingCount = 0;
+    let defaultTableKind = null;
+    const ambiguous = (reason) => ({ bindingCount, hasDefaultTable, ambiguous: reason });
+    const recordBinding = (value, shape) => {
+        const parsed = parseStringValue(value);
+        if (parsed === null)
+            return ambiguous(`${shape} config_file is not a plain TOML string`);
+        bindingCount += 1;
+        if (bindingCount > 1)
+            return ambiguous("multiple agents.default config_file bindings");
+        return null;
+    };
+    const recordDefaultTable = (kind) => {
+        if (defaultTableKind !== null && (defaultTableKind !== kind || kind !== "dotted")) {
+            return ambiguous("duplicate agents.default tables");
+        }
+        defaultTableKind = kind;
+        hasDefaultTable = true;
+        return null;
+    };
+    for (const raw of config.split("\n")) {
+        if (multilineCloser !== null) {
+            if (raw.includes(multilineCloser))
+                multilineCloser = null;
+            continue;
+        }
+        const line = stripTomlComment(raw);
+        const triple = multilineOpener(line);
+        if (triple !== null) {
+            multilineCloser = triple;
+            continue;
+        }
+        const trimmed = line.trim();
+        if (trimmed === "")
+            continue;
+        const header = parseHeader(trimmed);
+        if (header !== null) {
+            section = header.name;
+            if (sameKey(header.name, ["agents", "default"])) {
+                if (header.array)
+                    return ambiguous("agents.default array-of-tables is unsupported");
+                const failure = recordDefaultTable("header");
+                if (failure !== null)
+                    return failure;
+            }
+            continue;
+        }
+        const equals = findTopLevelEquals(trimmed);
+        if (equals < 0)
+            continue;
+        const key = parseKeyPath(trimmed.slice(0, equals));
+        if (key === null)
+            continue;
+        const value = trimmed.slice(equals + 1).trim();
+        const effectiveKey = section === null ? key : [...section, ...key];
+        const currentDefaultTable = section !== null && sameKey(section, ["agents", "default"]);
+        if (currentDefaultTable && sameKey(key, ["config_file"])) {
+            const failure = recordBinding(value, "table");
+            if (failure !== null)
+                return failure;
+            continue;
+        }
+        if (effectiveKey.length >= 2 && sameKey(effectiveKey.slice(0, 2), ["agents", "default"])) {
+            const inlineDefault = sameKey(effectiveKey, ["agents", "default"]) &&
+                ((section !== null && sameKey(section, ["agents"]) && sameKey(key, ["default"])) ||
+                    (section === null && sameKey(key, ["agents", "default"])));
+            if (!currentDefaultTable) {
+                const tableFailure = recordDefaultTable(inlineDefault ? "inline" : "dotted");
+                if (tableFailure !== null)
+                    return tableFailure;
+            }
+            if (sameKey(effectiveKey, ["agents", "default", "config_file"])) {
+                const failure = recordBinding(value, inlineDefault ? "inline" : "dotted");
+                if (failure !== null)
+                    return failure;
+                continue;
+            }
+            if (!inlineDefault)
+                continue;
+            const inline = scanInlineDefaultTable(value);
+            if (inline.ambiguous !== null)
+                return ambiguous(inline.ambiguous);
+            if (inline.configFile !== null) {
+                const failure = recordBinding(inline.configFile, "inline");
+                if (failure !== null)
+                    return failure;
+            }
+        }
+    }
+    return { bindingCount, hasDefaultTable, ambiguous: null };
+}
+function parseHeader(line) {
+    const array = line.startsWith("[[");
+    const opening = array ? "[[" : "[";
+    const closing = array ? "]]" : "]";
+    if (!line.startsWith(opening) || !line.endsWith(closing))
+        return null;
+    const name = parseKeyPath(line.slice(opening.length, -closing.length));
+    return name === null || name.length === 0 ? null : { name, array };
+}
+function sameKey(left, right) {
+    return left.length === right.length && left.every((part, index) => part === right[index]);
+}
+function findTopLevelEquals(line) {
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const char = line[index];
+        if (quote === '"' && escaped) {
+            escaped = false;
+            continue;
+        }
+        if (quote === '"' && char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote !== null && char === quote) {
+            quote = null;
+            continue;
+        }
+        if (quote === null && (char === '"' || char === "'")) {
+            quote = char;
+            continue;
+        }
+        if (quote === null && char === "=")
+            return index;
+    }
+    return -1;
+}
+function parseKeyPath(input) {
+    const parts = [];
+    let index = 0;
+    while (index < input.length) {
+        while (/\s/u.test(input[index] ?? ""))
+            index += 1;
+        if (index >= input.length)
+            break;
+        const first = input[index];
+        let part;
+        if (first === '"' || first === "'") {
+            const quote = first;
+            const start = index;
+            index += 1;
+            let escaped = false;
+            while (index < input.length) {
+                const char = input[index];
+                if (quote === '"' && escaped) {
+                    escaped = false;
+                    index += 1;
+                    continue;
+                }
+                if (quote === '"' && char === "\\") {
+                    escaped = true;
+                    index += 1;
+                    continue;
+                }
+                if (char === quote)
+                    break;
+                index += 1;
+            }
+            if (index >= input.length || input[index] !== quote)
+                return null;
+            part = parseStringValue(input.slice(start, index + 1));
+            index += 1;
+        }
+        else {
+            const start = index;
+            while (index < input.length && /[A-Za-z0-9_-]/u.test(input[index] ?? ""))
+                index += 1;
+            if (start === index)
+                return null;
+            part = input.slice(start, index);
+        }
+        if (part === null)
+            return null;
+        parts.push(part);
+        while (/\s/u.test(input[index] ?? ""))
+            index += 1;
+        if (index >= input.length)
+            return parts;
+        if (input[index] !== ".")
+            return null;
+        index += 1;
+    }
+    return parts.length === 0 ? null : parts;
+}
+function scanInlineDefaultTable(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("{"))
+        return { configFile: null, ambiguous: null };
+    if (!trimmed.endsWith("}"))
+        return { configFile: null, ambiguous: "default inline table is unterminated" };
+    const entries = splitInlineEntries(trimmed.slice(1, -1));
+    if (entries === null)
+        return { configFile: null, ambiguous: "default inline table could not be scanned safely" };
+    let configFile = null;
+    for (const entry of entries) {
+        if (entry.trim() === "")
+            continue;
+        const equals = findTopLevelEquals(entry);
+        if (equals < 0)
+            return { configFile: null, ambiguous: "default inline table contains an unparseable entry" };
+        const key = parseKeyPath(entry.slice(0, equals));
+        if (key === null)
+            return { configFile: null, ambiguous: "default inline table contains an unparseable key" };
+        if (!sameKey(key, ["config_file"]))
+            continue;
+        const valueText = entry.slice(equals + 1).trim();
+        if (configFile !== null)
+            return { configFile: null, ambiguous: "multiple agents.default config_file bindings" };
+        if (parseStringValue(valueText) === null) {
+            return { configFile: null, ambiguous: "inline config_file is not a plain TOML string" };
+        }
+        configFile = valueText;
+    }
+    return { configFile, ambiguous: null };
+}
+function splitInlineEntries(body) {
+    const entries = [];
+    let start = 0;
+    let quote = null;
+    let escaped = false;
+    let curly = 0;
+    let square = 0;
+    for (let index = 0; index < body.length; index += 1) {
+        const char = body[index];
+        if (quote === '"' && escaped) {
+            escaped = false;
+            continue;
+        }
+        if (quote === '"' && char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote !== null) {
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === "{")
+            curly += 1;
+        if (char === "}")
+            curly -= 1;
+        if (char === "[")
+            square += 1;
+        if (char === "]")
+            square -= 1;
+        if (curly < 0 || square < 0)
+            return null;
+        if (char === "," && curly === 0 && square === 0) {
+            entries.push(body.slice(start, index));
+            start = index + 1;
+        }
+    }
+    if (quote !== null || curly !== 0 || square !== 0)
+        return null;
+    entries.push(body.slice(start));
+    return entries;
+}
+function parseStringValue(value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            return typeof parsed === "string" ? parsed : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    if (trimmed.startsWith("'") && trimmed.endsWith("'"))
+        return trimmed.slice(1, -1);
+    return null;
+}
+function stripTomlComment(line) {
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const char = line[index];
+        if (quote === '"' && escaped) {
+            escaped = false;
+            continue;
+        }
+        if (quote === '"' && char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote !== null && char === quote) {
+            quote = null;
+            continue;
+        }
+        if (quote === null && (char === '"' || char === "'")) {
+            quote = char;
+            continue;
+        }
+        if (quote === null && char === "#")
+            return line.slice(0, index);
+    }
+    return line;
+}
+function multilineOpener(line) {
+    for (const delimiter of ['"""', "'''"]) {
+        const opener = line.indexOf(delimiter);
+        if (opener >= 0 && line.indexOf(delimiter, opener + delimiter.length) < 0)
+            return delimiter;
+    }
+    return null;
+}

package/dist/config-migration/profile-files.d.ts

@@ -0,0 +1,11 @@
+import { type Gpt56ModelContexts } from "./gpt56-policy.js";
+export interface ProfileFileResult {
+    readonly changed: readonly string[];
+    readonly backups: readonly string[];
+}
+export declare function ensureGpt56ProfileFiles(args: {
+    readonly codexHome: string;
+    readonly dryRun: boolean;
+    readonly reconfigure: boolean;
+    readonly modelContexts?: Gpt56ModelContexts;
+}): Promise<ProfileFileResult>;

package/dist/config-migration/profile-files.js

@@ -0,0 +1,72 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { backupConfigFile } from "./backup.js";
+import { writeConfigFile } from "./config-file-io.js";
+import { ASTRA_MODEL, EXPLICIT_GPT56_SOL_MODEL, GPT56_MODELS } from "./gpt56-policy.js";
+export async function ensureGpt56ProfileFiles(args) {
+    const changed = [];
+    const backups = [];
+    for (const [name, desired] of Object.entries(profileContent())) {
+        const path = join(args.codexHome, name);
+        const existing = await readOptional(path);
+        if (existing === desired) {
+            continue;
+        }
+        if (existing !== null) {
+            const exactExplicitSol = name === "gpt56-sol-high.config.toml" && isExactGeneratedExplicitSolProfile(existing);
+            const exactGeneratedTerra = name === "gpt56-terra-high.config.toml" && isExactGeneratedTerraProfile(existing);
+            const exactGeneratedLuna = name === "gpt56-luna-max.config.toml" && isExactGeneratedLunaProfile(existing);
+            const exactGeneratedAstra = name === "gpt6-astra-xhigh.config.toml" && isExactGeneratedAstraProfile(existing);
+            if (!args.reconfigure ||
+                (!exactExplicitSol && !exactGeneratedTerra && !exactGeneratedLuna && !exactGeneratedAstra)) {
+                continue;
+            }
+        }
+        changed.push(path);
+        if (args.dryRun) {
+            continue;
+        }
+        if (existing !== null) {
+            const backup = await backupConfigFile(path);
+            if (backup !== null) {
+                backups.push(backup);
+            }
+        }
+        await writeConfigFile(path, desired);
+    }
+    return { changed, backups };
+}
+function isExactGeneratedExplicitSolProfile(content) {
+    return new RegExp(`^model = "${EXPLICIT_GPT56_SOL_MODEL.replaceAll(".", "\\.")}"\\nmodel_reasoning_effort = "high"\\n(?:model_auto_compact_token_limit = 650000\\n|model_context_window = 372000\\nmodel_auto_compact_token_limit = 334800\\n)?$`).test(content);
+}
+function isExactGeneratedTerraProfile(content) {
+    return /^model = "gpt-5\.6-terra"\nmodel_reasoning_effort = "high"\n(?:model_auto_compact_token_limit = 650000\n|model_context_window = 372000\nmodel_auto_compact_token_limit = 334800\n)$/.test(content);
+}
+function isExactGeneratedLunaProfile(content) {
+    return /^model = "gpt-5\.6-luna"\nmodel_reasoning_effort = "max"\n(?:model_auto_compact_token_limit = 650000\n|model_context_window = 372000\nmodel_auto_compact_token_limit = 334800\n)?$/.test(content);
+}
+function isExactGeneratedAstraProfile(content) {
+    return content === `model = "${ASTRA_MODEL}"\nmodel_reasoning_effort = "xhigh"\n`;
+}
+function profileContent() {
+    return {
+        "gpt6-astra-xhigh.config.toml": renderProfile(ASTRA_MODEL, "xhigh"),
+        "gpt56-sol-high.config.toml": renderProfile(GPT56_MODELS.sol, "high"),
+        "gpt56-terra-high.config.toml": renderProfile(GPT56_MODELS.terra, "high"),
+        "gpt56-luna-max.config.toml": renderProfile(GPT56_MODELS.luna, "max"),
+    };
+}
+function renderProfile(model, effort) {
+    return `model = ${JSON.stringify(model)}\nmodel_reasoning_effort = ${JSON.stringify(effort)}\n`;
+}
+async function readOptional(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}

package/dist/config-migration/root-settings.d.ts

@@ -0,0 +1,10 @@
+import type { ReasoningProfile } from "./catalog.js";
+export declare const MANAGED_KEYS: readonly ["model", "model_context_window", "model_auto_compact_token_limit", "model_reasoning_effort", "plan_mode_reasoning_effort"];
+/** Replace, insert, or remove the five managed scalars among the ROOT lines only. Pure. */
+export declare function ensureCodexReasoningConfig(config: string, profile: ReasoningProfile): string;
+/** Write or remove the `litcodex_output_style` root key. "off" removes the key; other ids set it. */
+export declare function ensureLitCodexOutputStyleConfig(config: string, styleId: string): string;
+/** Read `litcodex_output_style` from the root scope of a TOML config string. Returns undefined if absent. */
+export declare function readLitCodexOutputStyleId(config: string): string | undefined;
+/** Read only the five managed keys from root scope (stops at first section). Pure. */
+export declare function readRootSettings(config: string): Partial<ReasoningProfile>;