sneakoscope 8.1.2 → 8.2.0

package/dist/core/architecture-hardening/migration/migration.js

@@ -1,111 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-import { writeCodexConfigGuarded } from '../../codex/codex-config-guard.js';
-import { sha256 } from '../../fsx.js';
-export function inspectArchitectureMigration(input) {
-    const findings = [];
-    const providerSections = [...input.configText.matchAll(/^\s*\[model_providers\.([A-Za-z0-9_-]+)\]\s*$/gm)].map((match) => match[1]).filter((value) => Boolean(value));
-    for (const provider of providerSections)
-        findings.push({ kind: 'custom_provider', code: 'legacy_custom_provider_injection', removable_path: `model_providers.${provider}` });
-    if (providerSections.length > 1)
-        findings.push({ kind: 'mixed_catalog', code: 'legacy_mixed_provider_catalog', removable_path: null });
-    if (!input.sessionMetadataPresent)
-        findings.push({ kind: 'missing_session_metadata', code: 'legacy_session_metadata_missing', removable_path: null });
-    if (input.command && /(?:\bux-review\b|\bvisual-review\b|--skip-evidence|--force-fast)/i.test(input.command)) {
-        findings.push({ kind: 'obsolete_command', code: 'legacy_command_or_option_obsolete', removable_path: null });
-    }
-    const ambiguous = findings.some((finding) => finding.kind === 'mixed_catalog' || finding.kind === 'missing_session_metadata');
-    return {
-        schema: 'sks.architecture-migration-plan.v1',
-        status: !findings.length ? 'no_op' : ambiguous ? 'migration_required' : 'ready',
-        source_hash: sha256(input.configText), findings,
-        removable_paths: findings.flatMap((finding) => finding.removable_path ? [finding.removable_path] : []),
-        blockers: ambiguous ? findings.filter((finding) => finding.kind === 'mixed_catalog' || finding.kind === 'missing_session_metadata').map((finding) => finding.code) : []
-    };
-}
-export async function applyArchitectureMigration(input) {
-    if (!input.explicitApply)
-        throw new Error('architecture_migration_explicit_apply_required');
-    if (input.plan.status !== 'ready')
-        throw new Error('architecture_migration_plan_not_ready');
-    const current = await fsp.readFile(input.configPath, 'utf8');
-    if (sha256(current) !== input.plan.source_hash)
-        throw new Error('architecture_migration_user_edit_conflict');
-    const confirmed = new Set(input.confirmedRemovablePaths);
-    if (input.plan.removable_paths.some((entry) => !confirmed.has(entry)))
-        throw new Error('architecture_migration_reference_proof_required');
-    const stat = await fsp.stat(input.configPath);
-    const migrated = migrateConfigText(current, input.targetMode, input.loopbackBaseUrl || null, input.plan.removable_paths);
-    const write = await writeCodexConfigGuarded({
-        root: path.dirname(input.configPath),
-        configPath: input.configPath,
-        before: current,
-        mutate: () => migrated,
-        cause: 'architecture-migration',
-        backupTag: 'architecture-backup',
-        ownershipVerified: true,
-        verifyUnchangedBeforeWrite: true,
-        expectedBeforeExists: true,
-        expectedBeforeMode: stat.mode & 0o777,
-        preserveTextFormatting: true
-    });
-    if (!write.ok || !write.changed || !write.backup_path)
-        throw new Error(`architecture_migration_${write.status}`);
-    return {
-        schema: 'sks.architecture-migration-receipt.v1', status: 'applied', source_hash: input.plan.source_hash,
-        output_hash: sha256(migrated), backup_hash: sha256(current), backup_path_hash: sha256(path.resolve(write.backup_path)), target_mode: input.targetMode
-    };
-}
-export async function rollbackArchitectureMigration(input) {
-    if (!input.explicitRollback)
-        throw new Error('architecture_migration_explicit_rollback_required');
-    const current = await fsp.readFile(input.configPath, 'utf8');
-    if (sha256(current) !== input.receipt.output_hash)
-        throw new Error('architecture_migration_rollback_conflict');
-    const backup = await fsp.readFile(input.backupPath, 'utf8');
-    if (sha256(backup) !== input.receipt.backup_hash || sha256(path.resolve(input.backupPath)) !== input.receipt.backup_path_hash) {
-        throw new Error('architecture_migration_backup_mismatch');
-    }
-    const stat = await fsp.stat(input.configPath);
-    const write = await writeCodexConfigGuarded({
-        root: path.dirname(input.configPath),
-        configPath: input.configPath,
-        before: current,
-        mutate: () => backup,
-        cause: 'architecture-migration-rollback',
-        backupTag: `architecture-rollback-${randomUUID()}`,
-        ownershipVerified: true,
-        verifyUnchangedBeforeWrite: true,
-        expectedBeforeExists: true,
-        expectedBeforeMode: stat.mode & 0o777,
-        preserveTextFormatting: true
-    });
-    if (!write.ok || !write.changed)
-        throw new Error(`architecture_migration_${write.status}`);
-    return { ...input.receipt, status: 'rolled_back', output_hash: sha256(backup) };
-}
-function migrateConfigText(source, mode, loopbackBaseUrl, removablePaths) {
-    if (mode !== 'chatgpt-oauth') {
-        const parsed = loopbackBaseUrl ? new URL(loopbackBaseUrl) : null;
-        if (!parsed || parsed.protocol !== 'http:' || !['127.0.0.1', '::1', 'localhost'].includes(parsed.hostname.replace(/^\[|\]$/g, ''))) {
-            throw new Error('architecture_migration_loopback_required');
-        }
-    }
-    const removable = new Set(removablePaths);
-    const lines = source.split(/\r?\n/);
-    const kept = [];
-    let skip = false;
-    for (const line of lines) {
-        const section = line.match(/^\s*\[([^\]]+)\]\s*$/)?.[1] || null;
-        if (section)
-            skip = removable.has(section);
-        if (!skip)
-            kept.push(line);
-    }
-    let text = kept.join('\n').replace(/^\s*#\s*sks-managed-provider-mode:.*$/gm, '').replace(/^\s*model_provider\s*=.*$/gm, '').replace(/^\s*openai_base_url\s*=.*$/gm, '').trim();
-    const header = [`# sks-managed-provider-mode:${mode}`, 'model_provider = "openai"'];
-    if (mode !== 'chatgpt-oauth')
-        header.push(`openai_base_url = ${JSON.stringify(loopbackBaseUrl)}`);
-    return `${header.join('\n')}\n${text ? `${text}\n` : ''}`;
-}

