sneakoscope 7.1.0 → 7.3.0

package/dist/core/agent-guidance/directive-registry.js

@@ -0,0 +1,123 @@
+export const CANONICAL_DIRECTIVES = [
+    {
+        id: 'solid',
+        statement: 'Follow SOLID: one responsibility per unit, depend on abstractions, extend rather than edit, and reuse instead of duplicating.',
+        subsumes: [
+            /\bmodular(ise|ize|ity)?\b/i,
+            /\breusab(le|ility)\b/i,
+            /\bavoid duplicat/i,
+            /\bdon'?t repeat yourself\b|\bDRY\b/i,
+            /\bkeep (?:functions|modules|files|classes) small\b/i,
+            /\bsingle responsibility\b/i,
+            /\bloose(ly)? coupl/i,
+            /\bseparation of concerns\b/i
+        ]
+    },
+    {
+        id: 'self-documenting',
+        statement: 'Write code that reads without commentary; comment only what the code cannot state itself.',
+        subsumes: [
+            /\badd comments?\b/i,
+            /\bcomment your code\b/i,
+            /\bdocument (?:everything|all|each) (?:function|method|class)/i,
+            /\bwrite (?:jsdoc|docstrings?)\b/i
+        ]
+    },
+    {
+        id: 'managed-block',
+        statement: 'Preserve user-authored content outside managed blocks.',
+        subsumes: [/\bpreserve user-authored content\b/i, /\bdo not (?:edit|touch) user content\b/i]
+    },
+    {
+        id: 'hydrate',
+        statement: 'Hydrate TriWiki/current source before risky edits, and treat a directory marked `Risk: high` as always risky.',
+        subsumes: [/\bhydrate triwiki\b/i, /\bread (?:the )?current source before edit/i]
+    },
+    {
+        id: 'owner-scope',
+        statement: 'Follow the conventions of the directory you are editing and keep every change owner-scoped.',
+        subsumes: [/\buse local source conventions\b/i, /\bowner-scoped\b/i, /\bmatch (?:the )?surrounding (?:code|style)\b/i]
+    },
+    {
+        id: 'proportionate-effort',
+        statement: 'Do the smallest change that solves the request, and test the failures a real defect would produce — exhaustive cases are owed only where money moves.',
+        subsumes: [
+            /\bdo not over-?engineer\b/i,
+            /\bkeep it simple\b|\bKISS\b/i,
+            /\bYAGNI\b|\byou aren'?t gonna need it\b/i,
+            /\bavoid (?:premature|speculative) (?:abstraction|optimi[sz]ation|generali[sz]ation)\b/i,
+            /\bwrite (?:more|exhaustive|comprehensive) tests\b/i,
+            /\btest every (?:branch|edge case|permutation)\b/i
+        ]
+    }
+];
+export function extractDirectives(text) {
+    const directives = [];
+    for (const raw of String(text || '').split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line.startsWith('- '))
+            continue;
+        const body = line.slice(2).trim();
+        if (!body)
+            continue;
+        if (/^(files|files observed|languages|generated|local anchors|risk)\b\s*:/i.test(body))
+            continue;
+        if (!/\s/.test(body))
+            continue;
+        directives.push(body.replace(/^guidance:\s*/i, ''));
+    }
+    return directives;
+}
+function canonicalFor(directive) {
+    for (const canonical of CANONICAL_DIRECTIVES) {
+        if (canonical.statement.toLowerCase() === directive.toLowerCase())
+            continue;
+        if (canonical.subsumes.some((pattern) => pattern.test(directive)))
+            return canonical;
+    }
+    return null;
+}
+export function analyzeAgentGuidance(files, opts = {}) {
+    const seen = new Map();
+    const subsumed = [];
+    for (const file of files) {
+        const directives = extractDirectives(file.text);
+        const withinFile = new Map();
+        for (const directive of directives) {
+            const key = directive.toLowerCase();
+            seen.set(key, [...(seen.get(key) || []), file.path]);
+            const canonical = canonicalFor(directive);
+            if (canonical)
+                withinFile.set(directive, canonical);
+        }
+        const statements = new Set(directives.map((entry) => entry.toLowerCase()));
+        for (const [directive, canonical] of withinFile) {
+            const siblings = directives.filter((entry) => entry !== directive && canonicalFor(entry)?.id === canonical.id);
+            if (statements.has(canonical.statement.toLowerCase()) || siblings.length) {
+                subsumed.push({ path: file.path, directive, canonical: canonical.statement });
+            }
+        }
+    }
+    const repeated = [];
+    for (const [key, paths] of seen) {
+        const unique = [...new Set(paths)];
+        if (unique.length < 2)
+            continue;
+        if (opts.sharedScopePath && unique.length === 1 && unique[0] === opts.sharedScopePath)
+            continue;
+        repeated.push({ directive: key, paths: unique.sort() });
+    }
+    repeated.sort((a, b) => b.paths.length - a.paths.length);
+    const blockers = [
+        ...repeated.map((entry) => `agent_guidance_repeated:${entry.paths.length}:${entry.directive.slice(0, 60)}`),
+        ...subsumed.map((entry) => `agent_guidance_subsumed:${entry.path}:${entry.directive.slice(0, 60)}`)
+    ];
+    return {
+        schema: 'sks.agent-guidance-dedup.v1',
+        ok: blockers.length === 0,
+        files: files.length,
+        repeated,
+        subsumed,
+        blockers
+    };
+}

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

