sneakoscope 6.0.2 → 6.0.3

package/dist/core/provider/model-router.js

@@ -4,16 +4,75 @@ const CATEGORY_POLICY = {
     agentic: { reasoning: 'high', serviceTier: 'fast' },
     ultrabrain: { reasoning: 'xhigh', serviceTier: 'standard' },
     verify: { reasoning: 'medium', serviceTier: 'fast' },
-    review: { reasoning: 'high', serviceTier: 'fast' }
+    review: { reasoning: 'high', serviceTier: 'fast' },
+    e2e: { reasoning: 'xhigh', serviceTier: 'fast' },
+    refactor: { reasoning: 'max', serviceTier: 'fast' },
+    strategy: { reasoning: 'max', serviceTier: 'fast' }
 };
+export const NARUTO_GPT56_MODELS = ['gpt-5.6-luna', 'gpt-5.6-terra', 'gpt-5.6-sol'];
+const NARUTO_LUNA_WORK_RE = /(e2e|end[-\s]?to[-\s]?end|test_execution|ux_review|browser|chrome|computer[-\s]?use|computer\s+use|gui|visual\s+(?:qa|test|check)|cross[-\s]?app|playwright|selenium|puppeteer|브라우저|컴퓨터\s*유즈|화면\s*검증)/i;
+const NARUTO_SOL_WORK_RE = /(refactor|re-?architect|architecture|architect|planning|\bplan\b|strategy|strategic|integrat|conflict[-_\s]?resolv|patch[-_\s]?rebase|rollback[-_\s]?plan|gpt[-_\s]?final|arbiter|리팩터|아키텍처|기획|전략|통합|충돌\s*해결|롤백\s*계획)/i;
+const NARUTO_MAX_WORK_RE = /(complex|critical|high[-\s]?risk|security|database|migration|release|publish|forensic|flaky|failure|cross[-\s]?app|multi[-\s]?step|복잡|고위험|보안|데이터베이스|마이그레이션|릴리즈|포렌식|실패)/i;
 export async function routeModel(category, opts = {}) {
+    if (opts.narutoOnly) {
+        return routeNarutoGpt56Model({
+            category,
+            ...(opts.taskText !== undefined ? { taskText: opts.taskText } : {}),
+            ...(opts.riskText !== undefined ? { riskText: opts.riskText } : {}),
+            ...(opts.model !== undefined ? { explicitModel: opts.model } : {}),
+            ...(opts.availableModels !== undefined ? { availableModels: opts.availableModels } : {}),
+            ...(opts.availableModelEfforts !== undefined ? { availableModelEfforts: opts.availableModelEfforts } : {}),
+            degradedModels: opts.lbHealth?.degraded_models || []
+        });
+    }
     const policy = CATEGORY_POLICY[category] || CATEGORY_POLICY.standard;
     const model = String(opts.model || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || '').trim();
     const reasoning = opts.lbHealth?.quota_low && policy.reasoning === 'xhigh' ? 'high' : policy.reasoning;
     return { model, reasoning, serviceTier: policy.serviceTier };
 }
