sneakoscope 10.1.2 → 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.2**. 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 |
@@ -176,6 +177,7 @@ freshness semantics.
 - [Essential Trust](docs/essential-trust.md) — verification profiles and safety boundaries.
 - [Astra guidance](docs/astra-guidance.md) — how SKS applies the official model recommendations.
 - [Agent Bridge](docs/AGENT-BRIDGE.md) — integrate through the CLI or MCP interface.
+- [Codex-LB priority](docs/codex-lb-priority.md) — how Codex App WebSockets follow the Center priority setting.
 - [Release readiness](docs/release-readiness.md) — build, verify, and publish a release.
 - [Release evidence](docs/release-proof-truth.md) — what each verification result proves.
 - [Changelog](CHANGELOG.md) — changes by version.

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.2"
+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.2"
+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.2",
+  "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',