package/dist/core/codex-app/auxiliary-oauth-policy.js

@@ -1,36 +0,0 @@
-export function decideAuxiliaryOAuthRoute(input) {
-    const base = {
-        schema: 'sks.auxiliary-oauth-route-decision.v1',
-        session_mode: input.mode,
-        feature: input.contract.feature,
-        request_path: input.contract.request_path,
-        session_mode_changed: false
-    };
-    if (input.contract.proxy_supported) {
-        return { ...base, route: input.mode, auxiliary_oauth_used: false, status: 'proxy_supported', blockers: [] };
-    }
-    if (!input.contract.protocol_verified) {
-        return { ...base, route: null, auxiliary_oauth_used: false, status: 'blocked', blockers: ['auxiliary_oauth_feature_protocol_unverified'] };
-    }
-    if (!input.userAllowed) {
-        return { ...base, route: null, auxiliary_oauth_used: false, status: 'permission_required', blockers: ['auxiliary_oauth_user_permission_required'] };
-    }
-    if (!input.oauthConnected) {
-        return { ...base, route: null, auxiliary_oauth_used: false, status: 'oauth_required', blockers: ['auxiliary_oauth_connection_required'] };
-    }
-    return {
-        ...base,
-        route: 'chatgpt-oauth',
-        auxiliary_oauth_used: true,
-        status: 'auxiliary_oauth',
-        blockers: [],
-        audit_event: {
-            schema: 'sks.auxiliary-oauth-event.v1',
-            event: 'feature_request_routed_via_auxiliary_oauth',
-            feature: input.contract.feature,
-            reason: `${input.mode}_proxy_does_not_support_feature`,
-            credential_path: 'chatgpt-oauth',
-            session_mode: input.mode
-        }
-    };
-}

package/dist/core/codex-app/catalog-compat/catalog-service.js

