sneakoscope 10.3.9 → 10.3.10

package/README.md

@@ -16,7 +16,7 @@
 Sneakoscope Codex (`sks`) is an open-source trust layer for Codex CLI and ChatGPT Desktop. It coordinates bounded AI coding agents, records machine-verifiable evidence, preserves project memory, and blocks release claims that are not supported by current tests or artifacts. Search visibility outcomes are measured separately; SKS does not promise rankings or traffic.
 <!-- END SKS SEARCH VISIBILITY MARKETING -->
 
-Current package: **SKS 10.3.9**. Install the latest stable release from npm.
+Current package: **SKS 10.3.10**. Install the latest stable release from npm.
 
 [Quick start](#install-in-one-command) · [Commands](#everyday-commands) · [SKS Center](#sks-center-macos) · [Documentation](#documentation) · [Changelog](CHANGELOG.md)
 
@@ -59,8 +59,8 @@ for setup boundaries and reported execution evidence.
 
 ## Everyday commands
 
-SKS enables experimental Astra context management by default during setup and
-repair. Turn it off in **SKS Center → Settings → Astra context management**, or
+SKS enables experimental Codex context management by default during setup and
+repair. Turn it off in **SKS Center → Settings → Context management**, or
 use `sks codex-app context-management off`. Updates preserve an explicit opt-out.
 Start a new task after changing the setting. Availability depends on a supported
 Codex client and eligible ChatGPT sign-in; API-key and custom-provider sessions
@@ -183,8 +183,8 @@ soon as Codex lists it:
 | Work | Tier | Effort | Today |
 | --- | --- | --- | --- |
 | Tiny mechanical tasks | fast | low | `gpt-6-luna` |
-| Instructed implementation | balanced | low | `gpt-6-sol` |
-| Exploration, large-context reads, and direct tool operation | context | medium | `gpt-6-sol` |
+| Instructed implementation | balanced | low | `gpt-6.1-sol` |
+| Exploration, large-context reads, and direct tool operation | context | medium | `gpt-6.1-sol` |
 | Planning, review, debugging, and focused judgment | deep | max | `gpt-6-astra` |
 
 With Jev mode on, Jev picks the tier for every spawn, every gated parent edit,

package/crates/sks-core/Cargo.lock

@@ -259,7 +259,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "10.3.9"
+version = "10.3.10"
 dependencies = [
  "globset",
  "grep-matcher",

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "10.3.9"
+version = "10.3.10"
 edition = "2021"
 
 [dependencies]

package/dist/config/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema": "sks.skills-manifest.v1",
-  "package_version": "10.3.9",
+  "package_version": "10.3.10",
   "skills": [
     {
       "canonical_name": "sks",

package/dist/core/agent-bridge/async-command.js

@@ -8,6 +8,7 @@ import { desktopBridgeStatusV3 } from '../codex-lb/desktop-controller-v3.js';
 import { bridgeClientUrl } from '../codex-lb/desktop-controller-v3/shared.js';
 import { runProcess } from '../fsx.js';
 import { createResponsesTransport } from './responses-transport.js';
+import { latestModelForTier } from '../subagents/model-tiers.js';
 const USAGE = 'sks agent-bridge async --prompt "task" [--tools status,stats] [--json]';
 const MAX_PROMPT_BYTES = 16 * 1024;
 export function redactAsyncToolOutput(stdout) {
@@ -55,7 +56,7 @@ export function parseAsyncCommandArgs(args) {
 export async function agentBridgeAsyncCommand(args) {
     const json = args.includes('--json');
     if (args.includes('--help')) {
-        const help = { schema: 'sks.async-tool-run.v1', ok: true, status: 'help', usage: USAGE, model: 'gpt-6-astra', provider: 'codex-lb', tools: 'Explicitly selected R0 remote-readable SKS command contracts only.' };
+        const help = { schema: 'sks.async-tool-run.v1', ok: true, status: 'help', usage: USAGE, model: latestModelForTier('deep'), provider: 'codex-lb', tools: 'Explicitly selected R0 remote-readable SKS command contracts only.' };
         console.log(json ? JSON.stringify(help, null, 2) : USAGE);
         return help;
     }
@@ -63,9 +64,10 @@ export async function agentBridgeAsyncCommand(args) {
         const parsed = parseAsyncCommandArgs(args);
         const home = homedir();
         const status = await desktopBridgeStatusV3({ home });
-        const model = 'codex-lb:gpt-6-astra';
+        const deepModel = latestModelForTier('deep');
+        const model = `codex-lb:${deepModel}`;
         const route = status.routing.policy?.model_routes[model];
-        if (!status.service.running || !status.service.loopback_origin || route?.provider_id !== 'codex-lb' || route.upstream_model !== 'gpt-6-astra') {
+        if (!status.service.running || !status.service.loopback_origin || route?.provider_id !== 'codex-lb' || route.upstream_model !== deepModel) {
             throw new Error('async_astra_bridge_route_unavailable');
         }
         const endpoint = await bridgeClientUrl(status.service.loopback_origin, '/backend-api/codex/responses', { home });

package/dist/core/agents/agent-effort-policy.js

@@ -2,9 +2,6 @@ import { codexModelEffortCapability } from '../codex-control/codex-model-capabil
 import { managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
 import { decideSubagentModel, subagentModelProfile } from '../subagents/model-policy.js';
 import { MODEL_TIERS, resolveLatestModelTiers } from '../subagents/model-tiers.js';
-export function decideAgentEffort(input = {}) {
-    return decideOfficialSubagentModel(input);
-}
 export function decideOfficialSubagentModel(input = {}) {
     const persona = input.persona || {};
     const prompt = String(input.prompt || '');
@@ -46,7 +43,7 @@ export function decideOfficialSubagentModel(input = {}) {
             downshift_triggers: [
                 'instructed UI, logic, backend, or native implementation selects the balanced tier',
                 'long-context, Browser/Chrome, Computer Use, image-generation, or large search selects the context tier',
-                'tiny short-context mechanical search/typing/rename work selects the balanced tier'
+                'tiny short-context mechanical search/typing/rename work selects the fast tier'
             ]
         };
     }
@@ -100,7 +97,7 @@ export function decideOfficialSubagentModel(input = {}) {
         downshift_triggers: [
             'instructed UI, logic, backend, or native implementation selects the balanced tier',
             'long-context, Browser/Chrome, Computer Use, or image-generation execution selects the context tier',
-            'tiny short-context mechanical work selects the balanced tier'
+            'tiny short-context mechanical work selects the fast tier'
         ]
     };
 }
@@ -125,7 +122,7 @@ export function buildAgentEffortPolicy(roster = {}) {
         policy_version: 1,
         dynamic: true,
         service_tier: 'fast',
-        model_catalog_policy: 'official_subagent_four_profile_matrix',
+        model_catalog_policy: 'official_subagent_model_tiers',
         model_constraint: [...new Set(MODEL_TIERS.map((tier) => latest.models[tier]))],
         model_tiers: MODEL_TIERS.map((tier) => `${tier}:${latest.models[tier]}-${latest.efforts[tier]}`),
         allowed_efforts: ['low', 'medium', 'high', 'max'],

package/dist/core/agents/agent-orchestrator.js

@@ -93,7 +93,6 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         concurrency: opts.concurrency,
         prompt,
         maxAgentCount,
-        officialSubagentPolicy,
         ...(opts.readonly === undefined ? {} : { readonly: opts.readonly })
     });
     roster = applyFastModeToRoster(roster, fastModePolicy);

package/dist/core/agents/agent-roster.js

@@ -1,6 +1,6 @@
 import { DEFAULT_AGENT_CONCURRENCY, DEFAULT_AGENT_COUNT, HARD_AGENT_CONCURRENCY, MAX_AGENT_COUNT, agentSessionId } from './agent-schema.js';
 import { defaultAgentPersonas, validatePersonaUniqueness } from './agent-persona.js';
-import { buildAgentEffortPolicy, decideAgentEffort, decideOfficialSubagentModel } from './agent-effort-policy.js';
+import { buildAgentEffortPolicy, decideOfficialSubagentModel } from './agent-effort-policy.js';
 function resolveMaxAgentCount(value) {
     const parsed = Number(value);
     if (!Number.isFinite(parsed) || parsed < 1)
@@ -35,9 +35,7 @@ export function buildAgentRoster(opts = {}) {
     if (!uniqueness.ok)
         throw new Error('Invalid agent personas: ' + JSON.stringify(uniqueness));
     const roster = personas.map((persona, index) => {
-        const effort = opts.officialSubagentPolicy === true
-            ? decideOfficialSubagentModel({ persona, prompt: opts.prompt || '', agentId: persona.id, readonly: opts.readonly === true || persona.read_only })
-            : decideAgentEffort({ persona, prompt: opts.prompt || '', agentId: persona.id, readonly: opts.readonly === true || persona.read_only });
+        const effort = decideOfficialSubagentModel({ persona, prompt: opts.prompt || '', agentId: persona.id, readonly: opts.readonly === true || persona.read_only });
         return {
             id: persona.id,
             session_id: agentSessionId(persona.id, index + 1),

package/dist/core/agents/native-worker-backend-router.js

@@ -8,7 +8,7 @@ import { runCodexTask } from '../codex-control/codex-control-plane.js';
 import { CODEX_AGENT_WORKER_RESULT_SCHEMA_ID, codexAgentWorkerResultSchema } from '../codex-control/schemas/agent-worker-result.schema.js';
 import { leanEngineeringCompactText, leanPolicyReference } from '../lean-engineering-policy.js';
 import { readCodexLbModelCatalog, readLbHealth } from '../codex-lb/codex-lb-env.js';
-import { categoryForWorkerRole, isNarutoGpt56Model, modelRouteReason, routeModel } from '../provider/model-router.js';
+import { categoryForWorkerRole, isNarutoTierModel, modelRouteReason, routeModel } from '../provider/model-router.js';
 import { codexTimeoutClassForRoute } from '../codex-control/codex-reliability-shield.js';
 import { decideSubagentModel } from '../subagents/model-policy.js';
 import { latestTierModelSet } from '../subagents/model-tiers.js';
@@ -246,7 +246,7 @@ export async function resolveWorkerModelRouting(input, deps = {}) {
     const explicitTierRaw = String(env.SKS_WORKER_SERVICE_TIER || env.SKS_SERVICE_TIER || '').trim();
     const explicitReasoning = normalizeModelReasoning(explicitReasoningRaw);
     const explicitTier = normalizeServiceTier(explicitTierRaw);
-    const explicitNarutoModelInvalid = narutoOnly && Boolean(explicitModel) && !isNarutoGpt56Model(explicitModel);
+    const explicitNarutoModelInvalid = narutoOnly && Boolean(explicitModel) && !isNarutoTierModel(explicitModel);
     const explicitNarutoReasoningInvalid = narutoOnly && Boolean(explicitReasoningRaw) && !explicitReasoning;
     const explicitNarutoTierInvalid = narutoOnly && Boolean(explicitTierRaw) && !explicitTier;
     const currentModels = latestTierModelSet();
@@ -254,7 +254,7 @@ export async function resolveWorkerModelRouting(input, deps = {}) {
         && currentModels.has(String(input.agent?.routed_model || ''))
         ? String(input.agent?.routed_model)
         : '';
-    const savedAstraEffort = savedPreferenceModel
+    const savedPreferenceEffort = savedPreferenceModel
         ? normalizeModelReasoning(input.agent?.routed_model_reasoning_effort)
         : null;
     const jevModel = !explicitModel && input.agent?.routed_model_policy === 'jev_sealed_routing'
@@ -277,14 +277,14 @@ export async function resolveWorkerModelRouting(input, deps = {}) {
             narutoOnly: true,
             taskText: taskKindText,
             riskText,
-            reasoningEffort: jevEffort || savedAstraEffort || liveJevEffort,
+            reasoningEffort: jevEffort || savedPreferenceEffort || liveJevEffort,
             availableModels: lbCatalog?.models || [],
             availableModelEfforts: lbCatalog?.model_efforts || {},
             ...(selectedModel ? { model: selectedModel } : {})
         })
         : {
             model: (explicitModel && currentModels.has(explicitModel) ? explicitModel : '') || savedPreferenceModel || liveJevModel || taskPolicy.model,
-            reasoning: explicitReasoning || savedAstraEffort || liveJevEffort || taskPolicy.modelReasoningEffort,
+            reasoning: explicitReasoning || savedPreferenceEffort || liveJevEffort || taskPolicy.modelReasoningEffort,
             serviceTier: explicitTier || input.fastModePolicy.service_tier || 'fast'
         };
     const blockers = [

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

@@ -14,9 +14,6 @@ export function codexHomePath(input = {}) {
 export function codexUserConfigPath(input = {}) {
     return path.join(codexHomePath(input), 'config.toml');
 }
-export function defaultOpenCodexCatalogPath(input = {}) {
-    return path.join(codexHomePath(input), 'opencodex-catalog.json');
-}
 export async function readConfiguredCodexModelRoutingContext(input = {}) {
     const configPath = input.configPath || codexUserConfigPath(input);
     let config = '';

package/dist/core/codex-app/openrouter-provider.js

@@ -1,4 +1,3 @@
-export const OPENROUTER_DEFAULT_MODEL = 'z-ai/glm-5.2';
 export function normalizeOpenRouterModelId(value) {
     const model = String(value || '').trim();
     if (!model)

package/dist/core/codex-compat/codex-capability-matrix.js

@@ -7,7 +7,6 @@ export const SKS_CODEX_CAPABILITY_IDS = [
     'agents_max_concurrent_threads_per_session',
     'thread_list_search_read',
     'mcp_startup_tool_timeouts',
-    'gpt56_terra_luna_sol_routing',
     'exec_mcp_transient_recovery',
     'rollout_token_budget'
 ];
@@ -46,13 +45,6 @@ export function buildCodexCapabilityMatrix(input = {}) {
         sources: [help, config],
         forceAvailable: true
     });
-    const gpt56 = resolveBooleanCapability({
-        id: 'gpt56_terra_luna_sol_routing',
-        policy: policies.gpt56TerraLunaSolRouting || 'delegate',
-        markers: [/gpt-5\.6-(?:luna|terra|sol)/],
-        sources: [help, config],
-        forceAvailable: Boolean(detected)
-    });
     const execMcp = resolveBooleanCapability({
         id: 'exec_mcp_transient_recovery',
         policy: policies.execMcpTransientRecovery || 'probe',
@@ -75,7 +67,6 @@ export function buildCodexCapabilityMatrix(input = {}) {
             agents_max_concurrent_threads_per_session: agentsConcurrency,
             thread_list_search_read: threadList,
             mcp_startup_tool_timeouts: mcpTimeouts,
-            gpt56_terra_luna_sol_routing: gpt56,
             exec_mcp_transient_recovery: execMcp,
             rollout_token_budget: rollout
         },

package/dist/core/codex-compat/codex-runtime-contract.js

@@ -26,7 +26,6 @@ export const CURRENT_CODEX_RUNTIME_CONTRACT = {
         remoteNativeEnvironment: 'probe',
         rolloutTokenBudget: 'probe',
         mcpStartupToolTimeouts: 'wrap',
-        gpt56TerraLunaSolRouting: 'delegate',
         mcpPaginatedDiscovery: 'wrap',
         portableAgentPlugins: 'delegate',
         automaticApprovalReview: 'delegate'

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

@@ -1,4 +1,5 @@
 import { mapCodexSdkSandboxPolicy } from './codex-sdk-sandbox-policy.js';
+import { parseGptModelId } from '../subagents/model-tiers.js';
 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');
@@ -26,7 +27,7 @@ export function buildCodexSdkConfig(input) {
     return config;
 }
 export function normalizeAstraSdkEffort(model, effort) {
-    return model.trim().toLowerCase() === 'gpt-6-astra' && ['none', 'minimal'].includes(effort.trim().toLowerCase())
+    return parseGptModelId(model.trim().toLowerCase())?.family === 'astra' && ['none', 'minimal'].includes(effort.trim().toLowerCase())
         ? 'low' : effort;
 }
 export function buildCodexExecutionPolicy(input) {

package/dist/core/codex-lb/combined-catalog/builder.js

@@ -1,6 +1,7 @@
 import { buildBridgeRouteIndex, sha256Stable } from '../route-index.js';
 import { COMBINED_BRIDGE_CATALOG_SCHEMA } from './contracts.js';
 import { normalizeProviderCatalog, providerCatalogStatus, routeProviderState } from './normalize.js';
+import { pinCatalogToLatestGenerations } from './latest-generation.js';
 import { compareModels, unique } from './shared.js';
 import { applyBridgeModelSelection, availableModelRows, emptyBridgeModelSelection } from './model-selection.js';
 export function buildCombinedBridgeCatalog(registry, options) {
@@ -10,8 +11,7 @@ export function buildCombinedBridgeCatalog(registry, options) {
         openrouter: normalizeProviderCatalog(options.catalogs.openrouter)
     };
     const selection = options.selection || emptyBridgeModelSelection(createdAt);
-    const allModels = [...normalized['codex-lb'].models, ...normalized.openrouter.models]
-        .sort(compareModels);
+    const allModels = pinCatalogToLatestGenerations([...normalized['codex-lb'].models, ...normalized.openrouter.models].sort(compareModels));
     const availableOpenRouterModels = availableModelRows(allModels, selection);
     const models = options.selection ? applyBridgeModelSelection(allModels, selection) : allModels;
     const routeBuild = buildBridgeRouteIndex({

package/dist/core/codex-lb/combined-catalog/latest-generation.js

@@ -0,0 +1,53 @@
+import { compareModelVersions, parseGptModelId } from '../../subagents/model-tiers.js';
+function isListed(model) {
+    const visibility = String(model.visibility || 'list').toLowerCase();
+    return visibility !== 'hide' && visibility !== 'hidden';
+}
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function displayNamePattern(displayName) {
+    const body = escapeRegExp(displayName.trim()).replace(/\\?-|\s+/g, '[-\\s]');
+    return new RegExp(`(?<![\\w-])${body}(?![\\w-])`, 'gi');
+}
+export function pinCatalogToLatestGenerations(models) {
+    const newest = new Map();
+    for (const model of models) {
+        const id = parseGptModelId(model.public_id);
+        if (!id || !isListed(model))
+            continue;
+        const best = newest.get(id.family);
+        if (!best || compareModelVersions(id.version, parseGptModelId(best.public_id).version) > 0)
+            newest.set(id.family, model);
+    }
+    const byId = new Map(models.map((model) => [model.public_id, model]));
+    return models.map((model) => {
+        const id = parseGptModelId(model.public_id);
+        let next = model;
+        if (id && isListed(model)) {
+            const best = newest.get(id.family);
+            if (best && compareModelVersions(parseGptModelId(best.public_id).version, id.version) > 0)
+                next = { ...next, visibility: 'hide' };
+        }
+        const upgrade = model.upgrade;
+        const target = upgrade && typeof upgrade === 'object' ? String(upgrade.model || '') : '';
+        const targetId = parseGptModelId(target);
+        const replacement = targetId ? newest.get(targetId.family) : undefined;
+        if (targetId && replacement && replacement.public_id !== target
+            && compareModelVersions(parseGptModelId(replacement.public_id).version, targetId.version) > 0) {
+            const old = byId.get(target);
+            const markdown = upgrade.migration_markdown;
+            next = {
+                ...next,
+                upgrade: {
+                    ...upgrade,
+                    model: replacement.public_id,
+                    ...(typeof markdown === 'string' && old?.display_name
+                        ? { migration_markdown: markdown.replace(displayNamePattern(old.display_name), () => replacement.display_name) }
+                        : {})
+                }
+            };
+        }
+        return next;
+    });
+}

package/dist/core/codex-lb/desktop-controller-v3/live-probes.js

@@ -5,6 +5,7 @@ import { runVoiceRealtimeProbeV3 } from '../probes/voice-realtime-probe.js';
 import { runAuxiliarySurfacesProbeV3 } from '../probes/auxiliary-surfaces-probe.js';
 import { capabilityProbeResultV3 } from '../probes/probe-evidence.js';
 import { validateCapabilityDeepEvidenceV2 } from '../trusted-deep-evidence.js';
+import { probeRouteForProvider } from './probe-route.js';
 import { bridgeClientUrl, providerCode, safeCode, timeoutMs, unique } from './shared.js';
 export function textResponsePayloadValid(contentType, text) {
     if (/text\/event-stream/i.test(contentType || '')) {
@@ -40,9 +41,7 @@ export function textResponsePayloadValid(contentType, text) {
     return payload !== null && typeof payload === 'object';
 }
 export async function probeProviderText(core, providerId, loopbackOrigin, context, options) {
-    const route = core.policy
-        ? Object.entries(core.policy.model_routes).find(([, target]) => target.provider_id === providerId)
-        : null;
+    const route = probeRouteForProvider(core.policy, providerId);
     if (!loopbackOrigin || !route) {
         return capabilityProbeResultV3({
             ...context,

package/dist/core/codex-lb/desktop-controller-v3/preflight-probes.js

@@ -1,4 +1,5 @@
 import { capabilityProbeResultV3 } from '../probes/probe-evidence.js';
+import { probeRouteForProvider } from './probe-route.js';
 import { activeProviderIds, providerCode } from './shared.js';
 export function nativeIdentityProbe(core, context) {
     const oauth = core.auth.mode === 'chatgpt_oauth' || core.auth.mode === 'mixed';
@@ -123,9 +124,7 @@ export function providerAuthProbe(core, providerId, context) {
     });
 }
 export function providerModelRouteProbe(core, providerId, context, liveText = null) {
-    const route = core.policy
-        ? Object.entries(core.policy.model_routes).find(([, target]) => target.provider_id === providerId)
-        : null;
+    const route = probeRouteForProvider(core.policy, providerId);
     const verified = Boolean(route && core.catalogSync.providers[providerId].state === 'verified');
     const liveRouteProven = Boolean(verified && route && liveText
         && liveText.capability === 'text_responses'

package/dist/core/codex-lb/desktop-controller-v3/probe-route.js

@@ -0,0 +1,23 @@
+import { compareModelVersions, parseGptModelId } from '../../subagents/model-tiers.js';
+const FAMILY_ORDER = ['sol', 'astra', 'luna', 'terra'];
+function familyRank(family) {
+    const index = FAMILY_ORDER.indexOf(family);
+    return index === -1 ? FAMILY_ORDER.length : index;
+}
+export function probeRouteForProvider(policy, providerId) {
+    if (!policy)
+        return null;
+    const routes = Object.entries(policy.model_routes).filter(([, target]) => target.provider_id === providerId);
+    let best = null;
+    for (const entry of routes) {
+        const id = parseGptModelId(entry[0]);
+        if (!id)
+            continue;
+        if (!best
+            || compareModelVersions(id.version, best.version) > 0
+            || (compareModelVersions(id.version, best.version) === 0 && familyRank(id.family) < familyRank(best.family))) {
+            best = { entry, version: id.version, family: id.family };
+        }
+    }
+    return best?.entry ?? routes[0] ?? null;
+}

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

@@ -5,12 +5,3 @@ function copyArgs(args = []) {
 export function preserveCodexModelArgs(args = []) {
     return copyArgs(args);
 }
-export function forceRequiredCodexModelArgs(args = []) {
-    return preserveCodexModelArgs(args);
-}
-export function forceRequiredCodexModelConfigArgs(args = []) {
-    return preserveCodexModelArgs(args);
-}
-export function isForbiddenCodexModel(_value = '') {
-    return false;
-}

package/dist/core/commands/naruto-command.js

@@ -740,8 +740,8 @@ function blockGlmOverride(json) {
         schema: NARUTO_RESULT_SCHEMA,
         ok: false,
         status: 'blocked',
-        reason: 'naruto_gpt_5_6_family_only_glm_override_forbidden',
-        blockers: ['naruto_gpt_5_6_family_only_glm_override_forbidden'],
+        reason: 'retired_glm_naruto_flag:--glm',
+        blockers: ['retired_glm_naruto_flag:--glm'],
         hint: 'Use normal sks naruto for the official Codex subagent workflow. OpenRouter models are selected in SKS Center Providers via Use OpenRouter.'
     };
     process.exitCode = 1;

package/dist/core/doctor/doctor-codex-startup-repair.js

@@ -3,6 +3,7 @@ import os from 'node:os';
 import { exists, nowIso, readText, writeJsonAtomic } from '../fsx.js';
 import { isUnmanagedProjectCodexConfig, writeCodexConfigGuarded } from '../codex/codex-config-guard.js';
 import { escapeRegExp } from '../text/regex.js';
+import { moveStaleSubagentDefault } from './stale-subagent-default.js';
 export const DOCTOR_CODEX_STARTUP_REPAIR_SCHEMA = 'sks.doctor-codex-startup-repair.v1';
 export async function runDoctorCodexStartupRepair(input) {
     const root = path.resolve(input.root || process.cwd());
@@ -103,6 +104,13 @@ async function inspectOrRepairConfig(root, candidate, fix, nodeReplCommandCandid
     warnings.push(...nodeReplRepair.warnings);
     staleMcpBlocksRemoved.push(...nodeReplRepair.removed);
     mcpBlocksRepaired.push(...nodeReplRepair.repaired);
+    if (candidate.scope === 'global') {
+        const moved = moveStaleSubagentDefault(next);
+        if (fix)
+            next = moved.text;
+        if (moved.from)
+            warnings.push(`default_subagent_model_${fix ? 'moved_to_latest' : 'not_latest'}:${moved.from}->${moved.to}`);
+    }
     for (const server of ['supabase_sauron']) {
         if (tomlBlock(next, `mcp_servers.${server}`))
             optionalMcpBlocksIgnored.push(server);

package/dist/core/doctor/stale-subagent-default.js

@@ -0,0 +1,30 @@
+import { catalogIsAuthoritative, latestModelForTier, supersededByNewerSameFamily } from '../subagents/model-tiers.js';
+const ANY_TABLE = /^\s*\[/;
+const AGENTS_TABLE = /^\s*\[agents\]\s*(?:#.*)?$/;
+const DEFAULT_LINE = /^(\s*default_subagent_model\s*=\s*")([^"]*)("\s*(?:#[^\r\n]*)?\s*)$/;
+export function moveStaleSubagentDefault(text) {
+    const unchanged = { text, from: null, to: null };
+    if (!catalogIsAuthoritative())
+        return unchanged;
+    const lines = text.split('\n');
+    let inAgents = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] || '';
+        if (ANY_TABLE.test(line)) {
+            inAgents = AGENTS_TABLE.test(line);
+            continue;
+        }
+        if (!inAgents)
+            continue;
+        const match = DEFAULT_LINE.exec(line);
+        if (!match)
+            continue;
+        const current = String(match[2] || '');
+        if (!supersededByNewerSameFamily(current))
+            return unchanged;
+        const latest = latestModelForTier('deep');
+        lines[index] = `${match[1]}${latest}${match[3]}`;
+        return { text: lines.join('\n'), from: current, to: latest };
+    }
+    return unchanged;
+}

package/dist/core/harness-conflicts.js

@@ -349,7 +349,7 @@ export function formatHarnessConflictReport(scan, opts = {}) {
 }
 export function llmHarnessCleanupPrompt(scan) {
     const paths = (scan?.conflicts || []).map((x) => `- ${x.scope}: ${x.path} (${x.reason})`).join('\n') || '- No paths supplied. Re-run `sks doctor --json` first.';
-    return `Use GPT-5.6 with reasoning effort high.
+    return `Use the model currently selected in Codex with reasoning effort high.
 
 Goal: completely remove the conflicting Codex harnesses before installing Sneakoscope Codex.