sneakoscope 6.0.3 → 6.1.2

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

@@ -9,7 +9,7 @@ export async function writeCodexConfigGuarded(input) {
     const root = path.resolve(input.root || process.cwd());
     const cause = input.cause || 'codex-config';
     const before = input.before === undefined ? String(await readText(configPath, '')) : String(input.before || '');
-    if (isUnmanagedProjectCodexConfig(root, configPath, before)) {
+    if (isUnmanagedProjectCodexConfig(root, configPath, before) && input.ownershipVerified !== true) {
         const result = { ok: false, status: 'blocked_unmanaged_project_config', config_path: configPath, backup_path: null, changed: false };
         await recordCodexConfigGuard(root, input.reportPath, {
             cause,
@@ -64,6 +64,7 @@ export async function writeCodexConfigGuarded(input) {
         return result;
     }
     if (next === ensureTrailingNewline(before)) {
+        await writeTextAtomic(configPath, next, { mode: 0o600 });
         const result = { ok: true, status: 'present', config_path: configPath, backup_path: null, changed: false, repaired_keys: preserved.keys, forbidden_top_level: forbiddenTopLevel };
         if (preserved.keys.length || forbiddenTopLevel.length) {
             await recordCodexConfigGuard(root, input.reportPath, {
@@ -80,7 +81,7 @@ export async function writeCodexConfigGuarded(input) {
     }
     const backupPath = before.trim() ? await backupCodexConfig(configPath, before, input.backupTag || cause) : null;
     await ensureDir(path.dirname(configPath));
-    await writeTextAtomic(configPath, next);
+    await writeTextAtomic(configPath, next, { mode: 0o600 });
     const afterSnapshot = await snapshotForConfig(root, configPath).catch(() => null);
     const diff = beforeSnapshot && afterSnapshot ? diffCodexAppUiSnapshots(beforeSnapshot, afterSnapshot) : null;
     const result = {
@@ -145,7 +146,12 @@ export function isProjectCodexConfig(root, configPath) {
     return path.resolve(configPath) === path.resolve(root, '.codex', 'config.toml');
 }
 export function hasSksManagedCodexConfigMarker(text) {
-    return /(?:SKS managed|Sneakoscope|sneakoscope|sks_|agents\.native_agent|agents\.implementation_worker|multi_agent)/i.test(String(text || ''));
+    const source = String(text || '');
+    return /^\s*#\s*SKS-MANAGED-CODEX-CONFIG\b/im.test(source)
+        || /(?:SKS managed|Sneakoscope|sneakoscope|sks_|agents\.native_agent|agents\.implementation_worker|multi_agent)/i.test(source)
+        || /^\s*model_provider\s*=\s*["']codex-lb["']\s*(?:#.*)?$/mi.test(source)
+        || /^\s*default_profile\s*=\s*["']sks-fast-high["']\s*(?:#.*)?$/mi.test(source)
+        || /^\s*\[(?:user\.fast_mode|model_providers\.(?:"codex-lb"|codex-lb)|profiles\.(?:"sks-fast-high"|sks-fast-high))\]\s*(?:#.*)?$/mi.test(source);
 }
 export function isUnmanagedProjectCodexConfig(root, configPath, text) {
     return isProjectCodexConfig(root, configPath)
@@ -161,15 +167,36 @@ export function removeLegacyTopLevelCodexModeLocks(text = '') {
             return true;
         if (!/^\s*(?:model|model_reasoning_effort)\s*=/.test(line))
             return true;
-        return !isSksProvenanceLine(line, lines[index - 1] || '');
+        return !hasSksModeLockProvenance(lines, index);
     }).join('\n').replace(/^\n+/, '').replace(/\n{3,}/g, '\n\n'));
 }
-function isSksProvenanceLine(...lines) {
-    return lines.some((line) => {
-        const trimmed = String(line || '').trim();
-        const comment = trimmed.startsWith('#') ? trimmed : trimmed.includes('#') ? trimmed.slice(trimmed.indexOf('#')) : '';
-        return /(?:SKS|Sneakoscope|codex-lb|sks fast)/i.test(comment);
-    });
+function hasSksModeLockProvenance(lines, index) {
+    const current = String(lines[index] || '');
+    const inlineComment = current.includes('#') ? current.slice(current.indexOf('#')) : '';
+    if (isSksModeLockMarker(inlineComment))
+        return true;
+    const allowedManagedKeys = new Set([
+        'service_tier', 'model', 'model_reasoning_effort', 'model_provider',
+        'approval_policy', 'sandbox_mode', 'web_search', 'notify', 'preferred_auth_method'
+    ]);
+    const lowerBound = Math.max(0, index - 16);
+    for (let cursor = index - 1; cursor >= lowerBound; cursor -= 1) {
+        const candidate = String(lines[cursor] || '').trim();
+        if (!candidate)
+            continue;
+        if (candidate.startsWith('#')) {
+            if (isSksModeLockMarker(candidate))
+                return true;
+            continue;
+        }
+        const key = candidate.match(/^([A-Za-z0-9_-]+)\s*=/)?.[1] || '';
+        if (!allowedManagedKeys.has(key))
+            return false;
+    }
+    return false;
+}
+function isSksModeLockMarker(value = '') {
+    return /^#\s*(?:SKS|Sneakoscope)\b.*(?:moved machine-local Codex config|forced fast UI|managed (?:Codex )?(?:model|reasoning)|codex-lb (?:model|reasoning))/i.test(String(value || '').trim());
 }
 function mergeLostFastUiKeys(before, nextInput) {
     let next = String(nextInput || '');
@@ -301,7 +328,7 @@ async function snapshotForConfig(root, configPath) {
 async function backupCodexConfig(configPath, text, tag) {
     try {
         const backupPath = `${configPath}.sks-${tag}-${Date.now().toString(36)}.bak`;
-        await writeTextAtomic(backupPath, text);
+        await writeTextAtomic(backupPath, text, { mode: 0o600 });
         await cleanupCodexConfigBackups(configPath, { keepPerTag: 3, maxAgeMs: 30 * 24 * 60 * 60 * 1000 }).catch(() => undefined);
         return backupPath;
     }

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

@@ -2,7 +2,7 @@ import fsp from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { ensureDir, nowIso, readText, writeJsonAtomic } from '../fsx.js';
-import { writeCodexConfigGuarded } from './codex-config-guard.js';
+import { hasSksManagedCodexConfigMarker, writeCodexConfigGuarded } from './codex-config-guard.js';
 import { cleanupCodexConfigBackups } from './codex-config-toml.js';
 export const CODEX_PROJECT_CONFIG_POLICY_SCHEMA = 'sks.codex-project-config-policy.v1';
 const MACHINE_LOCAL_TOP_LEVEL_KEYS = new Set([
@@ -95,7 +95,7 @@ export async function splitCodexProjectConfigPolicy(rootInput = process.cwd(), o
             await writeJsonAtomic(reportPath, { ...report, report_path: reportPath });
         return report;
     }
-    if (opts.apply && isCodexConfigToml(configPath) && !hasSksManagedCodexMarker(String(original))) {
+    if (opts.apply && isCodexConfigToml(configPath) && !hasSksManagedCodexConfigMarker(String(original))) {
         const report = {
             schema: CODEX_PROJECT_CONFIG_POLICY_SCHEMA,
             generated_at: nowIso(),
@@ -208,7 +208,7 @@ export async function repairCodexConfigStructure(configPathInput, opts = {}) {
     if (original === null) {
         return { config_path: configPath, ok: true, status: 'config_missing', changed: false, applied: false, hoisted_keys: [], backup_path: null };
     }
-    if (opts.apply && isCodexConfigToml(configPath) && !hasSksManagedCodexMarker(String(original))) {
+    if (opts.apply && isCodexConfigToml(configPath) && !hasSksManagedCodexConfigMarker(String(original))) {
         return {
             config_path: configPath,
             ok: false,
@@ -249,9 +249,6 @@ export async function repairCodexConfigStructure(configPathInput, opts = {}) {
 function isCodexConfigToml(file) {
     return path.basename(file) === 'config.toml' && path.basename(path.dirname(file)) === '.codex';
 }
-function hasSksManagedCodexMarker(text) {
-    return /(?:SKS managed|Sneakoscope|sneakoscope|sks_|agents\.native_agent|agents\.implementation_worker|multi_agent)/i.test(text);
-}
 function hoistMisplacedMachineLocalKeys(text) {
     const blocks = tomlBlocks(text);
     const preamble = [];

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

@@ -1,64 +1,64 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { nowIso, writeJsonAtomic } from '../fsx.js';
-import { missingAgentConfigFiles } from './agent-config-file-repair.js';
-import { managedAgentRoleConfigForFile, managedAgentRoleConfigForRole } from '../agents/agent-role-config.js';
+import { inspectOfficialSubagentToml, installOfficialSubagentAgentConfigs, readOfficialSubagentConfig } from '../subagents/official-subagent-config.js';
 export async function postcheckCodexStartupConfig(input) {
     const root = path.resolve(input.root);
     const configPath = path.join(root, '.codex', 'config.toml');
     const text = await fs.readFile(configPath, 'utf8').catch(() => '');
-    const missing = await missingAgentConfigFiles(text);
-    const managedBlocks = managedAgentBlocks(text);
-    const unsupportedRoleFields = managedBlocks.some((block) => /^\s*message_role_prefix\s*=/m.test(block.text));
-    const relativePaths = managedBlocks
-        .map((block) => block.text.match(/^\s*config_file\s*=\s*"([^"]+)"/m)?.[1])
-        .filter((file) => Boolean(file && !path.isAbsolute(file)));
+    const configPresent = Boolean(text.trim());
+    const tomlValidation = inspectOfficialSubagentToml(text);
+    const officialConfig = await readOfficialSubagentConfig(root, {
+        ...(input.home ? { home: input.home } : {}),
+        ...(input.codexHome ? { codexHome: input.codexHome } : {}),
+        projectConfigPath: configPath
+    });
+    const rolePlan = await installOfficialSubagentAgentConfigs(root, { apply: false });
     const tomlSmoke = tomlSyntaxSmoke(text);
     const orphanChildTables = orphanMcpChildTables(text);
+    const blockers = [
+        ...(!configPresent ? ['project_official_subagent_config_missing'] : []),
+        ...(!tomlValidation.ok ? ['project_official_subagent_config_toml_parse_failed'] : []),
+        ...officialConfig.blockers.map((item) => `official_subagent_config:${item}`),
+        ...rolePlan.missing.map((file) => `missing_official_subagent_agent:${file}`),
+        ...rolePlan.stale.map((file) => `stale_official_subagent_agent:${file}`),
+        ...rolePlan.manual_blockers,
+        ...tomlSmoke.blockers,
+        ...orphanChildTables.map((table) => `orphan_mcp_child_table:${table}`)
+    ];
     const report = {
         schema: 'sks.codex-startup-config-postcheck.v1',
         generated_at: nowIso(),
-        ok: missing.length === 0 && relativePaths.length === 0 && !unsupportedRoleFields && tomlSmoke.ok && orphanChildTables.length === 0,
+        ok: blockers.length === 0,
         config_path: configPath,
-        missing_config_files: missing,
-        relative_config_files: relativePaths,
-        unsupported_managed_role_fields: unsupportedRoleFields,
+        missing_config_files: [],
+        relative_config_files: [],
+        unsupported_managed_role_fields: false,
+        official_subagent_config: {
+            max_threads: officialConfig.maxThreads,
+            max_depth: officialConfig.maxDepth,
+            job_max_runtime_seconds: officialConfig.jobMaxRuntimeSeconds,
+            interrupt_message: officialConfig.interruptMessage,
+            sources: officialConfig.sources,
+            warnings: officialConfig.warnings
+        },
+        official_subagent_agents: {
+            missing: rolePlan.missing,
+            stale: rolePlan.stale,
+            existing: rolePlan.existing,
+            preserved: rolePlan.preserved,
+            manual_blockers: rolePlan.manual_blockers
+        },
+        legacy_agent_tables_preserved: true,
         toml_syntax_smoke_ok: tomlSmoke.ok,
         orphan_mcp_child_tables: orphanChildTables,
-        blockers: [
-            ...missing.map((file) => `missing_agent_config_file:${file}`),
-            ...relativePaths.map((file) => `relative_agent_config_file:${file}`),
-            ...(unsupportedRoleFields ? ['unsupported_message_role_prefix_field'] : []),
-            ...tomlSmoke.blockers,
-            ...orphanChildTables.map((table) => `orphan_mcp_child_table:${table}`)
-        ]
+        blockers
     };
-    if (input.reportPath !== null)
+    if (input.reportPath !== null) {
         await writeJsonAtomic(input.reportPath || path.join(root, '.sneakoscope', 'reports', 'codex-startup-config-postcheck.json'), report).catch(() => undefined);
+    }
     return report;
 }
-function managedAgentBlocks(text) {
-    const blocks = tomlBlocks(text);
-    return blocks.filter((block) => {
-        if (!block.header.startsWith('agents.'))
-            return false;
-        const role = block.header.slice('agents.'.length);
-        if (managedAgentRoleConfigForRole(role))
-            return true;
-        const configFile = block.text.match(/^\s*config_file\s*=\s*"([^"]+)"/m)?.[1] || '';
-        return Boolean(configFile && managedAgentRoleConfigForFile(configFile));
-    });
-}
-function tomlBlocks(text) {
-    const source = String(text || '');
-    const matches = [...source.matchAll(/(^|\n)\s*\[([^\]]+)\]\s*(?:#.*)?(?:\n|$)/g)];
-    return matches.map((match, index) => {
-        const start = Number(match.index || 0) + (match[1] ? 1 : 0);
-        const next = matches[index + 1];
-        const end = next ? Number(next.index || 0) + (next[1] ? 1 : 0) : source.length;
-        return { header: String(match[2] || '').trim(), text: source.slice(start, end) };
-    });
-}
 function tomlSyntaxSmoke(text) {
     const blockers = [];
     for (const [index, line] of String(text || '').split(/\r?\n/).entries()) {
@@ -80,4 +80,14 @@ function orphanMcpChildTables(text) {
         return Boolean(match && !headers.has(`mcp_servers.${match[1]}`));
     });
 }
+function tomlBlocks(text) {
+    const source = String(text || '');
+    const matches = [...source.matchAll(/(^|\n)\s*\[([^\]]+)\]\s*(?:#.*)?(?:\n|$)/g)];
+    return matches.map((match, index) => {
+        const start = Number(match.index || 0) + (match[1] ? 1 : 0);
+        const next = matches[index + 1];
+        const end = next ? Number(next.index || 0) + (next[1] ? 1 : 0) : source.length;
+        return { header: String(match[2] || '').trim(), text: source.slice(start, end) };
+    });
+}
 //# sourceMappingURL=codex-startup-config-postcheck.js.map

package/dist/core/codex-adapter.js

@@ -3,6 +3,7 @@ import { runProcess } from './fsx.js';
 import { preserveCodexModelArgs } from './codex-model-guard.js';
 import { managedProxyEnvForChild } from './codex/managed-proxy-env.js';
 import { resolveCodexRuntime } from './codex-runtime/resolve-codex-runtime.js';
+import { codexLbRecoveryBlockedProcessResult, withCodexLbCliLaunchRecovery } from './codex-control/codex-lb-launch-recovery.js';
 export async function findCodexBinary() {
     const resolved = await resolveCodexRuntime({
         explicitPath: process.env.DCODEX_CODEX_BIN || null,
@@ -39,30 +40,42 @@ export function buildCodexExecArgs({ root, prompt, outputFile, json = true, prof
     args.push(prompt);
     return args;
 }
-export async function runCodexExec({ root, prompt, outputFile, json = true, profile = null, extraArgs = [], onStdout, onStderr, logDir = null, stdoutFile = null, stderrFile = null, maxBufferBytes = 256 * 1024, timeoutMs = null }) {
-    const bin = await findCodexBinary();
-    if (!bin) {
-        return {
-            code: 127,
-            stdout: '',
-            stderr: 'Codex CLI not found. Install @openai/codex or set SKS_CODEX_BIN.',
-            stdoutBytes: 0,
-            stderrBytes: 0,
-            truncated: false,
-            timedOut: false
-        };
-    }
+export async function runCodexExec({ root, recoveryRoot = root, prompt, outputFile, json = true, profile = null, extraArgs = [], onStdout, onStderr, logDir = null, stdoutFile = null, stderrFile = null, maxBufferBytes = 256 * 1024, timeoutMs = null, env = process.env, codexBin = null, findCodexBinaryImpl = findCodexBinary, runProcessImpl = runProcess, recoveryFetch = undefined, recoveryTimeoutMs = undefined }) {
     const args = buildCodexExecArgs({ root, prompt, outputFile, json, profile, extraArgs });
     const effectiveTimeoutMs = Number(timeoutMs || process.env.SKS_CODEX_TIMEOUT_MS || process.env.DCODEX_CODEX_TIMEOUT_MS || 30 * 60 * 1000);
-    return runProcess(bin, args, {
-        cwd: root,
-        env: managedProxyEnvForChild(process.env),
-        onStdout,
-        onStderr,
-        timeoutMs: effectiveTimeoutMs,
-        maxOutputBytes: maxBufferBytes,
-        stdoutFile: stdoutFile || (logDir ? path.join(logDir, 'codex.stdout.log') : undefined),
-        stderrFile: stderrFile || (logDir ? path.join(logDir, 'codex.stderr.log') : undefined)
+    const recoveryArgs = args.slice(1, -1);
+    const guarded = await withCodexLbCliLaunchRecovery({
+        root: recoveryRoot,
+        env,
+        cliArgs: recoveryArgs,
+        ...(typeof recoveryFetch === 'function' ? { fetchImpl: recoveryFetch } : {}),
+        ...(recoveryTimeoutMs === undefined ? {} : { timeoutMs: recoveryTimeoutMs })
+    }, async () => {
+        const bin = codexBin || await findCodexBinaryImpl();
+        if (!bin) {
+            return {
+                code: 127,
+                stdout: '',
+                stderr: 'Codex CLI not found. Install @openai/codex or set SKS_CODEX_BIN.',
+                stdoutBytes: 0,
+                stderrBytes: 0,
+                truncated: false,
+                timedOut: false
+            };
+        }
+        return runProcessImpl(bin, args, {
+            cwd: root,
+            env: { ...env, ...managedProxyEnvForChild(env) },
+            onStdout,
+            onStderr,
+            timeoutMs: effectiveTimeoutMs,
+            maxOutputBytes: maxBufferBytes,
+            stdoutFile: stdoutFile || (logDir ? path.join(logDir, 'codex.stdout.log') : undefined),
+            stderrFile: stderrFile || (logDir ? path.join(logDir, 'codex.stderr.log') : undefined)
+        });
     });
+    return guarded.launched
+        ? guarded.value
+        : codexLbRecoveryBlockedProcessResult(guarded.toolOutputRecovery);
 }
 //# sourceMappingURL=codex-adapter.js.map

package/dist/core/codex-app/codex-agent-role-sync.js

@@ -1,23 +1,14 @@
-import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
-import { PACKAGE_VERSION, nowIso, writeJsonAtomic, writeTextAtomic, ensureDir } from '../fsx.js';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
 import { repairAgentRoleConfigs } from '../agents/agent-role-config.js';
+import { MANAGED_OFFICIAL_SUBAGENT_ROLES } from '../managed-assets/managed-assets-manifest.js';
 import { agentRolePayloadFor, probeCodexAgentTypeSupport } from './codex-agent-type-probe.js';
-const DIRECTIVE_ROLES = [
-    'sks-explorer',
-    'sks-planner',
-    'sks-implementer',
-    'sks-checker',
-    'sks-release-verifier',
-    'sks-zellij-ui-verifier',
-    'sks-codex-probe-verifier'
-];
+const OFFICIAL_ROLES = MANAGED_OFFICIAL_SUBAGENT_ROLES.map((role) => role.codex_name);
 export async function syncCodexAgentRoles(input) {
     const root = path.resolve(input.root);
     const env = input.env || process.env;
     const codexHome = input.codexHome || process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
-    const targetDir = path.join(codexHome, 'agents');
     const baseRepair = await repairAgentRoleConfigs({
         root,
         apply: input.apply === true,
@@ -49,19 +40,9 @@ export async function syncCodexAgentRoles(input) {
             blockers: [],
             warnings: []
         };
-    const rolePayloads = Object.fromEntries(DIRECTIVE_ROLES.map((role) => [role, agentRolePayloadFor(role, agentTypeProbe)]));
-    const created = [];
-    if (input.apply === true) {
-        await ensureDir(targetDir);
-        for (const role of DIRECTIVE_ROLES) {
-            const file = path.join(targetDir, `${role}.toml`);
-            const current = await fs.readFile(file, 'utf8').catch(() => '');
-            if (current && !isSksManagedDirectiveRole(current))
-                continue;
-            await writeTextAtomic(file, roleToml(role, rolePayloads[role]));
-            created.push(file);
-        }
-    }
+    const rolePayloads = Object.fromEntries(OFFICIAL_ROLES.map((role) => [role, agentRolePayloadFor(role, agentTypeProbe)]));
+    const created = stringList(baseRepair, 'created');
+    const updated = stringList(baseRepair, 'repaired');
     const report = {
         schema: 'sks.codex-agent-role-sync.v1',
         generated_at: nowIso(),
@@ -73,42 +54,18 @@ export async function syncCodexAgentRoles(input) {
         probe_artifact_path: '.sneakoscope/reports/codex-agent-type-probe.json',
         clobbered_user_roles: false,
         codex_home: codexHome,
-        directive_roles: DIRECTIVE_ROLES,
+        official_roles: [...OFFICIAL_ROLES],
+        directive_roles: [],
         role_payloads: rolePayloads,
         agent_type_probe: agentTypeProbe,
         created,
+        updated,
         base_repair: baseRepair,
         blockers: blockersOf(baseRepair)
     };
     await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-agent-role-sync.json'), report).catch(() => undefined);
     return report;
 }
-function roleToml(role, payload) {
-    return [
-        `name = "${role}"`,
-        `description = "SKS managed ${PACKAGE_VERSION} directive role: ${role}"`,
-        role.includes('implementer') ? 'sandbox_mode = "workspace-write"' : 'sandbox_mode = "read-only"',
-        'approval_policy = "never"',
-        'developer_instructions = """',
-        `You are ${role}. SKS managed ${PACKAGE_VERSION} directive role with bounded ownership.`,
-        'Bounded ownership: use only the assigned owner files/directories and treat memory as guidance, not permission.',
-        role.includes('implementer') ? 'Maker/checker separation: implementer may patch only owner scope and cannot self-approve.' : 'Maker/checker separation: checker is read-only and must reject missing gates or missing proof artifacts.',
-        role.includes('implementer') ? 'Allowed sandbox: workspace-write only within assigned owner scope.' : 'Allowed sandbox: read-only; checker roles cannot mutate.',
-        role.includes('release') ? 'Release verifier: verify version truth, release DAG coverage, package scripts, packlist, and changelog evidence.' : '',
-        role.includes('zellij') ? 'UI/Zellij verifier: inspect readiness status, headless fallback, repair_required, pane proof, and slot telemetry without mutating unrelated UI state.' : '',
-        role.includes('codex') ? 'Codex native verifier: inspect hook approval, agent_type, skill sync, plugin inventory, MCP candidates, and invocation plan artifacts.' : '',
-        'Side-effect restrictions: no destructive shell, package publish, global config mutation, database mutation, or external service write unless the sealed route contract explicitly allows it.',
-        'Required proof artifacts: cite concrete repo paths, command outputs, and route-local JSON proof before claiming completion.',
-        'Final arbiter constraints: parent integration owns final acceptance; this role supplies evidence and cannot override missing gates.',
-        `Execution role strategy: ${payload?.strategy || 'message-role'}. Probe: ${payload?.probe_artifact_path || '.sneakoscope/reports/codex-agent-type-probe.json'}.`,
-        '"""',
-        ''
-    ].join('\n');
-}
-function isSksManagedDirectiveRole(text) {
-    return /SKS managed (?:3\.1\.(?:4|5|6|7|11)|4\.1\.\d+) (?:directive|bounded) role/.test(text)
-        || /\bmessage_role_prefix\s*=/.test(text) && /SKS managed 3\.1\./.test(text);
-}
 function blockersOf(value) {
     return Boolean(value) && typeof value === 'object' && Array.isArray(value.blockers)
         ? (value.blockers).map((item) => String(item)).filter(Boolean)
@@ -119,8 +76,10 @@ function recordOk(value) {
         ? value.ok
         : undefined;
 }
-function escapeToml(value) {
-    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+function stringList(value, key) {
+    return Boolean(value) && typeof value === 'object' && Array.isArray(value[key])
+        ? value[key].map(String).filter(Boolean)
+        : [];
 }
 function messageOf(err) {
     return err instanceof Error ? err.message : String(err);

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

@@ -4,8 +4,12 @@ import { ensureDir, nowIso, readText, sha256, writeJsonAtomic, writeTextAtomic }
 import { codexHome, scanProjectLocalForbiddenKeys, snapshotCodexAppUiState } from './codex-app-ui-state-snapshot.js';
 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';
-const FAST_UI_TOP_LEVEL_RE = /^\s*(?:model|model_reasoning_effort|service_tier)\s*=/;
+// `service_tier = "fast"` is the current Codex Desktop default-selection
+// contract. Removing it would silently turn Fast mode off, not restore the
+// selector. Only legacy SKS model/effort pins lock the native picker.
+const FAST_UI_TOP_LEVEL_RE = /^\s*(?:model|model_reasoning_effort)\s*=/;
 const FAST_UI_FEATURE_LINE_RE = /^\s*fast_mode\s*=/;
 const FAST_UI_LEGACY_TABLES = new Set(['user.fast_mode', 'profiles.sks-fast-high']);
 const SKS_CAUSED_RE = /(?:SKS|Sneakoscope|codex-lb|sks-mad|sks fast)/i;
@@ -20,6 +24,7 @@ export async function repairCodexAppFastUi(root = process.cwd(), input = {}) {
     const actions = [];
     const detectedProjectLocalForbiddenKeys = [];
     const unsafeReasons = [];
+    let permissionsHardened = 0;
     let detectedSksCausedMutation = false;
     for (const candidate of candidates) {
         const text = await readText(candidate.file, null);
@@ -27,34 +32,39 @@ export async function repairCodexAppFastUi(root = process.cwd(), input = {}) {
             actions.push({ scope: candidate.scope, file: displayPath(candidate.file), status: 'missing', changed: false });
             continue;
         }
+        if (input.apply === true)
+            permissionsHardened += await hardenCodexConfigPermissions(candidate.file);
         const repaired = candidate.mode === 'project_forbidden_keys'
             ? stripProjectLocalForbiddenKeys(text)
             : stripSksCausedHostOwnedLines(text);
+        const candidateUnsafeReasons = detectUnsafeFastUiRepair(text);
+        unsafeReasons.push(...candidateUnsafeReasons);
         if (candidate.mode === 'project_forbidden_keys')
             detectedProjectLocalForbiddenKeys.push(...repaired.removedKeys);
         if (candidate.mode === 'sks_caused_host_owned_keys') {
-            const unsafe = detectUnsafeFastUiRepair(text);
-            unsafeReasons.push(...unsafe);
             if (repaired.text !== text)
                 detectedSksCausedMutation = true;
         }
         if (repaired.text === text) {
-            actions.push({ scope: candidate.scope, file: displayPath(candidate.file), status: unsafeReasons.length && candidate.mode === 'sks_caused_host_owned_keys' ? 'requires_confirmation' : 'ok', changed: false, removed_keys: repaired.removedKeys });
+            actions.push({ scope: candidate.scope, file: displayPath(candidate.file), status: candidateUnsafeReasons.length ? 'requires_confirmation' : 'ok', changed: false, removed_keys: repaired.removedKeys });
             continue;
         }
         const backupPath = `${candidate.file}.codex-app-ui-repair-${Date.now().toString(36)}.bak`;
-        if (input.apply) {
+        const applyAllowed = input.apply === true && (candidateUnsafeReasons.length === 0 || input.force === true);
+        if (applyAllowed) {
             await ensureDir(path.dirname(candidate.file));
-            await fs.writeFile(backupPath, text, 'utf8');
+            await fs.writeFile(backupPath, text, { encoding: 'utf8', mode: 0o600 });
+            await fs.chmod(backupPath, 0o600);
             assertCodexAppUiMutationAllowed({ kind: 'codex_app_ui_state', scope: 'codex-app-ui-repair', backupPath });
-            await writeTextAtomic(candidate.file, repaired.text);
+            await writeTextAtomic(candidate.file, repaired.text, { mode: 0o600 });
+            await cleanupCodexConfigBackups(candidate.file, { keepPerTag: 3, maxAgeMs: 30 * 24 * 60 * 60 * 1000 }).catch(() => undefined);
         }
         actions.push({
             scope: candidate.scope,
             file: displayPath(candidate.file),
-            status: input.apply ? 'repaired' : 'planned',
+            status: applyAllowed ? 'repaired' : input.apply ? 'requires_confirmation' : 'planned',
             changed: true,
-            backup_path: input.apply ? displayPath(backupPath) : null,
+            backup_path: applyAllowed ? displayPath(backupPath) : null,
             before_hash: sha256(text),
             after_hash: sha256(repaired.text),
             removed_keys: repaired.removedKeys
@@ -63,17 +73,24 @@ export async function repairCodexAppFastUi(root = process.cwd(), input = {}) {
     const after = await snapshotCodexAppUiState(resolvedRoot, { codexHome: home });
     const providerModelUi = await codexProviderModelUiStatus({
         cwd: resolvedRoot,
+        env: input.env,
         home: path.dirname(home),
         configPath: path.join(home, 'config.toml'),
         codexLbEnvPath: path.join(home, 'sks-codex-lb.env')
     });
     const changed = actions.some((action) => action.changed);
+    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 selectedProviderBlockers = Array.isArray(providerModelUi.selected_provider_blockers)
+        ? providerModelUi.selected_provider_blockers
+        : [];
     const safeAutoApply = changed && !requiresConfirmation;
     const manual = changed && !input.apply;
     const blockers = [
         ...(requiresConfirmation ? ['codex_app_fast_ui_repair_requires_confirmation'] : []),
         ...(manual && !safeAutoApply ? ['codex_app_fast_ui_repair_requires_explicit_apply'] : []),
+        ...selectedProviderBlockers.map((blocker) => `selected_provider:${blocker}`),
         ...(after.indicators.secret_leak_suspected ? ['codex_app_ui_repair_secret_leak_suspected'] : [])
     ];
     const report = {
@@ -86,12 +103,15 @@ export async function repairCodexAppFastUi(root = process.cwd(), input = {}) {
         detected_sks_caused_mutation: detectedSksCausedMutation,
         detected_project_local_forbidden_keys: [...new Set(detectedProjectLocalForbiddenKeys)],
         unsafe_repair_reasons: [...new Set(unsafeReasons)],
-        fast_selector: changed ? (input.apply ? 'repaired' : 'manual_action_required') : before.indicators.fast_selector === 'maybe_hidden_or_locked' ? 'manual_action_required' : 'ok',
-        provider_selector: providerModelUi.ok ? 'ok' : 'manual_action_required',
+        permissions_hardened: permissionsHardened,
+        fast_selector: pending ? 'manual_action_required' : applied ? 'repaired' : before.indicators.fast_selector === 'maybe_hidden_or_locked' ? 'manual_action_required' : 'ok',
+        provider_selector: selectedProviderBlockers.length ? 'manual_action_required' : 'selected_provider_ready',
         provider_model_ui: providerModelUi,
         provider_actions: providerModelUi.ui_actions || [],
         provider_blockers: providerModelUi.blockers || [],
-        host_owned_config: input.apply && changed ? 'repaired_with_backup' : changed ? 'preserved_until_explicit_apply' : 'preserved',
+        selected_provider_blockers: selectedProviderBlockers,
+        optional_provider_blockers: providerModelUi.optional_provider_blockers || [],
+        host_owned_config: applied && !pending ? 'repaired_with_backup' : changed ? 'preserved_until_explicit_apply' : 'preserved',
         actions,
         before_fast_selector: before.indicators.fast_selector,
         after_fast_selector: after.indicators.fast_selector,
@@ -102,16 +122,27 @@ export async function repairCodexAppFastUi(root = process.cwd(), input = {}) {
         await writeJsonAtomic(input.reportPath, report);
     return report;
 }
+async function hardenCodexConfigPermissions(configFile) {
+    const dir = path.dirname(configFile);
+    const base = path.basename(configFile);
+    const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+    const targets = [configFile, ...entries
+            .filter((entry) => entry.isFile() && entry.name.startsWith(`${base}.`) && entry.name.endsWith('.bak'))
+            .map((entry) => path.join(dir, entry.name))];
+    let hardened = 0;
+    for (const target of targets) {
+        const stat = await fs.lstat(target).catch(() => null);
+        if (!stat?.isFile() || stat.isSymbolicLink())
+            continue;
+        if ((stat.mode & 0o777) !== 0o600) {
+            await fs.chmod(target, 0o600);
+            hardened += 1;
+        }
+    }
+    return hardened;
+}
 function detectUnsafeFastUiRepair(text) {
     const reasons = [];
-    const lines = text.split(/\r?\n/);
-    for (let i = 0; i < lines.length; i += 1) {
-        const line = lines[i] || '';
-        const serviceTier = line.match(/^\s*service_tier\s*=\s*"(standard|flex)"\s*(?:#.*)?$/i)?.[1];
-        const sksMarked = SKS_CAUSED_RE.test(line) || SKS_CAUSED_RE.test(lines[i - 1] || '') || SKS_CAUSED_RE.test(lines[i + 1] || '');
-        if (serviceTier && !sksMarked)
-            reasons.push(`user_selected_service_tier_${serviceTier.toLowerCase()}`);
-    }
     if (hasOddUnescapedQuotes(text))
         reasons.push('unparseable_config_requires_manual_review');
     return [...new Set(reasons)];