sneakoscope 10.5.5 → 10.5.6

package/README.md

@@ -8,7 +8,7 @@
 
 [![CI](https://github.com/mandarange/Sneakoscope-Codex/actions/workflows/ci.yml/badge.svg)](https://github.com/mandarange/Sneakoscope-Codex/actions/workflows/ci.yml)
 [![npm version](https://img.shields.io/npm/v/sneakoscope?color=cb3837&logo=npm)](https://www.npmjs.com/package/sneakoscope)
-[![Node.js >=20.11](https://img.shields.io/badge/node-%3E%3D20.11-339933?logo=node.js&logoColor=white)](#quick-start)
+[![Recommended Node.js 24 LTS](https://img.shields.io/badge/node-24%20LTS-339933?logo=node.js&logoColor=white)](#requirements)
 [![MIT license](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
 
 </div>
@@ -17,50 +17,124 @@
 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.5.5**. Install the latest stable release from npm.
+Current package: **SKS 10.5.6**. Install the latest stable release from npm.
 
 Sneakoscope Codex (`sks`) is a local trust layer for Codex CLI and ChatGPT Desktop. It keeps agent work bounded, preserves project context, records machine-verifiable evidence, and prevents release claims that current tests or artifacts cannot support.
 
 Use SKS when you want an AI coding session to end with something you can inspect: the change, the checks that ran, and the evidence behind the result. SKS is local-first and deterministic. It does not promise model quality, search rankings, or traffic.
 
+## SKS Center — one place for your Codex setup
+
+On macOS, **SKS Center** puts connections, subagent model choices, updates,
+and diagnostics in a native menu bar app. Open the SKS menu bar icon and choose
+**Open SKS Control Center…** to manage your setup without memorizing CLI commands.
+
+![SKS Center showing a connection-specific subagent model list with separate reasoning efforts](docs/assets/sks-center-subagent-models.png)
+
+*Native SKS Center UI with an example configuration. Models and available
+reasoning efforts depend on your connection's current catalog.*
+
+| Page | What you can manage |
+| --- | --- |
+| **Connections** | Codex-LB, OpenAI OAuth, OpenRouter, and model visibility. |
+| **Subagent Models** | Separate lists per connection, a default option, reasoning effort, and criteria for Jev. The same model can have different efforts for different work. |
+| **Decisions** | Jev's decision mode and cloud consent. |
+| **Settings** | Naruto's execution preference and app settings. |
+| **Image Generation** | Image mode, supported model choices, and provider setup. |
+| **MCP Servers** | Connected tools and server configuration. |
+| **Updates & Diagnostics** | Available updates, operation progress, logs, and health checks. |
+
+After installing SKS, install or rebuild the macOS app with:
+
+```sh
+sks menubar install
+```
+
+Interactive macOS installs can build it automatically. Dependency, CI, and
+piped installs skip the menu bar setup; scripts can opt in with
+`SKS_POSTINSTALL_MENUBAR=1` or opt out with `SKS_POSTINSTALL_NO_MENUBAR=1`.
+See [connection setup](docs/codex-lb.md), [subagent model lists](docs/naruto.md#connection-specific-subagent-lists),
+and [image generation](docs/image-generation.md) for the underlying settings.
+
 ## Quick start
 
-Requirements: Node.js **20.11+**, npm, Git, and a current Codex CLI or supported Codex desktop host.
+### Requirements
+
+- **Recommended: the latest patch release of Node.js 24 LTS.** Get it from the [official Node.js releases](https://nodejs.org/en/about/previous-releases).
+- npm, Git, and a current Codex CLI or supported Codex desktop host.
+- For source development and tests, see the locked dependency compatibility ranges in [Contributing](CONTRIBUTING.md#local-setup). CI uses the 24.x line.
+
+The published CLI's declared `package.json` engine floor is still `>=20.11`.
+That is separate from the development/test requirements above; Node 20 is now
+end-of-life, so use a supported LTS release for a new installation.
+
+### Install SKS globally
+
+Install SKS once for your user account so `sks` is available across projects:
+
+```sh
+npm install --global sneakoscope@latest
+sks doctor --fix --global-only --yes
+sks --version
+```
+
+Run these commands in your terminal. The global-only Doctor step reconciles
+user-level SKS skills and configuration, and reports any setup blockers.
+Make sure your npm global binary directory is on `PATH`.
+
+Alternatively, the verified installer performs the global npm installation,
+runs Doctor, and checks that `sks` on `PATH` resolves to the installed version:
 
 ```sh
 npm exec --yes --package=sneakoscope@latest -- sneakoscope install --yes
 ```
 
-From the root of a project you want SKS to understand:
+### Enable SKS for a project
+
+From the root of each project you want SKS to understand:
 
 ```sh
 sks bootstrap
 sks doctor --json
 ```
 
-Then open the project in Codex. Start with the smallest useful loop:
+Then open the project in Codex. Refresh its context and ask for ordinary work
+directly in the conversation:
 
 ```text
-$sks-plan "Describe the change and the checks it needs"
-$sks-work
+$sks-align
+Fix the failing test and verify the changed behavior.
 $sks-review
 ```
 
-Use the terminal to inspect the same state:
+`sks bootstrap` adds project-local SKS context and ignore rules. Ordinary work
+stays with the main agent; choose `$sks-naruto` or `$sks-work` when you want
+parallel child work.
+
+## Update an existing installation
+
+Run this from your project root in a terminal:
 
 ```sh
-sks status --json
-sks review --staged
-sks update-check
+sks update
+sks --version
+sks doctor --json
 ```
 
-The installer resolves the latest npm release, installs `sks`, runs setup and Doctor, and verifies that the command on your `PATH` is the version it installed. `sks bootstrap` adds the project-local SKS context and ignore rules; it does not replace your source of truth.
+`sks update` updates the **global** SKS package, verifies the installed command,
+and reconciles SKS-managed skills, hooks, configuration and SKS Center where
+available. In 10.5.5 and later it also repairs the known ignored Codex settings
+and refreshes managed guidance. User-authored text and explicit preferences
+are preserved. If a step fails, follow the recovery action in its output.
+
+To check available updates first, run `sks update check`. For a repair without
+requesting a newer package, run `sks doctor --fix` yourself in the terminal.
 
 ## What you get
 
 | Need | SKS provides |
 | --- | --- |
-| Keep work focused | Answers, tiny edits, ordinary implementation, reviews, and DB work run directly in the main agent, the way Codex works by default. Naruto splits work across official Codex subagents only when you ask for it. |
+| Keep work focused | Answers, tiny edits, ordinary implementation, reviews, and DB work run directly in the main agent. Naruto delegates through official Codex subagents when explicitly requested or selected by Jev. |
 | Keep context bounded | TriWiki indexes repository code into context that can be checked against source. |
 | Know what actually ran | Tests, diagnostics, and release evidence are recorded for completion claims. |
 | Recover safely | Doctor and update flows report a concrete recovery action when a check needs attention. |
@@ -73,23 +147,58 @@ and model choices are preserved. See [harness maintenance](docs/align-modernizat
 
 ## Everyday commands
 
-Inside a Codex conversation:
+### Core dollar commands
+
+Type these into the **Codex desktop app or Codex CLI conversation**:
 
 | Command | Use it for |
 | --- | --- |
+| `$sks-align` | Refresh official guidance and rebuild TriWiki from the current codebase. |
+| `$sks-mad-sks "scope and task"` | Explicitly authorize a bounded high-risk task; combine with another dollar command when appropriate. |
 | `$sks-plan "task"` | Write a plan without editing product code. |
-| `$sks-work` | Execute the latest plan with Naruto child agents. |
+| `$sks-work` | Run parallel child work through the Naruto execution alias. |
 | `$sks-review` | Review the current changes. |
 | `$sks-naruto "task"` | Explicitly split independent work across official subagents. |
 | `$sks-help` | Explore available SKS workflows. |
 
-In a terminal:
+#### `$sks-align`: keep the harness and project context current
+
+Use it when starting in a repository, after structural code changes, or when
+you want to refresh the managed instructions against current official guidance:
+
+```text
+$sks-align
+```
+
+Align searches current official Codex/model guidance, refreshes only
+SKS-managed instruction areas, and rebuilds the source-only TriWiki index.
+Your own instructions and model choices are preserved. External references
+stay separate from code facts; unavailable retrieval is reported while the
+previous references are retained. See [harness maintenance](docs/align-modernization.md).
+
+#### `$sks-mad-sks`: explicitly authorize a scoped high-risk task
+
+Name the target, allowed changes and boundaries in the request. For example:
+
+```text
+$sks-mad-sks Fix permissions only under ./dist so this project's build can run.
+Preserve source files, credentials, and other projects.
+```
+
+It temporarily widens only the approved scopes for that invocation and can
+be combined with another dollar command, such as `$sks-db` for an explicitly
+authorized database task. Database work uses the bound
+project's SQL-plane capability, read-back verification and final read-only
+restoration. Host approval boundaries and protected control-plane operations
+remain enforced. See [MAD-SKS](docs/mad-sks.md) before authorizing such work.
+
+### Terminal commands
 
 ```sh
 sks --help
 sks status --json
 sks doctor --json
-sks update-check
+sks update check
 sks update
 ```
 
@@ -106,16 +215,6 @@ SKS keeps these steps observable. It does not turn a failed check into a success
 
 ## Optional integrations
 
-### SKS Center on macOS
-
-The menu bar app exposes connections, updates, MCP servers, image generation, and diagnostics in one place. Build it from an interactive macOS install or run:
-
-```sh
-sks menubar install
-```
-
-Dependency, CI, and piped installs do not touch your home directory. Set `SKS_POSTINSTALL_MENUBAR=1` to force the build in a script, or `SKS_POSTINSTALL_NO_MENUBAR=1` to skip it.
-
 ### Desktop Bridge
 
 The Desktop Bridge can route eligible models through Codex-LB or OpenRouter while keeping provider choice and session pins explicit:
@@ -144,7 +243,8 @@ See [Image generation](docs/image-generation.md) for provider boundaries and evi
 
 - [Product contract](docs/PRODUCT-CONTRACT.md) — supported surfaces and ownership.
 - [Essential Trust](docs/essential-trust.md) — verification profiles and safety boundaries.
-- [Astra guidance](docs/astra-guidance.md) — how SKS applies official model recommendations.
+- [Harness maintenance and Align](docs/align-modernization.md) — current official references, thin managed instructions, and source-only TriWiki.
+- [MAD-SKS](docs/mad-sks.md) — explicit permission scope, execution boundaries, and verification.
 - [Agent Bridge](docs/AGENT-BRIDGE.md) — integrate through the CLI or MCP interface.
 - [Context Graph](docs/architecture/context-graph.md) — bounded source lookup and freshness.
 - [Release readiness](docs/release-readiness.md) — build, verify, and publish a release.

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

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

package/dist/config/skills-manifest.json

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

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

@@ -14,7 +14,7 @@ import { decideSubagentModel } from '../subagents/model-policy.js';
 import { latestTierModelSet } from '../subagents/model-tiers.js';
 import { consultJevTurnModel } from '../decisions/integration.js';
 import { chooseChildModel, fallbackChildModel } from '../decisions/child-model-choice.js';
-import { allowlistedChildModel, effectiveChildModelAllowlist, childModelListProfile, listChildModelEffort, isSubagentModelEffort } from '../subagents/child-model-allowlist.js';
+import { allowlistedChildModel, effectiveChildModelAllowlist, childModelListProfile, listChildModelEffort, isSubagentModelEffort, isAllowedChildModelEffort } from '../subagents/child-model-allowlist.js';
 export const NATIVE_WORKER_BACKEND_ROUTER_SCHEMA = 'sks.native-worker-backend-router.v1';
 export async function runNativeWorkerBackendRouter(input) {
     const root = path.resolve(input.agentRoot);
@@ -317,28 +317,31 @@ async function resolveOpenRouterOnlyWorkerRouting(input, deps, ctx) {
         ? allowlistedChildModel(input.agent?.routed_model, allowlist)
         : null;
     const requested = String(input.agent?.routed_model || input.agent?.model || '').trim() || null;
+    const requestedEffort = explicitReasoning || String(input.agent?.routed_model_reasoning_effort || input.agent?.model_reasoning_effort || '') || null;
     const explicitListed = explicitModel ? allowlistedChildModel(explicitModel, allowlist) : null;
     const task = `${ctx.taskKindText}\n${ctx.riskText}`.trim().slice(0, 1200);
     const choice = explicitModel
-        ? (explicitListed ? fallbackChildModel(state, explicitListed, 'explicit') : null)
+        ? (explicitListed ? fallbackChildModel(state, explicitListed, 'explicit', requestedEffort) : null)
         : planned
-            ? fallbackChildModel(state, planned, 'planned')
+            ? fallbackChildModel(state, planned, 'planned', requestedEffort)
             : deps.consultJev === false || !task
-                ? fallbackChildModel(state, requested, deps.consultJev === false ? 'jev_skipped' : 'empty_task')
-                : await chooseChildModel({ root: deps.root || process.cwd(), task, role: input.agent?.role || null, requestedModel: requested, state, env, profile: childModelListProfile(allowlist) })
-                    .catch(() => fallbackChildModel(state, requested, 'consult_failed'));
+                ? fallbackChildModel(state, requested, deps.consultJev === false ? 'jev_skipped' : 'empty_task', requestedEffort)
+                : await chooseChildModel({ root: deps.root || process.cwd(), task, role: input.agent?.role || null, requestedModel: requested, requestedEffort, state, env, profile: childModelListProfile(allowlist) })
+                    .catch(() => fallbackChildModel(state, requested, 'consult_failed', requestedEffort));
     const taskPolicy = decideSubagentModel({ title: ctx.taskKindText, description: ctx.riskText, role: input.agent?.role });
     const choiceModel = choice?.entry.model || '';
     const routed = {
         model: choiceModel,
-        reasoning: allowlist.mode === 'openrouter_only'
-            ? explicitReasoning || choice?.entry.reasoning_effort || listReasoning(taskPolicy.modelReasoningEffort) || 'medium'
-            : explicitReasoning || (choice ? listChildModelEffort(choice.entry, null) : null),
+        reasoning: choice ? listChildModelEffort(choice.entry, requestedEffort
+            || (allowlist.mode === 'openrouter_only' ? listReasoning(taskPolicy.modelReasoningEffort) || 'medium' : null)) : null,
         serviceTier: explicitTier || input.fastModePolicy.service_tier || 'fast'
     };
     const blockers = [
         ...(!allowlist.entries.length ? [allowlist.mode === 'openrouter_only' ? 'openrouter_only_subagent_list_empty' : 'configured_subagent_list_unavailable'] : []),
         ...(explicitModel && !explicitListed ? [allowlist.mode === 'openrouter_only' ? 'openrouter_only_subagent_model_not_listed' : 'configured_subagent_model_not_listed'] : []),
+        ...(explicitListed && choiceModel !== explicitListed ? ['subagent_model_effort_ambiguous'] : []),
+        ...(rawEffort && (!explicitReasoning || !isAllowedChildModelEffort(choiceModel, explicitReasoning, allowlist)
+            || explicitReasoning !== routed.reasoning) ? ['subagent_effort_conflicts_with_list'] : []),
         ...(allowlist.mode === 'configured' && rawEffort
             && (!explicitReasoning || !choice?.entry.supported_reasoning_efforts?.includes(explicitReasoning))
             ? ['configured_subagent_effort_unsupported'] : []),

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

@@ -10,7 +10,7 @@ import { parseNarutoArgs } from '../subagents/naruto-command-args.js';
 import { buildNarutoProofProjection } from '../subagents/naruto-proof-projection.js';
 import { attachNarutoLaunchDiagnostics, normalizedNarutoOperatorActions } from '../subagents/naruto-launch-diagnostics.js';
 import { withFileLock } from '../locks/file-lock.js';
-import { codexAppSessionKey, detectCodexAppSession, runOfficialSubagentWorkflow } from '../subagents/official-subagent-runner.js';
+import { codexAppSessionKey, currentCodexThreadSessionKey, detectCodexAppSession, runOfficialSubagentWorkflow } from '../subagents/official-subagent-runner.js';
 import { NARUTO_GATE_FILENAME, NARUTO_RESULT_SCHEMA, NARUTO_SUMMARY_FILENAME, SUBAGENT_PLAN_FILENAME, buildNarutoSummary, officialSubagentPreparationInProgress, prepareOfficialSubagentMission, withOfficialSubagentLifecycleLock, withNarutoMissionRunAdmission, writeNarutoGate } from '../subagents/official-subagent-preparation.js';
 import { effectiveSubagentTarget, refreshSubagentWaveLifecycle } from '../subagents/wave-lifecycle.js';
 import { HOST_CAPABILITY_HOOK_RUNTIME_FILENAME, bindParentSummaryToHostCapabilityEvidence, createHostCapabilityHookRuntimeBinding, resolveHostCapabilityHookRuntimeBinding } from '../agent-bridge/host-capability-runtime.js';
@@ -115,9 +115,8 @@ async function narutoExecution(parsed) {
 }
 async function narutoParentSummary(parsed) {
     const root = await sksRoot();
-    const appSession = detectCodexAppSession();
-    const sessionKey = appSession ? codexAppSessionKey() : null;
-    if (!appSession || !sessionKey) {
+    const sessionKey = currentCodexThreadSessionKey();
+    if (!sessionKey) {
         return blockedParentSummary(parsed, ['naruto_parent_summary_app_session_required']);
     }
     return withFileLock({

package/dist/core/decisions/child-model-choice.js

@@ -1,5 +1,6 @@
 import { consultJevOptions } from './integration.js';
-import { canonicalChildModelId, defaultSubagentEntry, subagentEntryForModel } from '../subagents/child-model-allowlist.js';
+import { redactDecisionText } from './state.js';
+import { canonicalChildModelId, defaultSubagentEntry, subagentEntryForModel, subagentEntryLabel } from '../subagents/child-model-allowlist.js';
 const QUESTION_BUDGET_BYTES = 16_000;
 const TASK_CHARS = 1200;
 function optionId(index) {
@@ -7,7 +8,7 @@ function optionId(index) {
 }
 function optionSummary(entry) {
     const criteria = entry.criteria || 'General work; no special criteria.';
-    return `${entry.model}${entry.default ? ' (default)' : ''}: ${criteria}`;
+    return `${subagentEntryLabel(entry)}${entry.default ? ' (default)' : ''}: ${criteria}`;
 }
 function laneQuestionId(lane, index) {
     const slug = String(lane.id || '').toLowerCase().replace(/[^a-z0-9_]+/g, '_').replace(/^_+|_+$/g, '').slice(0, 24);
@@ -19,18 +20,23 @@ export function childModelQuestion(id, entries, lane) {
     const fallback = entries.findIndex((entry) => entry.default);
     return {
         id,
-        instructions: 'Choose the model on the user\'s list that should run the child task in state.task. Each option is the user\'s rule for when to use that model; follow those rules. When several fit equally, choose the default.',
+        instructions: 'Choose the model and reasoning-effort option on the user\'s list that should run the child task in state.task. Options with the same model but different efforts are separate choices with separate criteria. Follow each option\'s criteria, including the task objective and role. The chosen option\'s effort is applied to the child. When several fit equally, choose the default.',
         options,
         state: {
             task: String(lane.task || '').slice(0, TASK_CHARS),
             role: lane.role || null,
             requested_model: lane.requestedModel || null,
-            default_option: optionId(fallback === -1 ? 0 : fallback)
+            requested_effort: lane.requestedEffort || null,
+            default_option: optionId(fallback === -1 ? 0 : fallback),
+            entries: Object.fromEntries(entries.map((entry, index) => [optionId(index), {
+                    model: entry.model, reasoning_effort: entry.reasoning_effort,
+                    criteria: redactDecisionText(entry.criteria || 'General work; no special criteria.', 240)
+                }]))
         }
     };
 }
-export function fallbackChildModel(state, requestedModel, reason) {
-    const requested = subagentEntryForModel(state, requestedModel);
+export function fallbackChildModel(state, requestedModel, reason, requestedEffort) {
+    const requested = subagentEntryForModel(state, requestedModel, requestedEffort);
     if (requested)
         return { entry: requested, source: 'requested', reason };
     const fallback = defaultSubagentEntry(state);
@@ -43,7 +49,7 @@ export async function chooseChildModels(input) {
         return result;
     const fallbackAll = (reason) => {
         for (const lane of input.lanes) {
-            const choice = fallbackChildModel(input.state, lane.requestedModel, reason);
+            const choice = fallbackChildModel(input.state, lane.requestedModel, reason, lane.requestedEffort);
             if (choice)
                 result[lane.id] = choice;
         }
@@ -72,7 +78,7 @@ export async function chooseChildModels(input) {
             workflowId: input.workflowId,
             goal: input.goal,
             questions,
-            facts: { openrouter_only: (input.profile ?? 'openrouter_only') === 'openrouter_only', subagent_model_profile: input.profile ?? 'openrouter_only', subagent_models: entries.map((entry) => canonicalChildModelId(entry.model)) },
+            facts: { openrouter_only: (input.profile ?? 'openrouter_only') === 'openrouter_only', subagent_model_profile: input.profile ?? 'openrouter_only', subagent_models: entries.map((entry) => canonicalChildModelId(entry.model)), subagent_options: entries.map((entry) => ({ model: entry.model, reasoning_effort: entry.reasoning_effort })) },
             ...(input.env ? { env: input.env } : {}),
             ...(input.deadlineMs === undefined ? {} : { deadlineMs: input.deadlineMs })
         })
@@ -87,7 +93,7 @@ export async function chooseChildModels(input) {
             continue;
         }
         const reason = !questionId ? 'budget' : decision.reason === 'applied' ? 'keep_baseline' : decision.reason;
-        const choice = fallbackChildModel(input.state, lane.requestedModel, reason);
+        const choice = fallbackChildModel(input.state, lane.requestedModel, reason, lane.requestedEffort);
         if (choice)
             result[lane.id] = choice;
     }
@@ -98,7 +104,7 @@ export async function chooseChildModel(input) {
         root: input.root,
         workflowId: 'spawn-child-model',
         goal: input.task || 'Spawn a child agent.',
-        lanes: [{ id: 'spawn', task: input.task, role: input.role ?? null, requestedModel: input.requestedModel ?? null }],
+        lanes: [{ id: 'spawn', task: input.task, role: input.role ?? null, requestedModel: input.requestedModel ?? null, requestedEffort: input.requestedEffort ?? null }],
         state: input.state,
         ...(input.profile ? { profile: input.profile } : {}),
         ...(input.env ? { env: input.env } : {}),

package/dist/core/decisions/policy.js

@@ -1,4 +1,4 @@
-import { CHOICE_MIN_CONFIDENCE, CHOICE_MIN_PROBABILITY, CONTEXT_DROP_NOUL_MAX, DISTRIBUTION_SUM_TOLERANCE, DELEGATION_CHOICES, KEEP_BASELINE_CHOICE, NEEDS_EVIDENCE_CHOICE, ROUTING_RISK_NOUL_MIN, ROUTING_ROLE_OMIT_NOUL_MAX, UNKNOWN_USAGE, ESCALATION_ROUTING_TIER, routingTier } from './types.js';
+import { CHOICE_MIN_CONFIDENCE, CHOICE_MIN_PROBABILITY, CONTEXT_DROP_NOUL_MAX, DISTRIBUTION_SUM_TOLERANCE, DELEGATION_CHOICES, KEEP_BASELINE_CHOICE, NEEDS_EVIDENCE_CHOICE, ROUTING_RISK_NOUL_MIN, ROUTING_ROLE_OMIT_NOUL_MAX, UNKNOWN_USAGE, DESIGN_DEFAULTS, ESCALATION_ROUTING_TIER, routingTier } from './types.js';
 export function compileDecision(bundle, response) {
     const usage = usageFromWire(response.usage);
     const decoded = decodeWireResponse(bundle, response);
@@ -75,7 +75,9 @@ export function decodeWireResponse(bundle, response) {
     const model = text(response.model);
     if (!model)
         return { ok: false, reason: 'invalid_response' };
-    if (model !== bundle.binding.requestedModel)
+    const knownSnapshot = bundle.binding.requestedModel === DESIGN_DEFAULTS.model
+        && model === 'typesafe/jev-1.13-20260917';
+    if (model !== bundle.binding.requestedModel && !knownSnapshot)
         return { ok: false, reason: 'unknown_model' };
     const answersRaw = response.answers;
     if (!isRecord(answersRaw))

package/dist/core/hooks-runtime/jev-spawn-routing.js

@@ -1,7 +1,7 @@
 import { consultJevTurnModel } from '../decisions/integration.js';
 import { chooseChildModel, fallbackChildModel } from '../decisions/child-model-choice.js';
 import { managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
-import { effectiveChildModelAllowlist, childModelListLabel, childModelListProfile, listChildModelEffort } from '../subagents/child-model-allowlist.js';
+import { effectiveChildModelAllowlist, childModelListLabel, childModelListProfile, listChildModelEffort, subagentEntryKey } from '../subagents/child-model-allowlist.js';
 import { subagentModelProfile } from '../subagents/model-policy.js';
 import { effortForTier, latestModelForTier, latestTierModelSet } from '../subagents/model-tiers.js';
 import { readRoleModelPreferences } from '../subagents/role-model-preferences.js';
@@ -67,18 +67,21 @@ async function openRouterOnlySpawnRouting(root, parentState, input, allowlist) {
         return { input: null, route: null };
     const state = listState(allowlist);
     const requested = String(input.model || '').trim() || null;
+    const requestedEffort = String(input.reasoning_effort || '') || null;
     const agent = String(input.agent_type || input.agentType || '').trim() || null;
     const task = spawnTask(input, { items: true });
     const choice = task
-        ? await chooseChildModel({ root, task, role: agent, requestedModel: requested, state, profile: childModelListProfile(allowlist) })
-            .catch(() => fallbackChildModel(state, requested, 'consult_failed'))
-        : fallbackChildModel(state, requested, 'empty_task');
+        ? await chooseChildModel({ root, task, role: agent, requestedModel: requested, requestedEffort, state, profile: childModelListProfile(allowlist) })
+            .catch(() => fallbackChildModel(state, requested, 'consult_failed', requestedEffort))
+        : fallbackChildModel(state, requested, 'empty_task', requestedEffort);
     if (!choice)
         return { input: null, route: null };
     const route = {
         mode: allowlist.mode,
         ...(allowlist.mode === 'configured' ? { profile: allowlist.profile } : {}),
         model: choice.entry.model,
+        reasoning_effort: listChildModelEffort(choice.entry, requestedEffort),
+        entry_key: subagentEntryKey(choice.entry),
         source: choice.source,
         reason: choice.reason
     };

package/dist/core/hooks-runtime/official-subagent-lifecycle.js

@@ -175,10 +175,10 @@ export async function recordAndRefreshSubagentEvidence(root, state, payload, eve
         if (!event)
             return null;
         const events = [...priorEvents, event];
+        const lifecycle = await refreshSubagentWaveLifecycle(artifactDir, { plan, event, events });
         if (eventName !== 'SubagentResume') {
             await clearOfficialSubagentLifecycleCaptureFailure(artifactDir, state, eventPayload, eventName);
         }
-        const lifecycle = await refreshSubagentWaveLifecycle(artifactDir, { plan, event, events });
         const refreshedPlan = lifecycle ? { ...plan, wave_lifecycle: lifecycle } : plan;
         const existing = await readJson(path.join(artifactDir, SUBAGENT_EVIDENCE_FILENAME), {});
         const parentSummary = await readJson(path.join(artifactDir, SUBAGENT_PARENT_SUMMARY_FILENAME), null);

package/dist/core/hooks-runtime/parent-orchestration-gate.js

@@ -35,7 +35,12 @@ function spawnRouteOf(raw) {
         return null;
     const row = raw;
     const text = (value) => String(value ?? '').trim().slice(0, 200);
-    const route = { mode: text(row.mode), model: text(row.model), source: text(row.source), reason: text(row.reason) };
+    const route = {
+        mode: text(row.mode), model: text(row.model), source: text(row.source), reason: text(row.reason),
+        ...(Object.hasOwn(row, 'reasoning_effort') ? { reasoning_effort: text(row.reasoning_effort) || null } : {}),
+        ...(typeof row.entry_key === 'string' ? { entry_key: text(row.entry_key) } : {}),
+        ...(typeof row.profile === 'string' ? { profile: text(row.profile) } : {})
+    };
     return route.mode && route.model && route.source ? route : null;
 }
 export function isSpawnToolPayload(payload = {}) {

package/dist/core/hooks-runtime/subagent-spawn-policy.js

@@ -2,18 +2,18 @@ import { managedOfficialSubagentRoleByName } from '../managed-assets/managed-ass
 import { READ_ONLY_LIST_ROLE, readOnlyListRoleInstalled } from '../subagents/read-only-list-role.js';
 import { stalePinBlockReason, stalePinForAgentType } from '../subagents/role-model-pins.js';
 import { isSpawnAgentToolName, spawnPayloadToolName } from './spawn-tool-name.js';
-import { effectiveChildModelAllowlist, childModelListLabel, isAllowedChildModel } from '../subagents/child-model-allowlist.js';
+import { effectiveChildModelAllowlist, childModelListLabel, isAllowedChildModel, isAllowedChildModelEffort, subagentEntryLabel } from '../subagents/child-model-allowlist.js';
 export const SUBAGENT_MODELS_SETTINGS_HINT = 'SKS Control Center > Subagent Models';
 export function renderChildModelList(allowlist) {
     if (allowlist.mode === 'tiers')
         return allowlist.models.join(', ');
-    return allowlist.entries.map((entry) => `${entry.model}${entry.default ? ' (default)' : ''}`).join(', ');
+    return allowlist.entries.map((entry) => `${subagentEntryLabel(entry)}${entry.default ? ' (default)' : ''}`).join(', ');
 }
 export function renderChildModelCriteria(allowlist) {
     if (allowlist.mode === 'tiers')
         return allowlist.models.join(', ');
     return allowlist.entries
-        .map((entry) => `${entry.model}${entry.default ? ' (default)' : ''}: ${entry.criteria || 'general work'}`)
+        .map((entry) => `${subagentEntryLabel(entry)}${entry.default ? ' (default)' : ''}: ${entry.criteria || 'general work'}`)
         .join('; ');
 }
 function openRouterOnlyBlockReason(allowlist) {
@@ -67,5 +67,8 @@ export function subagentSpawnPolicyBlockReason(payload = {}, opts = {}) {
     }
     if (!boundedForkTurns(input.fork_turns))
         return FORK_BLOCK_REASON;
+    if (allowlist.mode !== 'tiers' && !isAllowedChildModelEffort(input.model, input.reasoning_effort, allowlist)) {
+        return `SKS ${childModelListLabel(allowlist)} subagent list: the model and reasoning_effort must match a listed option: ${renderChildModelList(allowlist)}. Retry with the selected option's effort.`;
+    }
     return null;
 }

package/dist/core/subagents/child-model-allowlist.js

@@ -48,12 +48,12 @@ export function normalizeSubagentModelList(raw, profile = 'openrouter_only') {
             issues.push({ index, code: 'subagent_model_id_invalid' });
             return;
         }
-        const key = canonicalChildModelId(model);
+        const effort = record.reasoning_effort ?? null;
+        const key = subagentEntryKey({ model, reasoning_effort: effort });
         if (seen.has(key)) {
             issues.push({ index, code: 'subagent_model_duplicate' });
             return;
         }
-        const effort = record.reasoning_effort ?? null;
         if (effort !== null && effort !== '' && !isSubagentModelEffort(effort, profile)) {
             issues.push({ index, code: 'subagent_model_effort_invalid' });
             return;
@@ -64,7 +64,7 @@ export function normalizeSubagentModelList(raw, profile = 'openrouter_only') {
         }
         seen.add(key);
         entries.push({
-            model: profile === 'openrouter_only' ? key : model,
+            model: profile === 'openrouter_only' ? canonicalChildModelId(model) : model,
             criteria: cleanCriteria(record.criteria),
             reasoning_effort: isSubagentModelEffort(effort, profile) ? effort : null,
             default: record.default === true
@@ -117,11 +117,22 @@ export async function writeOpenRouterOnlyState(update, input = {}) {
 export function defaultSubagentEntry(state) {
     return state.subagent_models.find((entry) => entry.default) || state.subagent_models[0] || null;
 }
-export function subagentEntryForModel(state, model) {
+export function subagentEntryKey(entry) {
+    return JSON.stringify([canonicalChildModelId(entry.model), entry.reasoning_effort || null]);
+}
+export function subagentEntryLabel(entry) {
+    return `${entry.model} [${entry.reasoning_effort || 'default effort'}]`;
+}
+export function subagentEntryForModel(state, model, requestedEffort) {
     const key = canonicalChildModelId(model);
     if (!key)
         return null;
-    return state.subagent_models.find((entry) => canonicalChildModelId(entry.model) === key) || null;
+    const entries = state.subagent_models.filter((entry) => canonicalChildModelId(entry.model) === key);
+    const effort = String(requestedEffort || '');
+    return (effort ? entries.find((entry) => entry.reasoning_effort === effort) : null)
+        || entries.find((entry) => !entry.reasoning_effort)
+        || entries.find((entry) => entry.default)
+        || (entries.length === 1 ? entries[0] : null);
 }
 export function childModelListProfile(list) {
     return list.mode === 'openrouter_only' ? 'openrouter_only' : list.profile;
@@ -134,6 +145,15 @@ export function listChildModelEffort(entry, requested) {
     const effort = entry.reasoning_effort || String(requested || '');
     return supported.includes(effort) && isSubagentModelEffort(effort, 'openai') ? effort : null;
 }
+export function isAllowedChildModelEffort(model, effort, allowlist) {
+    if (allowlist.mode === 'tiers')
+        return isAllowedChildModel(model, allowlist);
+    const key = canonicalChildModelId(model);
+    const requested = String(effort || '');
+    return allowlist.entries.some((entry) => canonicalChildModelId(entry.model) === key
+        && (entry.reasoning_effort ? entry.reasoning_effort === requested
+            : !requested || listChildModelEffort(entry, requested) === requested));
+}
 export function subagentModelListsPath(input = {}) {
     return path.join(path.dirname(openRouterOnlyStatePath(input)), 'sks-subagent-model-lists.json');
 }
@@ -253,7 +273,7 @@ export function effectiveChildModelAllowlist(input = {}) {
         return {
             mode: 'configured', profile, models: entries.map((entry) => entry.model), entries,
             default_model: defaultSubagentEntry({ subagent_models: entries })?.model ?? null,
-            unroutable: selected.filter((row) => !entries.some((entry) => canonicalChildModelId(entry.model) === canonicalChildModelId(row.model))).map((row) => row.model),
+            unroutable: selected.filter((row) => !entries.some((entry) => subagentEntryKey(entry) === subagentEntryKey(row))).map(subagentEntryLabel),
             blockers: saved.blockers
         };
     }

package/dist/core/subagents/child-model-plan.js

@@ -1,6 +1,6 @@
 import { chooseChildModels } from '../decisions/child-model-choice.js';
 import { MAX_JEV_ROUTING_ROLES } from '../decisions/routing.js';
-import { defaultSubagentEntry, effectiveChildModelAllowlist, childModelListProfile, listChildModelEffort } from './child-model-allowlist.js';
+import { defaultSubagentEntry, effectiveChildModelAllowlist, childModelListProfile, listChildModelEffort, subagentEntryKey } from './child-model-allowlist.js';
 import { readCodexMainModel } from './naruto-host-credentials.js';
 import { READ_ONLY_LIST_ROLE } from './read-only-list-role.js';
 export function readChildModelPlanContext(location = {}) {
@@ -24,7 +24,7 @@ function routedRow(row, choice, list) {
         routing_dynamic: true,
         role_model_preference_source: `ignored_${prefix}`,
         [list.mode === 'openrouter_only' ? 'openrouter_only_choice' : 'subagent_list_choice']: choice
-            ? { model: choice.entry.model, source: choice.source, reason: choice.reason, default_entry: choice.entry.default }
+            ? { model: choice.entry.model, reasoning_effort: listEntryEffort(choice.entry, row.model_reasoning_effort), entry_key: subagentEntryKey(choice.entry), source: choice.source, reason: choice.reason, default_entry: choice.entry.default }
             : { model: null, source: 'default', reason: 'subagent_list_empty', default_entry: false }
     };
 }

package/dist/core/subagents/naruto-host-credentials.js

@@ -3,7 +3,7 @@ import { codexUserConfigPath, readTopLevelTomlString } from '../codex-app/codex-
 import { isOpenRouterModelId } from '../imagegen/imagegen-config.js';
 import { defaultSubagentModel } from './model-policy.js';
 import { codexListedEfforts, latestTierModelSet } from './model-tiers.js';
-import { SUBAGENT_MODEL_EFFORTS, defaultSubagentEntry, effectiveChildModelAllowlist, allowlistedChildModel, readOpenRouterOnlyStateSync, subagentEntryForModel } from './child-model-allowlist.js';
+import { SUBAGENT_MODEL_EFFORTS, defaultSubagentEntry, effectiveChildModelAllowlist, allowlistedChildModel, readOpenRouterOnlyStateSync, subagentEntryForModel, isAllowedChildModelEffort } from './child-model-allowlist.js';
 export const NARUTO_AUTH_MODES = ['managed', 'host'];
 const IDENTIFIER_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 const RETIRED_DIRECT_MANAGED_PROVIDERS = new Set(['codex-lb', 'openrouter']);
@@ -134,13 +134,17 @@ export function resolveNarutoCredentialPolicy(input) {
     }
     else if (configured) {
         const model = allowlistedChildModel(resolvedModels.subagentModel, configured);
-        const entry = configured.entries.find((row) => row.model === model);
+        const entry = subagentEntryForModel({ subagent_models: configured.entries }, model, sources.subagentEffort === 'default' ? null : resolvedModels.subagentEffort)
+            || (sources.subagentModel === 'default' && sources.subagentEffort === 'default' ? configuredDefault : null);
         if (!entry)
             blockers.push(configured.entries.length ? 'naruto_subagent_model_not_in_list' : 'naruto_subagent_model_list_empty');
         else {
             resolvedModels.subagentModel = entry.model;
             if (sources.subagentEffort === 'default')
                 resolvedModels.subagentEffort = entry.reasoning_effort ?? '';
+            if (!isAllowedChildModelEffort(entry.model, resolvedModels.subagentEffort, configured)) {
+                blockers.push('naruto_subagent_effort_not_in_list');
+            }
             if (resolvedModels.subagentEffort && !entry.supported_reasoning_efforts?.includes(resolvedModels.subagentEffort)) {
                 blockers.push(`naruto_subagent_effort_unsupported:${resolvedModels.subagentModel}:${resolvedModels.subagentEffort}`);
             }
@@ -218,13 +222,16 @@ function validateOpenRouterOnlyModels(context, resolved, sources, blockers) {
         blockers.push('naruto_subagent_model_list_empty');
     }
     else {
-        const listed = subagentEntryForModel(context.state, resolved.subagentModel);
+        const listed = subagentEntryForModel(context.state, resolved.subagentModel, sources.subagentEffort === 'default' ? null : resolved.subagentEffort);
         if (!listed)
             blockers.push(`naruto_subagent_model_not_in_list:${String(resolved.subagentModel || '').slice(0, 64)}`);
         const entry = listed ?? listDefault;
         resolved.subagentModel = entry.model;
         if (sources.subagentEffort === 'default' && entry.reasoning_effort)
             resolved.subagentEffort = entry.reasoning_effort;
+        if (sources.subagentEffort !== 'default' && entry.reasoning_effort && entry.reasoning_effort !== resolved.subagentEffort) {
+            blockers.push('naruto_subagent_effort_not_in_list');
+        }
     }
     for (const scope of ['parent', 'subagent']) {
         const effort = String(resolved[`${scope}Effort`] || '');

package/dist/core/subagents/official-subagent-prompt.js

@@ -2,7 +2,7 @@ import { latestTierModelSet } from './model-tiers.js';
 import { HARD_NARUTO_MAX_THREADS } from './thread-budget.js';
 import { coreEngineeringDirectiveReferenceText } from '../lean-engineering-policy.js';
 import { MAX_AUTOMATIC_REVIEWER_COUNT, MAX_AUTOMATIC_SUBAGENT_COUNT, MAX_CRITICAL_AUTOMATIC_REVIEWER_COUNT, officialSubagentOnDemandRoleCatalog, officialSubagentRoleCatalog, selectOfficialSubagentRole } from './agent-catalog.js';
-import { allowlistedChildModel, effectiveChildModelAllowlist, childModelListLabel, listChildModelEffort } from './child-model-allowlist.js';
+import { allowlistedChildModel, effectiveChildModelAllowlist, childModelListLabel, listChildModelEffort, subagentEntryForModel, defaultSubagentEntry } from './child-model-allowlist.js';
 import { READ_ONLY_LIST_ROLE } from './read-only-list-role.js';
 import { EXCLUSIVE_SURFACE_RULE } from './exclusive-surface-rule.js';
 export function buildOfficialSubagentPrompt(input) {
@@ -169,7 +169,7 @@ Plan and capacity:
 - ${EXCLUSIVE_SURFACE_RULE}
 - reject duplicate slice fingerprints and homogeneous clone work; diversity may come from roles, disjoint shards, or non-exclusive tool surfaces (never from a second child on the same Computer Use or browser surface)
 - security, database, release, authorization, and irreversible-effect checks are protected strata; aggregate speed or accuracy never offsets a failed protected gate
-- after each SubagentStart/SubagentStop, update \`subagent-plan.json.wave_lifecycle\` under the same workflow_run_id
+- after each SubagentStart/SubagentStop, read the runtime-maintained \`subagent-plan.json.wave_lifecycle\` under the same workflow_run_id; hooks rebuild it from official events. Never write planned slice rows into this derived field or edit the event ledger.
 - after each settled wave: collect results, close completed threads, refresh evidence/ledger, follow \`next_parent_actions\` / \`parent_guidance\`, rescan the ready DAG, then launch the next defensible direct-child wave when \`remaining_to_start > 0\`; capacity is reusable
 - when guidance says \`spawn_next_direct_child_wave_upto:N\`, immediately spawn that wave with sealed role profiles
 - automatic targets may resize between waves when the ready DAG changes, but update plan/evidence before spawning; explicit operator and route-owned counts remain exact
@@ -291,16 +291,17 @@ function renderListSpawnModelRouting(list, jevRouting) {
 }
 function renderListSliceContract(input) {
     const routedModel = allowlistedChildModel(input.routed?.routed_model, input.allowlist);
-    const model = routedModel || input.allowlist.default_model;
-    if (!model) {
+    const routedEffort = String(input.routed?.routed_model_reasoning_effort || '');
+    const state = { subagent_models: input.allowlist.entries };
+    const entry = subagentEntryForModel(state, routedModel, routedEffort) || defaultSubagentEntry(state);
+    if (!entry) {
         return {
             model: `none (the ${childModelListLabel(input.allowlist)} subagent list is empty)`,
             contract: 'stop before spawning: the user must add a model to the subagent list first'
         };
     }
-    const entry = input.allowlist.entries.find((row) => row.model === model);
-    const routedEffort = String(input.routed?.routed_model_reasoning_effort || '');
-    const effort = entry ? listChildModelEffort(entry, routedModel ? routedEffort : null) : null;
+    const model = entry.model;
+    const effort = listChildModelEffort(entry, routedModel ? routedEffort : null);
     const brief = String(input.brief || '').replace(/\s+/g, ' ').trim().slice(0, 200);
     return {
         model: `${model} (${effort ? `effort ${effort}` : 'model default effort'}, ${input.allowlist.mode === 'openrouter_only' ? 'OpenRouter' : childModelListLabel(input.allowlist)} list)`,

package/dist/core/subagents/official-subagent-runner.js

@@ -83,6 +83,9 @@ export function detectCodexAppSession(env = process.env) {
 export function codexAppSessionKey(env = process.env) {
     if (!detectCodexAppSession(env))
         return null;
+    return currentCodexThreadSessionKey(env);
+}
+export function currentCodexThreadSessionKey(env = process.env) {
     const threadId = String(env.CODEX_THREAD_ID || '').trim();
     return threadId || null;
 }

package/dist/core/subagents/wave-lifecycle.js

@@ -195,8 +195,8 @@ function projectLifecycle(previous, input) {
     const starts = timeline.started;
     const open = new Set(timeline.open);
     const stops = new Set();
-    const waves = previous.waves.map((wave) => ({ ...wave, thread_ids: [...wave.thread_ids], settled_thread_ids: [...wave.settled_thread_ids] }));
-    const assigned = new Set(waves.flatMap((wave) => wave.thread_ids));
+    const waves = [];
+    const assigned = new Set();
     for (const event of input.events) {
         const threadId = event.thread_id;
         if (!threadId || event.event_name === 'SubagentResume')

package/dist/core/version.js

@@ -1 +1 @@
-export const PACKAGE_VERSION = '10.5.5';
+export const PACKAGE_VERSION = '10.5.6';

package/dist/native/sks-menubar/Sources/OpenRouterOnlyState.swift

@@ -164,7 +164,7 @@ enum OpenRouterOnlyMessages {
         case "subagent_model_id_invalid":
             return row + "not a valid model id for this connection."
         case "subagent_model_duplicate":
-            return row + "this model is already on the list."
+            return row + "this model and effort are already on the list. Choose a different effort."
         case "subagent_model_effort_invalid":
             return row + "choose Default or an effort supported by this model."
         case "subagent_model_effort_unsupported":

package/dist/native/sks-menubar/Sources/SubagentModelsModels.swift

@@ -101,12 +101,26 @@ enum SubagentModelDraft {
         return available + missing
     }
 
-    /// A new row takes the first available model not already on the list.
+    static func entryKey(_ entry: SubagentModelEntry) -> String {
+        entry.model.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() + "|" + (entry.reasoningEffort ?? "")
+    }
+
+    /// Prefer a new model, then an unused effort of an existing model.
     static func adding(_ entries: [SubagentModelEntry], available: [SubagentModelOption]) -> [SubagentModelEntry]? {
         guard entries.count < SubagentModelRules.maxModels else { return nil }
         let used = Set(entries.map { $0.model.lowercased() })
-        guard let next = available.first(where: { !used.contains($0.publicId.lowercased()) }) else { return nil }
-        return entries + [SubagentModelEntry(model: next.publicId, criteria: "", reasoningEffort: nil, isDefault: entries.isEmpty, routable: nil)]
+        if let next = available.first(where: { !used.contains($0.publicId.lowercased()) }) {
+            return entries + [SubagentModelEntry(model: next.publicId, criteria: "", reasoningEffort: nil, isDefault: entries.isEmpty, routable: nil)]
+        }
+        let keys = Set(entries.map(entryKey))
+        for model in available {
+            let efforts: [String?] = [nil] + (model.reasoningEfforts ?? SubagentModelRules.efforts).map { Optional($0) }
+            for effort in efforts {
+                let next = SubagentModelEntry(model: model.publicId, criteria: "", reasoningEffort: effort, isDefault: entries.isEmpty, routable: nil)
+                if !keys.contains(entryKey(next)) { return entries + [next] }
+            }
+        }
+        return nil
     }
 
     static func removing(_ entries: [SubagentModelEntry], at index: Int) -> [SubagentModelEntry] {
@@ -189,7 +203,7 @@ enum SubagentModelDraft {
             let efforts = profile == "openrouter_only" ? SubagentModelRules.efforts : SubagentModelRules.nativeEfforts
             if !SubagentModelRules.isModelId(model, profile: profile) {
                 issues.append("subagent_model_id_invalid:\(index)")
-            } else if !seen.insert(model.lowercased()).inserted {
+            } else if !seen.insert(entryKey(entry)).inserted {
                 issues.append("subagent_model_duplicate:\(index)")
             } else if let effort = entry.reasoningEffort, !efforts.contains(effort) {
                 issues.append("subagent_model_effort_invalid:\(index)")
@@ -215,7 +229,7 @@ enum SubagentModelDraft {
     static func restoringCriteria(_ incoming: [SubagentModelEntry], known: [SubagentModelEntry], redact: (String) -> String) -> [SubagentModelEntry] {
         incoming.map { entry in
             guard entry.criteriaUnreadable, let match = known.first(where: {
-                $0.model.lowercased() == entry.model.lowercased() && !$0.criteriaUnreadable
+                entryKey($0) == entryKey(entry) && !$0.criteriaUnreadable
                     && (redact(cleanCriteria($0.criteria)) == entry.criteria || fitsRedacted(cleanCriteria($0.criteria), answer: entry.criteria))
             }) else { return entry }
             var copy = entry

package/dist/native/sks-menubar/Sources/SubagentModelsViewController.swift

@@ -65,7 +65,7 @@ final class SubagentModelsViewController: NSViewController, ControlCenterPage, N
         let modeCard = NativeView.card(title: "Connection", subtitle: "", views: [badge, modeDetail, modeIssues, hintRow])
         let listCard = NativeView.card(
             title: "Subagent model list",
-            subtitle: "Save a separate list for Codex-LB, OpenAI OAuth, and OpenRouter Only. Subagents use this connection's listed models. With Jev on, Jev chooses by your criteria; otherwise a listed requested model or the default is used.",
+            subtitle: "Save a separate list for each connection. Add the same model at different efforts with separate criteria. With Jev on, Jev chooses a model and effort together; otherwise a listed requested option or the default is used.",
             views: [rowsStack, listStatus, ControlKit.actionRow([addButton, applyButton, spinner], trailing: [revertButton, refreshButton]), actionStatus]
         )
         view = NativeView.page([
@@ -252,15 +252,15 @@ final class SubagentModelsViewController: NSViewController, ControlCenterPage, N
         refreshButton.isEnabled = !busy
         if busy || loading { spinner.startAnimation(nil) } else { spinner.stopAnimation(nil) }
         guard snapshot != nil else { return show(listStatus, "") }
-        var parts = ["\(draft.count) of \(SubagentModelRules.maxModels) models"]
-        if let preferred = draft.first(where: \.isDefault) { parts.append("default \(preferred.model)") }
+        var parts = ["\(draft.count) of \(SubagentModelRules.maxModels) options"]
+        if let preferred = draft.first(where: \.isDefault) { parts.append("default \(preferred.model) [\(preferred.reasoningEffort ?? "Default")]") }
         if dirty { parts.append("unapplied changes") }
         if editable, available.isEmpty {
             parts.append(snapshot?.profile == "openrouter_only"
                 ? "no OpenRouter models are in the bridge catalog yet; select some under Models in Codex on the Connections page"
                 : "no models are available for this connection; open Codex and refresh the catalog")
         } else if editable, draft.count < SubagentModelRules.maxModels, SubagentModelDraft.adding(draft, available: available) == nil {
-            parts.append("every catalog model is already on the list")
+            parts.append("every available model and effort is already on the list")
         }
         show(listStatus, parts.joined(separator: " · "), color: dirty ? .systemOrange : .secondaryLabelColor)
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "10.5.5",
+  "version": "10.5.6",
   "description": "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.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -57,6 +57,7 @@
     "crates/sks-core/Cargo.toml",
     "crates/sks-core/src",
     "docs/demo.tape",
+    "docs/assets/sks-center-subagent-models.png",
     "README.md",
     "LICENSE"
   ],