sneakoscope 7.0.2 → 7.0.5

package/dist/core/codex/codex-config-readability.js

@@ -22,13 +22,6 @@ export async function inspectCodexConfigReadability(rootInput = process.cwd(), o
     for (const dir of parentDirsFor(root, configPath)) {
         add(await accessCheck('parent_traverse', dir, fs.constants.X_OK));
     }
-    // Fresh project: the managed config simply does not exist yet. Every downstream check
-    // (stat, symlink, macOS ACL/flags/xattr, node/child read, codex config load) would
-    // operate on a nonexistent path and fail with ENOENT, turning the single real cause —
-    // a missing config — into a misleading cascade (`macos_acl_ls_le_failed`,
-    // `macos_flags_ls_lO_failed`, `spawned_child_read_failed`, ...). Skip them and report
-    // only the honest `missing_config` / `missing_codex_dir` blocker so the caller can
-    // regenerate the managed config instead of chasing phantom ACL/permission problems.
     const configMissing = projectConfigExists.error?.code === 'ENOENT';
     if (!configMissing) {
         const lstatCheck = await statCheck('config_lstat', configPath, 'lstat');
@@ -55,8 +48,6 @@ export async function inspectCodexConfigReadability(rootInput = process.cwd(), o
             childReadCheck(configPath, root),
             codexCliConfigLoadCheck(root, configPath, opts)
         ]);
-        // These are independent read-only metadata probes. Running them serially
-        // multiplied a single TCC/ACL timeout by three on the MAD launch path.
         const macChecksPromise = process.platform === 'darwin'
             ? Promise.all([
                 commandCheck('macos_acl_ls_le', 'ls', ['-le', configPath], root),
@@ -224,7 +215,6 @@ function errorDetail(err) {
     return { name: err?.name || 'Error', code: err?.code || '', message: err?.message || String(err) };
 }
 function resolveCodexConfigLoadProbe() {
-    // The probe ships as executable runtime JS under dist/scripts.
     const candidates = [
         path.join(packageRoot(), 'dist', 'scripts', 'codex-config-load-probe.js')
     ];
@@ -234,7 +224,6 @@ function resolveCodexConfigLoadProbe() {
                 return candidate;
         }
         catch {
-            // ignore and try the next candidate
         }
     }
     return null;
@@ -250,8 +239,6 @@ async function codexCliConfigLoadCheck(root, configPath, opts = {}) {
     }
     const script = resolveCodexConfigLoadProbe();
     if (!script) {
-        // The probe ships in dist/scripts; if it is genuinely absent (packaging gap),
-        // do not block MAD preflight on an unverifiable check — degrade gracefully.
         return {
             name: 'actual_codex_cli_config_load',
             ok: true,

package/dist/core/codex/codex-project-config-policy.js

@@ -26,16 +26,6 @@ const MACHINE_LOCAL_TABLE_PREFIXES = [
     'telemetry',
     'experimental_telemetry'
 ];
-// Codex 0.134+ removed the legacy config-profile consumers: `--profile NAME` now
-// layers `$CODEX_HOME/<name>.config.toml` over the base config and the top-level
-// `profile = "..."` selector / `[profiles.*]` tables are deprecated and warned about
-// at startup. So these are NO LONGER machine-local-and-moved-to-home — they are
-// DROPPED from the project config entirely. The per-file profiles are owned by
-// migrateSksProfilesToPerFile (src/core/auto-review.ts), which runs on `sks --mad`.
-// 2026-07 ChatGPT desktop merge: `default_profile` and `[user.fast_mode]` left the
-// config schema entirely (alongside the already-removed [profiles.*] tables), so
-// they are DROPPED from project configs, not relocated to the home config.
-// `service_tier` remains a real, machine-local top-level key and still moves home.
 const DEPRECATED_LEGACY_PROFILE_TOP_LEVEL_KEYS = new Set(['profile', 'profiles', 'default_profile']);
 const DEPRECATED_LEGACY_PROFILE_TABLE_PREFIXES = ['profiles', 'user.fast_mode'];
 const FAST_MODE_GLOBAL_TOP_LEVEL_KEYS = new Set(['service_tier']);
@@ -52,10 +42,6 @@ export async function splitCodexProjectConfigPolicy(rootInput = process.cwd(), o
     const codexHome = path.resolve(opts.codexHome || process.env.CODEX_HOME || path.join(process.env.HOME || os.homedir(), '.codex'));
     const reportPath = opts.reportPath || path.join(root, '.sneakoscope', 'reports', 'codex-project-config-policy.json');
     const codexHomeConfigPath = path.join(codexHome, 'config.toml');
-    // Guard: never split the global Codex home config against itself. When `sks`
-    // runs from (or near) the home directory the project config can resolve to the
-    // same file as the move target. Splitting it would strip machine-local keys and
-    // re-append them, corrupting the file. Treat this as a no-op.
     if (await isSameFile(configPath, codexHomeConfigPath)) {
         const report = {
             schema: CODEX_PROJECT_CONFIG_POLICY_SCHEMA,
@@ -195,13 +181,6 @@ export async function splitCodexProjectConfigPolicy(rootInput = process.cwd(), o
         await writeJsonAtomic(reportPath, { ...report, report_path: reportPath });
     return report;
 }
-// Recovery pass for already-corrupted configs. The pre-fix mover appended
-// machine-local top-level keys after the last [table], so TOML absorbed them
-// into that table (e.g. `notify`/`model_provider` landing inside
-// `[mcp_servers.*.env]`, which Codex rejects with
-// `invalid type: sequence, expected a string`). The splitter cannot recover this
-// because it now sees those lines as table members, not top-level keys. This pass
-// hoists them back above the first table so Codex can load the config again.
 export async function repairCodexConfigStructure(configPathInput, opts = {}) {
     const configPath = path.resolve(configPathInput);
     const original = await readText(configPath, null);
@@ -262,9 +241,6 @@ function hoistMisplacedMachineLocalKeys(text) {
         }
         const lines = block.text.split('\n');
         const header = lines[0];
-        // `mcp_servers.*` / `*.env` tables never legitimately contain machine-local
-        // Codex root keys; treat keys found there (or anything after an absorbed
-        // SKS-moved comment) as misplaced.
         const corruptionProne = /^mcp_servers(\.|$)/.test(block.table) || /\.env$/.test(block.table) || block.table === 'env';
         const kept = [header];
         let sawMovedComment = false;
@@ -297,8 +273,6 @@ function hoistMisplacedMachineLocalKeys(text) {
     const sections = [head, ...tables.map((table) => table.trim())].filter(Boolean);
     return { changed: true, text: normalizeProjectText(sections.join('\n\n')), hoisted_keys: [...new Set(hoistedKeys)] };
 }
-// Capture a TOML assignment that may span multiple lines (multiline arrays
-// `[ ... ]` or triple-quoted strings) so hoisting never splits a value.
 function captureAssignmentSpan(lines, start) {
     const first = lines[start] ?? '';
     const collected = [first];
@@ -338,8 +312,6 @@ function splitProjectToml(text) {
     let profileName = null;
     let deprecatedFixed = false;
     for (const block of blocks) {
-        // Deprecated legacy config profiles are DROPPED, not moved to the home config
-        // (Codex 0.134+ warns about `[profiles.*]` tables and the `profile=` selector).
         if (block.table && isFastModeGlobalTable(block.table)) {
             moved.push(block.text);
             machineBlocks.push(block);
@@ -513,11 +485,6 @@ async function isSameFile(a, b) {
         return false;
     }
 }
-// Merge machine-local Codex config into the user (CODEX_HOME) config while
-// preserving TOML structure: bare top-level keys must appear before any
-// `[table]` header, otherwise they are parsed as members of the preceding
-// table. Appending moved keys blindly at end-of-file corrupted configs
-// (e.g. `notify`/`model_provider` landing inside `[mcp_servers.*.env]`).
 function mergeMachineLocalIntoUserConfig(userText, machineText, commentLine) {
     const preamble = [];
     const tables = [];

package/dist/core/codex/codex-startup-config-postcheck.js

@@ -35,10 +35,15 @@ export async function postcheckCodexStartupConfig(input) {
         relative_config_files: [],
         unsupported_managed_role_fields: false,
         official_subagent_config: {
+            enabled: officialConfig.enabled,
             max_threads: officialConfig.maxThreads,
+            max_concurrent_threads_per_session: officialConfig.maxThreads,
             max_depth: officialConfig.maxDepth,
             job_max_runtime_seconds: officialConfig.jobMaxRuntimeSeconds,
             interrupt_message: officialConfig.interruptMessage,
+            default_subagent_model: officialConfig.defaultSubagentModel,
+            default_subagent_reasoning_effort: officialConfig.defaultSubagentReasoningEffort,
+            multi_agent_v2: officialConfig.multiAgentV2,
             sources: officialConfig.sources,
             warnings: officialConfig.warnings
         },

package/dist/core/codex/official-goal-mode.js

@@ -31,8 +31,6 @@ export async function detectOfficialGoalMode(opts = {}) {
         warnings: official ? [] : ['official_goal_unavailable_no_fallback']
     };
 }
-// Capability evidence for non-Goal routes. This records whether the active
-// Codex runtime exposes native Goal; it never creates or controls a goal.
 export async function writeOfficialGoalModeArtifact(dir, detection) {
     const artifact = path.join(dir, 'goal-mode-applied.json');
     await writeJsonAtomic(artifact, detection);

package/dist/core/codex-app/codex-agent-type-probe.js

@@ -97,7 +97,7 @@ async function probeHelp(codexBin, env) {
     const text = `${run?.stdout || ''}${run?.stderr || ''}`;
     if (!run || run.code !== 0 || !text)
         return unknownProbe(['codex_help_unavailable']);
-    const legacyV2 = /\bmulti_agent_v2\b/.test(text);
+    const multiAgentV2 = /\bmulti_agent_v2\b/.test(text);
     const supported = /\bagent_type\b/.test(text) && /\bspawn_agent\b/.test(text);
     return {
         schema: 'sks.codex-agent-type-probe.v1',
@@ -107,11 +107,13 @@ async function probeHelp(codexBin, env) {
         source: supported ? 'codex-help' : 'unknown',
         spawn_tool_name: supported ? 'spawn_agent' : 'unknown',
         schema_path: supported ? 'codex --help' : null,
-        evidence: supported ? ['help_mentions_agent_type', 'help_mentions_spawn_agent'] : legacyV2 ? ['legacy_multi_agent_v2_ignored'] : [],
+        evidence: [
+            ...(supported ? ['help_mentions_agent_type', 'help_mentions_spawn_agent'] : []),
+            ...(multiAgentV2 ? ['help_mentions_multi_agent_v2'] : [])
+        ],
         blockers: [],
         warnings: [
-            ...(supported ? [] : ['agent_type_not_found_in_help']),
-            ...(legacyV2 ? ['legacy_multi_agent_v2_ignored_use_spawn_agent_subagents'] : [])
+            ...(supported ? [] : ['agent_type_not_found_in_help'])
         ]
     };
 }
@@ -157,48 +159,53 @@ function probeSchema(value, source, schemaPath) {
         spawn_tool_name: found.tool,
         schema_path: found.path || schemaPath,
         evidence: found.supported
-            ? [`agent_type:${found.path || 'found'}`]
-            : found.legacy_path
-                ? ['legacy_multi_agent_v2_ignored']
-                : ['agent_type_absent'],
+            ? [`agent_type:${found.path || 'found'}`, ...(found.multi_agent_v2_path ? [`multi_agent_v2:${found.multi_agent_v2_path}`] : [])]
+            : ['agent_type_absent'],
         blockers: [],
         warnings: [
-            ...(found.supported ? [] : ['agent_type_not_supported_message_role_fallback']),
-            ...(found.legacy_path ? [`legacy_multi_agent_v2_ignored:${found.legacy_path}`] : [])
+            ...(found.supported ? [] : ['agent_type_not_supported_message_role_fallback'])
         ]
     };
 }
 function findAgentType(value, trail = []) {
     if (Array.isArray(value)) {
-        let legacyPath = null;
+        let multiAgentPath = null;
         for (let index = 0; index < value.length; index += 1) {
             const found = findAgentType(value[index], [...trail, String(index)]);
             if (found.supported)
                 return found;
-            if (!legacyPath && found.legacy_path)
-                legacyPath = found.legacy_path;
+            if (!multiAgentPath && found.multi_agent_v2_path)
+                multiAgentPath = found.multi_agent_v2_path;
         }
-        return { supported: false, tool: 'unknown', path: null, legacy_path: legacyPath };
+        return { supported: false, tool: 'unknown', path: null, multi_agent_v2_path: multiAgentPath };
     }
     if (!isRecord(value))
         return { supported: false, tool: 'unknown', path: null };
     const name = String(value.name || value.tool || value.id || '');
-    const legacyV2 = name.includes('multi_agent_v2');
+    const multiAgentV2 = name.includes('multi_agent_v2');
     const tool = name.includes('spawn_agent') ? 'spawn_agent' : 'unknown';
     if ('agent_type' in value || isRecord(value.properties) && 'agent_type' in value.properties) {
-        if (legacyV2)
-            return { supported: false, tool: 'unknown', path: null, legacy_path: [...trail, 'agent_type'].join('.') };
-        return { supported: true, tool: tool === 'unknown' ? 'spawn_agent' : tool, path: [...trail, 'agent_type'].join('.') };
+        return {
+            supported: true,
+            tool: tool === 'unknown' ? 'spawn_agent' : tool,
+            path: [...trail, 'agent_type'].join('.'),
+            multi_agent_v2_path: multiAgentV2 ? trail.join('.') || 'multi_agent_v2' : null
+        };
     }
-    let legacyPath = legacyV2 ? trail.join('.') || 'multi_agent_v2' : null;
+    let multiAgentPath = multiAgentV2 ? trail.join('.') || 'multi_agent_v2' : null;
     for (const [key, entry] of Object.entries(value)) {
         const found = findAgentType(entry, [...trail, key]);
-        if (found.supported)
-            return { ...found, tool: found.tool === 'unknown' && tool !== 'unknown' ? tool : found.tool };
-        if (!legacyPath && found.legacy_path)
-            legacyPath = found.legacy_path;
+        if (found.supported) {
+            return {
+                ...found,
+                tool: found.tool === 'unknown' && tool !== 'unknown' ? tool : found.tool,
+                multi_agent_v2_path: found.multi_agent_v2_path || multiAgentPath
+            };
+        }
+        if (!multiAgentPath && found.multi_agent_v2_path)
+            multiAgentPath = found.multi_agent_v2_path;
     }
-    return { supported: false, tool, path: null, legacy_path: legacyPath };
+    return { supported: false, tool, path: null, multi_agent_v2_path: multiAgentPath };
 }
 function unknownProbe(blockers) {
     return {

package/dist/core/codex-app/codex-app-fast-ui-repair.js

@@ -6,9 +6,6 @@ import { assertCodexAppUiMutationAllowed } from './codex-app-ui-clobber-guard.js
 import { codexProviderModelUiStatus } from '../codex-app.js';
 import { cleanupCodexConfigBackups } from '../codex/codex-config-toml.js';
 export const CODEX_APP_FAST_UI_REPAIR_SCHEMA = 'sks.codex-app-fast-ui-repair.v1';
-// `service_tier = "fast"` and `[features].fast_mode = true` are capability
-// signals. Removing either would turn Fast off rather than restore native UI.
-// Only provenance-backed SKS global provider/model/reasoning locks are removed.
 const FAST_UI_TOP_LEVEL_RE = /^\s*(?:model_provider|model|model_reasoning_effort)\s*=/;
 const FAST_UI_LEGACY_TABLES = new Set(['user.fast_mode', 'profiles.sks-fast-high']);
 export async function repairCodexAppFastUi(root = process.cwd(), input = {}) {
@@ -81,6 +78,7 @@ export async function repairCodexAppFastUi(root = process.cwd(), input = {}) {
     const applied = actions.some((action) => action.status === 'repaired');
     const pending = actions.some((action) => action.changed && action.status !== 'repaired');
     const requiresConfirmation = unsafeReasons.length > 0 && input.force !== true;
+    const chatgptOauthInactive = after.indicators.chat_surface === 'chatgpt_oauth_inactive';
     const selectedProviderBlockers = Array.isArray(providerModelUi.selected_provider_blockers)
         ? providerModelUi.selected_provider_blockers
         : [];
@@ -114,7 +112,10 @@ export async function repairCodexAppFastUi(root = process.cwd(), input = {}) {
         actions,
         before_fast_selector: before.indicators.fast_selector,
         after_fast_selector: after.indicators.fast_selector,
-        next_action: requiresConfirmation ? 'Run `sks doctor --fix --repair-codex-app-ui` after reviewing the repair plan.' : manual && safeAutoApply ? 'Run `sks doctor --fix` to apply the safe Codex App UI repair.' : manual ? 'Run `sks doctor --fix --repair-codex-app-ui` after reviewing the repair plan.' : changed ? 'Restart Codex App if the selector was already hidden.' : 'No Codex App UI repair needed.',
+        auth_mode: after.indicators.auth_mode,
+        chat_surface: after.indicators.chat_surface,
+        chatgpt_oauth_backup_available: after.indicators.chatgpt_oauth_backup_available,
+        next_action: requiresConfirmation ? 'Run `sks doctor --fix --repair-codex-app-ui` after reviewing the repair plan.' : manual && safeAutoApply ? 'Run `sks doctor --fix` to apply the safe Codex App UI repair.' : manual ? 'Run `sks doctor --fix --repair-codex-app-ui` after reviewing the repair plan.' : chatgptOauthInactive ? 'Run `sks codex-lb use-oauth --restart-app` to restore the Codex App Chat/Pro surface. This explicit switch leaves saved codex-lb credentials available for later reuse.' : changed ? 'Restart Codex App if the selector was already hidden.' : 'No Codex App UI repair needed.',
         blockers
     };
     if (input.reportPath)
@@ -165,9 +166,6 @@ function stripProjectLocalForbiddenKeys(text) {
 }
 function stripSksCausedHostOwnedLines(text) {
     const sourceLines = String(text || '').split(/\r?\n/);
-    // An active, contract-shaped codex-lb selection is a runtime provider choice,
-    // not a Fast UI lock. Preserve it so Desktop keeps GPT-5.6/tool exposure after
-    // project→global config migration markers are present.
     const preserveCodexLbSelection = hasActiveCodexLbProviderSelection(text);
     const stripped = stripMatchingLines(text, (line, table, _previous, _next, index) => {
         const isLegacyFastTable = table ? FAST_UI_LEGACY_TABLES.has(table) : false;

package/dist/core/codex-app/codex-app-ui-state-snapshot.js

@@ -26,6 +26,7 @@ export async function snapshotCodexAppUiState(root = process.cwd(), input = {})
     const home = codexHome(input);
     const files = await snapshotConfigFiles(resolvedRoot, home);
     const authMetadata = await readAuthMetadata(path.join(home, 'auth.json'));
+    const authBackupMetadata = await readAuthMetadata(path.join(home, 'auth.chatgpt-backup.json'));
     const appPreferenceFiles = await discoverAppPreferenceFiles(home);
     const sksManagedBlocks = files.flatMap((file) => findSksManagedBlocks(file));
     const projectLocalForbiddenKeys = files.flatMap((file) => file.forbidden_project_local_keys || []);
@@ -45,13 +46,19 @@ export async function snapshotCodexAppUiState(root = process.cwd(), input = {})
             return true;
         if (signal.key_path.startsWith('user.fast_mode') && /hidden|fixed|disabled|false/i.test(signal.value_preview))
             return true;
-        // Active contract-valid codex-lb selection is a provider choice, not a Fast UI lock.
         if (signal.key_path === 'model_provider' && activeCodexLbSelection)
             return false;
         if (SKS_GLOBAL_UI_LOCK_KEYS.has(signal.key_path) && signal.sks_related)
             return true;
         return false;
     });
+    const authMode = authMetadataMode(authMetadata);
+    const chatgptOauthBackupAvailable = authMetadataMode(authBackupMetadata) === 'chatgpt_oauth';
+    const chatSurface = authMode === 'chatgpt_oauth' || authMode === 'browser_marker'
+        ? 'available'
+        : authMode === 'apikey' && chatgptOauthBackupAvailable
+            ? 'chatgpt_oauth_inactive'
+            : 'unknown';
     return {
         schema: CODEX_APP_UI_STATE_SNAPSHOT_SCHEMA,
         generated_at: nowIso(),
@@ -59,6 +66,7 @@ export async function snapshotCodexAppUiState(root = process.cwd(), input = {})
         codex_home: redactHome(home),
         files,
         auth_metadata: authMetadata,
+        auth_backup_metadata: authBackupMetadata,
         app_preference_files: appPreferenceFiles,
         sks_managed_blocks: sksManagedBlocks,
         indicators: {
@@ -67,7 +75,10 @@ export async function snapshotCodexAppUiState(root = process.cwd(), input = {})
             provider_signals: providerSignals,
             host_owned_signal_count: hostOwnedSignals.length,
             project_local_forbidden_keys: [...new Set(projectLocalForbiddenKeys)],
-            secret_leak_suspected: JSON.stringify({ files, authMetadata }).match(/sk-[A-Za-z0-9_-]{16,}|CODEX_LB_API_KEY\s*=\s*["'][^"']+/) != null
+            secret_leak_suspected: JSON.stringify({ files, authMetadata, authBackupMetadata }).match(/sk-[A-Za-z0-9_-]{16,}|CODEX_LB_API_KEY\s*=\s*["'][^"']+/) != null,
+            auth_mode: authMode,
+            chatgpt_oauth_backup_available: chatgptOauthBackupAvailable,
+            chat_surface: chatSurface
         }
     };
 }
@@ -149,8 +160,11 @@ export function isSksOwnedGlobalUiLock(lines, index) {
         const candidate = String(lines[cursor] || '').trim();
         if (!candidate)
             continue;
-        if (candidate.startsWith('#'))
-            return isSksGlobalUiLockMarker(candidate);
+        if (candidate.startsWith('#')) {
+            if (isSksGlobalUiLockMarker(candidate))
+                return true;
+            continue;
+        }
         if (/^\s*\[/.test(candidate))
             return false;
         const previousKey = candidate.match(/^([A-Za-z0-9_-]+)\s*=/)?.[1] || '';
@@ -232,13 +246,37 @@ function sanitizeAuthMetadata(value) {
         return { type: typeof value };
     const record = value;
     const keys = Object.keys(record).sort();
+    const authMode = normalizeAuthMode(record);
     return {
         keys,
-        has_chatgpt_auth: keys.some((key) => /chatgpt|account|user|oauth/i.test(key)),
-        has_api_key_material: keys.some((key) => SECRET_KEY_RE.test(key)),
+        auth_mode: authMode,
+        has_chatgpt_auth: authMode === 'chatgpt_oauth' || authMode === 'browser_marker',
+        has_api_key_material: authMode === 'apikey',
         redacted: Object.fromEntries(keys.map((key) => [key, SECRET_KEY_RE.test(key) ? '<redacted>' : summarizeMetadataValue(record[key])]))
     };
 }
+function authMetadataMode(value) {
+    if (value == null)
+        return 'missing';
+    const mode = String(value.auth_mode || '');
+    return ['chatgpt_oauth', 'apikey', 'browser_marker'].includes(mode)
+        ? mode
+        : 'unknown';
+}
+function normalizeAuthMode(record) {
+    const rawMode = String(record.auth_mode || record.authMode || record.mode || '').trim().toLowerCase();
+    const tokens = record.tokens && typeof record.tokens === 'object' ? record.tokens : null;
+    const hasOauthTokens = Boolean(tokens && Object.keys(tokens).some((key) => /access|refresh|id[_-]?token/i.test(key)))
+        || Object.keys(record).some((key) => /^(?:access|refresh|id)[_-]?token$/i.test(key));
+    const hasApiKey = Object.keys(record).some((key) => /^(?:openai_)?api[_-]?key$|^key$/i.test(key));
+    if (/chatgpt|oauth/.test(rawMode) || hasOauthTokens)
+        return 'chatgpt_oauth';
+    if (rawMode === 'browser')
+        return 'browser_marker';
+    if (/api[-_]?key|apikey/.test(rawMode) || hasApiKey)
+        return 'apikey';
+    return 'unknown';
+}
 function summarizeMetadataValue(value) {
     if (value == null)
         return null;
@@ -289,7 +327,6 @@ function hasActiveCodexLbProviderSelectionSignals(signals) {
         return false;
     const has = (key, value) => signals.some((signal) => signal.key_path === key && signal.value_preview === value);
     const present = (key) => signals.some((signal) => signal.key_path === key);
-    // env_key / requires_openai_auth previews are redacted by SECRET_KEY_RE ("key"/"auth").
     return has('model_providers.codex-lb.name', 'openai')
         && has('model_providers.codex-lb.wire_api', 'responses')
         && present('model_providers.codex-lb.env_key')

package/dist/core/codex-app/glm-model-profile.js

@@ -1 +1 @@
-export { GLM_CODEX_APP_PROFILE_ID, GLM_CODEX_APP_PROFILE_LABEL, GLM_CODEX_CONFIG_PROFILE_ID, GLM_CODEX_CONFIG_PROVIDER_ID, GLM_CODEX_CONFIG_REASONING_PROFILES, GLM_CODEX_SELECTABLE_REASONING_EFFORTS, buildGlmCodexAppModelProfile } from '../providers/glm/glm-52-profile.js';
+export { GLM_CODEX_APP_PROFILE_ID, GLM_CODEX_APP_PROFILE_LABEL, GLM_CODEX_CONFIG_PROFILE_ID, GLM_CODEX_CONFIG_PROVIDER_ID, GLM_CODEX_CONFIG_REASONING_PROFILES, GLM_CODEX_SELECTABLE_REASONING_EFFORTS, OPENROUTER_DEFAULT_MODEL, OPENROUTER_PROVIDER_ID, buildGlmCodexAppModelProfile, normalizeOpenRouterModelId } from './openrouter-provider.js';

package/dist/core/codex-app/glm-profile-installer.js

@@ -1,10 +1,8 @@
 import path from 'node:path';
 import { codexLbConfigPath, ensureGlobalCodexAppGlmProfile } from '../../cli/install-helpers.js';
-import { readJson, readText, writeJsonAtomic, nowIso } from '../fsx.js';
-import { GLM_CODEX_CONFIG_PROFILE_ID, GLM_CODEX_CONFIG_PROVIDER_ID, GLM_CODEX_CONFIG_REASONING_PROFILES, buildGlmCodexAppModelProfile } from './glm-model-profile.js';
-import { validateGlmCodexAppModelProfile } from './glm-profile-schema.js';
+import { readText, writeJsonAtomic, nowIso, rmrf } from '../fsx.js';
+import { OPENROUTER_DEFAULT_PROFILE_ID, OPENROUTER_PROVIDER_ID, RETIRED_GLM_DESKTOP_CONFIG_PROFILE_IDS, buildGlmCodexAppModelProfile } from './openrouter-provider.js';
 import { resolveOpenRouterApiKey } from '../providers/openrouter/openrouter-secret-store.js';
-import { GLM_52_OPENROUTER_MODEL } from '../providers/glm/glm-52-settings.js';
 export async function installCodexAppGlmProfile(input) {
     const root = path.resolve(input.root);
     const profile = buildGlmCodexAppModelProfile();
@@ -15,54 +13,63 @@ export async function installCodexAppGlmProfile(input) {
     const configWrite = input.apply === false
         ? null
         : await ensureGlobalCodexAppGlmProfile({ home, configPath: input.configPath });
+    if (input.apply !== false) {
+        await rmrf(profilePath).catch(() => undefined);
+        await rmrf(reportPath).catch(() => undefined);
+    }
     const configStatus = input.apply === false
         ? await previewCodexAppGlmConfigStatus({ home, configPath: input.configPath })
-        : await inspectCodexAppGlmConfig({ home, configPath: input.configPath });
+        : await inspectCodexAppOpenRouterConfig({ home, configPath: input.configPath });
     const configWriteBlockers = configWrite?.ok === false
         ? [`glm_codex_app_config_${configWrite.status || 'failed'}`]
         : [];
     const blockers = input.apply === false ? [] : [...configWriteBlockers, ...configStatus.blockers];
     const warnings = [
         ...key.warnings,
-        ...(key.key ? [] : ['openrouter_key_missing_until_sks_--mad_--glm_--repair']),
-        ...(input.apply === false ? ['codex_desktop_glm_config_not_written_apply_false'] : [])
+        ...(key.key ? [] : ['openrouter_key_missing_until_sks_codex_app_set_openrouter_key']),
+        ...(input.apply === false ? ['codex_desktop_openrouter_config_not_written_apply_false'] : []),
+        'glm_desktop_profiles_retired_use_openrouter'
     ];
-    if (input.apply !== false)
-        await writeJsonAtomic(profilePath, profile);
     const result = {
         schema: 'sks.codex-app-glm-profile-result.v1',
         generated_at: nowIso(),
         ok: blockers.length === 0,
-        status: blockers.length === 0 ? input.apply === false ? 'valid' : 'installed' : 'blocked',
+        status: blockers.length === 0
+            ? input.apply === false
+                ? 'valid'
+                : 'removed'
+            : 'blocked',
         profile,
         profile_path: '.sneakoscope/codex-app/glm-model-profile.json',
         report_path: '.sneakoscope/reports/codex-app-glm-profile.json',
         config_path: configStatus.config_path,
-        codex_config_profile: GLM_CODEX_CONFIG_PROFILE_ID,
-        codex_reasoning_profiles: GLM_CODEX_CONFIG_REASONING_PROFILES.map((item) => item.id),
+        codex_config_profile: OPENROUTER_DEFAULT_PROFILE_ID,
+        codex_reasoning_profiles: [],
         config_write: configWrite,
         config_status: configStatus,
         openrouter_key_source: key.source,
         blockers,
         warnings
     };
-    await writeJsonAtomic(reportPath, result).catch(() => undefined);
     return result;
 }
 export async function doctorCodexAppGlmProfile(input) {
     const root = path.resolve(input.root);
     const profilePath = path.join(root, '.sneakoscope', 'codex-app', 'glm-model-profile.json');
     const reportPath = path.join(root, '.sneakoscope', 'reports', 'codex-app-glm-profile.json');
-    const existing = await readJson(profilePath, null);
-    const validation = validateGlmCodexAppModelProfile(existing);
     const key = await resolveOpenRouterApiKey({ env: input.env || process.env });
-    const profile = validation.profile || buildGlmCodexAppModelProfile();
+    const profile = buildGlmCodexAppModelProfile();
     const home = input.home || input.env?.HOME;
-    const configStatus = await inspectCodexAppGlmConfig({ home, configPath: input.configPath });
-    const blockers = [...validation.blockers, ...configStatus.blockers];
+    const configStatus = await inspectCodexAppOpenRouterConfig({ home, configPath: input.configPath });
+    const leftoverMeta = await readText(profilePath, '').catch(() => '');
+    const blockers = [
+        ...configStatus.blockers,
+        ...(leftoverMeta.trim() ? ['retired_glm_model_profile_metadata_present'] : [])
+    ];
     const warnings = [
         ...key.warnings,
-        ...(key.key ? [] : ['openrouter_key_missing_until_sks_--mad_--glm_--repair'])
+        ...(key.key ? [] : ['openrouter_key_missing_until_sks_codex_app_set_openrouter_key']),
+        'glm_desktop_profiles_retired_use_openrouter'
     ];
     const result = {
         schema: 'sks.codex-app-glm-profile-result.v1',
@@ -73,8 +80,8 @@ export async function doctorCodexAppGlmProfile(input) {
         profile_path: '.sneakoscope/codex-app/glm-model-profile.json',
         report_path: '.sneakoscope/reports/codex-app-glm-profile.json',
         config_path: configStatus.config_path,
-        codex_config_profile: GLM_CODEX_CONFIG_PROFILE_ID,
-        codex_reasoning_profiles: GLM_CODEX_CONFIG_REASONING_PROFILES.map((item) => item.id),
+        codex_config_profile: OPENROUTER_DEFAULT_PROFILE_ID,
+        codex_reasoning_profiles: [],
         config_write: null,
         config_status: configStatus,
         openrouter_key_source: key.source,
@@ -93,13 +100,14 @@ async function previewCodexAppGlmConfigStatus(input) {
         provider_present: false,
         profiles_present: [],
         profiles_missing: [],
+        retired_profiles_remaining: [],
         blockers: []
     };
 }
-async function inspectCodexAppGlmConfig(input) {
+async function inspectCodexAppOpenRouterConfig(input) {
     const configPath = input.configPath || codexLbConfigPath(input.home);
     const text = await readText(configPath, '').catch(() => '');
-    const providerBody = tomlTableBody(text, `model_providers.${GLM_CODEX_CONFIG_PROVIDER_ID}`);
+    const providerBody = tomlTableBody(text, `model_providers.${OPENROUTER_PROVIDER_ID}`);
     const providerPresent = Boolean(providerBody);
     const blockers = [];
     if (!providerPresent) {
@@ -113,30 +121,21 @@ async function inspectCodexAppGlmConfig(input) {
         if (!hasTomlString(providerBody, 'env_key', 'OPENROUTER_API_KEY'))
             blockers.push('glm_codex_app_config_invalid_openrouter_env_key');
     }
-    const profilesPresent = [];
-    const profilesMissing = [];
-    for (const profile of GLM_CODEX_CONFIG_REASONING_PROFILES) {
-        const body = tomlTableBody(text, `profiles.${profile.id}`);
-        if (!body) {
-            profilesMissing.push(profile.id);
-            blockers.push(`glm_codex_app_config_missing_profile:${profile.id}`);
-            continue;
+    const retiredRemaining = [];
+    for (const profileId of RETIRED_GLM_DESKTOP_CONFIG_PROFILE_IDS) {
+        if (tomlTableBody(text, `profiles.${profileId}`)) {
+            retiredRemaining.push(profileId);
+            blockers.push(`retired_glm_desktop_profile_present:${profileId}`);
         }
-        profilesPresent.push(profile.id);
-        if (!hasTomlString(body, 'model_provider', GLM_CODEX_CONFIG_PROVIDER_ID))
-            blockers.push(`glm_codex_app_config_invalid_profile_provider:${profile.id}`);
-        if (!hasTomlString(body, 'model', GLM_52_OPENROUTER_MODEL))
-            blockers.push(`glm_codex_app_config_invalid_profile_model:${profile.id}`);
-        if (!hasTomlString(body, 'model_reasoning_effort', profile.reasoning_effort))
-            blockers.push(`glm_codex_app_config_invalid_profile_reasoning:${profile.id}`);
     }
     return {
         schema: 'sks.codex-app-glm-config-status.v1',
         ok: blockers.length === 0,
         config_path: configPath,
         provider_present: providerPresent,
-        profiles_present: profilesPresent,
-        profiles_missing: profilesMissing,
+        profiles_present: [],
+        profiles_missing: [],
+        retired_profiles_remaining: retiredRemaining,
         blockers
     };
 }
@@ -160,5 +159,5 @@ function hasTomlString(text, key, value) {
     return pattern.test(text);
 }
 function escapeRegExp(value) {
-    return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }

package/dist/core/codex-app/glm-profile-schema.js

@@ -1,5 +1,4 @@
-import { GLM_CODEX_APP_PROFILE_ID, GLM_CODEX_CONFIG_PROFILE_ID, GLM_CODEX_CONFIG_PROVIDER_ID, GLM_CODEX_CONFIG_REASONING_PROFILES, GLM_CODEX_SELECTABLE_REASONING_EFFORTS, buildGlmCodexAppModelProfile } from './glm-model-profile.js';
-import { GLM_52_OPENROUTER_MODEL, GLM_MAD_MODE } from '../providers/glm/glm-52-settings.js';
+import { OPENROUTER_DEFAULT_PROFILE_ID, OPENROUTER_PROVIDER_ID, GLM_CODEX_SELECTABLE_REASONING_EFFORTS, GLM_CODEX_CONFIG_REASONING_PROFILES, GLM_52_OPENROUTER_MODEL, buildGlmCodexAppModelProfile } from './openrouter-provider.js';
 export function validateGlmCodexAppModelProfile(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         return { ok: false, blockers: ['glm_codex_app_profile_missing'], profile: null };
@@ -8,15 +7,15 @@ export function validateGlmCodexAppModelProfile(value) {
     const expected = buildGlmCodexAppModelProfile();
     const blockers = [
         profile.schema === expected.schema ? null : 'glm_codex_app_profile_invalid_schema',
-        profile.id === GLM_CODEX_APP_PROFILE_ID ? null : 'glm_codex_app_profile_invalid_id',
+        profile.id === OPENROUTER_DEFAULT_PROFILE_ID ? null : 'glm_codex_app_profile_invalid_id',
         profile.provider === 'openrouter' ? null : 'glm_codex_app_profile_invalid_provider',
         profile.model === GLM_52_OPENROUTER_MODEL ? null : 'glm_codex_app_profile_invalid_model',
-        profile.codexConfigProvider === GLM_CODEX_CONFIG_PROVIDER_ID ? null : 'glm_codex_app_profile_invalid_codex_config_provider',
-        profile.codexConfigProfile === GLM_CODEX_CONFIG_PROFILE_ID ? null : 'glm_codex_app_profile_invalid_codex_config_profile',
+        profile.codexConfigProvider === OPENROUTER_PROVIDER_ID ? null : 'glm_codex_app_profile_invalid_codex_config_provider',
+        profile.codexConfigProfile === OPENROUTER_DEFAULT_PROFILE_ID ? null : 'glm_codex_app_profile_invalid_codex_config_profile',
         hasExpectedReasoningEfforts(profile.supportedReasoningEfforts) ? null : 'glm_codex_app_profile_invalid_reasoning_efforts',
         hasExpectedReasoningProfiles(profile.reasoningProfiles) ? null : 'glm_codex_app_profile_invalid_reasoning_profiles',
-        profile.mode === GLM_MAD_MODE ? null : 'glm_codex_app_profile_invalid_mode',
-        profile.strictModelLock === true ? null : 'glm_codex_app_profile_not_strict',
+        profile.mode === 'openrouter-desktop' ? null : 'glm_codex_app_profile_invalid_mode',
+        profile.strictModelLock === false ? null : 'glm_codex_app_profile_unexpected_strict_lock',
         profile.gptFallbackAllowed === false ? null : 'glm_codex_app_profile_allows_gpt_fallback',
         profile.defaultProfile === 'speed' ? null : 'glm_codex_app_profile_default_not_speed',
         profile.defaultSettings?.tool_choice === 'none' ? null : 'glm_codex_app_profile_default_tools_not_omitted',
@@ -39,8 +38,5 @@ function hasExpectedReasoningProfiles(value) {
     if (!Array.isArray(value)) {
         return false;
     }
-    return GLM_CODEX_CONFIG_REASONING_PROFILES.every((expected) => value.some((item) => item &&
-        typeof item === 'object' &&
-        item.id === expected.id &&
-        item.reasoning_effort === expected.reasoning_effort));
+    return value.length === 0 && GLM_CODEX_CONFIG_REASONING_PROFILES.length === 0;
 }

package/dist/core/codex-app/menubar/constants.js

@@ -19,6 +19,7 @@ export const NATIVE_SOURCE_FILES = [
     'UpdatesViewController.swift',
     'MCPServersViewController.swift',
     'ProvidersViewController.swift',
+    'ProvidersOpenRouter.swift',
     'RemoteTelegramViewController.swift',
     'DiagnosticsViewController.swift',
     'SettingsViewController.swift',