@@ -1,104 +0,0 @@
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-import { stableArchitectureHash } from '../../architecture-hardening/contracts/contracts.js';
-import { writeJsonAtomic } from '../../fsx.js';
-export class CatalogCompatibilityService {
-    statePath;
-    constructor(statePath) {
-        this.statePath = path.resolve(statePath);
-    }
-    async refresh(input) {
-        const previous = await this.read();
-        const checkedAt = (input.now || new Date()).toISOString();
-        try {
-            if (input.credential.status !== 'ready')
-                throw new Error(`catalog_credential_${input.credential.status}`);
-            const nativeModels = [...new Set(await input.port.readNativeCatalog())].filter(Boolean).sort();
-            const modeCandidates = nativeModels.filter((model) => (input.mode === 'openrouter') === model.includes('/'));
-            const candidateSet = new Set(modeCandidates);
-            const validated = [...new Set(await input.port.validateModels(input.mode, modeCandidates))];
-            if (validated.some((model) => !candidateSet.has(model)))
-                throw new Error('catalog_validation_returned_unknown_model');
-            const filtered = validated.sort();
-            const snapshot = {
-                schema: 'sks.catalog-snapshot.v1',
-                version: stableArchitectureHash({ mode: input.mode, models: filtered }),
-                models: filtered,
-                checked_at: checkedAt
-            };
-            const changed = previous.last_good?.version !== snapshot.version;
-            const state = {
-                schema: 'sks.catalog-compatibility-state.v1', last_good: snapshot, changed,
-                last_checked_at: checkedAt, failure_reason: null,
-                cache_invalidation_required: changed, restart_required: changed && (input.pinnedSessions?.length || 0) > 0,
-                trigger: input.trigger
-            };
-            await this.write(state);
-            return state;
-        }
-        catch (error) {
-            const state = {
-                schema: 'sks.catalog-compatibility-state.v1', last_good: previous.last_good, changed: false,
-                last_checked_at: checkedAt, failure_reason: safeReason(error), cache_invalidation_required: false,
-                restart_required: false, trigger: input.trigger
-            };
-            await this.write(state);
-            return state;
-        }
-    }
-    async read() {
-        try {
-            const value = JSON.parse(await fsp.readFile(this.statePath, 'utf8'));
-            if (value.schema !== 'sks.catalog-compatibility-state.v1')
-                throw new Error('catalog_state_invalid');
-            return value;
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT' && error.message !== 'catalog_state_invalid')
-                throw error;
-            return {
-                schema: 'sks.catalog-compatibility-state.v1', last_good: null, changed: false,
-                last_checked_at: new Date(0).toISOString(), failure_reason: null,
-                cache_invalidation_required: false, restart_required: false, trigger: 'startup'
-            };
-        }
-    }
-    async write(state) {
-        await fsp.mkdir(path.dirname(this.statePath), { recursive: true, mode: 0o700 });
-        await writeJsonAtomic(this.statePath, state, { mode: 0o600 });
-    }
-}
-export function computeFeatureCompatibility(input) {
-    if (input.directProxySupported)
-        return feature(input.feature, 'direct-proxy', false, null);
-    if (!input.protocolVerified)
-        return feature(input.feature, 'unavailable', false, 'feature_protocol_unverified');
-    if (!input.oauthAllowed)
-        return feature(input.feature, 'unavailable', true, 'feature_oauth_permission_required');
-    if (!input.oauthConnected)
-        return feature(input.feature, 'unavailable', true, 'feature_oauth_connection_required');
-    return feature(input.feature, 'oauth-auxiliary', true, null);
-}
-export function scheduleCatalogBackgroundRefresh(refresh, intervalMs, schedule = setInterval, onFailure) {
-    if (intervalMs < 60_000)
-        throw new Error('catalog_background_interval_too_short');
-    let failure = null;
-    const timer = schedule(() => {
-        void refresh().catch((error) => {
-            failure = safeReason(error);
-            onFailure?.(failure);
-        });
-    }, intervalMs);
-    timer.unref?.();
-    return {
-        stop: () => clearInterval(timer),
-        lastFailure: () => failure
-    };
-}
-function feature(name, route, oauth, reason) {
-    return { schema: 'sks.feature-compatibility.v1', feature: name, route, oauth_required: oauth, reason_code: reason };
-}
-function safeReason(error) {
-    const value = error instanceof Error ? error.message : '';
-    return /^[a-z][a-z0-9_]{2,99}$/.test(value) ? value : 'catalog_refresh_failed';
-}

package/dist/core/codex-app/child-policy/child-policy.js

