sneakoscope 7.1.0 → 7.3.0

package/dist/core/codex-app/codex-init-deep.js

@@ -1,8 +1,11 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { CANONICAL_DIRECTIVES } from '../agent-guidance/directive-registry.js';
 import { ensureDir, nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 import { guardContextForRoute, guardedRm } from '../safety/mutation-guard.js';
 import { createRequestedScopeContract } from '../safety/requested-scope-contract.js';
+import { escapeRegExp } from '../text/regex.js';
+import { messageOf } from '../errors/message.js';
 export async function runCodexInitDeep(input = {}) {
     const root = path.resolve(input.root || process.cwd());
     const dirs = await scoreDirectories(root);
@@ -107,9 +110,6 @@ function initDeepBackupPath(root, agentsPath, beforeHash) {
 function backupBaseName(root, agentsPath) {
     return path.relative(root, agentsPath).replace(/[\\/]+/g, '__');
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
 function hashText(text) {
     let hash = 2166136261;
     for (let index = 0; index < text.length; index += 1) {
@@ -207,12 +207,27 @@ async function walk(dir, root, counts, depth = 0) {
         }
     }
 }
+export function renderInitDeepAgentGuidance(rows) {
+    return [
+        { path: 'ROOT', text: renderSharedAgentDirectives() },
+        ...rows.map((row) => ({ path: row.dir, text: renderDirectoryAgentsBlock(row) }))
+    ];
+}
+export function renderSharedAgentDirectives() {
+    return [
+        '## Shared directives',
+        '',
+        ...CANONICAL_DIRECTIVES.map((entry) => `- ${entry.statement}`)
+    ].join('\n');
+}
 function renderGeneratedAgents(rows) {
     return [
         '# SKS Init-Deep Generated Context',
         '',
         'This file is generated under `.sneakoscope/context` so user-authored `AGENTS.md` files are preserved.',
         '',
+        renderSharedAgentDirectives(),
+        '',
         ...rows.flatMap((row) => [
             `## ${row.dir}`,
             '',
@@ -224,15 +239,15 @@ function renderGeneratedAgents(rows) {
     ].join('\n');
 }
 function renderDirectoryAgentsBlock(row) {
+    const risky = CANONICAL_DIRECTIVES.find((entry) => entry.id === 'hydrate')
+        .subsumes.some((pattern) => pattern.test(row.guidance));
     return [
         `# SKS Init-Deep Local Guidance: ${row.dir}`,
         '',
         `- Files observed: ${row.file_count}`,
         `- Languages: ${row.languages.join(', ') || 'unknown'}`,
-        `- Guidance: ${row.guidance}`,
-        '- Preserve user-authored content outside this managed block.',
-        '- Hydrate TriWiki/current source before risky edits in this directory.'
-    ].join('\n');
+        risky ? '- Risk: high' : ''
+    ].filter(Boolean).join('\n');
 }
 function extractManagedSection(text, markerName) {
     const begin = `<!-- BEGIN ${markerName} -->`;
@@ -243,6 +258,3 @@ function extractManagedSection(text, markerName) {
         return '';
     return text.slice(beginIdx + begin.length, endIdx).trim();
 }
-function messageOf(err) {
-    return err instanceof Error ? err.message : String(err);
-}

package/dist/core/codex-app/codex-model-catalog.js

@@ -0,0 +1,384 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { escapeRegExp } from '../text/regex.js';
+import { isRecord } from '../json/records.js';
+import { uniqueStrings } from '../text/strings.js';
+export const CODEX_MODEL_CATALOG_MAX_BYTES = 16 * 1024 * 1024;
+export const CODEX_MODEL_CATALOG_MAX_MODELS = 512;
+export function codexHomePath(input = {}) {
+    const env = input.env || process.env;
+    const home = input.home || env.HOME || os.homedir();
+    return path.resolve(env.CODEX_HOME || path.join(home, '.codex'));
+}
+export function codexUserConfigPath(input = {}) {
+    return path.join(codexHomePath(input), 'config.toml');
+}
+export function defaultOpenCodexCatalogPath(input = {}) {
+    return path.join(codexHomePath(input), 'opencodex-catalog.json');
+}
+export function sksOpenRouterCatalogPath(input = {}) {
+    return path.join(codexHomePath(input), 'sks-openrouter-catalog.json');
+}
+export async function readConfiguredCodexModelCatalog(input = {}) {
+    return (await readConfiguredCodexModelRoutingContext(input)).catalog;
+}
+export async function readConfiguredCodexModelRoutingContext(input = {}) {
+    const configPath = input.configPath || codexUserConfigPath(input);
+    let config = '';
+    try {
+        config = await fs.readFile(configPath, 'utf8');
+    }
+    catch (err) {
+        if (err?.code !== 'ENOENT') {
+            return {
+                schema: 'sks.codex-model-routing-context.v1',
+                config_path: configPath,
+                selected_provider: null,
+                selected_model: null,
+                catalog: emptyCatalogResult(null, false, ['codex_model_catalog_config_unreadable'])
+            };
+        }
+    }
+    const configuredPath = readTopLevelTomlString(config, 'model_catalog_json');
+    const catalog = configuredPath
+        ? await readCodexModelCatalogFile({
+            filePath: expandCatalogPath(configuredPath, { ...input, configPath }),
+            configured: true
+        })
+        : emptyCatalogResult(null, false, []);
+    return {
+        schema: 'sks.codex-model-routing-context.v1',
+        config_path: configPath,
+        selected_provider: readTopLevelTomlString(config, 'model_provider'),
+        selected_model: readTopLevelTomlString(config, 'model'),
+        catalog
+    };
+}
+export async function readCodexModelCatalogFile(input) {
+    const filePath = path.resolve(String(input.filePath || ''));
+    if (!String(input.filePath || '').trim()) {
+        return emptyCatalogResult(null, Boolean(input.configured), ['codex_model_catalog_path_missing']);
+    }
+    let stat;
+    try {
+        stat = await fs.lstat(filePath);
+    }
+    catch (err) {
+        const code = err?.code;
+        return emptyCatalogResult(filePath, Boolean(input.configured), [
+            code === 'ENOENT' ? 'codex_model_catalog_missing' : 'codex_model_catalog_unreadable'
+        ]);
+    }
+    const fileBlockers = secureCatalogFileBlockers(stat);
+    if (fileBlockers.length)
+        return emptyCatalogResult(filePath, Boolean(input.configured), fileBlockers);
+    let parsed;
+    try {
+        parsed = JSON.parse(await fs.readFile(filePath, 'utf8'));
+    }
+    catch {
+        return emptyCatalogResult(filePath, Boolean(input.configured), ['codex_model_catalog_invalid_json']);
+    }
+    const rawRows = catalogRows(parsed);
+    if (!rawRows) {
+        return emptyCatalogResult(filePath, Boolean(input.configured), ['codex_model_catalog_shape_invalid']);
+    }
+    const totalModelCount = rawRows.length;
+    const normalized = rawRows
+        .slice(0, CODEX_MODEL_CATALOG_MAX_MODELS)
+        .map((row, index) => normalizeCatalogModel(row, index));
+    const models = normalized
+        .map((row) => row.model)
+        .filter((row) => row !== null);
+    const duplicateModels = duplicateModelIds(models);
+    const blockers = uniqueStrings([
+        ...(totalModelCount > CODEX_MODEL_CATALOG_MAX_MODELS
+            ? [`codex_model_catalog_model_limit_exceeded:${totalModelCount}:${CODEX_MODEL_CATALOG_MAX_MODELS}`]
+            : []),
+        ...normalized.flatMap((row) => row.blockers),
+        ...duplicateModels.map((model) => `codex_model_catalog_duplicate_model:${model}`),
+        ...(models.length ? [] : ['codex_model_catalog_empty'])
+    ]);
+    return {
+        schema: 'sks.codex-model-catalog-read.v1',
+        ok: blockers.length === 0,
+        configured: Boolean(input.configured),
+        path: filePath,
+        model_count: models.length,
+        total_model_count: totalModelCount,
+        truncated: totalModelCount > CODEX_MODEL_CATALOG_MAX_MODELS,
+        models,
+        blockers,
+        warnings: []
+    };
+}
+export function normalizeCodexModelId(value) {
+    const model = String(value || '').trim();
+    if (!model || model.length > 240)
+        return null;
+    return /^[A-Za-z0-9][A-Za-z0-9._:/+\-]*$/.test(model) ? model : null;
+}
+export function normalizeCodexReasoningEffort(value) {
+    const effort = String(value || '').trim().toLowerCase();
+    if (!effort || effort.length > 32)
+        return null;
+    return /^[a-z0-9][a-z0-9_-]*$/.test(effort) ? effort : null;
+}
+export function inferProviderFromModel(model) {
+    const normalized = normalizeCodexModelId(model) || '';
+    const slash = normalized.indexOf('/');
+    return slash > 0 ? normalized.slice(0, slash) : 'openai';
+}
+export function readTopLevelTomlString(text, key) {
+    const lines = String(text || '').split('\n');
+    const firstTable = lines.findIndex((line) => /^\s*\[.+\]\s*$/.test(line));
+    const rootEnd = firstTable === -1 ? lines.length : firstTable;
+    const pattern = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*"((?:\\\\.|[^"])*)"\\s*(?:#.*)?$`);
+    for (let index = 0; index < rootEnd; index += 1) {
+        const match = lines[index]?.match(pattern);
+        if (!match)
+            continue;
+        return decodeTomlBasicString(match[1] || '');
+    }
+    return null;
+}
+function expandCatalogPath(value, input) {
+    const env = input.env || process.env;
+    const home = input.home || env.HOME || os.homedir();
+    const trimmed = String(value || '').trim();
+    if (trimmed === '~')
+        return path.resolve(home);
+    if (trimmed.startsWith('~/'))
+        return path.resolve(home, trimmed.slice(2));
+    if (path.isAbsolute(trimmed))
+        return path.resolve(trimmed);
+    return path.resolve(input.configPath ? path.dirname(input.configPath) : codexHomePath({ home, env }), trimmed);
+}
+function catalogRows(value) {
+    if (!isRecord(value) || !Array.isArray(value.models))
+        return null;
+    return value.models;
+}
+function normalizeCatalogModel(value, index) {
+    if (!isRecord(value)) {
+        return { model: null, blockers: [`codex_model_catalog_row_invalid:${index}:object`] };
+    }
+    const blockers = validateCatalogModelInfo(value, index);
+    const visibility = String(value.visibility || '').trim().toLowerCase();
+    const model = normalizeCodexModelId(value.slug);
+    const efforts = normalizeReasoningEfforts(value.supported_reasoning_levels);
+    const defaultReasoning = value.default_reasoning_level === undefined || value.default_reasoning_level === null
+        ? null
+        : normalizeCodexReasoningEffort(value.default_reasoning_level);
+    const provider = normalizeProvider(value.provider) || inferProviderFromModel(model);
+    const multiAgentVersion = normalizeMultiAgentVersion(value.multi_agent_version);
+    if (blockers.length || !model || !provider || visibility === 'hide' || value.supported_in_api !== true) {
+        return { model: null, blockers };
+    }
+    return {
+        model: {
+            model,
+            provider,
+            display_name: String(value.display_name).trim(),
+            reasoning_efforts: efforts,
+            default_reasoning_effort: defaultReasoning && efforts.includes(defaultReasoning) ? defaultReasoning : null,
+            supported_in_api: true,
+            multi_agent_version: multiAgentVersion
+        },
+        blockers
+    };
+}
+export function catalogModelRowBlockers(value, index = 0) {
+    if (!isRecord(value))
+        return [`codex_model_catalog_row_invalid:${index}:object`];
+    return validateCatalogModelInfo(value, index);
+}
+function validateCatalogModelInfo(value, index) {
+    const blockers = [];
+    const required = [
+        ['slug', 'string'],
+        ['display_name', 'string'],
+        ['supported_reasoning_levels', 'array'],
+        ['shell_type', 'string'],
+        ['visibility', 'string'],
+        ['supported_in_api', 'boolean'],
+        ['priority', 'number'],
+        ['base_instructions', 'string'],
+        ['support_verbosity', 'boolean'],
+        ['truncation_policy', 'object'],
+        ['supports_parallel_tool_calls', 'boolean'],
+        ['experimental_supported_tools', 'array']
+    ];
+    for (const [field, expected] of required) {
+        if (!Object.prototype.hasOwnProperty.call(value, field)) {
+            blockers.push(`codex_model_catalog_required_field_missing:${index}:${field}`);
+        }
+        else if (valueType(value[field]) !== expected) {
+            blockers.push(`codex_model_catalog_field_type_invalid:${index}:${field}`);
+        }
+    }
+    const reasoningSummaryFields = ['supports_reasoning_summaries', 'supports_reasoning_summary_parameter']
+        .filter((field) => Object.prototype.hasOwnProperty.call(value, field));
+    if (!reasoningSummaryFields.length) {
+        blockers.push(`codex_model_catalog_required_field_missing:${index}:supports_reasoning_summaries`);
+    }
+    else {
+        for (const field of reasoningSummaryFields) {
+            if (valueType(value[field]) !== 'boolean') {
+                blockers.push(`codex_model_catalog_field_type_invalid:${index}:${field}`);
+            }
+        }
+    }
+    if (!normalizeCodexModelId(value.slug))
+        blockers.push(`codex_model_catalog_field_invalid:${index}:slug`);
+    if (typeof value.display_name === 'string' && !value.display_name.trim()) {
+        blockers.push(`codex_model_catalog_field_empty:${index}:display_name`);
+    }
+    if (typeof value.shell_type === 'string'
+        && !['default', 'local', 'unified_exec', 'disabled', 'shell_command'].includes(value.shell_type)) {
+        blockers.push(`codex_model_catalog_field_invalid:${index}:shell_type`);
+    }
+    if (typeof value.visibility === 'string' && !['list', 'hide', 'none'].includes(value.visibility)) {
+        blockers.push(`codex_model_catalog_field_invalid:${index}:visibility`);
+    }
+    if (typeof value.priority === 'number' && !Number.isFinite(value.priority)) {
+        blockers.push(`codex_model_catalog_field_invalid:${index}:priority`);
+    }
+    if (Array.isArray(value.supported_reasoning_levels)) {
+        for (const entry of value.supported_reasoning_levels) {
+            if (!isRecord(entry) || !normalizeCodexReasoningEffort(entry.effort)) {
+                blockers.push(`codex_model_catalog_reasoning_level_invalid:${index}`);
+                break;
+            }
+        }
+    }
+    const defaultReasoning = value.default_reasoning_level === undefined || value.default_reasoning_level === null
+        ? null
+        : normalizeCodexReasoningEffort(value.default_reasoning_level);
+    const efforts = normalizeReasoningEfforts(value.supported_reasoning_levels);
+    if (value.default_reasoning_level !== undefined
+        && value.default_reasoning_level !== null
+        && !defaultReasoning) {
+        blockers.push(`codex_model_catalog_field_invalid:${index}:default_reasoning_level`);
+    }
+    else if (defaultReasoning && !efforts.includes(defaultReasoning)) {
+        blockers.push(`codex_model_catalog_default_reasoning_not_supported:${index}`);
+    }
+    if (isRecord(value.truncation_policy)) {
+        if (!['bytes', 'tokens'].includes(String(value.truncation_policy.mode || ''))) {
+            blockers.push(`codex_model_catalog_truncation_policy_invalid:${index}:mode`);
+        }
+        if (typeof value.truncation_policy.limit !== 'number'
+            || !Number.isFinite(value.truncation_policy.limit)
+            || value.truncation_policy.limit <= 0) {
+            blockers.push(`codex_model_catalog_truncation_policy_invalid:${index}:limit`);
+        }
+    }
+    if (Array.isArray(value.experimental_supported_tools)
+        && value.experimental_supported_tools.some((entry) => typeof entry !== 'string')) {
+        blockers.push(`codex_model_catalog_field_invalid:${index}:experimental_supported_tools`);
+    }
+    if (value.provider !== undefined && !normalizeProvider(value.provider)) {
+        blockers.push(`codex_model_catalog_field_invalid:${index}:provider`);
+    }
+    if (value.multi_agent_version !== undefined
+        && value.multi_agent_version !== null
+        && !normalizeMultiAgentVersion(value.multi_agent_version)) {
+        blockers.push(`codex_model_catalog_field_invalid:${index}:multi_agent_version`);
+    }
+    return uniqueStrings(blockers);
+}
+function normalizeReasoningEfforts(value) {
+    if (!Array.isArray(value))
+        return [];
+    const seen = new Set();
+    const efforts = [];
+    for (const entry of value) {
+        const raw = isRecord(entry)
+            ? entry.effort || entry.reasoning_effort || entry.reasoningEffort || entry.id
+            : entry;
+        const effort = normalizeCodexReasoningEffort(raw);
+        if (!effort || seen.has(effort))
+            continue;
+        seen.add(effort);
+        efforts.push(effort);
+    }
+    return efforts;
+}
+function normalizeProvider(value) {
+    const provider = String(value || '').trim().toLowerCase();
+    if (!provider || provider.length > 80)
+        return null;
+    return /^[a-z0-9][a-z0-9._-]*$/.test(provider) ? provider : null;
+}
+function normalizeMultiAgentVersion(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    return normalized === 'v1' || normalized === 'v2' || normalized === 'disabled'
+        ? normalized
+        : null;
+}
+function secureCatalogFileBlockers(stat) {
+    const blockers = [];
+    if (!stat.isFile() || stat.isSymbolicLink())
+        blockers.push('codex_model_catalog_not_regular_file');
+    if (stat.size > CODEX_MODEL_CATALOG_MAX_BYTES)
+        blockers.push('codex_model_catalog_too_large');
+    const expectedUid = typeof process.getuid === 'function' ? process.getuid() : null;
+    if (expectedUid !== null && stat.uid !== expectedUid)
+        blockers.push('codex_model_catalog_owner_mismatch');
+    if (process.platform !== 'win32') {
+        const mode = Number(stat.mode) & 0o777;
+        if ((mode & 0o077) !== 0 || (mode & 0o400) === 0 || (mode & 0o100) !== 0) {
+            blockers.push(`codex_model_catalog_mode_insecure:${mode.toString(8).padStart(3, '0')}`);
+        }
+    }
+    return blockers;
+}
+function duplicateModelIds(models) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const model of models) {
+        if (seen.has(model.model))
+            duplicates.add(model.model);
+        seen.add(model.model);
+    }
+    return [...duplicates].sort();
+}
+function valueType(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    if (typeof value === 'object')
+        return 'object';
+    if (typeof value === 'string')
+        return 'string';
+    if (typeof value === 'number')
+        return 'number';
+    if (typeof value === 'boolean')
+        return 'boolean';
+    return 'undefined';
+}
+function emptyCatalogResult(filePath, configured, blockers) {
+    return {
+        schema: 'sks.codex-model-catalog-read.v1',
+        ok: blockers.length === 0,
+        configured,
+        path: filePath,
+        model_count: 0,
+        total_model_count: 0,
+        truncated: false,
+        models: [],
+        blockers,
+        warnings: []
+    };
+}
+function decodeTomlBasicString(value) {
+    try {
+        return JSON.parse(`"${value}"`);
+    }
+    catch {
+        return value;
+    }
+}

package/dist/core/codex-app/codex-models-cache.js

@@ -0,0 +1,160 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { writeTextAtomic } from '../fsx.js';
+import { codexHomePath } from './codex-model-catalog.js';
+export const CODEX_MODELS_CACHE_STALE_FETCHED_AT = '2000-01-01T00:00:00Z';
+export const CODEX_MODELS_CACHE_FILENAME = 'models_cache.json';
+export function codexModelsCachePath(input = {}) {
+    return path.join(codexHomePath(input), CODEX_MODELS_CACHE_FILENAME);
+}
+function modelSlug(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return '';
+    const row = value;
+    for (const key of ['slug', 'model', 'id']) {
+        const raw = row[key];
+        if (typeof raw === 'string' && raw.trim())
+            return raw.trim();
+    }
+    return '';
+}
+function mergeModelsBySlug(existingModels, catalogModels) {
+    const bySlug = new Map();
+    const unkeyed = [];
+    for (const row of existingModels) {
+        const slug = modelSlug(row);
+        if (slug)
+            bySlug.set(slug, row);
+        else
+            unkeyed.push(row);
+    }
+    for (const row of catalogModels) {
+        const slug = modelSlug(row);
+        if (slug)
+            bySlug.set(slug, row);
+        else
+            unkeyed.push(row);
+    }
+    return [...bySlug.values(), ...unkeyed];
+}
+export async function invalidateCodexModelsCache(input = {}) {
+    const cachePath = codexModelsCachePath(input);
+    const warnings = [];
+    const blockers = [];
+    const seedMode = input.seedMode || 'merge';
+    let existing = null;
+    try {
+        const raw = await fs.readFile(cachePath, 'utf8');
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                existing = parsed;
+            else
+                warnings.push('codex_models_cache_previous_shape_invalid');
+        }
+        catch {
+            warnings.push('codex_models_cache_previous_invalid_json');
+        }
+    }
+    catch (err) {
+        if (err?.code !== 'ENOENT') {
+            return {
+                schema: 'sks.codex-models-cache-invalidate.v1',
+                ok: false,
+                status: 'failed',
+                path: cachePath,
+                models_cache_invalidated: false,
+                restart_recommended: true,
+                model_count: 0,
+                warnings,
+                blockers: [`codex_models_cache_unreadable:${err?.code || 'unknown'}`]
+            };
+        }
+    }
+    let models = Array.isArray(existing?.models) ? [...existing.models] : [];
+    let seededFromCatalog = false;
+    const catalogPath = String(input.catalogPath || '').trim();
+    if (catalogPath && seedMode !== 'none') {
+        try {
+            const catalogRaw = await fs.readFile(catalogPath, 'utf8');
+            const catalog = JSON.parse(catalogRaw);
+            const catalogModels = Array.isArray(catalog?.models)
+                ? catalog.models
+                : Array.isArray(catalog)
+                    ? catalog
+                    : null;
+            if (Array.isArray(catalogModels)) {
+                models = seedMode === 'replace'
+                    ? catalogModels
+                    : mergeModelsBySlug(models, catalogModels);
+                seededFromCatalog = true;
+            }
+            else {
+                warnings.push('codex_models_cache_catalog_shape_invalid');
+            }
+        }
+        catch (err) {
+            if (err?.code === 'ENOENT')
+                warnings.push('codex_models_cache_catalog_missing');
+            else
+                warnings.push('codex_models_cache_catalog_unreadable');
+        }
+    }
+    if (!existing && models.length === 0) {
+        return {
+            schema: 'sks.codex-models-cache-invalidate.v1',
+            ok: true,
+            status: 'missing',
+            path: cachePath,
+            models_cache_invalidated: false,
+            restart_recommended: true,
+            model_count: 0,
+            warnings,
+            blockers
+        };
+    }
+    const existingClient = typeof existing?.client_version === 'string' ? existing.client_version.trim() : '';
+    const clientVersion = existingClient && existingClient !== '0.0.0'
+        ? existingClient
+        : '0.146.0';
+    const wrapper = {
+        fetched_at: CODEX_MODELS_CACHE_STALE_FETCHED_AT,
+        client_version: clientVersion,
+        models
+    };
+    try {
+        await writeTextAtomic(cachePath, `${JSON.stringify(wrapper, null, 2)}\n`, { mode: 0o600 });
+    }
+    catch (err) {
+        return {
+            schema: 'sks.codex-models-cache-invalidate.v1',
+            ok: false,
+            status: existing ? 'malformed_preserved' : 'failed',
+            path: cachePath,
+            models_cache_invalidated: false,
+            restart_recommended: true,
+            model_count: models.length,
+            warnings,
+            blockers: [`codex_models_cache_write_failed:${err?.code || err?.message || 'unknown'}`]
+        };
+    }
+    return {
+        schema: 'sks.codex-models-cache-invalidate.v1',
+        ok: true,
+        status: seededFromCatalog ? 'seeded_from_catalog' : 'invalidated',
+        path: cachePath,
+        models_cache_invalidated: true,
+        restart_recommended: true,
+        model_count: models.length,
+        warnings,
+        blockers
+    };
+}
+export function desktopPickerStatusFromCache(input) {
+    const cache = input.cache;
+    return {
+        catalog_ok: input.catalogOk,
+        models_cache_invalidated: cache?.models_cache_invalidated === true,
+        restart_recommended: cache?.restart_recommended === true || input.restartAppRequested === true
+    };
+}