sneakoscope 10.3.2 → 10.3.4

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.2**. Install the latest stable release from npm.
+Current package: **SKS 10.3.4**. 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)
 
@@ -39,7 +39,7 @@ sks bootstrap --yes
 
 | Capability | What you get |
 | --- | --- |
-| Focused execution | Small tasks stay lightweight; independent work can use official Codex subagents with parent-owned integration. |
+| Focused execution | Answers and tiny edits stay lightweight; implementation work runs through official Codex subagents while the parent orchestrates and integrates. |
 | Project context | TriWiki indexes repository code and supplies bounded context that can be checked against source. |
 | Verification | Tests, diagnostics, and release evidence support completion claims. Security and data-integrity checks stay in place. |
 | Native controls | SKS Center brings connections, updates, MCP servers, and diagnostics together on macOS. |
@@ -138,16 +138,26 @@ configuration, transport checks, and recovery commands.
 
 ## Naruto workflow
 
-SKS enforces GPT-6 Astra for every managed child and varies effort by task.
-The parent owns decomposition, integration,
-and final verification; children receive bounded tasks and do not spawn children.
-
-| Work | Managed model | Effort |
-| --- | --- | --- |
-| Tiny mechanical tasks | GPT-6 Astra | low |
-| Exploration, large-context reads, and direct tool operation | GPT-6 Astra | medium |
-| Implementation | GPT-6 Astra | high |
-| Review, debugging, and focused judgment | GPT-6 Astra | max |
+The parent orchestrates: it decomposes the task, spawns a child for each
+disjoint slice, waits, and owns integration and final verification. It does not
+implement slices itself. The SKS PreToolUse hook denies parent source edits
+until the first child starts and while children are still running. Children
+receive bounded tasks and do not spawn children.
+
+No model family is pinned. Every child runs the newest model of the tier its
+work needs, read from the Codex models cache, so a new model family is used as
+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` |
+| 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,
+the plan, and the context, so the parent spends no time on those choices. A
+stored role-model preference on a current model wins in both modes.
 
 An active Codex task keeps the user's selected main model, effort, and service
 tier. Codex native `/goal` remains the persisted goal owner. Parallelism depends

package/config/skills-hash-ledger.v1.json

@@ -4,6 +4,7 @@
     {
       "canonical_name": "sks",
       "trusted_sha256": [
+        "8aa34586ba331f0447668c2ce863fe6c9ec4f881828ebed26ca5ecc754d66840",
         "d0288d27c8bc1c89decb258c6805ed4286cd0d65371ef0eec453be233b39a2a1",
         "905fc5472d36f0780b56f0e09404f42ea20293b1a4615d2050b7db3043231dbd",
         "6d90142f3617a8ae92d9af8cb2fc18ab58a7d0070868504e1fe89e0effc305a5",
@@ -324,13 +325,14 @@
     {
       "canonical_name": "sks-naruto",
       "trusted_sha256": [
+        "b2eb207b2773ab1995ee6e113ba6f3b64de43389e76aef4a0f06d4845ff86223",
+        "65e19a5d16f486b13541048c239e828f8039bfc6e38bafd7949d9c936fe4b5b2",
         "da43debf97f0b4a1583d8202a7306aca97ac97865accf9bca8f41d75c84a1cb9",
         "b981bea4183376c6c0204941ad6c2e78782e2cdea4f8d25cc85630c609faaf95",
         "5df9c9678eb68fd79ceb998ae7a52dd54dc92336ad5169e8a01acca89f76bd60",
         "a1219f6dbad9c8c185953125ef0b8dccf081aa01efb8e8acaa543c6214ac049c",
         "d0d5968e78ac25e1d3e588735de1ddbcf149cfb3165edebca5dec1ed7c7a5c46",
         "34222c72e4e1ead3584907f4d905444b7de820283ee7348018f110d5e6b04461",
-        "f8e808622e222b4ad7dcb2907e5f06a890db83139ae443ec6c8c33781dfa3e37",
         "49b5e3dcc1b537b49c2cf09e5b875cb16acb05c622b22798e265e64dacd8ac90"
       ]
     },
@@ -345,6 +347,7 @@
     {
       "canonical_name": "sks-pipeline-runner",
       "trusted_sha256": [
+        "6f38d3387e4ab020291afe7f74713b135543e52707f5bfbffa6b3584542f45a5",
         "7749638f1e8393f3beb1f7b0c37195dd0463abdb6fd7da5d31b3d816ee91fa37",
         "fd06dfb27be41e5ffec3e3ec8c5362289f5919cf2afa9da5ab6b97e7baa4a0ac",
         "66e105773b8e042eec5d5679b97b7cb305cad8d45671034907fbfa728fc4d68a",
@@ -372,6 +375,8 @@
     {
       "canonical_name": "sks-prompt-pipeline",
       "trusted_sha256": [
+        "f82a103e7962e416961add515d7b3e65df89848dec1fbb9319bd49d7f1dac982",
+        "93fd938dccd65d9b4d1dd140b60e1baedc627e7fcc54f9afd95eb2e44efd1143",
         "033bb114ec1fac3f8c312f698b1861ed4c2ce6f65c06f4f1a872c4b101b74b92",
         "e7c8ef56d38fdc4879c983f7d6706f26fc1cf0a60c508836bd628e815700bcc3",
         "480c8afffafa9d52c483a963b4b8fafdffc0a47cd6d2efd3fb6d7924c11832c5",
@@ -388,6 +393,7 @@
     {
       "canonical_name": "sks-reasoning-router",
       "trusted_sha256": [
+        "41e14e8d5b93d743096664869ee68c41c86e911b0bbc165bdcd10e4a45faa4b6",
         "03d68436e568b3cee2bffc6ca58819019ca406f7b648ef4704e3465c7c83c114",
         "647f730520a1c7dc89c2642f5b8502624c65a861ae41aecf1fb137db40fd0611",
         "da0ddb58adc68ddeebdb9c45bf111c26eaa64d3e9dffe1dd39d7f30b943b8b88",

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

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

package/dist/commands/doctor.js

@@ -127,7 +127,8 @@ export async function run(_command, args = [], deps = {}) {
     const doctorFix = flag(args, '--fix');
     const homeDir = path.resolve(deps.home || process.env.HOME || os.homedir());
     const globalOnly = doctorGlobalOnlySelection({ args, doctorFix, root, home: homeDir }).global_only;
-    if (doctorFix) {
+    const doctorProfile = doctorProfileFromArgs(args, doctorFix);
+    if (doctorFix && doctorProfile !== 'migration') {
         const conflictScan = await scanHarnessConflicts(root);
         if (conflictScan.hard_block) {
             const blocked = {
@@ -151,7 +152,6 @@ export async function run(_command, args = [], deps = {}) {
             return blocked;
         }
     }
-    const doctorProfile = doctorProfileFromArgs(args, doctorFix);
     if (!flag(args, '--json')) {
         cliUi.banner('doctor');
         cliUi.step(doctorFix ? 'repairing and validating' : 'validating');

package/dist/config/skills-manifest.json

@@ -1,12 +1,13 @@
 {
   "schema": "sks.skills-manifest.v1",
-  "package_version": "10.3.2",
+  "package_version": "10.3.4",
   "skills": [
     {
       "canonical_name": "sks",
       "type": "official",
-      "content_sha256": "d0288d27c8bc1c89decb258c6805ed4286cd0d65371ef0eec453be233b39a2a1",
+      "content_sha256": "8aa34586ba331f0447668c2ce863fe6c9ec4f881828ebed26ca5ecc754d66840",
       "hash_history": [
+        "d0288d27c8bc1c89decb258c6805ed4286cd0d65371ef0eec453be233b39a2a1",
         "905fc5472d36f0780b56f0e09404f42ea20293b1a4615d2050b7db3043231dbd",
         "6d90142f3617a8ae92d9af8cb2fc18ab58a7d0070868504e1fe89e0effc305a5",
         "5b17aeb1484e9e2b3791bff6dcb175f30857f47e71b36eb0340e575385e8e82b"
@@ -393,14 +394,15 @@
     {
       "canonical_name": "sks-naruto",
       "type": "core",
-      "content_sha256": "da43debf97f0b4a1583d8202a7306aca97ac97865accf9bca8f41d75c84a1cb9",
+      "content_sha256": "b2eb207b2773ab1995ee6e113ba6f3b64de43389e76aef4a0f06d4845ff86223",
       "hash_history": [
+        "65e19a5d16f486b13541048c239e828f8039bfc6e38bafd7949d9c936fe4b5b2",
+        "da43debf97f0b4a1583d8202a7306aca97ac97865accf9bca8f41d75c84a1cb9",
         "b981bea4183376c6c0204941ad6c2e78782e2cdea4f8d25cc85630c609faaf95",
         "5df9c9678eb68fd79ceb998ae7a52dd54dc92336ad5169e8a01acca89f76bd60",
         "a1219f6dbad9c8c185953125ef0b8dccf081aa01efb8e8acaa543c6214ac049c",
         "d0d5968e78ac25e1d3e588735de1ddbcf149cfb3165edebca5dec1ed7c7a5c46",
         "34222c72e4e1ead3584907f4d905444b7de820283ee7348018f110d5e6b04461",
-        "f8e808622e222b4ad7dcb2907e5f06a890db83139ae443ec6c8c33781dfa3e37",
         "49b5e3dcc1b537b49c2cf09e5b875cb16acb05c622b22798e265e64dacd8ac90"
       ],
       "deprecated_aliases": []
@@ -418,8 +420,9 @@
     {
       "canonical_name": "sks-pipeline-runner",
       "type": "official",
-      "content_sha256": "7749638f1e8393f3beb1f7b0c37195dd0463abdb6fd7da5d31b3d816ee91fa37",
+      "content_sha256": "6f38d3387e4ab020291afe7f74713b135543e52707f5bfbffa6b3584542f45a5",
       "hash_history": [
+        "7749638f1e8393f3beb1f7b0c37195dd0463abdb6fd7da5d31b3d816ee91fa37",
         "fd06dfb27be41e5ffec3e3ec8c5362289f5919cf2afa9da5ab6b97e7baa4a0ac",
         "66e105773b8e042eec5d5679b97b7cb305cad8d45671034907fbfa728fc4d68a",
         "020ba4da2f96bcda23cee4596b1e790816780178f1917dee748ff4b289cba0e5",
@@ -451,8 +454,10 @@
     {
       "canonical_name": "sks-prompt-pipeline",
       "type": "official",
-      "content_sha256": "033bb114ec1fac3f8c312f698b1861ed4c2ce6f65c06f4f1a872c4b101b74b92",
+      "content_sha256": "f82a103e7962e416961add515d7b3e65df89848dec1fbb9319bd49d7f1dac982",
       "hash_history": [
+        "93fd938dccd65d9b4d1dd140b60e1baedc627e7fcc54f9afd95eb2e44efd1143",
+        "033bb114ec1fac3f8c312f698b1861ed4c2ce6f65c06f4f1a872c4b101b74b92",
         "e7c8ef56d38fdc4879c983f7d6706f26fc1cf0a60c508836bd628e815700bcc3",
         "480c8afffafa9d52c483a963b4b8fafdffc0a47cd6d2efd3fb6d7924c11832c5",
         "5dc8524de9bad66cef133ea5ff2a8052331bd12a7ec85695f727d0d2c8523145"
@@ -471,8 +476,9 @@
     {
       "canonical_name": "sks-reasoning-router",
       "type": "official",
-      "content_sha256": "03d68436e568b3cee2bffc6ca58819019ca406f7b648ef4704e3465c7c83c114",
+      "content_sha256": "41e14e8d5b93d743096664869ee68c41c86e911b0bbc165bdcd10e4a45faa4b6",
       "hash_history": [
+        "03d68436e568b3cee2bffc6ca58819019ca406f7b648ef4704e3465c7c83c114",
         "647f730520a1c7dc89c2642f5b8502624c65a861ae41aecf1fb137db40fd0611",
         "da0ddb58adc68ddeebdb9c45bf111c26eaa64d3e9dffe1dd39d7f30b943b8b88",
         "1595beabf2d31397217311fa1323bd62c801cf6c87db9029ff544c457efec8bb",

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

@@ -1,6 +1,7 @@
 import { codexModelEffortCapability } from '../codex-control/codex-model-capabilities.js';
 import { managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
-import { ASTRA_SUBAGENT_MODEL, decideSubagentModel, subagentModelProfile } from '../subagents/model-policy.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);
 }
@@ -38,14 +39,14 @@ export function decideOfficialSubagentModel(input = {}) {
             reason: `managed_role:${managedRole.codex_name}:${profile.policy}`,
             dynamic: true,
             escalation_triggers: [
-                'focused review, debugging, planning, integration, security, database, research, release, or unresolved ambiguity selects Astra Max',
+                'focused review, debugging, planning, integration, security, database, research, release, or unresolved ambiguity selects the deep tier',
                 'incidental judgment vocabulary does not override a clearly classified implementation or context/tools slice',
                 'requested model/effort profile unavailable blocks instead of silently falling back'
             ],
             downshift_triggers: [
-                'instructed UI, logic, backend, or native implementation selects Astra Low',
-                'long-context, Browser/Chrome, Computer Use, image-generation, or large search selects Astra Medium',
-                'tiny short-context mechanical search/typing/rename work selects Astra Low'
+                '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'
             ]
         };
     }
@@ -92,14 +93,14 @@ export function decideOfficialSubagentModel(input = {}) {
         reason: routed.reason,
         dynamic: true,
         escalation_triggers: [
-            'focused review, debugging, planning, integration, security, database, research, release, or unresolved ambiguity selects Astra Max',
+            'focused review, debugging, planning, integration, security, database, research, release, or unresolved ambiguity selects the deep tier',
             'incidental judgment vocabulary does not override a clearly classified implementation or context/tools slice',
             'requested model/effort profile unavailable blocks instead of silently falling back'
         ],
         downshift_triggers: [
-            'instructed UI, logic, backend, or native implementation selects Astra Low',
-            'long-context, Browser/Chrome, Computer Use, or image-generation execution selects Astra Medium',
-            'tiny short-context mechanical work selects Astra Low'
+            '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'
         ]
     };
 }
@@ -118,21 +119,22 @@ export function buildAgentEffortPolicy(roster = {}) {
         reason: agent.reasoning_reason,
         dynamic: true
     })) : [];
+    const latest = resolveLatestModelTiers();
     return {
         schema: 'sks.agent-effort-policy.v1',
         policy_version: 1,
         dynamic: true,
         service_tier: 'fast',
         model_catalog_policy: 'official_subagent_four_profile_matrix',
-        model_constraint: [ASTRA_SUBAGENT_MODEL],
-        model_tiers: ['low', 'medium', 'high', 'max'].map((effort) => `${ASTRA_SUBAGENT_MODEL}-${effort}`),
+        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'],
-        model_effort_capability: codexModelEffortCapability({ model: ASTRA_SUBAGENT_MODEL }),
+        model_effort_capability: codexModelEffortCapability({ model: latest.models.deep }),
         max_agents: roster.max_agents || 20,
         agent_count: roster.agent_count || decisions.length,
         concurrency: roster.concurrency || decisions.length,
         decisions,
-        rule: 'All child agents use GPT-6 Astra: Low for tiny short-context mechanical work and instructed implementation, Medium for reads and tool execution, and Max for focused judgment. The parent keeps its user-selected model, reasoning effort, and service tier; explicit Astra effort preferences may override role defaults.'
+        rule: 'Every child uses the newest model of the tier its work needs: fast for tiny mechanical work, balanced for instructed implementation, context for reads and tool execution, and deep for focused judgment. With Jev mode on, Jev picks the tier for each spawn. The parent keeps its user-selected model, reasoning effort, and service tier; stored role preferences may override role defaults.'
     };
 }
 export function reasoningProfileName(effort) {

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

@@ -10,7 +10,8 @@ import { leanEngineeringCompactText, leanPolicyReference } from '../lean-enginee
 import { readCodexLbModelCatalog, readLbHealth } from '../codex-lb/codex-lb-env.js';
 import { categoryForWorkerRole, isNarutoGpt56Model, modelRouteReason, routeModel } from '../provider/model-router.js';
 import { codexTimeoutClassForRoute } from '../codex-control/codex-reliability-shield.js';
-import { ASTRA_SUBAGENT_MODEL, decideSubagentModel } from '../subagents/model-policy.js';
+import { decideSubagentModel } from '../subagents/model-policy.js';
+import { latestTierModelSet } from '../subagents/model-tiers.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);
@@ -241,15 +242,19 @@ export async function resolveWorkerModelRouting(input, deps = {}) {
     const explicitNarutoModelInvalid = narutoOnly && Boolean(explicitModel) && !isNarutoGpt56Model(explicitModel);
     const explicitNarutoReasoningInvalid = narutoOnly && Boolean(explicitReasoningRaw) && !explicitReasoning;
     const explicitNarutoTierInvalid = narutoOnly && Boolean(explicitTierRaw) && !explicitTier;
-    const savedAstraEffort = input.agent?.routed_model_policy === 'user_role_model_preference'
-        && input.agent?.routed_model === ASTRA_SUBAGENT_MODEL
+    const currentModels = latestTierModelSet();
+    const savedPreferenceModel = input.agent?.routed_model_policy === 'user_role_model_preference'
+        && currentModels.has(String(input.agent?.routed_model || ''))
+        ? String(input.agent?.routed_model)
+        : '';
+    const savedAstraEffort = savedPreferenceModel
         ? normalizeModelReasoning(input.agent?.routed_model_reasoning_effort)
         : null;
     const jevModel = !explicitModel && input.agent?.routed_model_policy === 'jev_sealed_routing'
         ? String(input.agent.routed_model || '').trim()
         : '';
     const jevEffort = jevModel ? normalizeModelReasoning(input.agent?.routed_model_reasoning_effort) : null;
-    const selectedModel = explicitModel || jevModel;
+    const selectedModel = explicitModel || jevModel || savedPreferenceModel;
     const taskPolicy = decideSubagentModel({ title: taskKindText, description: riskText, role: input.agent?.role });
     const routed = narutoOnly
         ? await routeModel(category, {
@@ -263,14 +268,14 @@ export async function resolveWorkerModelRouting(input, deps = {}) {
             ...(selectedModel ? { model: selectedModel } : {})
         })
         : {
-            model: ASTRA_SUBAGENT_MODEL,
+            model: (explicitModel && currentModels.has(explicitModel) ? explicitModel : '') || savedPreferenceModel || taskPolicy.model,
             reasoning: explicitReasoning || savedAstraEffort || taskPolicy.modelReasoningEffort,
             serviceTier: explicitTier || input.fastModePolicy.service_tier || 'fast'
         };
     const blockers = [
         ...(narutoOnly && !lbCatalog?.ok ? (lbCatalog?.blockers || ['codex_lb_model_catalog_unavailable']) : []),
-        ...(explicitNarutoModelInvalid ? ['naruto_worker_model_outside_gpt_5_6_family'] : []),
-        ...(!narutoOnly && explicitModel && explicitModel !== ASTRA_SUBAGENT_MODEL ? ['subagent_model_must_be_astra'] : []),
+        ...(explicitNarutoModelInvalid ? ['naruto_worker_model_not_current'] : []),
+        ...(!narutoOnly && explicitModel && !currentModels.has(explicitModel) ? ['subagent_model_must_be_current'] : []),
         ...(explicitNarutoReasoningInvalid ? ['naruto_reasoning_override_invalid'] : []),
         ...(explicitNarutoTierInvalid ? ['naruto_service_tier_override_invalid'] : []),
         ...(narutoOnly && explicitReasoning && explicitReasoning !== routed.reasoning ? ['naruto_reasoning_override_conflicts_with_policy'] : []),
@@ -306,7 +311,7 @@ export function narutoWorkerBackendBlocker(backend, narutoRequest = true) {
     if (!narutoRequest)
         return null;
     if (backend === 'process')
-        return 'naruto_gpt_5_6_family_only_process_backend_forbidden';
+        return 'naruto_process_backend_forbidden';
     return null;
 }
 function normalizeBackend(value) {

package/dist/core/codex-hooks/codex-hook-managed-install.js

@@ -1,5 +1,7 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
 import path from 'node:path';
-import { ensureDir, nowIso, readText, writeTextAtomic } from '../fsx.js';
+import { ensureDir, nowIso, packageRoot, readText, writeTextAtomic } from '../fsx.js';
 import { CODEX_HOOK_EVENTS } from '../codex-compat/codex-hook-events.js';
 import { postToolEvidenceEnabled } from '../verification-profile.js';
 import { buildCodexCommandHookToml, matcherApplies } from './codex-hook-config-writer.js';
@@ -22,7 +24,7 @@ export async function installManagedCodexHooks(root, opts = {}) {
     const requirementsPath = path.resolve(root, opts.requirementsPath || path.join('.codex', 'requirements.toml'));
     const scriptPath = path.join(managedDir, 'sks-managed-hook.sh');
     const tomlPath = path.join(managedDir, 'sks-managed-hooks.toml');
-    const binCommand = opts.binCommand || 'sks hook';
+    const binCommand = opts.binCommand || await defaultManagedHookCommand();
     const installedEvents = CODEX_HOOK_EVENTS.filter((event) => event !== 'PostToolUse' || postToolEvidenceEnabled(root));
     const hooksToml = installedEvents.map((event) => buildCodexCommandHookToml({
         event,
@@ -77,6 +79,32 @@ export async function installManagedCodexHooks(root, opts = {}) {
         blockers: actual?.blockers || []
     };
 }
+export async function defaultManagedHookCommand() {
+    const entrypoint = path.join(packageRoot(), 'dist', 'bin', 'sks.js');
+    if (!(await isRegularFile(entrypoint)))
+        return 'sks hook';
+    return `${shellQuote(process.execPath)} ${shellQuote(entrypoint)} hook`;
+}
+export async function retargetLiveManagedHookScript(env = process.env) {
+    const home = env.HOME || os.homedir();
+    const codexHome = path.resolve(env.CODEX_HOME || path.join(home, '.codex'));
+    const requirementsPath = path.join(codexHome, 'requirements.toml');
+    const requirements = await readText(requirementsPath, '');
+    const configuredDir = managedDirFromRequirements(String(requirements || ''), requirementsPath);
+    const managedDir = configuredDir || path.join(codexHome, 'managed-hooks');
+    const resolvedDir = path.resolve(managedDir);
+    const script = path.join(resolvedDir, 'sks-managed-hook.sh');
+    if (!pathIsInside(codexHome, script)) {
+        return { ok: false, status: 'absent', script, command: null };
+    }
+    if (!(await isRegularFile(script))) {
+        return { ok: true, status: 'absent', script, command: null };
+    }
+    const command = await defaultManagedHookCommand();
+    await writeTextAtomic(script, managedHookScript(command));
+    await chmodExecutable(script);
+    return { ok: true, status: 'rewritten', script, command };
+}
 function managedHookScript(binCommand) {
     return [
         '#!/usr/bin/env sh',
@@ -86,6 +114,32 @@ function managedHookScript(binCommand) {
         `exec ${binCommand} "$subcommand" "$@"`
     ].join('\n') + '\n';
 }
+function shellQuote(value) {
+    if (/[\0\r\n]/.test(value))
+        throw new Error('hook_command_path_invalid');
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function managedDirFromRequirements(text, requirementsPath) {
+    const match = text.match(/^\s*managed_dir\s*=\s*(.+)\s*$/m);
+    if (!match?.[1])
+        return null;
+    const raw = match[1].trim().replace(/^['"]|['"]$/g, '');
+    if (!raw || raw.includes('\0'))
+        return null;
+    return path.resolve(path.dirname(requirementsPath), raw);
+}
+function pathIsInside(root, target) {
+    const relative = path.relative(path.resolve(root), path.resolve(target));
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+async function isRegularFile(file) {
+    try {
+        return (await fs.stat(file)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
 function mergeRequirementsToml(existing, opts) {
     const withoutManagedOnly = String(existing || '')
         .replace(/^\s*allow_managed_hooks_only\s*=.*$/gm, '')

package/dist/core/codex-lb/desktop-bridge-migration/retired-runtime-cleanup.js

@@ -18,6 +18,7 @@ const SETTINGS_V2_KEYS = new Set([
     'schema', 'listen_host', 'listen_port', 'provider_registry', 'route_policy',
     'provider_session_pins', 'client_capability_sha256', 'allowed_origins',
     'connect_timeout_ms', 'idle_timeout_ms', 'official_passthrough',
+    'auth_priority_enabled',
 ]);
 const TRANSFERABLE_V1_KEYS = [
     'listen_host', 'listen_port', 'allowed_origins', 'connect_timeout_ms', 'idle_timeout_ms',

package/dist/core/codex-native/core-skill-manifest.js

@@ -14,13 +14,13 @@ const CORE_SKILL_DEFINITIONS = [
         display_name: 'naruto',
         route: '$Naruto',
         purpose: 'run a Codex official subagent workflow with official agent threads while parent integration remains owner.',
-        discovery: 'Run $sks-naruto for explicit parallel official subagents.',
-        when: 'Use when the user explicitly invokes $Naruto or the selected route requires bounded parallel delegation.',
-        workflow: 'Run sks naruto run "<task>" [--agents N] [--max-threads N] [--json] with Codex official subagent threads only. The parent owns decomposition, per-wave capacity, later root-owned waves, integration, and final verification. Automatic targets begin at 4/6/8/16 by task size: bounded, explicit parallel, large-scale, then mass mechanical or exploration fan-out on the Astra Low/Astra Medium lanes. After decomposition both lanes may expand to the SKS-owned 256-child ceiling when independent useful slices and real host capacity remain positive; max_threads defaults to a 256-child frame budget cap, never a target. A measured lower Codex host cap or explicit provider/API budget remains authoritative, and multi-wave scheduling reuses returned capacity. Use gpt-6-astra for every child, preserving parent settings and ignoring child-model overrides. Route tiny mechanical and mass shards to Astra Low, broad search and exploration shards to Astra Medium, instructed ordinary coding execution to Astra Low, and planning, analysis, review, or other judgment to Astra Max. Keep the four task-class profiles and compatibility IDs; explicit Astra effort preferences, including High, remain supported; max_depth=1 blocks nested delegation. Wait for every planned thread before final. In an active Codex App Naruto mission, commit the strict parent evidence with sks naruto parent-summary --mission <id> --stdin, then return localized Markdown without exposing the JSON.',
+        discovery: 'Run $sks-naruto to delegate implementation to child subagents.',
+        when: 'Use when the user invokes $sks-naruto or $sks-work, or the selected route is Naruto: ordinary implementation work, where the parent orchestrates and children implement.',
+        workflow: 'Run sks naruto run "<task>" [--agents N] [--max-threads N] [--json] with Codex official subagent threads only. The parent orchestrates only: decompose, assign disjoint slices, spawn, integrate, and verify. Do not implement slice work in the parent thread; the SKS PreToolUse gate denies parent-thread source edits until the first child thread starts and while children are still running, and .sneakoscope artifacts stay parent-writable. The parent owns decomposition, per-wave capacity, later root-owned waves, integration, and final verification. Automatic targets begin at 4/6/8/16 by task size: bounded, explicit parallel, large-scale, then mass mechanical or exploration fan-out. After decomposition both lanes may expand to the SKS-owned 256-child ceiling when independent useful slices and real host capacity remain positive; max_threads defaults to a 256-child frame budget cap, never a target. A measured lower Codex host cap or explicit provider/API budget remains authoritative, and multi-wave scheduling reuses returned capacity. Every child runs the newest model of the tier its work needs (fast, balanced, context, or deep); no model family is pinned. When Jev mode is on, Jev picks the tier for each new spawn and SKS seals it. A user role preference stays authoritative. Do not choose child models yourself. Keep the four task-class profiles and compatibility IDs; max_depth=1 blocks nested delegation. Wait for every planned thread before final. In an active Codex App Naruto mission, commit the strict parent evidence with sks naruto parent-summary --mission <id> --stdin, then return localized Markdown without exposing the JSON.',
         safety: 'Preserve user-authored content, inherit the parent permission mode, do not spawn nested subagents, do not inject the full pack or the full TriWiki context into every child, and do not fall back to another model, process runtime, custom scheduler, or worker pool. The historical Naruto process runtime is removed; stop with explicit blocker evidence when the official path is unavailable.',
         cli: 'sks naruto run "<task>" [--agents N] [--max-threads N] [--json]; sks naruto status|subagents|proof [--mission <id>] [--json]; sks naruto parent-summary --mission <id> --stdin [--json]',
         evidence: 'subagent-plan.json, subagent-events.jsonl, subagent-parent-summary.json, subagent-evidence.json, naruto-summary.json, and naruto-gate.json.',
-        fallback: 'Return explicit official-subagent availability blockers and continue parent-owned only when the sealed task still has meaningful in-scope work; never fabricate process, PID, or subagent evidence.'
+        fallback: 'When official subagents are unavailable, report the explicit availability blocker; the orchestration gate releases parent edits only after its bounded denials, and that release is recorded. Never fabricate process, PID, or subagent evidence.'
     },
     {
         id: 'sks-core-qa-loop',

package/dist/core/decisions/cli.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { printJson } from '../../cli/output.js';
 import { nowIso, writeJsonAtomic } from '../fsx.js';
 import { resolveOpenRouterApiKey } from '../providers/openrouter/openrouter-secret-store.js';
-import { jevEnabled, readDecisionConfig, writeDecisionConfig } from './config.js';
+import { jevEnabled, readDecisionConfig, writeDecisionConfig, jevCapabilityActive } from './config.js';
 import { buildEvaluationReport } from './evaluation.js';
 import { OPENROUTER_DECISIONS_ENDPOINT, OPENROUTER_DECISIONS_MODEL, requestOpenRouterDecision } from './openrouter.js';
 import { buildDecisionBundle } from './questions.js';
@@ -152,7 +152,14 @@ export async function statusReport(env) {
             source: resolved.source,
             preview: resolved.key_preview
         },
-        capabilities: config.capabilities,
+        capabilities: {
+            context: { ...config.capabilities.context, ready: jevCapabilityActive(config, 'context') },
+            plan: { ...config.capabilities.plan, ready: jevCapabilityActive(config, 'plan') },
+            recovery: config.capabilities.recovery
+        },
+        decision_points: jevEnabled(config)
+            ? ['turn_tier', 'spawn_tier', 'role_tiers', 'role_omission', 'plan', 'context', 'parent_edit_delegation']
+            : [],
         recovery: RECOVERY_CAPABILITY,
         nextStep,
         notes: [

package/dist/core/decisions/config.js

@@ -70,6 +70,13 @@ export async function writeDecisionConfig(patch, env = process.env) {
 export function jevEnabled(config) {
     return config.mode === 'jev' && config.consentCloud === true;
 }
+export function jevCapabilityActive(config, capability) {
+    if (!jevEnabled(config))
+        return false;
+    if (capability === 'recovery')
+        return config.capabilities.recovery.ready;
+    return true;
+}
 function normalizeConfig(raw) {
     const fallback = defaultDecisionConfig();
     if (!isRecord(raw) || raw.schema !== DECISION_CONFIG_SCHEMA)

package/dist/core/decisions/integration.js

@@ -1,6 +1,6 @@
 import { sha256 } from '../fsx.js';
 import { resolveOpenRouterApiKey } from '../providers/openrouter/openrouter-secret-store.js';
-import { jevEnabled, readDecisionConfig } from './config.js';
+import { jevCapabilityActive, jevEnabled, readDecisionConfig } from './config.js';
 import { requestOpenRouterDecision } from './openrouter.js';
 import { compileDecision } from './policy.js';
 import { buildDecisionBundle, validatePlanCoverage } from './questions.js';
@@ -8,7 +8,7 @@ import { applyRecoveryEffect, listProductionRecoveryCandidates } from './recover
 import { assembleRoutingSelection, buildRoutingCandidates } from './routing.js';
 import { buildDecisionReceipt } from './receipt.js';
 import { applyOptionalContextSelection, graphFileDigest, hydrateContextCandidates, sourceSnapshotDigest } from './state.js';
-import { DESIGN_DEFAULTS, POLICY_REVISION, UNKNOWN_USAGE, sealedRoutingModel } from './types.js';
+import { DESIGN_DEFAULTS, POLICY_REVISION, UNKNOWN_USAGE } from './types.js';
 let testOverrides = null;
 const appliedEffects = new Set();
 export function setDecisionTestOverrides(overrides) {
@@ -43,16 +43,16 @@ async function decideOfficialSubagentPreparationInner(input, started) {
         overrides?.observe?.({ mode: config.mode, eligible: false, compiled: missing.compiled, receipt: missing.receipt });
         return missing;
     }
-    const contextCandidates = config.capabilities.context.ready
+    const contextCandidates = jevCapabilityActive(config, 'context')
         ? await hydrateContextCandidates(input.root, input.attention, input.changedPaths || [])
         : [];
-    const planCandidates = config.capabilities.plan.ready && input.requestedSource === 'automatic'
+    const planCandidates = jevCapabilityActive(config, 'plan') && input.requestedSource === 'automatic'
         ? buildAutomaticPlanCandidates(input)
         : [];
     const routingCandidates = input.requestedSource === 'automatic'
         ? buildRoutingCandidates({ roles: input.routingRoles || [] })
         : [];
-    const recoveryCandidates = config.capabilities.recovery.ready
+    const recoveryCandidates = jevCapabilityActive(config, 'recovery')
         ? [...listProductionRecoveryCandidates()]
         : [];
     const optionalContext = contextCandidates.filter((row) => !row.pinned && row.excerpt);
@@ -134,7 +134,7 @@ export async function consultJevTurnModel(input) {
     const overrides = activeOverrides();
     const env = input.env || process.env;
     const config = overrides?.config ?? await readDecisionConfig(env);
-    const none = (reason) => ({ called: false, model: null, effort: null, reason });
+    const none = (reason) => ({ called: false, model: null, effort: null, tier: null, reason });
     if (!jevEnabled(config))
         return none('off');
     const resolved = await resolveOpenRouterApiKey({ env });
@@ -159,14 +159,56 @@ export async function consultJevTurnModel(input) {
         ...(overrides?.fetchImpl ? { fetchImpl: overrides.fetchImpl } : {})
     });
     if (!transport.ok)
-        return { called: true, model: null, effort: null, reason: transport.reason };
+        return { called: true, model: null, effort: null, tier: null, reason: transport.reason };
     const compiled = compileDecision(bundle, transport.response);
     if (compiled.kind !== 'apply')
-        return { called: true, model: null, effort: null, reason: compiled.reason };
-    const selected = assembleRoutingSelection(compiled.effects.flatMap((effect) => (effect.kind === 'select_routing' ? [{ roleId: effect.roleId, model: effect.model }] : [])));
+        return { called: true, model: null, effort: null, tier: null, reason: compiled.reason };
+    const selected = assembleRoutingSelection(compiled.effects.flatMap((effect) => (effect.kind === 'select_routing' ? [{ roleId: effect.roleId, tier: effect.tier }] : [])));
     const model = selected?.models[roleId] || null;
-    const sealed = model ? sealedRoutingModel(model) : null;
-    return { called: true, model: sealed?.id || null, effort: sealed?.effort || null, reason: sealed ? 'applied' : 'keep_baseline' };
+    const effort = selected?.efforts[roleId] || null;
+    const tier = selected?.tiers[roleId] || null;
+    if (!model || !effort || !tier)
+        return { called: true, model: null, effort: null, tier: null, reason: 'keep_baseline' };
+    return { called: true, model, effort, tier, reason: 'applied' };
+}
+export async function consultJevToolDelegation(input) {
+    const overrides = activeOverrides();
+    const env = input.env || process.env;
+    const config = overrides?.config ?? await readDecisionConfig(env);
+    const none = (reason) => ({ called: false, choice: null, reason });
+    if (!jevEnabled(config))
+        return none('off');
+    const resolved = await resolveOpenRouterApiKey({ env });
+    if (!resolved.key)
+        return none('missing_key');
+    const goal = String(input.missionGoal || '').trim();
+    const toolName = String(input.toolName || '').trim();
+    if (!goal || !toolName)
+        return none('empty_candidate');
+    const targets = input.targets.map((row) => String(row || '').trim()).filter(Boolean);
+    const bundle = buildDecisionBundle({
+        projectId: sha256(input.root).slice(0, 32),
+        workflowRunId: 'delegation',
+        workflowRevision: 'delegation',
+        sourceDigest: sha256(JSON.stringify([toolName, targets])).slice(0, 32),
+        graphDigest: null,
+        goal,
+        delegationCandidate: { toolName, targets, missionGoal: goal }
+    });
+    const transport = await requestOpenRouterDecision(bundle, {
+        env,
+        deadlineMs: DESIGN_DEFAULTS.deadlineMs,
+        ...(overrides?.fetchImpl ? { fetchImpl: overrides.fetchImpl } : {})
+    });
+    if (!transport.ok)
+        return { called: true, choice: null, reason: transport.reason };
+    const compiled = compileDecision(bundle, transport.response);
+    if (compiled.kind !== 'apply')
+        return { called: true, choice: null, reason: compiled.reason };
+    const effect = compiled.effects.find((row) => row.kind === 'select_delegation');
+    if (!effect || effect.kind !== 'select_delegation')
+        return { called: true, choice: null, reason: 'keep_baseline' };
+    return { called: true, choice: effect.choice, reason: 'applied' };
 }
 export function effectAlreadyConsumed(identity) {
     return appliedEffects.has(identity);
@@ -210,7 +252,7 @@ function applyEffects(attention, contextCandidates, planCandidates, compiled) {
                 evidence.push(`plan:${selectedPlan.id}`);
         }
         if (effect.kind === 'select_routing') {
-            routingEffects.push({ roleId: effect.roleId, model: effect.model });
+            routingEffects.push({ roleId: effect.roleId, tier: effect.tier });
         }
         if (effect.kind === 'omit_role') {
             omittedRoutingRoles.push(effect.roleId);