@@ -1,7 +1,8 @@
 import { codexModelEffortCapability } from '../codex-control/codex-model-capabilities.js';
 import { GLM_52_OPENROUTER_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 } from '../subagents/model-policy.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;
@@ -68,6 +69,45 @@ export function decideOfficialSubagentModel(input = {}) {
     const role = String(persona.role || '');
     const agentId = String(input.agentId || persona.id || 'subagent');
     const routingRole = [agentId, persona.naruto_role, persona.work_kind, role].filter(Boolean).join(' ');
+    const managedRole = managedOfficialSubagentRoleByName(agentId)
+        || managedOfficialSubagentRoleByName(String(persona.naruto_role || ''))
+        || managedOfficialSubagentRoleByName(role);
+    if (managedRole) {
+        const profile = subagentModelProfile(managedRole.model_policy);
+        const effort = profile.modelReasoningEffort;
+        const modelCapability = codexModelEffortCapability({
+            model: profile.model,
+            advertisedEfforts: [effort],
+            defaultEffort: effort
+        });
+        return {
+            schema: 'sks.agent-effort-decision.v1',
+            policy_version: 1,
+            agent_id: agentId,
+            role,
+            model: profile.model,
+            reasoning_effort: effort,
+            model_reasoning_effort: effort,
+            model_tier: `${profile.model}-${effort}`,
+            model_profile: `sks-official-subagent-${safeProfileSegment(profile.model)}-${effort}-fast`,
+            model_selection_reason: profile.policy,
+            model_effort_capability: modelCapability,
+            reasoning_profile: reasoningProfileName(effort),
+            service_tier: 'fast',
+            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 Sol Max',
+                '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: [
+                'ordinary UI, logic, backend, or native implementation selects Sol High',
+                'long-context, Browser/Chrome, Computer Use, image-generation, or large search selects Terra Medium',
+                'tiny short-context mechanical search/typing/rename work selects Luna Max'
+            ]
+        };
+    }
     const promptIsDocsExploration = /\b(?:read|scan|explore|compare|summarize|review)\b[^\n]{0,64}\b(?:docs?|documentation|manual|notes?|references?)\b/i.test(prompt);
     const promptIsFocusedJudgment = !promptIsDocsExploration
         && /^(?:\s*)(?:review|audit|debug(?:ger|ging)?|diagnos|investigat|plan|assess)\b|\b(?:security|database|release|production|high[- ]?risk)\b[^\n]{0,48}\b(?:review|audit|decision|plan|assessment)\b/i.test(prompt);