@@ -1,35 +0,0 @@
-import { stableArchitectureHash } from '../../architecture-hardening/contracts/contracts.js';
-import { sessionPinHash } from '../session-policy/session-pinning.js';
-export function createChildPolicySnapshot(policy, registeredOpenRouterModels = []) {
-    const owner = policy.mode === 'chatgpt-oauth' ? 'codex-native' : policy.mode === 'codex-lb' ? 'codex-lb' : 'sks-center';
-    const allowed = policy.mode === 'openrouter'
-        ? registeredOpenRouterModels.filter((model) => policy.allowed_models.includes(model) && model.includes('/'))
-        : policy.mode === 'codex-lb' ? policy.allowed_models.filter((model) => !model.includes('/')) : [];
-    const base = { schema: 'sks.child-policy-snapshot.v1', mode: policy.mode, owner, allowed_models: [...new Set(allowed)].sort() };
-    return { ...base, policy_hash: stableArchitectureHash(base) };
-}
-export function decideChildSelection(input) {
-    const parentHash = sessionPinHash(input.session);
-    const blocked = (code) => ({
-        schema: 'sks.child-selection-decision.v1', ok: false, owner: input.policy.owner, model: null,
-        parent_snapshot_hash: parentHash, blockers: [code]
-    });
-    if (input.session.mode !== input.policy.mode)
-        return blocked('child_policy_mode_mismatch');
-    if (input.session.child_policy_hash !== input.policy.policy_hash)
-        return blocked('child_policy_snapshot_mismatch');
-    const requested = String(input.requestedModel || '').trim();
-    if (input.policy.mode === 'chatgpt-oauth') {
-        if (requested)
-            return blocked('child_policy_oauth_override_forbidden');
-        return { schema: 'sks.child-selection-decision.v1', ok: true, owner: 'codex-native', model: null, parent_snapshot_hash: parentHash, blockers: [] };
-    }
-    if (input.policy.mode === 'codex-lb' && !requested) {
-        return { schema: 'sks.child-selection-decision.v1', ok: true, owner: 'codex-lb', model: null, parent_snapshot_hash: parentHash, blockers: [] };
-    }
-    if (!input.policy.allowed_models.includes(requested))
-        return blocked(input.policy.mode === 'openrouter' ? 'child_policy_openrouter_model_unregistered' : 'child_policy_lb_model_outside_family');
-    if (!input.session.allowed_models.includes(requested))
-        return blocked('child_policy_parent_model_mismatch');
-    return { schema: 'sks.child-selection-decision.v1', ok: true, owner: input.policy.owner, model: requested, parent_snapshot_hash: parentHash, blockers: [] };
-}

package/dist/core/codex-app/desktop-routing-snapshot.js

