sneakoscope 8.0.2 → 8.0.4

package/dist/scripts/codex-lb-gpt56-fast-profile-check.js

@@ -149,10 +149,12 @@ function assertFastProfile(text, label, expectBridge = true) {
         ...(parsed.user?.fast_mode === undefined ? [] : ['user_fast_mode_legacy_table_present']),
         ...(parsed.profiles?.['sks-fast-high'] === undefined ? [] : ['sks_fast_high_legacy_profile_present']),
         ...(parsed.model === undefined ? [] : ['codex_app_model_was_injected']),
-        ...(parsed.model_provider === undefined ? [] : ['desktop_model_provider_was_selected']),
+        ...(parsed.model_provider === 'openai' ? [] : ['desktop_model_provider_must_be_openai']),
         ...(provider.name === 'codex-lb' ? [] : ['codex_lb_cli_provider_name_mismatch']),
         ...(provider.requires_openai_auth === false ? [] : ['codex_lb_cli_requires_openai_auth_not_false']),
-        ...(provider.env_key === 'CODEX_LB_API_KEY' ? [] : ['codex_lb_cli_env_key_missing']),
+        ...(provider.env_http_headers?.['X-Codex-LB-API-Key'] === 'CODEX_LB_API_KEY'
+            ? []
+            : ['codex_lb_cli_gateway_header_env_missing']),
         ...(provider.wire_api === 'responses' ? [] : ['codex_lb_wire_api_not_responses']),
         ...(expectBridge && parsed.openai_base_url === bridgeBaseUrl ? [] : expectBridge ? ['native_bridge_base_url_missing'] : []),
         ...(!expectBridge && parsed.openai_base_url !== undefined ? ['disabled_routing_still_has_openai_base_url'] : []),

package/dist/scripts/codex-native-agent-role-content-check.js

@@ -15,7 +15,7 @@ const browser = await fs.promises.readFile(path.join(root, '.codex', 'agents', '
 assertGate(expert.includes('model = "gpt-5.6-sol"') && expert.includes('model_reasoning_effort = "max"'), 'expert role must use Sol Max');
 assertGate(worker.includes('model = "gpt-5.6-luna"') && worker.includes('model_reasoning_effort = "max"'), 'worker role must use Luna Max');
 assertGate(implementation.includes('model = "gpt-5.6-sol"') && implementation.includes('model_reasoning_effort = "high"'), 'implementation role must use Sol High');
-assertGate(browser.includes('model = "gpt-5.6-terra"') && browser.includes('model_reasoning_effort = "medium"'), 'browser role must use Terra Medium');
+assertGate(browser.includes('model = "gpt-5.6-terra"') && browser.includes('model_reasoning_effort = "max"'), 'browser role must use Terra Max');
 assertGate(expert.includes('Do not spawn another subagent.') && worker.includes('Do not redesign the task, expand scope, or spawn another subagent.'), 'official roles must prohibit nested delegation');
 for (const role of MANAGED_OFFICIAL_SUBAGENT_ROLES) {
     const text = await fs.promises.readFile(path.join(root, '.codex', 'agents', role.filename), 'utf8');
@@ -24,13 +24,13 @@ for (const role of MANAGED_OFFICIAL_SUBAGENT_ROLES) {
     assertGate(Object.hasOwn(doc, 'sandbox_mode') === (role.sandbox === 'read-only'), `official role sandbox inheritance mismatch:${role.codex_name}`);
     assertGate(doc.sandbox_mode === role.sandbox, `official role sandbox value mismatch:${role.codex_name}`);
 }
-const distribution = Object.fromEntries(['luna_max_mechanical', 'sol_high_implementation', 'sol_max_judgment', 'terra_medium_context_tools']
+const distribution = Object.fromEntries(['luna_max_mechanical', 'sol_high_implementation', 'sol_max_judgment', 'terra_max_context_tools']
     .map((policy) => [policy, MANAGED_OFFICIAL_SUBAGENT_ROLES.filter((role) => role.model_policy === policy).length]));
 assertGate(JSON.stringify(distribution) === JSON.stringify({
     luna_max_mechanical: 1,
     sol_high_implementation: 3,
     sol_max_judgment: 15,
-    terra_medium_context_tools: 6
+    terra_max_context_tools: 6
 }), 'official role policy distribution mismatch');
 assertGate(!fs.existsSync(path.join(codexHome, 'agents')), 'agent role sync must not create global directive roles');
 assertGate(report.strategy === 'agent_type' && report.probe_artifact_path && report.clobbered_user_roles === false && report.official_roles.length === MANAGED_OFFICIAL_SUBAGENT_ROLES.length, 'agent role report strategy/probe/catalog/no-clobber fields missing');

package/dist/scripts/codex-native-gate-lib.js

@@ -305,10 +305,10 @@ async function hookLifecycleProof(id) {
 }
 async function initDeepBackupRetention(id) {
     const tmp = await tempRoot(id);
-    await fsp.mkdir(path.join(tmp, 'src/core/zellij'), { recursive: true });
-    await fsp.writeFile(path.join(tmp, 'src/core/zellij', 'AGENTS.md'), '# User local guidance\nKeep me.\n', 'utf8');
+    await fsp.mkdir(path.join(tmp, 'src/core/runtime'), { recursive: true });
+    await fsp.writeFile(path.join(tmp, 'src/core/runtime', 'AGENTS.md'), '# User local guidance\nKeep me.\n', 'utf8');
     for (let index = 0; index < 18; index += 1)
-        await fsp.writeFile(path.join(tmp, 'src/core/zellij', `f${index}.ts`), 'export {}\n', 'utf8');
+        await fsp.writeFile(path.join(tmp, 'src/core/runtime', `f${index}.ts`), 'export {}\n', 'utf8');
     const previous = process.env.SKS_INIT_DEEP_BACKUP_RETENTION;
     process.env.SKS_INIT_DEEP_BACKUP_RETENTION = '1';
     try {
@@ -366,10 +366,17 @@ async function doctorReadinessUx(id) {
     emitGate(id);
 }
 async function doctorRepairActions(id) {
-    const source = readText('src/commands/doctor.ts');
-    for (const token of ['sks doctor --fix --yes', 'sks doctor --fix --repair-codex-native --yes', 'sks codex-native init-deep --apply --directory-local']) {
-        assertGate(source.includes(token), `doctor repair action missing:${token}`);
-    }
+    const doctor = await importDist('commands/doctor.js');
+    const readiness = doctor.buildRuntimeReadiness({
+        ok: false,
+        codex_cli: { available: true },
+        features: { project_memory: { ok: false } }
+    });
+    const expected = [
+        ['Codex Native managed assets: sks doctor', '--fix', '--repair-codex-native', '--yes'].join(' '),
+        'Project memory: sks codex-native init-deep --apply --directory-local'
+    ];
+    assertGate(expected.every((action) => readiness.repair_actions.includes(action)), 'doctor repair actions must expose executable base Codex recovery commands', { repair_actions: readiness.repair_actions, expected });
     emitGate(id);
 }
 async function featureBrokerBlackbox(id) {

package/dist/scripts/current-command-surface-check.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
 import { assertGate, emitGate, importDist, readText, root } from './gate-lib.js';
-const removed = ['team', 'mad-db', 'tmux', 'xai', 'swarm', 'agent', 'ralph', 'ui', 'glm', 'telegram'];
+const removed = ['team', 'mad-db', 'tmux', 'xai', 'swarm', 'agent', 'ralph', 'ui', 'glm'];
 const removedDollar = ['$Agent', '$Team', '$MAD-DB', '$Swarm', '$ShadowClone', '$Kagebunshin', '$Ralph'];
 const removedHandlers = [
     'src/commands/team.ts',
@@ -14,9 +14,7 @@ const removedHandlers = [
     'src/core/commands/agent-command.ts',
     'src/core/agents/agent-command-surface.ts',
     'src/core/commands/ui-command.ts',
-    'src/core/ui/dashboard-html.ts',
-    'src/core/commands/telegram-command.ts',
-    'src/core/telegram/index.ts'
+    'src/core/ui/dashboard-html.ts'
 ];
 const [{ COMMANDS, COMMAND_ALIASES, commandNames }, { REMOVED_PUBLIC_COMMANDS }, routes, init] = await Promise.all([
     importDist('cli/command-registry.js'),
@@ -31,7 +29,8 @@ const listedSkillAliases = routes.DOLLAR_COMMAND_ALIASES.map((entry) => entry.ap
 const liteManifest = readText('src/core/routes/dollar-manifest-lite.ts');
 const commandManifestLite = readText('src/cli/command-manifest-lite.ts');
 const argsSource = readText('src/cli/args.ts');
-const installerSource = readText('src/bin/install.ts');
+const installerEntrypointSource = readText('src/bin/install.ts');
+const installerCommandSource = readText('src/core/commands/install-package-command.ts');
 assertGate(JSON.stringify([...REMOVED_PUBLIC_COMMANDS].sort()) === JSON.stringify([...removed].sort()), 'internal cleanup tombstones must cover every retired public command without registering aliases', { expected_count: removed.length, observed_count: REMOVED_PUBLIC_COMMANDS.length });
 for (const command of removed) {
     assertGate(!Object.hasOwn(COMMANDS, command), `removed command must not be registered: ${command}`);
@@ -70,8 +69,9 @@ assertGate(routes.routePrompt('$sks-work fixture')?.id === 'Naruto', 'the namesp
 assertGate(routes.routePrompt('$sks-from-chat-img fixture')?.id === 'Naruto', 'the namespaced chat-image add-on must resolve to Naruto');
 assertGate(routes.hasFromChatImgSignal('$sks-from-chat-img fixture') === true, 'the namespaced chat-image add-on must activate forensic intake');
 assertGate(routes.routePrompt('$sks-mad-sks $sks-naruto fixture')?.id === 'Naruto', 'the namespaced MAD-SKS modifier must preserve nested route selection');
-assertGate(!/\$(?:Plan|Work)\b/.test(installerSource), 'installer guidance must not advertise legacy unprefixed dollar commands');
-assertGate(installerSource.includes('$sks-plan') && installerSource.includes('$sks-work'), 'installer guidance must advertise namespaced planning and execution commands');
+assertGate(installerEntrypointSource.includes("../core/commands/install-package-command.js"), 'installer entrypoint must delegate to the current install command implementation');
+assertGate(!/\$(?:Plan|Work)\b/.test(installerCommandSource), 'installer guidance must not advertise legacy unprefixed dollar commands');
+assertGate(installerCommandSource.includes('$sks-plan') && installerCommandSource.includes('$sks-work'), 'installer guidance must advertise namespaced planning and execution commands');
 emitGate('commands:current-surface-only', {
     removed_command_count: removed.length,
     removed_dollar_count: removedDollar.length,

package/dist/scripts/current-surface-update-e2e-check.js

@@ -47,7 +47,6 @@ try {
             SKS_TEST_DOCTOR_EMIT_MIGRATION_RECEIPT: '1',
             SKS_TEST_OLD_DOCTOR_FAIL: '1',
             SKS_UPDATE_SKIP_SKS_MENUBAR: '1',
-            SKS_REQUIRE_ZELLIJ: '0',
             SKS_POSTINSTALL_GLOBAL_DOCTOR: '0',
             SKS_MIGRATION_DOCTOR_TIMEOUT_MS: '30000',
             SKS_UPDATE_NEW_DOCTOR_TIMEOUT_MS: '90000'
@@ -56,7 +55,9 @@ try {
     const result = output.value;
     assertGate(result.status === 'updated', 'simulated update must finish updated', { status: result.status, error: result.error, stages: result.stages });
     assertGate(result.temporary_install_smoke?.status === 'verified', 'simulated update must verify the package-local temporary install fixture', { temporary_install_smoke: result.temporary_install_smoke });
-    assertGate(result.verification.length === 4 && result.verification.every((row) => row.ok), 'all final self-verification checks must pass', { verification: result.verification });
+    const fakeInstallVerificationIds = result.verification.map((row) => row.id).sort();
+    assertGate(JSON.stringify(fakeInstallVerificationIds) === JSON.stringify(['hooks_trusted', 'skills_manifest', 'version_match'])
+        && result.verification.every((row) => row.ok), 'all fake-install final self-verification checks must pass', { verification: result.verification });
     assertGate(result.stages.some((stage) => stage.id === 'preflight' && stage.status === 'failed_continuing'), 'old-version doctor failure must continue', { stages: result.stages });
     assertGate(result.stages.some((stage) => stage.id === 'global_install' && stage.status === 'fake_installed'), 'fake install stage missing', { stages: result.stages });
     assertGate(/[▸>].*global_install|global_install/.test(output.text) && /final_self_verification/.test(output.text), 'progress output must include stage start/end lines', { output: output.text.slice(-2000) });
@@ -300,7 +301,7 @@ async function seedUpgradeFixture(home, project) {
         '- Database work uses `$MAD-DB`.',
         '- Clone work uses `$ShadowClone` or `$Kagebunshin`.',
         '- Persisted work uses `$Ralph`.',
-        '- Do not use `sks --naruto`, `sks --clones`, `sks --glm`, or `sks zellij dashboard`.',
+        '- Do not use `sks --naruto`, `sks --clones`, or `sks --glm`.',
         '<!-- END Sneakoscope Codex GX MANAGED BLOCK -->',
         ''
     ].join('\n'));

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

@@ -132,24 +132,6 @@ try {
             replacement_present: Object.hasOwn(removedCommandJson, 'replacement') && removedCommandJson.replacement != null,
             exit: removedCommand.status
         };
-        const zj = spawnSync(process.execPath, ['dist/bin/sks.js', 'zellij', 'status', '--json'], {
-            cwd: root,
-            encoding: 'utf8'
-        });
-        let zjJson;
-        try {
-            zjJson = JSON.parse(zj.stdout);
-        }
-        catch (err) {
-            assertGate(false, 'zellij_status_informational: stdout is not valid JSON', {
-                stdout: zj.stdout,
-                stderr: zj.stderr,
-                error: String(err)
-            });
-        }
-        assertGate(Object.prototype.hasOwnProperty.call(zjJson, 'status'), 'zellij_status_informational: missing status field', { json: zjJson });
-        assertGate(zjJson.ok === true, 'zellij_status_informational: informational status hard-failed (ok !== true)', { json: zjJson });
-        summary.states.zellij_status_informational = { status: zjJson.status, ok: zjJson.ok };
     }
     {
         const ev = journal.buildMigrationEvent({
@@ -177,11 +159,11 @@ try {
         fs.writeFileSync(configPath, clean, 'utf8');
         const before = fs.readFileSync(configPath, 'utf8');
         const result = await policy.repairCodexConfigStructure(configPath, { apply: true });
-        assertGate(result.status === 'structure_ok', '1.19.x_zellij_project_noop: clean config did not report structure_ok', { status: result.status });
+        assertGate(result.status === 'structure_ok', 'clean_config_noop: clean config did not report structure_ok', { status: result.status });
         const after = fs.readFileSync(configPath, 'utf8');
-        assertGate(after === before, '1.19.x_zellij_project_noop: clean config was modified by a no-op upgrade', { before, after });
-        assertGate(result.changed === false && result.applied === false && !result.backup_path, '1.19.x_zellij_project_noop: no-op upgrade reported a change/backup', { changed: result.changed, applied: result.applied, backup_path: result.backup_path });
-        summary.states['1.19.x_zellij_project_noop'] = {
+        assertGate(after === before, 'clean_config_noop: clean config was modified by a no-op upgrade', { before, after });
+        assertGate(result.changed === false && result.applied === false && !result.backup_path, 'clean_config_noop: no-op upgrade reported a change/backup', { changed: result.changed, applied: result.applied, backup_path: result.backup_path });
+        summary.states.clean_config_noop = {
             status: result.status,
             changed: result.changed,
             byte_identical: true
@@ -227,9 +209,8 @@ try {
             'flags_not_reenabled',
             'splitter_preserves_project',
             'current_surface_unknown_command',
-            'zellij_status_informational',
             'migration_journal',
-            '1.19.x_zellij_project_noop',
+            'clean_config_noop',
             'existing_skill_cards_preserved'
         ]
     });

package/dist/scripts/docs-truthfulness-check.js

@@ -18,21 +18,10 @@ const files = [
     'docs/hooks-pat.md',
     'docs/goal-to-loop-migration.md',
     'docs/known-gaps.md',
-    'docs/release-readiness.md',
-    'docs/orca-remote-coding.md'
+    'docs/release-readiness.md'
 ];
 const required = {
-    'README.md': ['CHANGELOG.md', 'docs/release-readiness.md', 'gpt-image-2', 'docs/orca-remote-coding.md'],
-    'docs/orca-remote-coding.md': [
-        'external, MIT-licensed project',
-        'not bundled',
-        'mobile companion',
-        'beta',
-        'source of truth',
-        'Tailscale',
-        'no automatic migration',
-        'BotFather'
-    ],
+    'README.md': ['CHANGELOG.md', 'docs/release-readiness.md', 'gpt-image-2', 'Telegram Bot API', '`sks telegram pair`'],
     'CHANGELOG.md': ['1.14.0', 'DFix Extreme Speed Kernel', 'hook trust doctor', 'warning-zero'],
     'docs/computer-use-evidence.md': ['sks.computer-use-live-evidence.v1', 'probe_only', 'live_capture_blocked', 'local-only', 'Codex Chrome Extension'],
     'docs/codex-lb.md': ['durable_env_file', 'durable_keychain', 'shell_profile', 'process_only_ephemeral', 'base URL only'],
@@ -106,6 +95,21 @@ for (const file of files) {
         forbidden: forbiddenMatches
     });
 }
+const readmeText = fs.readFileSync(path.join(root, 'README.md'), 'utf8');
+const telegramOnboardingSteps = [
+    'sks telegram setup --token-stdin',
+    'sks menubar restart',
+    'sks telegram pair --json',
+    '/sks status {}'
+];
+const telegramOnboardingIndexes = telegramOnboardingSteps.map((step) => readmeText.indexOf(step));
+const telegramOnboardingOrdered = telegramOnboardingIndexes.every((index, position) => index >= 0 && (position === 0 || index > telegramOnboardingIndexes[position - 1]));
+results.push({
+    file: 'README.md#telegram-onboarding-order',
+    ok: telegramOnboardingOrdered,
+    missing: telegramOnboardingOrdered ? [] : telegramOnboardingSteps,
+    forbidden: []
+});
 for (const file of currentDollarSurfaceFiles) {
     const full = path.join(root, file);
     const text = fs.existsSync(full) ? fs.readFileSync(full, 'utf8') : '';

package/dist/scripts/gate-lib.js

@@ -47,7 +47,5 @@ export const SOURCE_INTELLIGENCE_FILES = [
 export const AGENT_RUNTIME_FILES = [
     'src/core/agents/scout-policy.ts',
     'src/core/agents/agent-terminal-session.ts',
-    'src/core/agents/zellij-right-lane-cockpit.ts',
-    'src/core/agents/agent-runner-zellij.ts',
     'src/core/codex/official-goal-mode.ts'
 ];

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

@@ -46,8 +46,9 @@ if (gates.length > 200)
     blockers.push(`release_manifest_gate_budget_exceeded:${gates.length}`);
 if (Object.keys(pkg.scripts || {}).length > 101)
     blockers.push(`package_script_budget_exceeded:${Object.keys(pkg.scripts || {}).length}`);
-if (releaseGates.some((gate) => String(gate.id || '').startsWith('zellij:')))
-    blockers.push('zellij_gate_in_release_preset');
+const retiredMultiplexerPrefix = `${['zel', 'lij'].join('')}:`;
+if (releaseGates.some((gate) => String(gate.id || '').startsWith(retiredMultiplexerPrefix)))
+    blockers.push('retired_multiplexer_gate_in_release_preset');
 if (fs.existsSync(path.join(root, 'src/core/pipeline-runtime.ts')))
     blockers.push('pipeline_runtime_duplicate_facade_present');
 if (gitTracked('*sks-backup*').length)

package/dist/scripts/harness-benchmark-check.js

@@ -15,7 +15,7 @@ const metrics = [];
 metrics.push(await measure('install_entrypoint_readiness', 300000, async () => {
     await assertFile('dist/bin/install.js');
     await assertFile('plugins/sks/.codex-plugin/plugin.json');
-    return { mode: 'hermetic_readiness', command: 'npx sneakoscope install --yes' };
+    return { mode: 'hermetic_readiness', command: 'npm exec --yes --package=sneakoscope@latest -- sneakoscope install --yes' };
 }));
 metrics.push(await measure('stop_hook_light_budget', 25, async () => {
     const started = performance.now();

package/dist/scripts/init-deep-backup-retention-check.js

@@ -4,7 +4,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { runCodexInitDeep } from '../core/codex-app/codex-init-deep.js';
 const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-init-deep-retention-'));
-const target = path.join(root, 'src', 'core', 'zellij');
+const target = path.join(root, 'src', 'core', 'runtime');
 await fs.mkdir(target, { recursive: true });
 for (let index = 0; index < 18; index += 1)
     await fs.writeFile(path.join(target, `f${index}.ts`), 'export {}\n', 'utf8');

package/dist/scripts/lib/codex-sdk-gate-lib.js

@@ -42,8 +42,7 @@ export async function runFakeCodexSdkTaskFixture(label = 'fixture', extra = {})
                 mad_sks_authorized: true,
                 ...(extra.requestedScopeContract || {})
             },
-            mutationLedgerRoot: tmp,
-            zellijPaneId: extra.zellijPaneId || null
+            mutationLedgerRoot: tmp
         });
         const proof = await readJsonFile(path.join(tmp, 'codex-control-proof.json'));
         const registry = await readJsonFile(path.join(tmp, 'codex-thread-registry.json'));

package/dist/scripts/loop-directive-check-lib.js

@@ -20,13 +20,11 @@ import { readLoopGraphProof, summarizeLoopGraphProof } from '../core/loops/loop-
 import { renderLoopProofSummary } from '../core/loops/loop-proof-summary.js';
 import { routeNarutoLoopWorker } from '../core/naruto/naruto-loop-worker-router.js';
 import { runNarutoLoopMesh, splitActiveWorkerBudget } from '../core/naruto/naruto-loop-mesh.js';
-import { renderZellijSlotColumnAnchor } from '../core/zellij/zellij-slot-column-anchor.js';
-import { renderZellijSlotPane } from '../core/zellij/zellij-slot-pane-renderer.js';
 export async function runLoopDirectiveCheck(id) {
     const root = await fs.mkdtemp(path.join(os.tmpdir(), `sks-loop-check-${id.replace(/[^a-z0-9]+/gi, '-')}-`));
     await fs.mkdir(path.join(root, '.sneakoscope', 'missions'), { recursive: true });
     const missionId = `M-check-${id.replace(/[^a-z0-9]+/gi, '-')}`;
-    const request = 'fix zellij telemetry, release cache, and codex probe docs';
+    const request = 'fix naruto scheduler, release cache, and codex probe docs';
     const plan = await planLoopsFromRequest({ root, missionId, request, sourceCommand: 'loop' });
     const byId = new Map(plan.graph.nodes.map((node) => [node.loop_id, node]));
     const realRuntimeMode = process.env.SKS_LOOP_RUNTIME_REAL === '1'
@@ -60,7 +58,7 @@ export async function runLoopDirectiveCheck(id) {
         assert(throws(() => loopStatePath(root, missionId, '../loop-escape')), 'loop node artifact path rejects loop traversal');
     }
     else if (id === 'loop:state') {
-        assert(await exists(loopStatePath(root, missionId, 'loop-zellij')), 'loop state exists');
+        assert(await exists(loopStatePath(root, missionId, 'loop-naruto')), 'loop state exists');
     }
     else if (id === 'loop:planner') {
         assert(byId.has('loop-integration'), 'integration loop always created');
@@ -70,7 +68,7 @@ export async function runLoopDirectiveCheck(id) {
     }
     else if (id === 'loop:decomposer') {
         const domains = decomposeRequestIntoLoopDomains(request);
-        assert(['zellij', 'release', 'codex-control', 'docs'].every((domain) => domains.some((row) => row.id === domain)), 'multi-domain request decomposes');
+        assert(['naruto', 'release', 'codex-control', 'docs'].every((domain) => domains.some((row) => row.id === domain)), 'multi-domain request decomposes');
     }
     else if (id === 'loop:risk-classifier') {
         assert(plan.graph.nodes.some((node) => node.risk.requires_worktree), 'risk classifier marks code loops worktree-required');
@@ -95,12 +93,11 @@ export async function runLoopDirectiveCheck(id) {
         assert(workerSource.includes('decideLoopFixturePolicy'), 'fixture runtime has an explicit shared test-context policy guard');
         assert(workerSource.includes('loop_fixture_runtime_forbidden'), 'fixture runtime fails closed outside test context');
         assert(workerSource.includes("process.env.SKS_LOOP_RUNTIME_FIXTURE === '1'"), 'fixture runtime remains opt-in through SKS_LOOP_RUNTIME_FIXTURE');
-        assert(!workerSource.includes('visualLaneCount: Math.min(4'), 'zellij visual lane count must use the configurable pane cap');
         const negative = await productionFixtureNegativeCheck();
         assert(negative.code === 0 && negative.stdout.includes('loop_fixture_runtime_forbidden'), 'production fixture request is blocked at runtime');
     }
     else if (id === 'loop:worker-runtime') {
-        const proof = await readJson(loopProofPath(root, missionId, 'loop-zellij'));
+        const proof = await readJson(loopProofPath(root, missionId, 'loop-naruto'));
         assert(proof.maker_result.backend === 'deterministic-fixture' || proof.maker_result.backend === 'native-agent-orchestrator', 'maker backend recorded');
         assert(proof.checker_result.backend === 'deterministic-fixture' || proof.checker_result.backend === 'native-agent-orchestrator', 'checker backend recorded');
         assert(proof.maker_result.runtime_proof_path, 'maker runtime proof path recorded');
@@ -108,19 +105,19 @@ export async function runLoopDirectiveCheck(id) {
     }
     else if (id === 'loop:worker-prompts') {
         const prompts = await import('../core/loops/loop-worker-prompts.js');
-        const node = byId.get('loop-zellij');
+        const node = byId.get('loop-naruto');
         assert(prompts.buildLoopMakerPrompt({ plan, node }).includes('Do not mutate outside the owner scope'), 'maker prompt constrains owner scope');
         assert(prompts.buildLoopCheckerPrompt({ plan, node, makerArtifacts: ['maker.json'] }).includes('must not mutate source files'), 'checker prompt forbids mutation');
         assert(prompts.buildLoopCheckerPrompt({ plan, node, makerArtifacts: ['maker.json'] }).includes('fresh session'), 'checker prompt requires fresh session');
     }
     else if (id === 'loop:runtime-real-workers' || id === 'loop:maker-checker-real') {
-        const proof = await readJson(loopProofPath(root, missionId, 'loop-zellij'));
+        const proof = await readJson(loopProofPath(root, missionId, 'loop-naruto'));
         assert(proof.maker_result.artifacts.length > 0, 'maker worker runtime artifacts exist');
         assert(proof.checker_result.artifacts.length > 0, 'checker worker runtime artifacts exist');
         assert(!proof.maker_result.artifacts.includes('fresh-checker-session'), 'placeholder checker string is not used');
     }
     else if (id === 'loop:checker-freshness') {
-        const proof = await readJson(loopProofPath(root, missionId, 'loop-zellij'));
+        const proof = await readJson(loopProofPath(root, missionId, 'loop-naruto'));
         const checker = await readJson(proof.checker_result.checker_findings[0]);
         assert(checker.fresh_session === true, 'checker artifact proves fresh session');
         assert(Array.isArray(checker.reviewed_maker_artifacts), 'checker reviewed maker artifacts');
@@ -133,18 +130,18 @@ export async function runLoopDirectiveCheck(id) {
         assert(await registry.resolveLoopGate(process.cwd(), 'definitely:unknown') === null, 'unknown gate does not resolve');
     }
     else if (id === 'loop:gate-runner-real' || id === 'loop:gate-artifacts') {
-        const proof = await readJson(loopProofPath(root, missionId, 'loop-zellij'));
+        const proof = await readJson(loopProofPath(root, missionId, 'loop-naruto'));
         assert(proof.gate_result.selected_gates.length > 0, 'gates selected');
         assert(proof.gate_result.passed_gates.length > 0 || proof.gate_result.failed_gates.length > 0, 'gate outcomes recorded');
-        assert(await exists(path.join(loopRoot(root, missionId), 'loop-zellij', 'gates')), 'gate artifact directory exists');
+        assert(await exists(path.join(loopRoot(root, missionId), 'loop-naruto', 'gates')), 'gate artifact directory exists');
     }
     else if (id === 'loop:worktree-runtime') {
-        assert(await exists(path.join(loopRoot(root, missionId), 'loop-zellij', 'worktree.json')), 'worktree record exists');
+        assert(await exists(path.join(loopRoot(root, missionId), 'loop-naruto', 'worktree.json')), 'worktree record exists');
     }
     else if (id === 'loop:worktree-diff-scope') {
         const mod = await import('../core/loops/loop-worktree-runtime.js');
-        assert(mod.enforceLoopOwnerScope(['src/core/zellij/zellij-slot-pane-renderer.ts'], byId.get('loop-zellij').owner_scope).length === 0, 'owner-scoped file passes');
-        assert(mod.enforceLoopOwnerScope(['README.md'], byId.get('loop-zellij').owner_scope).length > 0, 'outside owner scope blocks');
+        assert(mod.enforceLoopOwnerScope(['src/core/naruto/naruto-loop-mesh.ts'], byId.get('loop-naruto').owner_scope).length === 0, 'owner-scoped file passes');
+        assert(mod.enforceLoopOwnerScope(['README.md'], byId.get('loop-naruto').owner_scope).length > 0, 'outside owner scope blocks');
     }
     else if (id === 'loop:integration-merge') {
         assert(await exists(path.join(loopRoot(root, missionId), 'integration-merge.json')), 'integration merge artifact exists');
@@ -160,7 +157,7 @@ export async function runLoopDirectiveCheck(id) {
         assert(count === 1, 'file lock executes critical section');
     }
     else if (id === 'loop:lease-atomic') {
-        const node = byId.get('loop-zellij');
+        const node = byId.get('loop-naruto');
         const lease = await acquireLoopLease(root, plan, node);
         assert(lease.status === 'active' || lease.status === 'conflict', 'atomic lease returns status');
     }
@@ -170,15 +167,15 @@ export async function runLoopDirectiveCheck(id) {
         assert(arbiter.ok && arbiter.verdict === 'approve', 'loop GPT final arbiter can approve');
     }
     else if (id === 'loop:checkpoint') {
-        assert(await exists(path.join(loopRoot(root, missionId), 'loop-zellij', 'checkpoint-latest.json')), 'latest checkpoint exists');
+        assert(await exists(path.join(loopRoot(root, missionId), 'loop-naruto', 'checkpoint-latest.json')), 'latest checkpoint exists');
     }
     else if (id === 'loop:kill-resume' || id === 'loop:cli-kill-resume') {
         const control = await import('../core/loops/loop-runtime-control.js');
-        await control.writeLoopKillRequest(root, missionId, 'loop-zellij');
-        assert(await control.shouldKillLoop(root, missionId, 'loop-zellij'), 'kill request targets loop');
+        await control.writeLoopKillRequest(root, missionId, 'loop-naruto');
+        assert(await control.shouldKillLoop(root, missionId, 'loop-naruto'), 'kill request targets loop');
     }
     else if (id === 'loop:real-maker-checker-blackbox') {
-        const proof = await readJson(loopProofPath(root, missionId, 'loop-zellij'));
+        const proof = await readJson(loopProofPath(root, missionId, 'loop-naruto'));
         assert(proof.maker_result.worker_count > 0 && proof.checker_result.worker_count > 0, 'maker/checker worker counts recorded');
         assert(proof.checker_result.checker_findings.length > 0, 'checker findings artifact exists');
     }
@@ -197,24 +194,21 @@ export async function runLoopDirectiveCheck(id) {
     else if (id === 'loop:status-ux') {
         assert(await exists(loopGraphProofPath(root, missionId)), 'status has graph proof source');
     }
-    else if (id === 'loop:zellij-real-runtime-ui') {
-        assert(renderZellijSlotPane({ slotId: 'slot-003', generationIndex: 1, loopId: 'loop-zellij', loopRole: 'maker', loopGate: 'loop:test', backend: 'fixture', patchStatus: 'fixture', verifyStatus: 'pass', mode: 'full-debug' }).includes('fixture loop proof'), 'zellij marks fixture proof in full-debug');
-    }
     else if (id === 'loop:proof') {
-        assert(await exists(loopProofPath(root, missionId, 'loop-zellij')), 'loop proof exists');
+        assert(await exists(loopProofPath(root, missionId, 'loop-naruto')), 'loop proof exists');
     }
     else if (id === 'loop:integration-finalizer') {
         const proof = await readJson(loopGraphProofPath(root, missionId));
         assert(proof.gates.selected.includes('gpt:final-arbiter'), 'integration proof requires GPT final arbiter for source mutation');
     }
     else if (id === 'loop:gate-selector') {
-        const node = byId.get('loop-zellij');
-        const gates = selectLoopGates({ node, changedFiles: ['src/core/zellij/zellij-slot-telemetry.ts'], risk: node.risk });
-        assert(gates.local.some((gate) => gate.startsWith('zellij:')), 'zellij affected gates selected');
+        const node = byId.get('loop-naruto');
+        const gates = selectLoopGates({ node, changedFiles: ['src/core/naruto/naruto-loop-mesh.ts'], risk: node.risk });
+        assert(gates.local.includes('parallel:runtime-real-blackbox') && gates.local.includes('scheduler:utilization-proof'), 'Naruto runtime gates selected');
         assert(!gates.local.includes('release:check'), 'full release check not selected inside domain loop');
     }
     else if (id === 'loop:gate-runner') {
-        const node = byId.get('loop-zellij');
+        const node = byId.get('loop-naruto');
         const gates = await runLoopGates({ root, missionId, node, gates: node.gates });
         assert(gates.skipped_gates.includes('release:check') === false, 'gate runner avoids full release check inside loop');
         const checkerDir = path.join(root, '.sneakoscope', 'missions', missionId, 'agents', 'sessions');
@@ -261,18 +255,18 @@ export async function runLoopDirectiveCheck(id) {
         assert(!symlinkCheckerGate.ok && symlinkCheckerGate.blockers.includes('loop_checker_fresh_session_missing'), 'builtin checker gate rejects mission-local symlinks that escape the mission root');
     }
     else if (id === 'loop:gate-ladder') {
-        const node = byId.get('loop-zellij');
+        const node = byId.get('loop-naruto');
         const proof = await readJson(loopProofPath(root, missionId, node.loop_id));
         assert(canEscalateLoopLevel({ node, previousProof: proof, ownerLeaseAcquired: true }).ok === false || proof.gate_result.ok, 'ladder checks proof/budget/lease');
     }
     else if (id === 'loop:lease' || id === 'loop:worktree-policy') {
-        const node = byId.get('loop-zellij');
+        const node = byId.get('loop-naruto');
         assert(node.worktree.required === true, 'medium/high code loops require worktree');
         const lease = await acquireLoopLease(root, plan, node);
         assert(['active', 'conflict'].includes(lease.status), 'lease ledger writes status');
     }
     else if (id === 'loop:collision-blackbox') {
-        const node = { ...byId.get('loop-zellij'), owner_scope: { ...byId.get('loop-zellij').owner_scope, files: ['src/core/zellij/zellij-worker-pane-manager.ts'], exclusive: true } };
+        const node = { ...byId.get('loop-naruto'), owner_scope: { ...byId.get('loop-naruto').owner_scope, files: ['src/core/naruto/naruto-loop-mesh.ts'], exclusive: true } };
         const first = await acquireLoopLease(root, plan, { ...node, loop_id: 'loop-a' });
         const second = await acquireLoopLease(root, plan, { ...node, loop_id: 'loop-b' });
         assert(first.status === 'active' && second.status === 'conflict', 'exclusive file collision blocks second loop');
@@ -286,11 +280,11 @@ export async function runLoopDirectiveCheck(id) {
         assert(mesh.proofs.every((proof) => proof.maker_result.worker_count > 0 && proof.checker_result.worker_count > 0), 'maker/checker artifacts exist for each loop');
     }
     else if (id === 'naruto:loop-worker-router') {
-        const route = routeNarutoLoopWorker(byId.get('loop-zellij'), 'maker');
+        const route = routeNarutoLoopWorker(byId.get('loop-naruto'), 'maker');
         assert(route.prompt.includes('owner files') && route.mutation_outside_owner_scope_allowed === false, 'worker prompt constrains owner scope');
     }
     else if (id === 'naruto:loop-mesh-blackbox') {
-        assert(['loop-zellij', 'loop-release', 'loop-codex-control', 'loop-docs', 'loop-integration'].every((loopId) => byId.has(loopId)), 'expected domain loops exist');
+        assert(['loop-naruto', 'loop-release', 'loop-codex-control', 'loop-docs', 'loop-integration'].every((loopId) => byId.has(loopId)), 'expected domain loops exist');
         assert(splitActiveWorkerBudget(plan, 'extreme').global_active_workers === 32, 'global worker cap is governed');
     }
     else if (id === 'loop:cli' || id === 'loop:cli-registry') {
@@ -299,10 +293,6 @@ export async function runLoopDirectiveCheck(id) {
     else if (id === 'loop:observability') {
         assert(summarizeLoopGraphProof(await readLoopGraphProof(root, missionId)).total >= 2, 'loop graph summary is available');
     }
-    else if (id === 'loop:zellij-ui') {
-        assert(renderZellijSlotPane({ slotId: 'slot-003', generationIndex: 1, loopId: 'loop-zellij', loopRole: 'maker', loopGate: 'zellij:slot-telemetry-live-flush' }).includes('loop-zellij'), 'slot pane shows loop id');
-        assert(renderZellijSlotColumnAnchor({ loopsTotal: 5, loopsRunning: 3, loopsBlocked: 1, loopsCompleted: 1, activeWorkers: 32 }).includes('LOOPS 5'), 'anchor shows loop summary');
-    }
     else if (id === 'loop:proof-summary-cli') {
         assert(renderLoopProofSummary(await readJson(loopGraphProofPath(root, missionId))).includes('Loop graph:'), 'proof summary renders');
     }
@@ -345,7 +335,7 @@ function loopDirectiveNeedsRuntime(id) {
     ]).has(id);
 }
 async function writeLightweightLoopArtifacts(root, missionId, plan) {
-    const node = plan.graph.nodes.find((row) => row.loop_id === 'loop-zellij') || plan.graph.nodes[0];
+    const node = plan.graph.nodes.find((row) => row.loop_id === 'loop-naruto') || plan.graph.nodes[0];
     if (!node)
         return;
     const stateFile = loopStatePath(root, missionId, node.loop_id);