@@ -78,7 +118,9 @@ export function decideOfficialSubagentModel(input = {}) {
             ? 'implementation'
             : /(?:explorer|docs_maintainer|long_context_analyst|computer_use_operator|browser_use_operator|image_generation_operator)/i.test(routingRole)
                 ? 'context_tools'
-                : undefined;
+                : /\bworker\b/i.test(routingRole)
+                    ? 'mechanical'
+                    : undefined;
     const routed = decideSubagentModel({
         title: routingRole,
         description: [prompt, persona.risk_focus, persona.write_policy].filter(Boolean).join(' '),
@@ -219,10 +261,7 @@ function isGlmWorkerMode(mainModel) {
     const model = String(mainModel || '').trim().toLowerCase();
     return model === GLM_52_OPENROUTER_MODEL
         || model === 'glm-5.2'
-        || model === 'glm5.2'
-        || process.env.SKS_GLM_MODE === '1'
-        || process.env.SKS_GLM_WRAPPER_ACTIVE === '1'
-        || process.env.SKS_GLM_MAD_ACTIVE === '1';
+        || model === 'glm5.2';
 }
 function glmWorkerEffort(input) {
     if (input.effort === 'xhigh')

package/dist/core/agents/agent-worker-pipeline.js

@@ -2,6 +2,7 @@ import { AGENT_RESULT_SCHEMA, AGENT_WORKER_PIPELINE } from './agent-schema.js';
 import { normalizeAgentPatchEnvelope, validateAgentPatchEnvelope } from './agent-patch-schema.js';
 import { scanAgentTextForRecursion } from './agent-recursion-guard.js';
 import { validateAgentResultSchema, validateAndNormalizeAgentFollowUps } from './agent-output-validator.js';
+import { isRecord } from '../json/records.js';
 export function agentWorkerEnv(agent, allowedCommandsFile) {
     return {
         SKS_AGENT_WORKER: '1',
@@ -168,9 +169,6 @@ function normalizeLeaseCompliance(value) {
         violations: Array.isArray(value?.violations) ? value.violations : []
     };
 }
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
 function normalizeVerification(value) {
     return {
         status: String(value?.status || 'not_run'),

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

@@ -13,6 +13,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';
 export const NATIVE_WORKER_BACKEND_ROUTER_SCHEMA = 'sks.native-worker-backend-router.v1';
 export async function runNativeWorkerBackendRouter(input) {
     const root = path.resolve(input.agentRoot);
@@ -288,8 +289,22 @@ 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
+    const lbCatalog = narutoOnly && !providerModelSelected
         ? Object.prototype.hasOwnProperty.call(deps, 'lbCatalog')
             ? deps.lbCatalog
             : input.intake?.naruto_model_catalog || await readCodexLbModelCatalog().catch(() => null)
@@ -302,41 +317,50 @@ 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 routed = explicitModel && !narutoOnly
+    const inheritedReasoning = normalizeModelReasoning(sealedPlanModel
+        ? input.agent?.routed_model_reasoning_effort
+        : input.agent?.model_reasoning_effort);
+    const routed = providerModelSelected
         ? {
-            model: explicitModel,
-            reasoning: explicitReasoning || normalizeModelReasoning(input.agent?.model_reasoning_effort) || 'medium',
+            model: inheritedModel,
+            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: input.agent?.model || null })
-        });
+        : 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 && !lbCatalog?.ok ? (lbCatalog?.blockers || ['codex_lb_model_catalog_unavailable']) : []),
+        ...(narutoOnly && !providerModelSelected && !lbCatalog?.ok ? (lbCatalog?.blockers || ['codex_lb_model_catalog_unavailable']) : []),
         ...(explicitNarutoModelInvalid ? ['naruto_worker_model_outside_gpt_5_6_family'] : []),
         ...(explicitNarutoReasoningInvalid ? ['naruto_reasoning_override_invalid'] : []),
         ...(explicitNarutoTierInvalid ? ['naruto_service_tier_override_invalid'] : []),
         ...(narutoOnly && explicitReasoning && explicitReasoning !== routed.reasoning ? ['naruto_reasoning_override_conflicts_with_policy'] : []),
         ...(narutoOnly && explicitTier && explicitTier !== 'fast' ? ['naruto_service_tier_override_conflicts_with_policy'] : []),
-        ...(narutoOnly && !routed.model ? ['naruto_required_gpt_5_6_model_unavailable'] : [])
+        ...(narutoOnly && !routed.model ? ['naruto_worker_model_unavailable'] : [])
     ];
     return {
         category,
         choice: routed,
-        explicit: Boolean(explicitModel),
+        explicit: Boolean(explicitModel || providerModelSelected),
         lb_health: lbHealth,
         lb_catalog: lbCatalog,
         blockers: [...new Set(blockers)],
         reason: modelRouteReason(category, routed, {
-            explicit: Boolean(explicitModel),
+            explicit: Boolean(explicitModel || providerModelSelected),
             quotaLow: lbHealth?.quota_low === true,
             degraded: lbHealth?.degraded_models || []
         })

package/dist/core/auto-review.js

@@ -5,6 +5,7 @@ import { writeCodexConfigGuarded } from './codex/codex-config-guard.js';
 import { inspectConfinedPath, removeManagedPathVerified } from './managed-path-safety.js';
 import { RETIRED_AUTO_REVIEW_POLICY_TEXTS, RETIRED_SKS_CONFIG_PROFILE_NAMES } from './doctor/retired-auto-review-config.js';
 import { retiredGlmDesktopProfileBody } from './codex-app/openrouter-provider.js';
+import { escapeRegExp } from './text/regex.js';
 export { RETIRED_SKS_CONFIG_PROFILE_NAMES } from './doctor/retired-auto-review-config.js';
 export const AUTO_REVIEW_REVIEWER = 'auto_review';
 export const LEGACY_AUTO_REVIEW_REVIEWER = 'guardian_subagent';
@@ -435,9 +436,6 @@ function removeTopLevelStringIfValue(text, key, value) {
     }
     return `${lines.join('\n').replace(/\n{3,}/g, '\n\n').replace(/\s+$/, '')}\n`;
 }
-function escapeRegExp(value) {
-    return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
 function normalizeGeneratedProfileText(text) {
     return String(text || '')
         .split('\n')