sneakoscope 7.0.0 → 7.0.3

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/sks-menubar.js

@@ -1,2 +1 @@
-/** Compatibility facade retained for the 6.3 release. */
 export * from './menubar/index.js';

package/dist/core/codex-app.js

@@ -874,7 +874,6 @@ async function codexFastModeConfigStatus(opts = {}) {
             const line = lines[index] || '';
             if (!/^\s*model_reasoning_effort\s*=/.test(line))
                 continue;
-            // Preserve unmarked user reasoning choices. Only SKS-provenanced locks hide Fast UI.
             if (config.scope === 'global' ? isSksOwnedGlobalUiLock(lines, index) : true) {
                 blockers.push(`${config.scope}:top_level_model_reasoning_effort`);
             }
@@ -882,9 +881,6 @@ async function codexFastModeConfigStatus(opts = {}) {
         if (/(^|\n)\s*fast_default_opt_out\s*=\s*true\s*(?:#.*)?(?=\n|$)/.test(tomlTable(config.text, 'notice')))
             blockers.push(`${config.scope}:fast_default_opt_out`);
     }
-    // 2026-07 renewal: [user.fast_mode] left the config schema. Its PRESENCE is now
-    // the defect (a stale legacy stamp), not its absence — the old visible/enabled
-    // "missing" blockers inverted into a single legacy-residue blocker.
     const merged = configs.map((config) => config.text).join('\n');
     if (tomlTable(merged, 'user.fast_mode').trim())
         blockers.push('user.fast_mode.legacy_table_present');
@@ -970,8 +966,6 @@ export async function codexProviderModelUiStatus(opts = {}) {
         const loadedEnv = await loadCodexLbEnv({ home, envPath: codexLbEnvFilePath }).catch(() => null);
         liveCatalog = loadedEnv ? await readCodexLbModelCatalog({ loadedEnv }).catch(() => null) : null;
     }
-    // Prefer the persisted Codex-owned catalog that Desktop actually loads. Live
-    // /models remains freshness telemetry and a fallback when no managed file exists.
     const codexLbModelCatalog = opts.codexLbModelCatalog || (persistedCatalog?.ok
         ? {
             ok: true,
@@ -1020,9 +1014,6 @@ export async function codexProviderModelUiStatus(opts = {}) {
     const setKeyCommand = 'sks codex-lb set-key --api-key-stdin';
     return {
         schema: 'sks.codex-app-provider-model-ui.v1',
-        // The top-level readiness contract is intentionally scoped to the active
-        // provider. Optional GLM/OpenRouter and codex-lb setup diagnostics remain
-        // visible below without making an unrelated provider selection fail.
         ok: selectedProviderBlockers.length === 0,
         selected_provider_ok: selectedProviderBlockers.length === 0,
         selected_provider: codexLbSelectedDefault ? 'codex-lb' : 'oauth',

package/dist/core/codex-compat/codex-hook-output-builders.js

@@ -1,6 +1,14 @@
 import {} from './codex-schema-snapshot.js';
 export function buildPreToolUseContinue(options = {}) {
-    return withOptionalSystemMessage({ continue: true }, options.systemMessage);
+    const output = { continue: true };
+    const additionalContext = optionalText(options.additionalContext);
+    if (additionalContext) {
+        output.hookSpecificOutput = {
+            hookEventName: 'PreToolUse',
+            additionalContext
+        };
+    }
+    return withOptionalSystemMessage(output, options.systemMessage);
 }
 export function buildPreToolUseDeny(reason, options = {}) {
     const trimmed = requiredReason(reason, 'PreToolUse deny requires a non-empty reason');

package/dist/core/codex-compat/codex-hook-output-normalizer.js

@@ -25,7 +25,7 @@ export function normalizeCodexHookOutput(name, result = {}) {
         }
         if (decision === 'allow' && out.updatedInput !== undefined)
             return buildPreToolUseAllowRewrite(out.updatedInput, { systemMessage });
-        return buildPreToolUseContinue({ systemMessage });
+        return buildPreToolUseContinue({ additionalContext: out.additionalContext, systemMessage });
     }
     if (eventName === 'PermissionRequest') {
         if (out.decision === 'deny' || out.permissionDecision === 'deny') {

package/dist/core/codex-compat/codex-hook-semantic-validator.js

@@ -98,8 +98,9 @@ function validatePreToolUse(output, issues) {
     const specific = asRecord(output.hookSpecificOutput);
     if (!specific)
         return;
-    if (specific.additionalContext !== undefined)
-        pushStrictSubset(issues, 'pretooluse_additional_context', 'PreToolUse additionalContext is schema-compatible but disallowed by the SKS zero-warning strict subset.', '$.hookSpecificOutput.additionalContext');
+    if (specific.additionalContext !== undefined && typeof specific.additionalContext !== 'string') {
+        pushIssue(issues, 'schema_violation', 'pretooluse_additional_context_type', 'PreToolUse additionalContext must be a string.', '$.hookSpecificOutput.additionalContext', { upstream_supported: false });
+    }
     const decision = specific.permissionDecision;
     const hasUpdatedInput = Object.prototype.hasOwnProperty.call(specific, 'updatedInput');
     const hasReason = Object.prototype.hasOwnProperty.call(specific, 'permissionDecisionReason');

package/dist/core/codex-compat/codex-hook-warning-detector.js

@@ -56,10 +56,18 @@ export async function detectCodexHookOutputWarnings(eventLike, output) {
 function unknownTopLevelKeyIssues(output) {
     if (!output || typeof output !== 'object' || Array.isArray(output))
         return [];
-    const allowed = new Set(['continue', 'decision', 'reason', 'hookSpecificOutput']);
+    const allowed = new Set([
+        'continue',
+        'decision',
+        'reason',
+        'hookSpecificOutput',
+        'stopReason',
+        'suppressOutput',
+        'systemMessage'
+    ]);
     return Object.keys(output)
         .filter((key) => !allowed.has(key))
-        .map((key) => makeCodexHookIssue('policy_disallowed', `unknown_field_${key}`, `Unknown top-level hook field is not accepted by the SKS zero-warning contract: ${key}.`, { path: `$.${key}`, upstream_supported: false, sks_disallowed: true }));
+        .map((key) => makeCodexHookIssue('schema_violation', 'unknown_field', `Unknown top-level hook field is not accepted by the Codex hook output schema: ${key}.`, { path: `$.${key}`, upstream_supported: false, sks_disallowed: true }));
 }
 export async function codexHookWarningCheck(root, opts = {}) {
     root ||= await projectRoot();

package/dist/core/codex-control/codex-lb-launch-recovery.js

@@ -46,7 +46,6 @@ export async function inspectCodexLbCliLaunchRecovery(input) {
         : configLayer(await readText(projectConfigPath, '').catch(() => ''), 'project');
     const overrides = cliConfigOverrides(args);
     const environmentSelectsCodexLb = env.SKS_PROVIDER === 'codex-lb' || env.SKS_USE_CODEX_LB === '1';
-    // Local-provider CLI options are the final operator intent.
     if (cliSelectsLocalProvider(args)) {
         return codexLbToolOutputRecoveryNotSelected();
     }
@@ -59,8 +58,6 @@ export async function inspectCodexLbCliLaunchRecovery(input) {
     if (projectConfig.hasMachineLocalProviderConfig) {
         return projectProviderConfigBlocked();
     }
-    // Explicit model-provider overrides still win over user/profile defaults,
-    // but only after repository-local provider redirects have been rejected.
     if (overrides.modelProvider && overrides.modelProvider !== 'codex-lb') {
         return codexLbToolOutputRecoveryNotSelected();
     }

package/dist/core/codex-control/codex-reliability-shield.js

@@ -160,17 +160,9 @@ export function auditToolOutputContinuity(events) {
         missingToolCallIds: [...openToolCalls]
     };
 }
-/**
- * @deprecated Use auditToolOutputContinuity. Retained for one-release source
- * compatibility; this helper only audits and never repairs protocol state.
- */
 export function auditToolCallSequence(events) {
     return auditToolOutputContinuity(events);
 }
-/**
- * @deprecated This post-run helper cannot repair the Responses protocol. It now
- * preserves the event stream and reports missing outputs for fail-closed callers.
- */
 export function repairToolCallSequence(events) {
     const audit = auditToolOutputContinuity(events);
     return {

package/dist/core/codex-control/codex-sdk-adapter.js

@@ -179,9 +179,6 @@ async function prepareCodexLbToolCatalog(input, policy) {
     if (!isolatedCodexHome) {
         return { schema: 'sks.codex-lb-tool-catalog.v1', ok: false, required: true, status: 'blocked', path: null, blockers: ['codex_sdk_isolated_codex_home_missing'] };
     }
-    // Model catalogs contain no bearer secret and are identity-bound, owner-only
-    // files. Keep one validated global cache so isolated worker CODEX_HOME roots do
-    // not each spend a model-call slot fetching the same catalog.
     const sharedCodexHome = String(process.env.CODEX_HOME || path.join(os.homedir(), '.codex'));
     return ensureCodexLbToolCatalog({
         codexHome: isolatedCodexHome,

package/dist/core/codex-control/codex-sdk-config-policy.js

@@ -3,8 +3,6 @@ export function buildCodexSdkConfig(input) {
     const model = String(input.model || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || '').trim();
     const serviceTier = String(input.serviceTier || process.env.SKS_SERVICE_TIER || 'fast');
     const config = {
-        // Internal control-plane work is always native Codex. Ambient proxy
-        // credentials are not provider-selection consent.
         model_provider: 'openai',
         forced_login_method: 'chatgpt',
         service_tier: serviceTier === 'standard' ? 'standard' : 'fast',

package/dist/core/codex-control/codex-sdk-env-policy.js

@@ -91,7 +91,12 @@ export async function prepareNativeCodexAuthBridge(env, opts = {}) {
     }
     const nativeHome = String(process.env.HOME || os.homedir());
     const sourceHome = path.resolve(String(process.env.CODEX_HOME || path.join(nativeHome, '.codex')));
-    const sourceAuthCandidate = path.join(sourceHome, 'auth.json');
+    const primaryAuthCandidate = path.join(sourceHome, 'auth.json');
+    const backupAuthCandidate = path.join(sourceHome, 'auth.chatgpt-backup.json');
+    let sourceAuthCandidate = primaryAuthCandidate;
+    let sourceAuthProof = 'host_codex_home/auth.json';
+    let oauthBackupUsed = false;
+    let primaryAuthStatus = 'chatgpt_oauth';
     const originalHome = String(env.HOME || '');
     const originalCodexHome = String(env.CODEX_HOME || '');
     let tempRoot = null;
@@ -176,24 +181,35 @@ export async function prepareNativeCodexAuthBridge(env, opts = {}) {
         }
     };
     try {
-        const sourcePathStat = await fsp.lstat(sourceAuthCandidate);
-        if (sourcePathStat.isSymbolicLink())
-            throw new Error('native_codex_auth_source_symlink_forbidden');
-        if (!sourcePathStat.isFile())
-            throw new Error('native_codex_auth_source_not_file');
+        let source;
+        try {
+            source = await readNativeCodexOAuthSource(primaryAuthCandidate, 'native_codex_auth_source');
+        }
+        catch (error) {
+            const reason = String(error?.message || error);
+            if (reason === 'native_codex_auth_api_key_forbidden')
+                primaryAuthStatus = 'api_key';
+            else if (reason === 'native_codex_auth_source_missing')
+                primaryAuthStatus = 'missing';
+            else
+                throw error;
+            try {
+                source = await readNativeCodexOAuthSource(backupAuthCandidate, 'native_codex_auth_backup');
+                sourceAuthCandidate = backupAuthCandidate;
+                sourceAuthProof = 'host_codex_home/auth.chatgpt-backup.json';
+                oauthBackupUsed = true;
+            }
+            catch {
+                throw error;
+            }
+        }
+        const { pathStat: sourcePathStat, text: sourceText, auth: sourceAuth } = source;
         const noFollow = process.platform === 'win32' ? 0 : fsConstants.O_NOFOLLOW;
-        let sanitizedAuthText = '';
-        const sourceText = await readValidatedAuthFile(sourceAuthCandidate, {
-            expectedIdentity: { dev: sourcePathStat.dev, ino: sourcePathStat.ino },
-            requirePrivateMode: true,
-            errorPrefix: 'native_codex_auth_source'
-        });
-        const sourceAuth = parseStrictChatGptAuth(sourceText);
         sourceAuthIdentity = { dev: sourcePathStat.dev, ino: sourcePathStat.ino };
         sourceAuthFingerprint = fingerprintText(sourceText);
         originalTokenFingerprint = fingerprintJson(sourceAuth.tokens);
         originalApiKeyFields = Object.fromEntries(Object.entries(sourceAuth).filter(([key]) => isTopLevelApiKeyField(key)));
-        sanitizedAuthText = `${JSON.stringify(removeTopLevelApiKeyFields(sourceAuth), null, 2)}\n`;
+        const sanitizedAuthText = `${JSON.stringify(removeTopLevelApiKeyFields(sourceAuth), null, 2)}\n`;
         const tempBase = await fsp.realpath(os.tmpdir());
         tempRoot = await fsp.mkdtemp(path.join(tempBase, 'sks-native-codex-'));
         const rootStat = await fsp.lstat(tempRoot);
@@ -246,7 +262,10 @@ export async function prepareNativeCodexAuthBridge(env, opts = {}) {
             status: 'ready',
             method: 'exclusive_copy',
             auth_mode: 'chatgpt_oauth',
-            source: 'host_codex_home/auth.json',
+            source: sourceAuthProof,
+            oauth_backup_used: oauthBackupUsed,
+            primary_auth_status: primaryAuthStatus,
+            active_api_key_auth_preserved: oauthBackupUsed && primaryAuthStatus === 'api_key',
             destination: 'private_temp_codex_home/auth.json',
             temp_root_location: 'os_tmpdir',
             temp_root_mode: '0700',
@@ -286,7 +305,7 @@ export async function prepareNativeCodexAuthBridge(env, opts = {}) {
                 ok: false,
                 status: 'blocked',
                 method: null,
-                source: 'host_codex_home/auth.json',
+                source: sourceAuthProof,
                 destination: 'private_temp_codex_home/auth.json',
                 cleanup_required: Boolean(tempRoot && !cleanupComplete),
                 blockers: [blocker]
@@ -304,6 +323,32 @@ export async function prepareNativeCodexAuthBridge(env, opts = {}) {
         };
     }
 }
+async function readNativeCodexOAuthSource(filePath, errorPrefix) {
+    let pathStat;
+    try {
+        pathStat = await fsp.lstat(filePath);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            throw new Error(`${errorPrefix}_missing`);
+        throw new Error(`${errorPrefix}_unreadable`);
+    }
+    if (pathStat.isSymbolicLink())
+        throw new Error(`${errorPrefix}_symlink_forbidden`);
+    if (!pathStat.isFile())
+        throw new Error(`${errorPrefix}_not_file`);
+    const text = await readValidatedAuthFile(filePath, {
+        expectedIdentity: { dev: pathStat.dev, ino: pathStat.ino },
+        requirePrivateMode: true,
+        requireSingleLink: true,
+        errorPrefix
+    });
+    return {
+        pathStat,
+        text,
+        auth: parseStrictChatGptAuth(text)
+    };
+}
 function parseStrictChatGptAuth(sourceText, opts = {}) {
     let parsed;
     try {

package/dist/core/codex-control/codex-task-runner.js

@@ -139,10 +139,6 @@ export async function runCodexTask(input) {
     }
     const result = {
         ok: finalBlockers.length === 0,
-        // Must match backend_family below: a fake-adapter run self-reporting
-        // 'codex-sdk' here defeated every downstream `backend === 'fake'` check
-        // (fake-real-proof-policy, agent-proof-evidence, naruto-real-write-proof,
-        // etc.) that already exists specifically to disclaim fixture-only runs.
         backend: fakeAllowed ? 'fake' : 'codex-sdk',
         backend_family: fakeAllowed ? 'fake' : 'remote-gpt',
         sdkThreadId: String(adapterResult?.sdkThreadId || ''),
@@ -406,9 +402,6 @@ async function runLocalControlTask(root, task, schema, routerDecision) {
         ...(runFailed || validation.ok ? [] : ['local_llm_structured_output_invalid', ...validation.issues.map((issue) => `schema:${issue}`)])
     ];
     const workerResult = normalizeWorkerResult(structuredOutput, task, finalBlockers, validation.ok, 'local-llm');
-    // Stamp the local-llm request id as backend proof on model-authored patch
-    // envelopes; without it agent-patch-schema rejects every local-llm patch
-    // with model_authored_backend_proof_missing (the model cannot know the id).
     if (Array.isArray(workerResult.patch_envelopes)) {
         workerResult.patch_envelopes = workerResult.patch_envelopes.map((envelope) => ({
             ...envelope,

package/dist/core/codex-control/codex-thread-registry.js

@@ -81,10 +81,6 @@ async function readRegistryForUpdate(registryPath) {
         };
     }
 }
-// Previously a bespoke mkdir-lock with no stale recovery at all — a crash
-// mid-update left every future recordCodexThread() call permanently timing
-// out after 30s (20차 P1-2). Reuses the owner-token + heartbeat +
-// quarantine-reclaim lock from core/locks/file-lock.ts instead.
 function withRegistryLock(root, fn) {
     const lockPath = path.join(root, 'codex-thread-registry.lock');
     return withFileLock({ lockPath, timeoutMs: 30_000, staleMs: 60_000 }, fn);