-export function categoryForWorkerRole(role) {
-    const text = String(role || '').toLowerCase();
+export function routeNarutoGpt56Model(input = {}) {
+    const category = input.category || 'agentic';
+    const text = `${category} ${String(input.taskText || '')}`;
+    const riskText = `${text} ${String(input.riskText || '')}`;
+    const explicit = normalizeNarutoGpt56Model(input.explicitModel);
+    const preferred = explicit
+        || (category === 'refactor' || category === 'strategy' || category === 'ultrabrain' || NARUTO_SOL_WORK_RE.test(text)
+            ? 'gpt-5.6-sol'
+            : category === 'e2e' || NARUTO_LUNA_WORK_RE.test(text)
+                ? 'gpt-5.6-luna'
+                : 'gpt-5.6-terra');
+    const available = input.availableModels == null
+        ? [...NARUTO_GPT56_MODELS]
+        : input.availableModels.map(normalizeNarutoGpt56Model).filter((model) => Boolean(model));
+    const degraded = new Set((input.degradedModels || []).map((model) => String(model).toLowerCase()));
+    const usable = available.filter((model) => !degraded.has(model));
+    const availableEfforts = input.availableModelEfforts == null ? null : input.availableModelEfforts[preferred] || [];
+    const maxWork = NARUTO_MAX_WORK_RE.test(riskText);
+    const intendedReasoning = preferred === 'gpt-5.6-sol'
+        ? 'max'
+        : preferred === 'gpt-5.6-luna'
+            ? maxWork ? 'max' : 'xhigh'
+            : preferred === 'gpt-5.6-terra'
+                ? maxWork || category === 'review' ? 'max' : 'xhigh'
+                : 'xhigh';
+    const model = usable.includes(preferred) && (availableEfforts == null || availableEfforts.includes(intendedReasoning)) ? preferred : '';
+    return { model, reasoning: intendedReasoning, serviceTier: 'fast' };
+}
+export function isNarutoGpt56Model(value) {
+    return normalizeNarutoGpt56Model(value) !== null;
+}
+function normalizeNarutoGpt56Model(value) {
+    const model = String(value || '').trim().toLowerCase();
+    return NARUTO_GPT56_MODELS.includes(model) ? model : null;
+}
+export function categoryForWorkerRole(role, taskText = '') {
+    const text = `${String(role || '')} ${String(taskText || '')}`.toLowerCase();
+    if (NARUTO_LUNA_WORK_RE.test(text))
+        return 'e2e';
+    if (/(refactor|re-?architect|리팩터|아키텍처)/i.test(text))
+        return 'refactor';
+    if (/(planning|\bplan\b|strategy|strategic|기획|전략)/i.test(text))
+        return 'strategy';
     if (/verif|test|qa/.test(text))
         return 'verify';
     if (/review|critic|judge/.test(text))
@@ -28,6 +87,8 @@ export function modelRouteReason(category, choice, opts = {}) {
     const model = choice.model || 'codex-selected';
     if (opts.explicit)
         return `${category}->${model} (explicit model preserved)`;
+    if (isNarutoGpt56Model(choice.model))
+        return `${category}->${model}@${choice.reasoning} (Naruto GPT-5.6 family policy)`;
     const suffix = opts.quotaLow ? 'quota discipline' : 'Codex catalog passthrough';
     return `${category}->${model} (${suffix})`;
 }

package/dist/core/release/package-size-budget.js

@@ -0,0 +1,2 @@
+export const DEFAULT_MAX_PACK_BYTES = 2414 * 1024;
+//# sourceMappingURL=package-size-budget.js.map

package/dist/core/routes/constants.js

@@ -47,5 +47,5 @@ export const RECOMMENDED_SKILLS = [
 // Route-level effort names are scheduling intents, not model compatibility
 // claims. Actual per-model options come from Codex runtime metadata; SKS never
 // derives them from a model slug.
-export const ALLOWED_REASONING_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'ultra']);
+export const ALLOWED_REASONING_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
 //# sourceMappingURL=constants.js.map

package/dist/core/routes/model-mode-router.js

@@ -3,6 +3,9 @@ export function resolveSksModelMode(args = []) {
     const hasGlm = normalized.includes('--glm');
     const hasMad = normalized.includes('--mad') || normalized.includes('--MAD') || normalized.includes('--mad-sks');
     const hasNaruto = normalized.includes('--naruto') || normalized.includes('naruto');
+    if (hasGlm && hasNaruto && !hasMad) {
+        return decision('classic-naruto', false, true, 'naruto_command_glm_override_forbidden', normalized);
+    }
     if (hasGlm && hasNaruto) {
         return decision('glm-naruto', true, false, 'explicit_--glm_with_naruto', normalized);
     }

package/dist/core/routes.js

@@ -1162,19 +1162,17 @@ export function routeReasoning(route, prompt = '') {
     return reasoning('medium', 'simple_fulfillment');
 }
 function narutoRouteReasoning(text = '') {
-    if (/(frontier|autoresearch|novelty|hypothesis|falsify|forensic|from-chat-img|가설|포렌식)/i.test(text))
-        return reasoning('xhigh', 'naruto_research_or_forensic_signal');
-    if (/(research|current docs?|library|framework|sdk|api|database|supabase|sql|migration|security|permission|mad|release|publish|deploy|commit|push|architecture|algorithm|리서치|문서|데이터베이스|마이그레이션|보안|권한|배포|커밋|푸쉬)/i.test(text))
-        return reasoning('high', 'naruto_knowledge_safety_or_release_signal');
-    if (/(tmux|zellij|terminal|cli|cmd|warp|tool(?:\s|-)?call|hook|router|routing|pipeline|multi[-\s]?pane|pane|process|config|터미널|라우팅|파이프라인|훅|도구|툴)/i.test(text))
-        return reasoning('medium', 'naruto_tooling_or_runtime_signal');
-    if (/(tiny|simple|small|one[-\s]?line|typo|copy|label|spacing|rename|text|readme|docs?|간단|단순|오타|문구|라벨|간격|색상)/i.test(text))
-        return reasoning('low', 'naruto_simple_bounded_work_signal');
-    return reasoning('medium', 'naruto_default_balanced_reasoning');
+    if (/(frontier|autoresearch|novelty|hypothesis|falsify|forensic|from-chat-img|research|current docs?|library|framework|sdk|api|database|supabase|sql|migration|security|permission|mad|release|publish|deploy|commit|push|architecture|algorithm|strategy|planning|integration|refactor|가설|포렌식|리서치|문서|데이터베이스|마이그레이션|보안|권한|배포|커밋|푸쉬|전략|기획|통합|리팩터)/i.test(text))
+        return reasoning('max', 'naruto_complex_or_high_risk_signal');
+    return reasoning('xhigh', 'naruto_gpt56_baseline');
 }
 export function reasoningProfileName(effort) {
     if (effort === 'low')
         return 'sks-task-low';
+    if (effort === 'ultra')
+        return 'sks-research-ultra';
+    if (effort === 'max')
+        return 'sks-research-max';
     if (effort === 'xhigh')
         return 'sks-research-xhigh';
     if (effort === 'high')

package/dist/core/update/update-migration-state.js

@@ -342,7 +342,7 @@ async function runMenubarRetargetStage(root) {
     if (typeof text !== 'string')
         return { ok: true, status: 'ok', actions: ['menubar_action_script_absent'], blockers: [], warnings: [] };
     const desired = path.join(packageRoot(), 'dist', 'bin', 'sks.js');
-    const line = `SKS_ENTRY=${JSON.stringify(desired)}`;
+    const line = `SKS_ENTRY='${desired.replace(/'/g, `'\\''`)}'`;
     const actions = [];
     const next = /^\s*SKS_ENTRY\s*=.*$/m.test(text)
         ? text.replace(/^\s*SKS_ENTRY\s*=.*$/m, line)

package/dist/core/update/update-notice.js

@@ -3,6 +3,29 @@ import os from 'node:os';
 import path from 'node:path';
 import { ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 export const SKS_UPDATE_NOTICE_SCHEMA = 'sks.update-notice.v1';
+export async function persistSksUpdateNoticeFromVersions(input) {
+    const packageName = input.packageName || 'sneakoscope';
+    const latestVersion = input.latestVersion || null;
+    const updateAvailable = Boolean(latestVersion && compareVersions(latestVersion, input.currentVersion) > 0);
+    const notice = {
+        schema: SKS_UPDATE_NOTICE_SCHEMA,
+        checked_at: nowIso(),
+        package_name: packageName,
+        current_version: input.currentVersion,
+        latest_version: latestVersion,
+        update_available: updateAvailable,
+        source: input.error ? 'error' : 'cache',
+        cache_ttl_ms: 6 * 60 * 60 * 1000,
+        message: updateAvailable
+            ? `SKS ${latestVersion} is available; current ${input.currentVersion}.`
+            : `SKS ${input.currentVersion} is current enough.`,
+        ...(input.error ? { error: input.error } : {})
+    };
+    const cachePath = path.join(os.homedir(), '.sneakoscope', 'cache', 'update-notice.json');
+    await ensureDir(path.dirname(cachePath));
+    await writeJsonAtomic(cachePath, notice);
+    return notice;
+}
 export async function checkSksUpdateNotice(input = {}) {
     const env = input.env || process.env;
     const packageName = input.packageName || env.SKS_UPDATE_NOTICE_PACKAGE || 'sneakoscope';

package/dist/core/update-check.js

@@ -6,7 +6,7 @@ import { PACKAGE_VERSION, packageRoot, readJson, runProcess, throttleLines, whic
 import { createRequestedScopeContract } from './safety/requested-scope-contract.js';
 import { guardedPackageInstall, guardContextForRoute } from './safety/mutation-guard.js';
 import { isUpdateMigrationReceiptCurrent, resolveInstalledSksEntrypoint, runPackageLocalDoctor, writeProjectUpdateMigrationReceipt } from './update/update-migration-state.js';
-import { installSksMenuBar } from './codex-app/sks-menubar.js';
+import { installSksMenuBar, sksMenuBarPaths } from './codex-app/sks-menubar.js';
 import { reconcileSkills } from './init/skills.js';
 import { codexHookTrustDoctor } from './codex-hooks/codex-hook-trust-doctor.js';
 import { readCodexHookActualState } from './codex-hooks/codex-hook-actual-discovery.js';
@@ -367,7 +367,7 @@ export async function runSksUpdateNow(options = {}) {
             migrationCurrent = isUpdateMigrationReceiptCurrent(projectReceipt);
             stage('project_receipt', migrationCurrent, migrationCurrent ? 'current' : 'failed', { root: projectReceiptRoot });
             if (migrationCurrent)
-                sksMenuBar = await installUpdateSksMenuBar({ root: projectReceiptRoot, env, stage, quiet: machineOutput });
+                sksMenuBar = await installUpdateSksMenuBar({ root: projectReceiptRoot, env, stage, quiet: machineOutput, entrypoint: newBinary });
             await runUpdateGlobalSkillsReconcile(stage, {
                 quiet: machineOutput,
                 newPackageRoot: newBinary ? path.resolve(path.dirname(newBinary), '..', '..') : null
@@ -709,18 +709,20 @@ function buildUpdateNowResult(input) {
         error: input.error
     };
 }
-async function installUpdateSksMenuBar(input) {
+export async function installUpdateSksMenuBar(input) {
     if (input.env.SKS_UPDATE_SKIP_SKS_MENUBAR === '1') {
         input.stage('sks_menubar', true, 'skipped', { reason: 'SKS_UPDATE_SKIP_SKS_MENUBAR=1' });
         return null;
     }
-    const work = installSksMenuBar({
-        root: input.root,
-        apply: true,
-        launch: true,
-        env: input.env,
-        quiet: input.quiet === true
-    }).catch((err) => ({
+    const work = (input.entrypoint
+        ? installSksMenuBarFromEntrypoint(input.entrypoint, input)
+        : installSksMenuBar({
+            root: input.root,
+            apply: true,
+            launch: true,
+            env: input.env,
+            quiet: input.quiet === true
+        })).catch((err) => ({
         schema: 'sks.codex-app-sks-menubar.v1',
         ok: false,
         apply: true,
@@ -753,6 +755,30 @@ async function installUpdateSksMenuBar(input) {
     });
     return result;
 }
+async function installSksMenuBarFromEntrypoint(entrypoint, input) {
+    const run = await runProcess(process.execPath, [entrypoint, 'menubar', 'install', '--json'], {
+        cwd: input.root,
+        env: {
+            ...input.env,
+            SKS_DISABLE_UPDATE_CHECK: '1',
+            SKS_UPDATE_MIGRATION_GATE_DISABLED: '1'
+        },
+        timeoutMs: updateDoctorTimeoutMs(input.env),
+        maxOutputBytes: 128 * 1024
+    });
+    const output = String(run.stdout || '').trim();
+    let parsed = null;
+    try {
+        parsed = JSON.parse(output);
+    }
+    catch {
+        parsed = null;
+    }
+    if (run.code !== 0 || parsed?.schema !== 'sks.codex-app-sks-menubar.v1') {
+        throw new Error(String(run.stderr || output || `updated SKS menu bar installer exited ${run.code}`).trim());
+    }
+    return parsed;
+}
 async function detectNpmGlobalRoot(npmBin, env, opts = {}) {
     const result = await runProcess(npmBin, ['root', '--global', '--silent'], {
         env,
@@ -820,6 +846,16 @@ async function runFinalUpdateVerification(input) {
         detail: `expected ${input.installVersion}, got ${skillsManifest?.version || 'missing'}`,
         remediation: 'Run: sks doctor --fix --yes'
     });
+    if (process.platform === 'darwin' && input.env.SKS_UPDATE_SKIP_SKS_MENUBAR !== '1') {
+        const menuStampPath = sksMenuBarPaths(home, input.projectReceiptRoot).build_stamp_path;
+        const menuStamp = await readJson(menuStampPath, null).catch(() => null);
+        verification.push({
+            id: 'sks_menubar_version',
+            ok: menuStamp?.package_version === input.installVersion,
+            detail: `expected ${input.installVersion}, got ${menuStamp?.package_version || 'missing'}`,
+            remediation: `Run: ${process.execPath} ${input.newBinary} menubar install --json`
+        });
+    }
     return verification;
 }
 function verificationError(verification) {

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '6.0.2';
+export const PACKAGE_VERSION = '6.0.3';
 //# sourceMappingURL=version.js.map

package/dist/scripts/codex-app-provider-model-ui-check.js

@@ -17,7 +17,19 @@ await fs.writeFile(path.join(home, '.codex', 'sks-codex-lb.env'), "export CODEX_
 const ready = await codexProviderModelUiStatus({
     home,
     cwd,
-    env: { HOME: home, OPENROUTER_API_KEY: 'sk-or-fixture' }
+    env: { HOME: home, OPENROUTER_API_KEY: 'sk-or-fixture' },
+    codexLbModelCatalog: {
+        schema: 'sks.codex-lb-model-catalog.v1',
+        ok: true,
+        status: 'ready',
+        models: ['gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna'],
+        model_efforts: {
+            'gpt-5.6-sol': ['xhigh', 'max', 'ultra'],
+            'gpt-5.6-terra': ['xhigh', 'max', 'ultra'],
+            'gpt-5.6-luna': ['xhigh', 'max']
+        },
+        blockers: []
+    }
 });
 const readyText = formatCodexAppStatus(statusFixture(ready));
 const ok = missing.ok === false
@@ -34,7 +46,10 @@ const ok = missing.ok === false
     && ready.glm.profiles_present.length === GLM_CODEX_CONFIG_REASONING_PROFILES.length
     && ready.codex_lb.provider_present === true
     && ready.codex_lb.key_present === true
-    && /Provider UI:\s*ok/.test(readyText)
+    && ready.codex_lb.model_catalog_ok === true
+    && ready.codex_lb.expected_models_present === true
+    && /Provider UI:\s*config\/catalog ready/.test(readyText)
+    && ready.desktop_picker_verified === false
     && readyText.includes(`GLM Model:  ok ${GLM_52_OPENROUTER_MODEL}`)
     && /codex-lb Key:\s*configured/.test(readyText)
     && !JSON.stringify({ missing, ready, missingText, readyText }).includes('sk-codex-lb-fixture');

package/dist/scripts/doctor-fix-proves-codex-read-check.js

@@ -49,7 +49,7 @@ const c7Fixture = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-doctor-fix-c7-'))
 const c7Home = path.join(c7Fixture, 'home');
 await fs.mkdir(path.join(c7Fixture, '.codex'), { recursive: true });
 await fs.mkdir(c7Home, { recursive: true });
-await fs.writeFile(path.join(c7Fixture, '.codex', 'config.toml'), '[mcp_servers.context7]\ncommand = "npx"\nargs = ["-y", "@upstash/context7-mcp@latest"]\n');
+await fs.writeFile(path.join(c7Fixture, '.codex', 'config.toml'), '# Sneakoscope managed fixture\n[mcp_servers.context7]\ncommand = "npx"\nargs = ["-y", "@upstash/context7-mcp@latest"]\n');
 const c7Run = runDoctorFix(c7Fixture, c7Home, { SKS_FAKE_CODEX_CONFIG_CONTEXT7_STDIO_CONFLICT: '1' });
 const c7Parsed = parseLastJson(c7Run.stdout || '{}');
 const c7ConfigText = await fs.readFile(path.join(c7Fixture, '.codex', 'config.toml'), 'utf8').catch(() => '');

package/dist/scripts/gate-policy-audit-check.js

@@ -26,9 +26,9 @@ const directCodexConfigWrites = scanDirectCodexConfigWrites();
 const commandGateContract = scanCommandGateContract();
 const directMkdtempCalls = scanDirectMkdtempCalls();
 const rustTempdirCalls = scanRustTempdirCalls();
-if (releaseGates.length > 220)
+if (releaseGates.length > 200)
     blockers.push(`release_preset_gate_budget_exceeded:${releaseGates.length}`);
-if (gates.length > 220)
+if (gates.length > 200)
     blockers.push(`release_manifest_gate_budget_exceeded:${gates.length}`);
 if (Object.keys(pkg.scripts || {}).length > 100)
     blockers.push(`package_script_budget_exceeded:${Object.keys(pkg.scripts || {}).length}`);

package/dist/scripts/legacy-upgrade-matrix-check.js

@@ -121,7 +121,7 @@ try {
         const projectConfigPath = path.join(projectCodexDir, 'config.toml');
         // Machine-local keys/tables (model_provider, [profiles.*]) move out to CODEX_HOME;
         // project-scoped settings (sandbox_mode, [features]) must be PRESERVED in place.
-        fs.writeFileSync(projectConfigPath, 'model_provider = "codex-lb"\nsandbox_mode = "workspace-write"\n\n[features]\nhooks = true\n', 'utf8');
+        fs.writeFileSync(projectConfigPath, '# Sneakoscope managed fixture\nmodel_provider = "codex-lb"\nsandbox_mode = "workspace-write"\n\n[features]\nhooks = true\n', 'utf8');
         const result = await policy.splitCodexProjectConfigPolicy(projectRoot, {
             apply: true,
             codexHome: tmpHome2,

package/dist/scripts/lib/native-cli-session-swarm-check-lib.js

@@ -63,7 +63,8 @@ export function runNativeCliSwarmCheck({ agents, workItems = agents, reportName,
     assertGate(result.ok === true, 'native CLI session swarm run must pass', report);
     assertGate(proof.spawned_worker_process_count >= agents, 'spawned native worker process count below requested agents', report);
     assertGate(proof.unique_worker_session_count >= agents, 'unique worker session count below requested agents', report);
-    assertGate(proof.unique_slot_count >= agents, 'unique slot count below requested agents', report);
+    const expectedSlots = Math.min(agents, Number(proof.target_active_slots || agents));
+    assertGate(proof.unique_slot_count >= expectedSlots, 'unique slot count below effective concurrency target', report);
     assertGate(Array.isArray(proof.process_ids) && proof.process_ids.length >= agents, 'process ids missing from native CLI proof', report);
     assertGate(proof.close_report_count >= agents, 'worker close report count below requested agents', report);
     assertGate(noSubagent.ok === true && noSubagent.subagent_events_counted_as_worker_sessions === false, 'no-subagent scaling policy must pass', report);

package/dist/scripts/naruto-shadow-clone-swarm-check.js

@@ -29,31 +29,30 @@ assertGate(fullRoster.max_agents === 100, 'clone roster max_agents must be 100',
 // 4) Over-cap is clamped, not crashed.
 const overCap = roster.buildNarutoCloneRoster({ clones: 500, maxAgentCount: schema.MAX_NARUTO_AGENT_COUNT });
 assertGate(overCap.agent_count === 100, 'clones above the ceiling clamp to 100', { agent_count: overCap.agent_count });
-// 4b) Dynamic per-clone effort policy (like team mode), capped + always fast.
-//     A neutral/no-tool prompt yields a low/medium MIX: read-only personas -> low, writers -> medium.
+// 4b) Naruto-only GPT-5.6 family policy. The old low/medium cap is gone.
 const effortRoster = roster.buildNarutoCloneRoster({ clones: 24, prompt: 'review and summarize the current findings', maxAgentCount: schema.MAX_NARUTO_AGENT_COUNT });
 const efforts = new Set(effortRoster.roster.map((row) => row.reasoning_effort));
 const modelTiers = new Set(effortRoster.roster.map((row) => row.model_tier));
 const modelEfforts = new Set(effortRoster.roster.map((row) => row.model_reasoning_effort));
 const tiers = new Set(effortRoster.roster.map((row) => row.service_tier));
 const fastFlags = new Set(effortRoster.roster.map((row) => row.fast_mode));
-assertGate([...efforts].every((e) => e === 'low' || e === 'medium'), 'naruto clone efforts must be only low/medium (never high/xhigh)', { efforts: [...efforts] });
-assertGate(efforts.has('low') && efforts.has('medium'), 'naruto effort must be dynamic: a no-tool prompt must yield both low and medium clones', { efforts: [...efforts] });
-assertGate([...modelTiers].every((tier) => tier === 'codex-selected-low' || tier === 'codex-selected-medium'), 'Naruto must inherit the Codex-selected model and vary only reasoning effort', { modelTiers: [...modelTiers] });
-assertGate(modelTiers.has('codex-selected-low') && modelTiers.has('codex-selected-medium'), 'Naruto effort allocation must dynamically mix low and medium without changing model IDs', { modelTiers: [...modelTiers] });
-assertGate([...modelEfforts].every((effort) => effort === 'low' || effort === 'medium'), 'ordinary Naruto clone model reasoning must stay low/medium', { modelEfforts: [...modelEfforts] });
+assertGate([...efforts].every((effort) => effort === 'xhigh' || effort === 'max'), 'Naruto clone efforts must use only xhigh/max', { efforts: [...efforts] });
+assertGate([...effortRoster.roster].every((row) => ['gpt-5.6-luna', 'gpt-5.6-terra', 'gpt-5.6-sol'].includes(row.model)), 'Naruto workers must use only the GPT-5.6 trio', { models: [...new Set(effortRoster.roster.map((row) => row.model))] });
+assertGate([...modelTiers].every((tier) => /gpt-5\.6-(?:luna|terra|sol)-(?:xhigh|max)/.test(tier)), 'Naruto model tiers must record exact GPT-5.6 model and effort', { modelTiers: [...modelTiers] });
+assertGate([...modelEfforts].every((effort) => effort === 'xhigh' || effort === 'max'), 'Naruto model reasoning must use xhigh/max', { modelEfforts: [...modelEfforts] });
 assertGate([...tiers].length === 1 && tiers.has('fast'), 'every naruto clone must be fast service tier', { tiers: [...tiers] });
 assertGate([...fastFlags].length === 1 && fastFlags.has(true), 'every naruto clone must have fast_mode=true', { fastFlags: [...fastFlags] });
-// 4c) Unit rule: no tool use -> low; any tool use -> medium; always fast.
-const simple = effortPolicy.decideNarutoCloneEffort({ readonly: true, prompt: 'simple docs overview' });
-const toolWrite = effortPolicy.decideNarutoCloneEffort({ readonly: false, prompt: 'add a feature' });
-const toolReadCmd = effortPolicy.decideNarutoCloneEffort({ readonly: true, prompt: 'run the build and apply the migration' });
-const simpleWrite = effortPolicy.decideNarutoCloneEffort({ readonly: false, prompt: 'simple one-line typo fix' });
-assertGate(simple.reasoning_effort === 'low' && simple.service_tier === 'fast', 'no-tool read-only work must be low + fast', { simple });
-assertGate(simple.model === '' && simple.model_reasoning_effort === 'low', 'no-tool read-only work must inherit the Codex model at low effort', { simple });
-assertGate(toolWrite.reasoning_effort === 'medium' && toolWrite.service_tier === 'fast' && toolWrite.model === '' && toolWrite.model_reasoning_effort === 'medium', 'writing clone must inherit the Codex model at medium effort', { toolWrite });
-assertGate(simpleWrite.model === '' && simpleWrite.model_reasoning_effort === 'low', 'simple write work must inherit the Codex model at low effort', { simpleWrite });
-assertGate(toolReadCmd.reasoning_effort === 'medium' && toolReadCmd.service_tier === 'fast' && toolReadCmd.model_reasoning_effort === 'high', 'risky read-only command/migration work must escalate model reasoning to high', { toolReadCmd });
+// 4c) Deterministic work-kind matrix.
+const coding = effortPolicy.decideNarutoCloneEffort({ persona: { role: 'implementer', naruto_role: 'implementer' }, prompt: 'implement a normal coding feature' });
+const criticalCoding = effortPolicy.decideNarutoCloneEffort({ persona: { role: 'implementer', naruto_role: 'implementer' }, prompt: 'implement a critical security migration' });
+const refactor = effortPolicy.decideNarutoCloneEffort({ persona: { role: 'integrator', naruto_role: 'integrator' }, prompt: 'refactor the architecture and integration plan' });
+const e2e = effortPolicy.decideNarutoCloneEffort({ persona: { role: 'browser e2e verifier', naruto_role: 'verifier' }, prompt: 'run browser e2e tests' });
+const forensicGui = effortPolicy.decideNarutoCloneEffort({ persona: { role: 'Computer Use GUI verifier', naruto_role: 'verifier' }, prompt: 'forensic cross-app failure verification' });
+assertGate(coding.model === 'gpt-5.6-terra' && coding.model_reasoning_effort === 'xhigh', 'ordinary coding must use Terra xhigh', { coding });
+assertGate(criticalCoding.model === 'gpt-5.6-terra' && criticalCoding.model_reasoning_effort === 'max', 'critical coding must use Terra max', { criticalCoding });
+assertGate(refactor.model === 'gpt-5.6-sol' && refactor.model_reasoning_effort === 'max', 'refactor/architecture/integration must use Sol max', { refactor });
+assertGate(e2e.model === 'gpt-5.6-luna' && e2e.model_reasoning_effort === 'xhigh', 'browser E2E must use Luna xhigh', { e2e });
+assertGate(forensicGui.model === 'gpt-5.6-luna' && forensicGui.model_reasoning_effort === 'max', 'forensic Computer Use GUI verification must use Luna max', { forensicGui });
 // 5) System-safe concurrency: never spawn the whole count at once; throttle to host capacity.
 const fakeSafe = roster.systemSafeNarutoConcurrency({ backend: 'fake' });
 const heavySafe = roster.systemSafeNarutoConcurrency({ backend: 'codex-sdk' });
@@ -91,47 +90,60 @@ const run = spawnSync(process.execPath, [
     '--json',
     '--no-open-zellij'
 ], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 780000, maxBuffer: 8 * 1024 * 1024 });
-assertGate(run.status === 0, 'sks naruto run must exit 0', { status: run.status, stderr: tail(run.stderr) });
 const parsed = parseJson(run.stdout);
-assertGate(parsed !== null, 'sks naruto run must emit JSON', { stdout: tail(run.stdout) });
-assertGate(parsed.ok === true, 'naruto run must be ok', { ok: parsed.ok });
-assertGate(parsed.mode === 'NARUTO' && parsed.jutsu === 'kage_bunshin_no_jutsu', 'naruto run must report NARUTO mode', { mode: parsed.mode, jutsu: parsed.jutsu });
-assertGate(parsed.clones === proofClones, 'clone fan-out must use the requested queued count', { clones: parsed.clones });
-assertGate(parsed.max_clones === 100, 'naruto run must advertise the 100 ceiling', { max_clones: parsed.max_clones });
-assertGate(parsed.proof === 'passed', 'naruto run proof must pass', { proof: parsed.proof });
-// Throttle invariant: active concurrency never exceeds the requested count nor the host cap.
-assertGate(parsed.target_active_slots >= 1 && parsed.target_active_slots <= proofClones, 'active slots must be in [1, clones]', { target_active_slots: parsed.target_active_slots });
-assertGate(parsed.target_active_slots <= fakeSafe.cap, 'active slots must be throttled to the system-safe cap', { target_active_slots: parsed.target_active_slots, cap: fakeSafe.cap });
-assertGate(parsed.target_active_slots <= proofConcurrency && parsed.target_active_slots <= 4, 'release proof must keep Naruto live slots desktop-safe while queued fan-out remains larger', { target_active_slots: parsed.target_active_slots, proofConcurrency });
-// Task 9.1: fan-out (clones) and live concurrency (target_active_slots) are reported
-// distinctly, and concurrency_capped truthfully reflects "N clones, running M at a time".
-assertGate(typeof parsed.concurrency_capped === 'boolean', 'naruto run must report concurrency_capped', { concurrency_capped: parsed.concurrency_capped });
-assertGate(parsed.concurrency_capped === (parsed.clones > parsed.target_active_slots), 'concurrency_capped must reflect clones > live slots', { clones: parsed.clones, target_active_slots: parsed.target_active_slots, concurrency_capped: parsed.concurrency_capped });
-assertGate(parsed.system && Number(parsed.system.safe_concurrency) >= 1, 'naruto run must report system safe_concurrency (host-derived cap)', { system: parsed.system });
-assertGate(parsed.work_graph?.write_allowed_count > 0 && parsed.work_graph?.mixed_work_kinds?.length > 1, 'naruto run must report a mixed work graph with write-capable items', { work_graph: parsed.work_graph });
-assertGate(Number(parsed.work_graph?.parallel_write_wave_count || 0) > 0, 'naruto run must expose at least one parallel write-capable wave with non-overlapping leases', { work_graph: parsed.work_graph });
-assertGate(parsed.role_distribution?.verifier_only === false, 'naruto run proof/status must distinguish active worker roles beyond verifier-only', { role_distribution: parsed.role_distribution });
-assertGate(Number(parsed.role_distribution?.implementation_like_ratio || 0) >= 0.4, 'naruto run must include implementation-like role distribution', { role_distribution: parsed.role_distribution });
-const commandGraphPath = path.join(root, '.sneakoscope', 'missions', parsed.mission_id, 'agents', 'naruto-work-graph.json');
-const commandGraph = JSON.parse(fs.readFileSync(commandGraphPath, 'utf8'));
-const writePaths = commandGraph.work_items.filter((row) => row.write_allowed).flatMap((row) => row.write_paths);
-assertGate(new Set(writePaths).size > 1, 'naruto command default patch-envelope leases must be per work item, not one shared write path', { sample: writePaths.slice(0, 8), unique: new Set(writePaths).size });
-assertGate(commandGraph.active_waves.some((wave) => wave.write_paths.length > 1), 'naruto command graph must contain a parallel write wave when route-local patch envelopes do not overlap', { waves: commandGraph.active_waves.slice(0, 3) });
-const state = parsed.run?.scheduler?.state || parsed.run?.scheduler || {};
-assertGate(Number(state.completed_count) === Number(parsed.work_graph?.total_work_items || 0) && Number(state.completed_count) >= proofClones, 'all clone work items must complete despite throttling', { completed_count: state.completed_count, total_work_items: parsed.work_graph?.total_work_items, proofClones });
-assertGate(parsed.target_active_slots <= 4, 'explicit --concurrency cannot bypass the desktop-safe cap', { target_active_slots: parsed.target_active_slots });
+assertGate(parsed !== null, 'sks naruto run must emit JSON', { stdout: tail(run.stdout), stderr: tail(run.stderr) });
+let state = {};
+withMissionRouteClose(parsed, childEnv, () => {
+    assertGate(run.status === 0, 'sks naruto run must exit 0', { status: run.status, stderr: tail(run.stderr) });
+    assertGate(parsed.ok === true, 'naruto run must be ok', { ok: parsed.ok });
+    assertGate(parsed.mode === 'NARUTO' && parsed.jutsu === 'kage_bunshin_no_jutsu', 'naruto run must report NARUTO mode', { mode: parsed.mode, jutsu: parsed.jutsu });
+    assertGate(parsed.clones === proofClones, 'clone fan-out must use the requested queued count', { clones: parsed.clones });
+    assertGate(parsed.max_clones === 100, 'naruto run must advertise the 100 ceiling', { max_clones: parsed.max_clones });
+    assertGate(parsed.proof === 'passed', 'naruto run proof must pass', { proof: parsed.proof });
+    // Throttle invariant: active concurrency never exceeds the requested count nor the host cap.
+    assertGate(parsed.target_active_slots >= 1 && parsed.target_active_slots <= proofClones, 'active slots must be in [1, clones]', { target_active_slots: parsed.target_active_slots });
+    assertGate(parsed.target_active_slots <= fakeSafe.cap, 'active slots must be throttled to the system-safe cap', { target_active_slots: parsed.target_active_slots, cap: fakeSafe.cap });
+    assertGate(parsed.target_active_slots <= proofConcurrency && parsed.target_active_slots <= 4, 'release proof must keep Naruto live slots desktop-safe while queued fan-out remains larger', { target_active_slots: parsed.target_active_slots, proofConcurrency });
+    // Task 9.1: fan-out (clones) and live concurrency (target_active_slots) are reported
+    // distinctly, and concurrency_capped truthfully reflects "N clones, running M at a time".
+    assertGate(typeof parsed.concurrency_capped === 'boolean', 'naruto run must report concurrency_capped', { concurrency_capped: parsed.concurrency_capped });
+    assertGate(parsed.concurrency_capped === (parsed.clones > parsed.target_active_slots), 'concurrency_capped must reflect clones > live slots', { clones: parsed.clones, target_active_slots: parsed.target_active_slots, concurrency_capped: parsed.concurrency_capped });
+    assertGate(parsed.system && Number(parsed.system.safe_concurrency) >= 1, 'naruto run must report system safe_concurrency (host-derived cap)', { system: parsed.system });
+    assertGate(parsed.work_graph?.write_allowed_count > 0 && parsed.work_graph?.mixed_work_kinds?.length > 1, 'naruto run must report a mixed work graph with write-capable items', { work_graph: parsed.work_graph });
+    assertGate(Number(parsed.work_graph?.parallel_write_wave_count || 0) > 0, 'naruto run must expose at least one parallel write-capable wave with non-overlapping leases', { work_graph: parsed.work_graph });
+    assertGate(parsed.role_distribution?.verifier_only === false, 'naruto run proof/status must distinguish active worker roles beyond verifier-only', { role_distribution: parsed.role_distribution });
+    assertGate(Number(parsed.role_distribution?.implementation_like_ratio || 0) >= 0.4, 'naruto run must include implementation-like role distribution', { role_distribution: parsed.role_distribution });
+    assertGate(parsed.local_worker?.auto_select_eligible === false, 'normal Naruto must never auto-select a local/Ollama backend', { local_worker: parsed.local_worker });
+    const commandGraphPath = path.join(root, '.sneakoscope', 'missions', parsed.mission_id, 'agents', 'naruto-work-graph.json');
+    const commandGraph = JSON.parse(fs.readFileSync(commandGraphPath, 'utf8'));
+    const writePaths = commandGraph.work_items.filter((row) => row.write_allowed).flatMap((row) => row.write_paths);
+    assertGate(new Set(writePaths).size > 1, 'naruto command default patch-envelope leases must be per work item, not one shared write path', { sample: writePaths.slice(0, 8), unique: new Set(writePaths).size });
+    assertGate(commandGraph.active_waves.some((wave) => wave.write_paths.length > 1), 'naruto command graph must contain a parallel write wave when route-local patch envelopes do not overlap', { waves: commandGraph.active_waves.slice(0, 3) });
+    state = parsed.run?.scheduler?.state || parsed.run?.scheduler || {};
+    assertGate(Number(state.completed_count) === Number(parsed.work_graph?.total_work_items || 0) && Number(state.completed_count) >= proofClones, 'all clone work items must complete despite throttling', { completed_count: state.completed_count, total_work_items: parsed.work_graph?.total_work_items, proofClones });
+    assertGate(parsed.target_active_slots <= 4, 'explicit --concurrency cannot bypass the desktop-safe cap', { target_active_slots: parsed.target_active_slots });
+});
 // 7) A small request is never inflated; live pressure may still reduce it.
 const small = spawnSync(process.execPath, [cli, 'naruto', 'run', 'tiny', '--clones', '2', '--backend', 'fake', '--work-items', '2', '--json', '--no-open-zellij'], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 600000, maxBuffer: 4 * 1024 * 1024 });
 const smallParsed = parseJson(small.stdout);
-assertGate(small.status === 0 && smallParsed?.target_active_slots >= 1 && smallParsed?.target_active_slots <= 2, 'a 2-clone run must stay within [1, 2] active workers', { status: small.status, target_active_slots: smallParsed?.target_active_slots });
+withMissionRouteClose(smallParsed, childEnv, () => {
+    assertGate(small.status === 0 && smallParsed?.target_active_slots >= 1 && smallParsed?.target_active_slots <= 2, 'a 2-clone run must stay within [1, 2] active workers', {
+        status: small.status,
+        target_active_slots: smallParsed?.target_active_slots,
+        stdout: tail(small.stdout),
+        stderr: tail(small.stderr)
+    });
+});
 // 8) Naruto clones always run fast. Per-route --no-fast / standard-tier requests
 //    are intentionally not honored for shadow clones.
 const standardOptOut = spawnSync(process.execPath, [cli, 'naruto', 'run', 'fast opt-out ignored', '--clones', '2', '--backend', 'fake', '--work-items', '2', '--no-fast', '--service-tier', 'standard', '--json', '--no-open-zellij'], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 600000, maxBuffer: 4 * 1024 * 1024 });
 const standardOptOutParsed = parseJson(standardOptOut.stdout);
-assertGate(standardOptOut.status === 0 && standardOptOutParsed?.fast_mode_policy?.fast_mode === true && standardOptOutParsed?.fast_mode_policy?.service_tier === 'fast', 'naruto --no-fast / --service-tier standard must still run clones in fast mode', {
-    status: standardOptOut.status,
-    fast_mode_policy: standardOptOutParsed?.fast_mode_policy,
-    stderr: tail(standardOptOut.stderr)
+withMissionRouteClose(standardOptOutParsed, childEnv, () => {
+    assertGate(standardOptOut.status === 0 && standardOptOutParsed?.fast_mode_policy?.fast_mode === true && standardOptOutParsed?.fast_mode_policy?.service_tier === 'fast', 'naruto --no-fast / --service-tier standard must still run clones in fast mode', {
+        status: standardOptOut.status,
+        fast_mode_policy: standardOptOutParsed?.fast_mode_policy,
+        stderr: tail(standardOptOut.stderr)
+    });
 });
 emitGate('naruto:shadow-clone-swarm', {
     max_naruto_agent_count: schema.MAX_NARUTO_AGENT_COUNT,
@@ -162,4 +174,30 @@ function tail(value, limit = 2000) {
     const text = String(value || '');
     return text.length <= limit ? text : text.slice(-limit);
 }
+function closeMission(missionId, env) {
+    assertGate(Boolean(missionId), 'naruto proof mission id missing before route close', { missionId });
+    const closed = spawnSync(process.execPath, [cli, 'route', 'close', '--mission', String(missionId), '--json'], {
+        cwd: root,
+        env,
+        encoding: 'utf8',
+        timeout: 30000,
+        maxBuffer: 1024 * 1024
+    });
+    const parsedClose = parseJson(closed.stdout);
+    assertGate(closed.status === 0 && parsedClose?.ok === true, 'naruto proof mission route close must succeed', {
+        missionId,
+        status: closed.status,
+        stdout: tail(closed.stdout),
+        stderr: tail(closed.stderr)
+    });
+}
+function withMissionRouteClose(parsedResult, env, verify) {
+    try {
+        return verify();
+    }
+    finally {
+        if (parsedResult?.mission_id)
+            closeMission(parsedResult.mission_id, env);
+    }
+}
 //# sourceMappingURL=naruto-shadow-clone-swarm-check.js.map

package/dist/scripts/npm-publish-performance-check.js

@@ -3,9 +3,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { DEFAULT_MAX_PACK_BYTES } from '../core/release/package-size-budget.js';
 import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
 const MAX_FILES = Number(process.env.SKS_MAX_PACK_FILES || 2100);
-const MAX_PACKED = Number(process.env.SKS_MAX_PACK_BYTES || 2410 * 1024);
+const MAX_PACKED = Number(process.env.SKS_MAX_PACK_BYTES || DEFAULT_MAX_PACK_BYTES);
 const BUDGET_MS = Number(process.env.SKS_PACK_BUDGET_MS || 30000);
 function runNpmPack() {
     const npmCli = process.env.npm_execpath; // set when invoked via `npm run`

package/dist/scripts/packlist-performance-check.js

@@ -4,6 +4,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { DEFAULT_MAX_PACK_BYTES } from '../core/release/package-size-budget.js';
 import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
 const MAX_FILES = Number(process.env.SKS_MAX_PACK_FILES || 2100);
 const MAX_UNPACKED = Number(process.env.SKS_MAX_UNPACKED_BYTES || 10 * 1024 * 1024);
@@ -22,8 +23,10 @@ const MAX_UNPACKED = Number(process.env.SKS_MAX_UNPACKED_BYTES || 10 * 1024 * 10
 // checks; keep those scripts publishable because package contract validation
 // rejects scripts that point at files absent from the tarball. 5.12.0 adds ops
 // maturity diagnostics, migration/recovery smokes, and their package-referenced
-// gates, pushing the packed tarball to ~2400 KiB.
-const MAX_PACKED = Number(process.env.SKS_MAX_PACK_BYTES || 2410 * 1024);
+// gates, pushing the packed tarball to ~2400 KiB. 6.0.3 adds the menu restart
+// lifecycle and Naruto GPT-5.6 routing enforcement, bringing the measured
+// packed size to ~2411 KiB; keep the next 1 KiB boundary as the narrow cap.
+const MAX_PACKED = Number(process.env.SKS_MAX_PACK_BYTES || DEFAULT_MAX_PACK_BYTES);
 const SURFACE_MAX_PACKED = Number(process.env.SKS_PACKAGE_SURFACE_MAX_PACK_BYTES || 25_000_000);
 const SURFACE_MAX_FILES = Number(process.env.SKS_PACKAGE_SURFACE_MAX_FILES || 2500);
 function runNpmPack() {