sneakoscope 10.1.3 → 10.1.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.1.3**. Install the latest stable release from npm.
+Current package: **SKS 10.1.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)
 
@@ -133,12 +133,13 @@ configuration, transport checks, and recovery commands.
 
 ## Naruto workflow
 
-SKS uses official Codex subagents. The parent owns decomposition, integration,
+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-5.6 Luna | max |
+| 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 |

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

@@ -282,6 +282,7 @@
     {
       "canonical_name": "sks-naruto",
       "trusted_sha256": [
+        "5df9c9678eb68fd79ceb998ae7a52dd54dc92336ad5169e8a01acca89f76bd60",
         "a1219f6dbad9c8c185953125ef0b8dccf081aa01efb8e8acaa543c6214ac049c",
         "d0d5968e78ac25e1d3e588735de1ddbcf149cfb3165edebca5dec1ed7c7a5c46",
         "34222c72e4e1ead3584907f4d905444b7de820283ee7348018f110d5e6b04461",
@@ -337,6 +338,7 @@
     {
       "canonical_name": "sks-reasoning-router",
       "trusted_sha256": [
+        "647f730520a1c7dc89c2642f5b8502624c65a861ae41aecf1fb137db40fd0611",
         "da0ddb58adc68ddeebdb9c45bf111c26eaa64d3e9dffe1dd39d7f30b943b8b88",
         "1595beabf2d31397217311fa1323bd62c801cf6c87db9029ff544c457efec8bb",
         "a7d879d157c6d5b6b81a67dba7b5b731ac18ea986841fe1ab2cafbd6623481c3",

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

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

package/dist/config/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema": "sks.skills-manifest.v1",
-  "package_version": "10.1.3",
+  "package_version": "10.1.4",
   "skills": [
     {
       "canonical_name": "sks",
@@ -346,8 +346,9 @@
     {
       "canonical_name": "sks-naruto",
       "type": "core",
-      "content_sha256": "a1219f6dbad9c8c185953125ef0b8dccf081aa01efb8e8acaa543c6214ac049c",
+      "content_sha256": "5df9c9678eb68fd79ceb998ae7a52dd54dc92336ad5169e8a01acca89f76bd60",
       "hash_history": [
+        "a1219f6dbad9c8c185953125ef0b8dccf081aa01efb8e8acaa543c6214ac049c",
         "d0d5968e78ac25e1d3e588735de1ddbcf149cfb3165edebca5dec1ed7c7a5c46",
         "34222c72e4e1ead3584907f4d905444b7de820283ee7348018f110d5e6b04461",
         "f8e808622e222b4ad7dcb2907e5f06a890db83139ae443ec6c8c33781dfa3e37",
@@ -414,8 +415,9 @@
     {
       "canonical_name": "sks-reasoning-router",
       "type": "official",
-      "content_sha256": "da0ddb58adc68ddeebdb9c45bf111c26eaa64d3e9dffe1dd39d7f30b943b8b88",
+      "content_sha256": "647f730520a1c7dc89c2642f5b8502624c65a861ae41aecf1fb137db40fd0611",
       "hash_history": [
+        "da0ddb58adc68ddeebdb9c45bf111c26eaa64d3e9dffe1dd39d7f30b943b8b88",
         "1595beabf2d31397217311fa1323bd62c801cf6c87db9029ff544c457efec8bb",
         "a7d879d157c6d5b6b81a67dba7b5b731ac18ea986841fe1ab2cafbd6623481c3",
         "dc0b8c6a4093269c2c36b58432b25409704d06fea8ca558f43b598625ca0d9de"

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

@@ -1,67 +1,8 @@
 import { codexModelEffortCapability } from '../codex-control/codex-model-capabilities.js';
-import { OPENROUTER_DEFAULT_MODEL } from '../codex-app/openrouter-provider.js';
 import { managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
-import { isNarutoGpt56Model } from '../provider/model-router.js';
-import { decideSubagentModel, subagentModelProfile } from '../subagents/model-policy.js';
-const XHIGH_SIGNAL_RE = /(frontier|autoresearch|novelty|hypothesis|falsif|forensic|from-chat-img|image\s*work\s*order|새로운\s*연구|가설|포렌식)/i;
-const HIGH_SIGNAL_RE = /(database|supabase|sql|migration|security|permission|mad|release|publish|deploy|architecture|policy|schema|hook|rollback|db|보안|배포|마이그레이션|데이터베이스|권한|릴리즈)/i;
-const MEDIUM_SIGNAL_RE = /(terminal|cli|tool(?:\s|-)?call|router|routing|orchestrat|pipeline|multi[-\s]?session|multi[-\s]?agent|lease|ledger|proof|검증|파이프라인|오케스트레이션|병렬|에이전트)/i;
-const SIMPLE_SIGNAL_RE = /(tiny|simple|small|one[-\s]?line|typo|copy|label|spacing|rename|readme|docs?|간단|단순|오타|문구|라벨)/i;
-const SIMPLE_CODE_MOD_RE = /(tiny|simple|small|one[-\s]?line|typo|copy|label|spacing|rename|readme|docs?|minor|bounded|간단|단순|작은|오타|문구|라벨|이름\s*변경)/i;
+import { ASTRA_SUBAGENT_MODEL, decideSubagentModel, subagentModelProfile } from '../subagents/model-policy.js';
 export function decideAgentEffort(input = {}) {
-    const persona = input.persona || {};
-    const prompt = String(input.prompt || '');
-    const role = String(persona.role || '');
-    const agentId = String(input.agentId || persona.id || 'agent');
-    const text = [prompt, role, persona.risk_focus, persona.write_policy, persona.stable_id].join(' ');
-    let effort = promptEffort(text);
-    let reason = effortReason(effort);
-    if (/(db|safety|security|release|schema)/i.test([role, agentId, persona.stable_id, persona.risk_focus].join(' '))) {
-        effort = effort === 'xhigh' ? 'xhigh' : 'high';
-        reason = 'risk_guardian_lane';
-    }
-    else if (/(integrator|architect|verifier)/i.test([role, agentId, persona.stable_id].join(' ')) && effort === 'low') {
-        effort = 'medium';
-        reason = 'planning_verification_minimum';
-    }
-    else if (input.readonly === true && SIMPLE_SIGNAL_RE.test(prompt) && !HIGH_SIGNAL_RE.test(text) && !MEDIUM_SIGNAL_RE.test(text)) {
-        effort = 'low';
-        reason = 'read_only_simple_slice';
-    }
-    else if (/implementer/i.test(role) && effort === 'xhigh') {
-        effort = 'high';
-        reason = 'implementation_lane_capped_at_high';
-    }
-    const modelDecision = decideAgentWorkerModel({ effort, prompt, role, agentId, readonly: input.readonly === true || persona.read_only === true, writePolicy: String(persona.write_policy || '') });
-    const modelCapability = codexModelEffortCapability({ model: modelDecision.model, defaultEffort: modelDecision.model_reasoning_effort });
-    return {
-        schema: 'sks.agent-effort-decision.v1',
-        policy_version: 1,
-        agent_id: agentId,
-        role,
-        model: modelDecision.model,
-        reasoning_effort: effort,
-        model_reasoning_effort: modelDecision.model_reasoning_effort,
-        model_tier: modelDecision.model_tier,
-        model_profile: modelDecision.model_profile,
-        model_selection_reason: modelDecision.reason,
-        model_effort_capability: modelCapability,
-        reasoning_profile: reasoningProfileName(effort),
-        service_tier: 'fast',
-        reason,
-        dynamic: true,
-        escalation_triggers: [
-            'DB/security/release/schema risk detected',
-            'lease conflict or proof blocker appears',
-            'verification fails or output schema validation fails',
-            'user requests real backend or broader agent fan-out'
-        ],
-        downshift_triggers: [
-            'read-only simple docs/copy slice',
-            'mock fixture backend with no risky file ownership',
-            'agent assigned narrow inventory-only work'
-        ]
-    };
+    return decideOfficialSubagentModel(input);
 }
 export function decideOfficialSubagentModel(input = {}) {
     const persona = input.persona || {};
@@ -104,7 +45,7 @@ export function decideOfficialSubagentModel(input = {}) {
             downshift_triggers: [
                 'ordinary UI, logic, backend, or native implementation selects Astra High',
                 'long-context, Browser/Chrome, Computer Use, image-generation, or large search selects Astra Medium',
-                'tiny short-context mechanical search/typing/rename work selects Luna Max'
+                'tiny short-context mechanical search/typing/rename work selects Astra Low'
             ]
         };
     }
@@ -158,7 +99,7 @@ export function decideOfficialSubagentModel(input = {}) {
         downshift_triggers: [
             'ordinary UI, logic, backend, or native implementation selects Astra High',
             'long-context, Browser/Chrome, Computer Use, or image-generation execution selects Astra Medium',
-            'tiny short-context mechanical work selects Luna Max'
+            'tiny short-context mechanical work selects Astra Low'
         ]
     };
 }
@@ -177,101 +118,41 @@ export function buildAgentEffortPolicy(roster = {}) {
         reason: agent.reasoning_reason,
         dynamic: true
     })) : [];
-    const narutoFamilyOnly = decisions.length > 0 && decisions.every((decision) => isNarutoGpt56Model(decision.model));
     return {
         schema: 'sks.agent-effort-policy.v1',
         policy_version: 1,
         dynamic: true,
         service_tier: 'fast',
-        model_catalog_policy: narutoFamilyOnly ? 'official_subagent_four_profile_matrix' : 'codex_catalog_passthrough',
-        model_constraint: narutoFamilyOnly ? ['gpt-5.6-luna', 'gpt-6-astra'] : null,
-        model_tiers: narutoFamilyOnly
-            ? ['gpt-5.6-luna-max', 'gpt-6-astra-high', 'gpt-6-astra-max', 'gpt-6-astra-medium']
-            : ['codex-selected-low', 'codex-selected-medium', 'codex-selected-high', 'codex-selected-xhigh', 'glm-5.2-minimal', 'glm-5.2-low', 'glm-5.2-high', 'glm-5.2-xhigh'],
-        allowed_efforts: narutoFamilyOnly ? ['medium', 'high', 'max'] : codexModelEffortCapability().advertised_efforts,
-        model_effort_capability: codexModelEffortCapability(),
+        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}`),
+        allowed_efforts: ['low', 'medium', 'high', 'max'],
+        model_effort_capability: codexModelEffortCapability({ model: ASTRA_SUBAGENT_MODEL }),
         max_agents: roster.max_agents || 20,
         agent_count: roster.agent_count || decisions.length,
         concurrency: roster.concurrency || decisions.length,
         decisions,
-        rule: narutoFamilyOnly
-            ? 'Official Naruto subagents use GPT-5.6 Luna Max only for tiny short-context mechanical work, GPT-6 Astra High for ordinary implementation, GPT-6 Astra Max for judgment-heavy work, and GPT-6 Astra Medium for long-context or Browser/Chrome, Computer Use, and image-generation execution. Judgment wins when one slice cannot be safely split.'
-            : 'Codex/OpenAI workers inherit the current Codex-selected model, including future catalog entries; SKS changes only advertised reasoning effort. Explicit non-Codex provider modes retain their provider model.'
+        rule: 'All child agents use GPT-6 Astra: Low for tiny short-context mechanical work, Medium for reads and tool execution, High for ordinary implementation, and Max for focused judgment. The parent keeps its user-selected model.'
     };
 }
 export function reasoningProfileName(effort) {
     return 'sks-agent-' + String(effort || 'medium') + '-fast';
 }
-function promptEffort(text) {
-    if (XHIGH_SIGNAL_RE.test(text))
-        return 'xhigh';
-    if (HIGH_SIGNAL_RE.test(text))
-        return 'high';
-    if (SIMPLE_SIGNAL_RE.test(text) && !MEDIUM_SIGNAL_RE.test(text))
-        return 'low';
-    if (MEDIUM_SIGNAL_RE.test(text))
-        return 'medium';
-    return 'medium';
-}
-function effortReason(effort) {
-    if (effort === 'xhigh')
-        return 'frontier_or_forensic_signal';
-    if (effort === 'high')
-        return 'safety_release_db_schema_signal';
-    if (effort === 'low')
-        return 'simple_bounded_slice';
-    return 'default_orchestration_slice';
-}
 export function decideAgentWorkerModel(input = {}) {
-    const mainModel = String(input.mainModel || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || '').trim();
-    const glmMain = isGlmWorkerMode(mainModel);
-    const effort = String(input.effort || 'medium');
-    const text = [input.prompt, input.role, input.agentId, input.writePolicy].map((item) => String(item || '')).join(' ');
-    const simpleText = [input.prompt, input.role, input.agentId].map((item) => String(item || '')).join(' ');
-    const risky = HIGH_SIGNAL_RE.test(text) || XHIGH_SIGNAL_RE.test(text);
-    const simple = SIMPLE_CODE_MOD_RE.test(simpleText) && !HIGH_SIGNAL_RE.test(simpleText) && !XHIGH_SIGNAL_RE.test(simpleText);
-    if (glmMain) {
-        const openRouterEffort = openRouterWorkerEffort({ effort, risky, simple });
-        return {
-            model: OPENROUTER_DEFAULT_MODEL,
-            model_reasoning_effort: openRouterEffort,
-            model_tier: `glm-5.2-${openRouterEffort === 'none' ? 'minimal' : openRouterEffort}`,
-            model_profile: desktopBridgeOpenRouterProfile(openRouterEffort),
-            reason: `desktop_bridge_openrouter_${openRouterEffort}_worker`
-        };
-    }
-    const modelEffort = risky || effort === 'high' || effort === 'xhigh'
-        ? 'high'
-        : simple || effort === 'low'
-            ? 'low'
-            : 'medium';
-    const modelLabel = mainModel || 'codex-selected';
+    const decision = decideOfficialSubagentModel({
+        persona: { role: String(input.role || ''), write_policy: String(input.writePolicy || '') },
+        prompt: String(input.prompt || ''),
+        agentId: String(input.agentId || 'agent'),
+        readonly: input.readonly === true
+    });
     return {
-        model: mainModel,
-        model_reasoning_effort: modelEffort,
-        model_tier: `${modelLabel}-${modelEffort}`,
-        model_profile: `sks-agent-${safeProfileSegment(modelLabel)}-${modelEffort}-fast`,
-        reason: mainModel ? 'explicit_model_preserved' : 'codex_catalog_model_inherited'
+        model: decision.model,
+        model_reasoning_effort: decision.model_reasoning_effort,
+        model_tier: decision.model_tier,
+        model_profile: decision.model_profile,
+        reason: decision.model_selection_reason
     };
 }
 function safeProfileSegment(value) {
     return String(value || 'codex-selected').toLowerCase().replace(/[^a-z0-9.-]+/g, '-').replace(/^-+|-+$/g, '') || 'codex-selected';
 }
-function isGlmWorkerMode(mainModel) {
-    const model = String(mainModel || '').trim().toLowerCase();
-    return model === OPENROUTER_DEFAULT_MODEL
-        || model === 'glm-5.2'
-        || model === 'glm5.2';
-}
-function openRouterWorkerEffort(input) {
-    if (input.effort === 'xhigh')
-        return 'xhigh';
-    if (input.risky || input.effort === 'high')
-        return 'high';
-    if (input.simple || input.effort === 'low')
-        return 'minimal';
-    return 'low';
-}
-function desktopBridgeOpenRouterProfile(effort) {
-    return `desktop-bridge-openrouter-${effort}`;
-}

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

@@ -1925,12 +1925,12 @@ function buildProvidedAgentRoster(input, opts = {}) {
             index: index + 1,
             write_policy: String(entry.write_policy || (readOnly ? 'read-only' : 'route-local-artifact')),
             status: 'pending',
-            model: entry.model || modelDecision.model,
+            model: modelDecision.model,
             reasoning_effort: reasoningEffort,
             model_reasoning_effort: modelReasoningEffort,
-            model_tier: entry.model_tier || modelDecision.model_tier,
-            model_profile: entry.model_profile || modelDecision.model_profile,
-            model_selection_reason: entry.model_selection_reason || modelDecision.reason,
+            model_tier: modelDecision.model_tier,
+            model_profile: modelDecision.model_profile,
+            model_selection_reason: modelDecision.reason,
             reasoning_profile: entry.reasoning_profile || (readOnly ? 'sks-logic-high' : 'sks-logic-medium'),
             service_tier: entry.service_tier,
             reasoning_reason: entry.reasoning_reason || 'route_native_agent_plan',

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

@@ -10,7 +10,7 @@ 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 { readConfiguredCodexModelRoutingContext } from '../codex-app/codex-model-catalog.js';
+import { ASTRA_SUBAGENT_MODEL, decideSubagentModel } from '../subagents/model-policy.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);
@@ -227,22 +227,8 @@ export async function resolveWorkerModelRouting(input, deps = {}) {
     const riskText = [taskKindText, input.slice?.risk, input.slice?.risk_focus, input.slice?.acceptance, input.slice?.parent_prompt, input.slice?.description, input.intake?.prompt].map((value) => String(value || '')).join(' ');
     const category = categoryForWorkerRole(String(input.agent?.role || 'executor'), taskKindText);
     const env = deps.env || process.env;
-    const configuredRouting = !Object.prototype.hasOwnProperty.call(deps, 'env') || env.CODEX_HOME || env.HOME
-        ? await readConfiguredCodexModelRoutingContext({ env }).catch(() => null)
-        : null;
-    const sealedPlanModel = ['user_role_model_preference', 'active_main_model'].includes(String(input.agent?.routed_model_policy || ''))
-        ? String(input.agent?.routed_model || '').trim()
-        : '';
-    const configuredMainModel = String(input.intake?.main_model
-        || input.intake?.selected_model
-        || input.intake?.provider_model
-        || configuredRouting?.selected_model
-        || '').trim();
-    const managedAgentModel = String(input.agent?.model || '').trim();
-    const inheritedModel = sealedPlanModel || configuredMainModel || managedAgentModel;
-    const providerModelSelected = Boolean(sealedPlanModel || configuredMainModel);
     const lbHealth = Object.prototype.hasOwnProperty.call(deps, 'lbHealth') ? deps.lbHealth : await readLbHealth().catch(() => null);
-    const lbCatalog = narutoOnly && !providerModelSelected
+    const lbCatalog = narutoOnly
         ? Object.prototype.hasOwnProperty.call(deps, 'lbCatalog')
             ? deps.lbCatalog
             : input.intake?.naruto_model_catalog || await readCodexLbModelCatalog().catch(() => null)
@@ -255,35 +241,31 @@ 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 inheritedReasoning = normalizeModelReasoning(sealedPlanModel
-        ? input.agent?.routed_model_reasoning_effort
-        : input.agent?.model_reasoning_effort);
-    const routed = providerModelSelected
-        ? {
-            model: inheritedModel,
-            reasoning: explicitReasoning || inheritedReasoning || 'medium',
+    const savedAstraEffort = input.agent?.routed_model_policy === 'user_role_model_preference'
+        && input.agent?.routed_model === ASTRA_SUBAGENT_MODEL
+        ? normalizeModelReasoning(input.agent?.routed_model_reasoning_effort)
+        : null;
+    const taskPolicy = decideSubagentModel({ title: taskKindText, description: riskText, role: input.agent?.role });
+    const routed = narutoOnly
+        ? await routeModel(category, {
+            lbHealth,
+            narutoOnly: true,
+            taskText: taskKindText,
+            riskText,
+            reasoningEffort: savedAstraEffort,
+            availableModels: lbCatalog?.models || [],
+            availableModelEfforts: lbCatalog?.model_efforts || {},
+            ...(explicitModel ? { model: explicitModel } : {})
+        })
+        : {
+            model: ASTRA_SUBAGENT_MODEL,
+            reasoning: explicitReasoning || savedAstraEffort || taskPolicy.modelReasoningEffort,
             serviceTier: explicitTier || input.fastModePolicy.service_tier || 'fast'
-        }
-        : explicitModel && !narutoOnly
-            ? {
-                model: explicitModel,
-                reasoning: explicitReasoning || inheritedReasoning || 'medium',
-                serviceTier: explicitTier || input.fastModePolicy.service_tier || 'fast'
-            }
-            : await routeModel(category, {
-                lbHealth,
-                ...(narutoOnly ? {
-                    narutoOnly: true,
-                    taskText: taskKindText,
-                    riskText,
-                    availableModels: lbCatalog?.models || [],
-                    availableModelEfforts: lbCatalog?.model_efforts || {},
-                    ...(explicitModel ? { model: explicitModel } : {})
-                } : { model: inheritedModel || null })
-            });
+        };
     const blockers = [
-        ...(narutoOnly && !providerModelSelected && !lbCatalog?.ok ? (lbCatalog?.blockers || ['codex_lb_model_catalog_unavailable']) : []),
+        ...(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'] : []),
         ...(explicitNarutoReasoningInvalid ? ['naruto_reasoning_override_invalid'] : []),
         ...(explicitNarutoTierInvalid ? ['naruto_service_tier_override_invalid'] : []),
         ...(narutoOnly && explicitReasoning && explicitReasoning !== routed.reasoning ? ['naruto_reasoning_override_conflicts_with_policy'] : []),
@@ -293,12 +275,12 @@ export async function resolveWorkerModelRouting(input, deps = {}) {
     return {
         category,
         choice: routed,
-        explicit: Boolean(explicitModel || providerModelSelected),
+        explicit: Boolean(explicitModel),
         lb_health: lbHealth,
         lb_catalog: lbCatalog,
         blockers: [...new Set(blockers)],
         reason: modelRouteReason(category, routed, {
-            explicit: Boolean(explicitModel || providerModelSelected),
+            explicit: Boolean(explicitModel),
             quotaLow: lbHealth?.quota_low === true,
             degraded: lbHealth?.degraded_models || []
         })

package/dist/core/codex-compat/codex-hook-output-builders.js

@@ -13,7 +13,6 @@ export function buildPreToolUseContinue(options = {}) {
 export function buildPreToolUseDeny(reason, options = {}) {
     const trimmed = requiredReason(reason, 'PreToolUse deny requires a non-empty reason');
     return withOptionalSystemMessage({
-        continue: true,
         hookSpecificOutput: {
             hookEventName: 'PreToolUse',
             permissionDecision: 'deny',

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

@@ -14,7 +14,7 @@ const CORE_SKILL_DEFINITIONS = [
         route: '$Naruto',
         purpose: 'run a Codex official subagent workflow with official agent threads while parent integration remains owner.',
         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 Luna/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. Route tiny mechanical and mass shards to Luna Max, broad search and exploration shards to Astra Medium, implementation to Astra High, and judgment to Astra Max; 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.',
+        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, implementation to Astra High, and judgment to Astra Max; 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.',

package/dist/core/hooks-runtime/hook-context.js

@@ -19,7 +19,7 @@ const OFFICIAL_SUBAGENT_SPAWN_COMPATIBILITY_CONTEXT = [
     'SKS Codex 0.145 official-subagent spawn compatibility:',
     '- Full-history forks (`fork_turns="all"`, including the omitted/default full-history mode) inherit the parent agent type, model, and reasoning effort.',
     '- When selecting a custom `agent_type` or overriding `model`/`reasoning_effort`, set `fork_turns="none"` or a positive bounded turn count and put the complete bounded slice contract in `message`.',
-    '- Use a full-history fork only when `agent_type`, `model`, and `reasoning_effort` are all omitted.'
+    '- SKS children must use explicit `model=\"gpt-6-astra\"`, task-appropriate `reasoning_effort`, and `fork_turns=\"none\"` or a positive bounded turn count. Do not use omitted/default or full-history forks, which can inherit a non-Astra parent.'
 ].join('\n');
 export function officialSubagentSpawnCompatibilityContext() {
     return OFFICIAL_SUBAGENT_SPAWN_COMPATIBILITY_CONTEXT;

package/dist/core/hooks-runtime/subagent-context.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { readJson } from '../fsx.js';
 import { managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
+import { ASTRA_SUBAGENT_MODEL } from '../subagents/model-policy.js';
 export async function sealedSubagentRoutingContext(artifactDir, payload = {}) {
     const plan = await readJson(path.join(artifactDir, 'subagent-plan.json'), null).catch(() => null);
     if (!plan || plan.workflow !== 'official_codex_subagent')
@@ -9,10 +10,13 @@ export async function sealedSubagentRoutingContext(artifactDir, payload = {}) {
     const agents = plan.agents && typeof plan.agents === 'object' ? plan.agents : {};
     const planned = agentName && agents[agentName] ? agents[agentName] : null;
     const role = agentName ? managedOfficialSubagentRoleByName(agentName) : null;
-    const model = String(planned?.routed_model || planned?.model || role?.model || '').trim();
-    const effort = String(planned?.routed_model_reasoning_effort || planned?.model_reasoning_effort || role?.model_reasoning_effort || '').trim();
-    if (!agentName && !model)
+    if (!agentName)
         return '';
+    const model = ASTRA_SUBAGENT_MODEL;
+    const plannedModel = String(planned?.routed_model || planned?.model || '').trim();
+    const effort = String((plannedModel === ASTRA_SUBAGENT_MODEL
+        ? planned?.routed_model_reasoning_effort || planned?.model_reasoning_effort
+        : null) || role?.model_reasoning_effort || 'medium').trim();
     return [
         'SKS sealed child routing:',
         agentName ? `- custom agent: ${agentName}` : null,

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

@@ -0,0 +1,15 @@
+import { ASTRA_SUBAGENT_MODEL } from '../subagents/model-policy.js';
+const SPAWN_TOOLS = new Set(['spawn_agent', 'collaboration.spawn_agent', 'functions.spawn_agent']);
+export function subagentSpawnPolicyBlockReason(payload = {}) {
+    const name = String(payload.tool_name || payload.toolName || payload.tool?.name || '');
+    if (!SPAWN_TOOLS.has(name))
+        return null;
+    const input = payload.tool_input || payload.toolInput || payload.tool?.input || {};
+    if (input.model !== ASTRA_SUBAGENT_MODEL) {
+        return 'SKS children must use gpt-6-astra. Retry spawn_agent with model="gpt-6-astra", task-appropriate reasoning_effort, and fork_turns="none" or a positive bounded turn count. Include the complete slice contract in message; do not inherit the parent model.';
+    }
+    if (input.fork_turns !== 'none' && !/^[1-9]\d*$/.test(String(input.fork_turns || ''))) {
+        return 'SKS Astra child spawns require fork_turns="none" or a positive bounded turn count. Retry with the complete slice contract in message; full-history/default forks cannot carry an explicit child model.';
+    }
+    return null;
+}

package/dist/core/hooks-runtime.js

@@ -29,6 +29,7 @@ import { activeNarutoParentLaunchMissionId, claimStandaloneParentHostCapabilityR
 import { classifyTaskProfile } from './runtime/task-profile.js';
 import { resolveSubagentThreadBudget } from './subagents/thread-budget.js';
 import { readOfficialSubagentConfig } from './subagents/official-subagent-config.js';
+import { subagentSpawnPolicyBlockReason } from './hooks-runtime/subagent-spawn-policy.js';
 import { withFileLock } from './locks/file-lock.js';
 import { ensureConfinedDirectory, inspectConfinedPath, removeManagedPathVerified } from './managed-path-safety.js';
 import { buildBoundWaveParentGuidance, renderWaveParentGuidance } from './subagents/wave-parent-guidance.js';
@@ -165,7 +166,7 @@ async function hookSubagentStart(root, state, payload = {}, sessionKey = null) {
         : '';
     const resourceGuard = skillGuardBinding ? [
         `SKS Naruto policy: max_threads frame budget is ${budget.maxThreads} (cap, not a spawn target).`,
-        'GPT-5.6 four profiles are routing lanes, not an agent-count cap.',
+        'All children use gpt-6-astra; low/medium/high/max are effort lanes, not an agent-count cap.',
         'Use max_depth=1. Naruto children must not spawn children.',
         'Do not duplicate an already assigned slice.',
         'Parallel writes require disjoint paths; serialize overlapping paths.',
@@ -571,6 +572,9 @@ async function consumeActiveOfficialWorkflowQueue(root, missionId, workflowRunId
     }
 }
 async function hookPreTool(root, state, payload, noQuestion, sessionKey = null) {
+    const spawnPolicyBlock = subagentSpawnPolicyBlockReason(payload);
+    if (spawnPolicyBlock)
+        return { decision: 'block', permissionDecision: 'deny', reason: spawnPolicyBlock };
     const artifactDir = officialSubagentArtifactDir(root, state, sessionKey);
     const activeBinding = officialSubagentSkillGuardBinding(state, { allowClosedOfficialChild: true });
     let skillAvailabilityBlock = null;

package/dist/core/init/skills.js

@@ -66,7 +66,7 @@ async function installOfficialSkills(root) {
         'help': `---\nname: help\ndescription: Dollar-command route for $Help or $help explaining installed SKS commands and workflows.\n---\n\nUse when the user invokes $Help/$help or asks what commands exist. Prefer concise output from sks commands, sks usage <topic>, sks quickstart, sks aliases, and sks codex-app.\n`,
         'prompt-pipeline': `---\nname: prompt-pipeline\ndescription: Default SKS prompt routing for execution requests; Answer and DFix remain lightweight.\n---\n\nClassify only the route and the constraints that change execution. Answer handles real information requests; DFix handles tiny copy/config/docs/labels/spacing/translation/mechanical edits; general work stays parent-owned and uses Naruto only for explicit parallel work or concrete independent slices. Preserve the literal user request; TriWiki may enrich it but never replace an explicit requirement. ${coreEngineeringDirectiveReferenceText()} For code work, identify the requested outcome, actual code/data flow, exact write scope, acceptance criteria, and the smallest meaningful verification. Load route-specific Design, PPT, image, browser, research, DB, release, or Context7 rules only when that route or external contract requires them. Materialize pipeline-plan.json with route, scopes, verification, and blockers, then finish the requested work instead of stopping at the plan.\n`,
         [SOLUTION_SCOUT_SKILL_NAME]: `---\nname: ${SOLUTION_SCOUT_SKILL_NAME}\ndescription: Optional source scout for fixes that materially depend on external precedent.\n---\n\nUse only when the user asks for similar cases or when a package, API, platform, or externally documented behavior makes outside precedent materially useful. Search with the concrete symptom and current stack, prefer primary sources, and keep the local code path authoritative. Do not add this step to ordinary local bugfixes. If external evidence is unavailable, record that gap instead of inventing a workaround.\n`,
-        'reasoning-router': `---\nname: reasoning-router\ndescription: Inspect task reasoning hints while preserving the user's selected Codex settings.\n---\n\nUse the active Codex model catalog for supported reasoning efforts. GPT-6 Astra does not support none/minimal; use low when migrating those efforts, and preserve other supported choices. Task hints are advisory: do not override the selected model, effort, or service tier or persist profile changes without a request. Inspect with sks reasoning and sks pipeline status. Keep the Luna/Astra child role defaults when the parent uses Astra.\n`,
+        'reasoning-router': `---\nname: reasoning-router\ndescription: Inspect task reasoning hints while preserving the user's selected Codex settings.\n---\n\nUse the active Codex model catalog for supported reasoning efforts. GPT-6 Astra does not support none/minimal; use low when migrating those efforts, and preserve other supported choices. Task hints are advisory: do not override the selected model, effort, or service tier or persist profile changes without a request. Inspect with sks reasoning and sks pipeline status. Every child uses gpt-6-astra independently of the parent model; vary only effort by task.\n`,
         'pipeline-runner': `---\nname: pipeline-runner\ndescription: Execute SKS routes with bounded state and evidence.\n---\n\nEvery $ command selects a route. Use current.json, mission artifacts, and pipeline-plan.json as bounded execution state; load only the selected route skill. ${coreEngineeringDirectiveReferenceText()} Codex native /goal is the only persisted goal owner. Use official Codex subagents only when the route requires independent slices, keep parent-owned integration, use bounded TriWiki context, fetch current external docs only when relevant, record real blockers, and finish with a completion summary that states what was verified and what remains. Reflection and Honest Mode sections are strict-profile requirements only.\n`,
         'context7-docs': `---\nname: context7-docs\ndescription: Enforce Context7 MCP documentation evidence for SKS routes that depend on external libraries, frameworks, APIs, MCPs, package managers, DB SDKs, or generated docs.\n---\n\nWhen required, resolve-library-id, then query-docs for the resolved id. Legacy get-library-docs evidence is accepted. Prefer sks context7 tools/resolve/docs/evidence and finish only after both evidence stages exist. Check setup with sks context7 check.\n`,
         'super-search': `---\nname: super-search\ndescription: Dollar-command route for $Super-Search provider-independent source intelligence.\n---\n\nUse when the user invokes $Super-Search or asks for Super-Search source intelligence, source acquisition, X-search-style collection, URL acquisition, source normalization, claim ledgers, or citation proof. Prefer \`sks super-search doctor --json\` for readiness and \`sks super-search run "<query>" --mode balanced --json\` for provider-independent source proof; use \`sks super-search x "<query>" --json\` for X-search intent and \`sks super-search fetch "<url>" --json\` for URL acquisition. Context7 is required only when the query depends on current package/API/framework/MCP/generated documentation behavior. Provider-specific credentials are optional and must not be required for route readiness. Evidence/artifacts remain under \`.sneakoscope/missions/<super-search-* or route mission>/super-search/\`: intent.json, axes.json, query-variants.json, provider-plan.json, source-ledger.json, lead-ledger.json, claim-ledger.json, attempt-ledger.json, synthesis.md, super-search-proof.json, super-search-gate.json, and super-search-result.json. Do not turn weak discovery into supported claims; finish with an Honest Mode summary of verified sources, blockers, and unverified external coverage.\n`,

package/dist/core/init.js

@@ -276,9 +276,9 @@ const AGENTS_BLOCK = [
     '- Codex native `/goal` is the only persisted goal owner. Goal objectives must state the outcome, scope, constraints, verification, done-when conditions, stop conditions, and non-goals.',
     '- General work stays parent-owned. Use `$Naruto` for explicitly requested parallel work or concrete independent slices that benefit from delegation; Answer and tiny DFix work stay lightweight.',
     '- The parent owns decomposition, integration, verification, and the final answer. Delegate only independent slices with disjoint write scopes, reuse capacity across root-owned waves, and never nest subagents.',
-    '- Route model by the slice: Luna Max for tiny mechanical work, Astra High for implementation, Astra Medium for read-heavy context or direct tool operation, and Astra Max only for focused judgment, risk, or final review.',
-    '- Preserve the user-selected parent model, reasoning effort, and service tier. SKS-launched Naruto defaults to GPT-6 Astra; changing the parent does not replace the child role models.',
-    '- Codex 0.145 spawn compatibility: a full-history fork (`fork_turns="all"`, including the omitted/default mode) inherits the parent agent type, model, and reasoning effort. When selecting a custom `agent_type` or overriding `model`/`reasoning_effort`, use `fork_turns="none"` or a positive bounded turn count and carry the complete bounded slice contract in `message`; use full history only with those overrides omitted.',
+    '- Use gpt-6-astra for every subagent; vary reasoning effort by the slice: Astra Low for tiny mechanical work, Astra High for implementation, Astra Medium for read-heavy context or direct tool operation, and Astra Max only for focused judgment, risk, or final review.',
+    '- Preserve the user-selected parent model, reasoning effort, and service tier. SKS-launched Naruto defaults to GPT-6 Astra; parent settings and role preferences never override the sealed Astra child profiles.',
+    '- SKS child spawns must explicitly set model="gpt-6-astra" and the role reasoning effort with `fork_turns="none"` or a positive bounded turn count; carry the complete bounded slice contract in `message`. Never use full-history inheritance for children.',
     '- Route-specific skills own route-specific details. Do not inject unrelated Design, PPT, image, browser, research, DB, or release policy into ordinary work.',
     '- Do not stop at a plan when implementation was requested. Finish and verify, or report a concrete hard blocker.',
     '- User instructions outrank skill guidance. Infer routine details, honor authorization already provided, and finish authorized preparation before asking for a decision that changes scope or has irreversible effects.',
@@ -1120,7 +1120,7 @@ export function codexAppQuickReference(scope, commandPrefix) {
         'dollar-commands:',
         ...currentDollarCommands().map((c) => `- \`${sksPrefixedDollarCommand(c.command)}\`: ${c.route}`),
         'Routing: Answer is read-only, DFix handles tiny edits, and general work stays parent-owned. Use Naruto for explicit parallel work or independent slices that benefit from delegation.',
-        'Subagent context: Codex 0.145 full-history forks (`fork_turns="all"`, including the default) inherit agent type/model/reasoning. Custom `agent_type` or model/reasoning overrides must use `fork_turns="none"` or a positive bounded turn count, with the complete bounded slice contract in `message`.',
+        'Subagent context: explicitly set model="gpt-6-astra" and the role reasoning effort with `fork_turns="none"` or a positive bounded turn count. Pass the complete bounded slice contract in `message`; never inherit the parent model or apply a role-model preference.',
         'Goal: Codex native /goal is the only persisted goal owner; no SKS Goal mission, bridge, compatibility loop, or fallback state is allowed.',
         `Context: use bounded TriWiki recall, refresh after material changes, validate before handoff/final, and use Context7 or official vendor docs when external contracts or versions matter.`,
         'Completion: report the result, actual verification, and remaining gaps once. Reflection and Honest Mode are optional unless explicitly requested or required by the strict profile.',

package/dist/core/managed-assets/managed-assets-manifest.js

@@ -22,7 +22,7 @@ export const MANAGED_OFFICIAL_SUBAGENT_ROLES = Object.freeze([
         filename: 'worker.toml',
         aliases: ['worker'],
         codexName: 'worker',
-        description: 'Luna Max execution subagent only for tiny, short-context, mechanical work with an explicit done condition.',
+        description: 'Astra Low execution subagent only for tiny, short-context, mechanical work with an explicit done condition.',
         policy: 'luna_max_mechanical',
         keywords: ['tiny', 'short context', 'single file', 'mechanical', 'repeatable', 'exact rename', 'format only', 'typo', 'simple search', 'typing', '단순 검색', '타이핑'],
         nicknames: ['Kite', 'Moss', 'Pico', 'Reed', 'Vale', 'Wren'],
@@ -93,7 +93,7 @@ Return a concise result, evidence, risks, and next action.`
         instructions: `You are the read-only code explorer.
 
 Map only the code paths relevant to the assigned question.
-Prefer targeted search and exact symbol references, but use this role for repository-wide or long-context scans that would be unsafe for Luna.
+Prefer targeted search and exact symbol references, but use this role for repository-wide or long-context scans that would be unsuitable for tiny mechanical slices.
 Identify entry points, state transitions, owners, and evidence gaps.
 Do not propose a broad redesign and do not edit files.
 Return concise findings with exact paths and symbols.`