@@ -1,233 +0,0 @@
-import fs from 'node:fs/promises';
-import { execFileSync } from 'node:child_process';
-import os from 'node:os';
-import path from 'node:path';
-import { nowIso, writeTextAtomic } from '../fsx.js';
-import { codexHomePath, readTopLevelTomlString } from './codex-model-catalog.js';
-import { ensureTrailingNewline, removeTopLevelTomlKeyIfValue, safeWriteCodexConfigToml, upsertTopLevelTomlString } from '../codex-runtime/codex-desktop-config-policy.js';
-import { invalidateCodexModelsCache } from './codex-models-cache.js';
-export const DESKTOP_ROUTING_SNAPSHOT_SCHEMA = 'sks.codex-desktop-routing-snapshot.v1';
-export const DESKTOP_ROUTING_SNAPSHOT_FILENAME = 'sks-previous-desktop-routing.json';
-function snapshotPath(input = {}) {
-    return path.join(codexHomePath(input), DESKTOP_ROUTING_SNAPSHOT_FILENAME);
-}
-export function desktopRoutingSnapshotPath(input = {}) {
-    return snapshotPath(input);
-}
-function threadCatalogDbPath(input = {}) {
-    return path.join(codexHomePath(input), 'sqlite', 'codex-dev.db');
-}
-function sqlQuote(value) {
-    return `'${String(value).replace(/'/g, "''")}'`;
-}
-function runSqlite3(dbPath, sql) {
-    return execFileSync('sqlite3', ['-batch', '-noheader', dbPath, sql], {
-        encoding: 'utf8',
-        timeout: 10_000,
-        maxBuffer: 2 * 1024 * 1024
-    });
-}
-export function captureDesktopRoutingSnapshot(configText, input) {
-    return {
-        schema: DESKTOP_ROUTING_SNAPSHOT_SCHEMA,
-        captured_at: nowIso(),
-        reason: input.reason,
-        model_provider: readTopLevelTomlString(configText, 'model_provider'),
-        model: readTopLevelTomlString(configText, 'model'),
-        model_catalog_json: readTopLevelTomlString(configText, 'model_catalog_json'),
-        openai_base_url: readTopLevelTomlString(configText, 'openai_base_url'),
-        ...(input.threadSidebar ? { thread_sidebar: input.threadSidebar } : {})
-    };
-}
-export async function writeDesktopRoutingSnapshot(snapshot, input = {}) {
-    const filePath = snapshotPath(input);
-    try {
-        await writeTextAtomic(filePath, `${JSON.stringify(snapshot, null, 2)}\n`, { mode: 0o600 });
-        return { ok: true, path: filePath };
-    }
-    catch (err) {
-        return { ok: false, path: filePath, error: err?.message || String(err) };
-    }
-}
-export async function readDesktopRoutingSnapshot(input = {}) {
-    const filePath = snapshotPath(input);
-    try {
-        const raw = await fs.readFile(filePath, 'utf8');
-        const parsed = JSON.parse(raw);
-        if (!parsed || parsed.schema !== DESKTOP_ROUTING_SNAPSHOT_SCHEMA)
-            return null;
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
-export function assessThreadVisibilityImpact(input) {
-    const catalogDb = threadCatalogDbPath(input);
-    const warnings = [];
-    const counts = {};
-    let checked = false;
-    try {
-        const raw = runSqlite3(catalogDb, 'SELECT model_provider, COUNT(*) FROM local_thread_catalog GROUP BY model_provider;');
-        for (const line of raw.split(/\n/).map((entry) => entry.trim()).filter(Boolean)) {
-            const sep = line.includes('|') ? '|' : '\t';
-            const [provider, count] = line.split(sep);
-            counts[String(provider || 'unknown')] = Number(count || 0);
-        }
-        checked = true;
-    }
-    catch (err) {
-        warnings.push(`thread_catalog_unreadable:${err?.code || err?.message || 'unknown'}`);
-    }
-    const target = String(input.targetProvider || '').trim();
-    const hidden = Object.entries(counts)
-        .filter(([provider]) => provider !== target)
-        .reduce((sum, [, count]) => sum + count, 0);
-    if (checked && hidden > 0) {
-        warnings.push('desktop_hides_other_provider_threads_until_restore');
-    }
-    return {
-        schema: 'sks.codex-desktop-thread-visibility.v1',
-        checked,
-        catalog_db: checked ? catalogDb : null,
-        current_provider: input.currentProvider,
-        target_provider: target,
-        counts_by_provider: counts,
-        hidden_if_switched: hidden,
-        warnings
-    };
-}
-export function remapThreadCatalogProvider(input) {
-    const catalogDb = threadCatalogDbPath(input);
-    const fromProvider = String(input.fromProvider || '').trim();
-    const toProvider = String(input.toProvider || '').trim();
-    if (!fromProvider || !toProvider || fromProvider === toProvider) {
-        return { ok: true, remapped: 0, thread_ids: [], catalog_db: catalogDb };
-    }
-    try {
-        const idRaw = runSqlite3(catalogDb, `SELECT thread_id FROM local_thread_catalog WHERE model_provider = ${sqlQuote(fromProvider)};`);
-        const ids = idRaw.split(/\n/).map((entry) => entry.trim()).filter(Boolean);
-        if (ids.length === 0) {
-            return { ok: true, remapped: 0, thread_ids: [], catalog_db: catalogDb };
-        }
-        runSqlite3(catalogDb, `UPDATE local_thread_catalog SET model_provider = ${sqlQuote(toProvider)} WHERE model_provider = ${sqlQuote(fromProvider)};`);
-        return {
-            ok: true,
-            remapped: ids.length,
-            thread_ids: ids,
-            catalog_db: catalogDb
-        };
-    }
-    catch (err) {
-        return {
-            ok: false,
-            remapped: 0,
-            thread_ids: [],
-            catalog_db: catalogDb,
-            error: err?.message || String(err)
-        };
-    }
-}
-export async function restoreDesktopRoutingSnapshot(input) {
-    const home = input.home || input.env?.HOME || os.homedir();
-    const env = { ...(input.env || process.env), HOME: home };
-    const snapshot = await readDesktopRoutingSnapshot({ home, env });
-    if (!snapshot) {
-        return {
-            schema: 'sks.codex-app-restore-desktop-routing.v1',
-            ok: false,
-            status: 'snapshot_missing',
-            blockers: ['desktop_routing_snapshot_missing'],
-            warnings: [],
-            hint: 'No previous Desktop routing snapshot. Use `sks codex-lb use-desktop-full` to enable managed routing or `sks codex-lb disable` to remove only SKS-managed routing.'
-        };
-    }
-    const configPath = input.configPath || path.join(codexHomePath({ home, env }), 'config.toml');
-    const before = await fs.readFile(configPath, 'utf8').catch(() => '');
-    let next = before;
-    if (snapshot.model_provider)
-        next = upsertTopLevelTomlString(next, 'model_provider', snapshot.model_provider);
-    else
-        next = removeTopLevelTomlKeyIfValue(next, 'model_provider', readTopLevelTomlString(next, 'model_provider') || '');
-    if (snapshot.model)
-        next = upsertTopLevelTomlString(next, 'model', snapshot.model);
-    else
-        next = removeTopLevelTomlKeyIfValue(next, 'model', readTopLevelTomlString(next, 'model') || '');
-    if (snapshot.model_catalog_json) {
-        next = upsertTopLevelTomlString(next, 'model_catalog_json', snapshot.model_catalog_json);
-    }
-    else {
-        next = removeTopLevelTomlKeyIfValue(next, 'model_catalog_json', readTopLevelTomlString(next, 'model_catalog_json') || '');
-    }
-    next = ensureTrailingNewline(next);
-    const write = await safeWriteCodexConfigToml(configPath, before, next, 'restore-desktop-routing', { verifyUnchangedBeforeWrite: true, expectedBeforeExists: Boolean(before) });
-    if (!write.ok) {
-        return {
-            schema: 'sks.codex-app-restore-desktop-routing.v1',
-            ok: false,
-            status: 'config_write_blocked',
-            snapshot,
-            write,
-            blockers: [String(write.status || 'restore_config_write_blocked')],
-            warnings: []
-        };
-    }
-    let sidebarRestore = null;
-    if (snapshot.thread_sidebar?.remapped) {
-        const remapped = remapThreadCatalogProvider({
-            home,
-            env,
-            fromProvider: snapshot.thread_sidebar.to_provider,
-            toProvider: snapshot.thread_sidebar.from_provider
-        });
-        sidebarRestore = { ...remapped, expected_ids: snapshot.thread_sidebar.thread_ids.length };
-    }
-    const cache = await invalidateCodexModelsCache({
-        home,
-        env,
-        catalogPath: snapshot.model_catalog_json,
-        seedMode: 'merge'
-    });
-    const restart = await (input.restartImpl
-        ? input.restartImpl({ enabled: Boolean(input.restartApp) })
-        : Promise.resolve({ ok: true, blockers: [] }));
-    const sidebarRestoreOk = sidebarRestore === null || sidebarRestore.ok === true;
-    if (sidebarRestoreOk) {
-        try {
-            await fs.unlink(snapshotPath({ home, env }));
-        }
-        catch {
-        }
-    }
-    const sidebarBlocker = sidebarRestoreOk
-        ? []
-        : [`thread_sidebar_restore_failed:${String(sidebarRestore?.error || 'unknown')}`];
-    const sidebarRemapped = Number(sidebarRestore?.remapped ?? 0);
-    const sidebarExpected = Number(sidebarRestore?.expected_ids ?? 0);
-    const sidebarPartial = sidebarRestoreOk && sidebarRestore !== null && sidebarRemapped < sidebarExpected;
-    const sidebarWarning = sidebarPartial
-        ? [`thread_sidebar_restore_partial:${sidebarRemapped}_of_${sidebarExpected}`]
-        : [];
-    return {
-        schema: 'sks.codex-app-restore-desktop-routing.v1',
-        ok: Boolean(write.ok && restart.ok && sidebarRestoreOk),
-        status: !sidebarRestoreOk
-            ? (restart.ok ? 'restored_sidebar_blocked' : 'restored_sidebar_and_restart_blocked')
-            : restart.ok ? 'restored' : 'restored_restart_blocked',
-        snapshot,
-        write,
-        thread_sidebar_restore: sidebarRestore,
-        thread_sidebar_restore_ok: sidebarRestoreOk,
-        snapshot_retained: !sidebarRestoreOk,
-        models_cache: cache,
-        restart_app: restart,
-        blockers: [
-            ...sidebarBlocker,
-            ...(restart.ok ? [] : (restart.blockers || ['restore_restart_blocked']))
-        ],
-        warnings: [...sidebarWarning, ...(cache.warnings || [])],
-        hint: sidebarRestoreOk
-            ? 'Codex Desktop may need a full quit/reopen for the sidebar and picker to refresh.'
-            : 'Routing was restored but prior-provider chats stay hidden. Fully quit Codex Desktop, then re-run sks codex-app restore-desktop-routing — the snapshot was kept for that retry.'
-    };
-}

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

@@ -1 +0,0 @@
-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';