sneakoscope 4.0.3 → 4.0.5

package/README.md

@@ -35,15 +35,16 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **4.0.3** adds a GLM 5.2-only MAD mode through OpenRouter while preserving the proof-first SKS pipeline. `sks --mad --glm` resolves the GLM profile, keeps GPT/OpenAI fallback disabled, and records model-lock proof; `sks --mad --glm --repair` rotates the OpenRouter API key outside project files.
+SKS **4.0.5** tunes only the GLM 5.2 MAD path: `sks --mad --glm` now defaults to an xhigh reasoning profile while recovering speed through compact GLM context, disabled default tools, streaming, request/schema caches, and redacted bench/trace artifacts. Ordinary `sks --mad`, Naruto/Team, and non-GLM Codex paths keep their existing defaults.
 
-What changed in 4.0.3:
+What changed in 4.0.5:
 
-- **GLM 5.2 MAD mode.** `sks --mad --glm` enters a `mad-glm` profile using OpenRouter model `z-ai/glm-5.2`.
-- **No GPT fallback.** GLM requests use `provider.allow_fallbacks: false`, omit fallback `models`, and reject non-GLM response model ids before mutation.
-- **OpenRouter key lifecycle.** Keys resolve from `OPENROUTER_API_KEY`, `SKS_OPENROUTER_API_KEY`, or the user SKS secret store; stored keys use private permissions and redacted metadata.
-- **Codex App profile.** `sks codex-app glm-profile install` writes the `sks/glm-5.2-mad` profile metadata for Codex App selection.
-- **Codex 0.141 alignment.** SKS delegates remote relay, cwd/shell/path preservation, selected plugin MCP activation, App/MCP dedupe, bounded prompt-image cache, bounded feedback upload, and terminal resize behavior to Codex-native semantics where available.
+- **GLM-only xhigh speed profile.** `sks --mad --glm` keeps OpenRouter locked to `z-ai/glm-5.2`, uses `reasoning.effort: xhigh`, and bounds the default completion budget to the speed profile instead of changing global SKS reasoning defaults.
+- **Compact GLM request shape.** The GLM speed profile uses streaming, `tool_choice: none`, no fallback `models`, `provider.allow_fallbacks: false`, `provider.require_parameters: true`, and throughput/latency provider preferences.
+- **Opt-in GLM depth controls.** `--deep`, `--xhigh`, `--strict`, `--ttft`, and `--exact-provider` select explicit GLM profiles without affecting non-GLM routes.
+- **GLM speed infrastructure.** GLM-only context budgeting, encoded request cache, tool schema cache, model metadata cache, output envelope parsing, deterministic patch gating, latency traces, and `--bench` dry-run diagnostics are covered by tests.
+- **No GPT fallback panes.** GLM MAD keeps the existing GPT/codex-sdk native swarm disabled by default until a GLM worker backend exists, preserving the no-fallback guarantee.
+- **4.0.4 GLM launch proof remains.** Each GLM MAD launch still writes `mad-glm-launch.json` with provider/model/profile/wrapper evidence and keeps OpenRouter keys out of layout artifacts.
 
 SKS **3.1.16** was a launch-reliability patch on the 3.1.15 doctor-reliability release. It made `sks --mad` self-bootstrap a fresh project instead of dead-ending on a missing Codex config.
 
@@ -395,7 +396,7 @@ sks team open-zellij latest
 sks team attach-zellij latest
 ```
 
-Interactive SKS sessions use Zellij layouts. By default SKS launches Codex in Fast service tier with `--model gpt-5.5`, `-c service_tier="fast"`, the selected `model_reasoning_effort`, and `--no-alt-screen` for Zellij-backed interactive panes so terminal scrollback captures the conversation transcript. SKS always forces the model to `gpt-5.5`; `SKS_CODEX_MODEL` and `SKS_CODEX_FAST_HIGH=0` cannot downgrade or remove that model pin. You can still set `SKS_CODEX_REASONING` to change reasoning effort, and `SKS_ZELLIJ_CODEX_ALT_SCREEN=1` restores Codex's alternate-screen UI for the next launch. Use `sks --mad --workspace <name>` for an explicit MAD session and `sks help` for CLI help.
+Interactive SKS sessions use Zellij layouts. By default SKS launches Codex in Fast service tier with `--model gpt-5.5`, `-c service_tier="fast"`, the selected `model_reasoning_effort`, and `--no-alt-screen` for Zellij-backed interactive panes so terminal scrollback captures the conversation transcript. Non-GLM SKS sessions force the model to `gpt-5.5`; `sks --mad --glm` is the OpenRouter GLM 5.2 exception. `SKS_CODEX_MODEL` and `SKS_CODEX_FAST_HIGH=0` cannot downgrade or remove the non-GLM model pin. You can still set `SKS_CODEX_REASONING` to change reasoning effort, and `SKS_ZELLIJ_CODEX_ALT_SCREEN=1` restores Codex's alternate-screen UI for the next launch. Use `sks --mad --workspace <name>` for an explicit MAD session and `sks help` for CLI help.
 
 Before opening the interactive runtime, SKS checks the installed Codex CLI against npm `@openai/codex@latest`. If a newer version exists, it asks `Y/n`; answering `y` updates automatically with `npm i -g @openai/codex@latest` and then opens the runtime with the updated Codex CLI.
 

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "4.0.3"
+version = "4.0.5"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

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

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 4.0.3"),
+        Some("--version") => println!("sks-rs 4.0.5"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '4.0.3';
+const FAST_PACKAGE_VERSION = '4.0.5';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/core/codex-app/glm-profile-schema.js

@@ -13,7 +13,11 @@ export function validateGlmCodexAppModelProfile(value) {
         profile.model === GLM_52_OPENROUTER_MODEL ? null : 'glm_codex_app_profile_invalid_model',
         profile.mode === GLM_MAD_MODE ? null : 'glm_codex_app_profile_invalid_mode',
         profile.strictModelLock === true ? null : 'glm_codex_app_profile_not_strict',
-        profile.gptFallbackAllowed === false ? null : 'glm_codex_app_profile_allows_gpt_fallback'
+        profile.gptFallbackAllowed === false ? null : 'glm_codex_app_profile_allows_gpt_fallback',
+        profile.defaultProfile === 'speed' ? null : 'glm_codex_app_profile_default_not_speed',
+        profile.defaultSettings?.tool_choice === 'none' ? null : 'glm_codex_app_profile_default_tools_not_omitted',
+        profile.defaultSettings?.provider_require_parameters === true ? null : 'glm_codex_app_profile_default_does_not_require_parameters',
+        profile.defaultSettings?.provider_allow_fallbacks === false ? null : 'glm_codex_app_profile_allows_provider_fallback'
     ].filter((item) => Boolean(item));
     return {
         ok: blockers.length === 0,

package/dist/core/commands/glm-command.js

@@ -1,5 +1,24 @@
 import { runMadGlmMode } from '../providers/glm/glm-mad-mode.js';
+import { flag } from '../../cli/args.js';
+import { madHighCommand } from './mad-sks-command.js';
+import { runGlmBench } from '../providers/glm/glm-bench.js';
+import { printJson } from '../../cli/output.js';
 export async function glmCommand(args = []) {
-    return runMadGlmMode(args);
+    if (flag(args, '--bench')) {
+        const result = await runGlmBench(process.cwd(), args);
+        if (result.status === 'blocked')
+            process.exitCode = 1;
+        if (flag(args, '--json'))
+            printJson(result);
+        else if (result.status === 'blocked')
+            console.error(`GLM bench blocked: ${result.warnings.join(', ')}`);
+        else
+            console.log(`GLM bench: dry-run p50=${result.summary.speed_p50_total_ms}ms ratio=${result.summary.speed_vs_deep_ratio}`);
+        return result;
+    }
+    const result = await runMadGlmMode(args);
+    if (!result.ok || flag(args, '--repair') || flag(args, '--json'))
+        return result;
+    return madHighCommand(['--glm', ...args], { glmReadiness: result, glmArgs: args });
 }
 //# sourceMappingURL=glm-command.js.map

package/dist/core/commands/mad-sks-command.js

@@ -24,16 +24,37 @@ import { writeCodex0138CapabilityArtifacts } from '../codex-control/codex-0138-c
 import { writeCodex0139CapabilityArtifacts } from '../codex-control/codex-0139-capability.js';
 import { resolveCodexNativeInvocationPlan } from '../codex-native/codex-native-invocation-router.js';
 import { repairZellijForSks } from '../zellij/zellij-self-heal.js';
+import { buildMadGlmLaunchArtifact, buildMadGlmLaunchProfileNoWrite, resolveMadGlmLaunchKey, writeMadGlmCodexWrapper } from '../providers/glm/glm-mad-launch.js';
+import { GLM_MAD_MODE } from '../providers/glm/glm-52-settings.js';
 export async function madHighCommand(args = [], deps = {}) {
     const subcommand = firstSubcommand(args);
     if (subcommand)
         return madSksSubcommand(subcommand, args.filter((arg) => String(arg) !== subcommand));
-    const cleanArgs = stripMadLaunchOnlyArgs(args);
     const rawArgs = (args || []).map((arg) => String(arg));
+    const glmMadLaunch = isMadGlmLaunch(rawArgs, deps);
+    const glmOnlyFlagBlockers = findGlmOnlyMadFlagBlockers(rawArgs, glmMadLaunch);
+    if (glmOnlyFlagBlockers.length) {
+        const result = {
+            ok: false,
+            status: 'blocked',
+            blockers: glmOnlyFlagBlockers,
+            hint: 'GLM profile and diagnostics flags require sks --mad --glm.'
+        };
+        if (rawArgs.includes('--json'))
+            console.log(JSON.stringify(result, null, 2));
+        else {
+            console.error('SKS MAD launch blocked: GLM-only flags require --glm.');
+            for (const blocker of glmOnlyFlagBlockers)
+                console.error(`- ${blocker}`);
+        }
+        process.exitCode = 1;
+        return result;
+    }
+    const cleanArgs = stripMadLaunchOnlyArgs(args, { includeGlmFlags: glmMadLaunch });
     const madDbGrant = resolveMadLaunchMadDbGrant(rawArgs);
     const dryRun = rawArgs.includes('--dry-run');
-    if (args.includes('--json') && !dryRun) {
-        const profile = buildMadHighLaunchProfileNoWrite();
+    if (rawArgs.includes('--json') && !dryRun) {
+        const profile = glmMadLaunch ? buildMadGlmLaunchProfileNoWrite(rawArgs) : buildMadHighLaunchProfileNoWrite();
         return console.log(JSON.stringify(profile, null, 2));
     }
     const update = { status: 'notice_only', non_blocking: true };
@@ -76,7 +97,7 @@ export async function madHighCommand(args = [], deps = {}) {
         }
         return report;
     }
-    const codexUpdate = deps.maybePromptCodexUpdateForLaunch ? await deps.maybePromptCodexUpdateForLaunch(args, { label: 'MAD launch' }) : { status: 'skipped' };
+    const codexUpdate = deps.maybePromptCodexUpdateForLaunch ? await deps.maybePromptCodexUpdateForLaunch(args, { label: glmMadLaunch ? 'GLM MAD launch' : 'MAD launch' }) : { status: 'skipped' };
     if (codexUpdate.status === 'failed' || codexUpdate.status === 'updated_not_reflected') {
         console.error(`Codex CLI update failed: ${codexUpdate.error || 'updated version was not visible on PATH'}`);
         process.exitCode = 1;
@@ -86,7 +107,7 @@ export async function madHighCommand(args = [], deps = {}) {
         ? { status: 'skipped', command: 'sks doctor --fix --yes' }
         : deps.maybePromptZellijUpdateForLaunch
             ? await deps.maybePromptZellijUpdateForLaunch(args, {
-                label: 'MAD launch',
+                label: glmMadLaunch ? 'GLM MAD launch' : 'MAD launch',
                 root: launchRoot,
                 selfHealOnMissing: true,
                 autoApprove: rawArgs.includes('--yes') || rawArgs.includes('-y'),
@@ -121,8 +142,10 @@ export async function madHighCommand(args = [], deps = {}) {
         process.exitCode = 1;
         return;
     }
-    const lb = deps.maybePromptCodexLbSetupForLaunch ? await deps.maybePromptCodexLbSetupForLaunch(args) : { status: 'skipped' };
-    if (lb.status === 'missing_api_key') {
+    const lb = glmMadLaunch
+        ? { status: 'skipped_glm_openrouter', ok: false, reason: 'glm_mad_uses_openrouter_directly' }
+        : deps.maybePromptCodexLbSetupForLaunch ? await deps.maybePromptCodexLbSetupForLaunch(args) : { status: 'skipped' };
+    if (!glmMadLaunch && lb.status === 'missing_api_key') {
         process.exitCode = 1;
         return;
     }
@@ -171,6 +194,11 @@ export async function madHighCommand(args = [], deps = {}) {
         return launchPreflight;
     }
     const madLaunch = await activateMadZellijPermissionState(process.cwd(), args);
+    const glmRuntime = glmMadLaunch ? await prepareMadGlmLaunchRuntime(madLaunch, { ...deps, glmArgs: deps?.glmArgs || rawArgs }) : null;
+    if (glmMadLaunch && !glmRuntime?.ok) {
+        process.exitCode = 1;
+        return glmRuntime;
+    }
     const madDbCapability = madDbGrant.enabled
         ? await createMadDbCapability(madLaunch.root, { missionId: madLaunch.mission_id, ack: madDbGrant.ack, cwd: process.cwd() })
         : null;
@@ -221,7 +249,9 @@ export async function madHighCommand(args = [], deps = {}) {
         error: err?.message || String(err)
     }));
     await appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.update_notice_checked', non_blocking: true, update_available: updateNotice.update_available === true, source: updateNotice.source });
-    console.log(`SKS MAD ready: ${madHighProfileName()} | gate ${madLaunch.mission_id}`);
+    console.log(`SKS MAD ready: ${glmRuntime?.profile?.profile_name || madHighProfileName()} | gate ${madLaunch.mission_id}`);
+    if (glmRuntime?.profile)
+        console.log(`GLM MAD launch active: ${glmRuntime.profile.model} via OpenRouter; GPT fallback blocked.`);
     if (madDbCapability)
         console.log(`MAD-DB one-cycle capability active (${madDbGrant.source}); expires ${madDbCapability.expires_at}.`);
     if (updateNotice.update_available === true)
@@ -233,8 +263,18 @@ export async function madHighCommand(args = [], deps = {}) {
         SKS_MAD_SKS_TARGET_ROOT: madLaunch.gate.cwd,
         SKS_MAD_SKS_PROTECTED_CORE_DIGEST: madLaunch.gate.protected_core_digest
     };
-    const launchOpts = codexLbImmediateLaunchOpts(cleanArgs, launchLb, { codexArgs: profile.launch_args, conciseBlockers: true, madSksEnv, launchEnv: madSksEnv });
     const explicitWorkspace = readOption(cleanArgs, '--workspace', readOption(cleanArgs, '--session', null));
+    const launchProfile = glmRuntime?.profile || profile;
+    const launchOpts = glmRuntime
+        ? buildGlmMadLaunchOpts(cleanArgs, {
+            codexArgs: launchProfile.launch_args,
+            conciseBlockers: true,
+            madSksEnv,
+            launchEnv: madSksEnv,
+            codexBin: glmRuntime.wrapper.wrapper_path,
+            explicitWorkspace
+        })
+        : codexLbImmediateLaunchOpts(cleanArgs, launchLb, { codexArgs: launchProfile.launch_args, conciseBlockers: true, madSksEnv, launchEnv: madSksEnv });
     // Only the auto-derived stable `sks-mad-<cwd>` name accumulates panes across
     // runs; when the user names a session explicitly (or codex-lb already minted a
     // fresh unique session) respect it and skip the reset.
@@ -268,11 +308,12 @@ export async function madHighCommand(args = [], deps = {}) {
         worker_panes_created: 0,
         right_column_mode: 'spawn-on-first-worker'
     });
-    const madNativeSwarm = await startMadNativeSwarm(madLaunch.root, madLaunch, args, profile, {
+    const madNativeSwarm = await startMadNativeSwarm(madLaunch.root, madLaunch, args, launchProfile, {
         env: {
             ...madSksEnv,
             ...(launch.session_name ? { SKS_ZELLIJ_SESSION_NAME: launch.session_name } : {})
         },
+        glmLaunch: glmRuntime ? { provider: glmRuntime.profile.provider, model: glmRuntime.profile.model } : null,
         zellijSessionName: launch.session_name || null,
         workerPlacement: headlessZellij ? 'process' : shouldAutoAttachZellij(args) ? 'zellij-pane' : 'process',
         zellijVisiblePaneCap: Number(process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP || 8)
@@ -296,6 +337,73 @@ export async function madHighCommand(args = [], deps = {}) {
         console.log('MAD launch running headless: live_panes=false.');
     return launch;
 }
+function isMadGlmLaunch(args = [], deps = {}) {
+    const list = (args || []).map((arg) => String(arg));
+    return list.includes('--glm') || deps?.glmReadiness?.mode === GLM_MAD_MODE;
+}
+async function prepareMadGlmLaunchRuntime(madLaunch, deps = {}) {
+    const keyResolution = await resolveMadGlmLaunchKey(process.env);
+    const profile = buildMadGlmLaunchProfileNoWrite(deps?.glmArgs || []);
+    if (!keyResolution.key) {
+        const blocked = {
+            schema: 'sks.glm-mad-launch.v1',
+            ok: false,
+            status: 'blocked',
+            mission_id: madLaunch.mission_id,
+            provider: profile.provider,
+            model: profile.model,
+            glm_profile: profile.glm_profile,
+            glm_mode: profile.glm_mode,
+            model_reasoning_effort: profile.model_reasoning_effort,
+            gpt_fallback_allowed: false,
+            blockers: keyResolution.blockers,
+            warnings: keyResolution.warnings
+        };
+        await writeJsonAtomic(path.join(madLaunch.dir, 'mad-glm-launch.json'), blocked);
+        await appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), {
+            ts: nowIso(),
+            type: 'mad_sks.glm_launch_blocked',
+            blockers: keyResolution.blockers
+        });
+        console.error('SKS GLM MAD launch blocked: OpenRouter API key is missing.');
+        console.error('Run: sks --mad --glm --repair');
+        return blocked;
+    }
+    const wrapper = await writeMadGlmCodexWrapper({
+        missionDir: madLaunch.dir,
+        realCodexBin: process.env.SKS_CODEX_BIN || null
+    });
+    const report = {
+        ...buildMadGlmLaunchArtifact({
+            missionId: madLaunch.mission_id,
+            keyResolution,
+            wrapper,
+            profile
+        }),
+        readiness_status: deps?.glmReadiness?.status || null
+    };
+    await writeJsonAtomic(path.join(madLaunch.dir, 'mad-glm-launch.json'), report);
+    await appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), {
+        ts: nowIso(),
+        type: 'mad_sks.glm_launch_profile_ready',
+        provider: profile.provider,
+        model: profile.model,
+        glm_profile: profile.glm_profile,
+        glm_mode: profile.glm_mode,
+        model_reasoning_effort: profile.model_reasoning_effort,
+        key_source: keyResolution.source || null,
+        gpt_fallback_allowed: false
+    });
+    return { ok: true, profile, wrapper, report };
+}
+function buildGlmMadLaunchOpts(cleanArgs = [], opts = {}) {
+    if (opts.explicitWorkspace)
+        return opts;
+    const root = readOption(cleanArgs, '--root', process.cwd());
+    const session = sanitizeZellijSessionName(`sks-glm-${Date.now().toString(36)}-${path.basename(root) || 'project'}`);
+    console.log(`Using fresh GLM Zellij session: ${session}`);
+    return { ...opts, session, glmMadLaunch: true };
+}
 export function resolveMadLaunchMadDbGrant(args = []) {
     const list = (args || []).map((arg) => String(arg));
     return {
@@ -319,6 +427,9 @@ export async function startMadNativeSwarm(root, madLaunch, args = [], profile =
             status: 'disabled',
             reason: swarm.disabled_reason,
             mission_id: madLaunch.mission_id,
+            model_provider: opts.glmLaunch?.provider || null,
+            model: opts.glmLaunch?.model || null,
+            gpt_fallback_allowed: opts.glmLaunch ? false : null,
             lane_count: 1,
             ledger_root: path.relative(root, ledgerRoot)
         };
@@ -381,6 +492,9 @@ export async function startMadNativeSwarm(root, madLaunch, args = [], profile =
         zellij_session_name: opts.zellijSessionName || null,
         worker_placement: opts.workerPlacement || (swarm.backend === 'zellij' ? 'zellij-pane' : 'process'),
         zellij_visible_pane_cap: opts.zellijVisiblePaneCap || null,
+        model_provider: opts.glmLaunch?.provider || null,
+        model: opts.glmLaunch?.model || null,
+        gpt_fallback_allowed: opts.glmLaunch ? false : null,
         readonly: true,
         command,
         stdout_log: path.relative(root, stdoutLog),
@@ -430,13 +544,18 @@ export async function startMadNativeSwarm(root, madLaunch, args = [], profile =
 }
 export function resolveMadNativeSwarmOptions(args = [], profile = {}, opts = {}) {
     const list = (args || []).map((arg) => String(arg));
-    const disabled = list.includes('--no-swarm') || list.includes('--no-mad-swarm') || process.env.SKS_MAD_NATIVE_SWARM === '0';
+    const operatorDisabled = list.includes('--no-swarm') || list.includes('--no-mad-swarm') || process.env.SKS_MAD_NATIVE_SWARM === '0';
+    const glmRequested = list.includes('--glm') || opts.glmLaunch?.provider === 'openrouter';
+    const glmNativeSwarmDisabled = glmRequested && process.env.SKS_GLM_MAD_ALLOW_GPT_SWARM !== '1';
+    const disabled = operatorDisabled || glmNativeSwarmDisabled;
     const agents = clampInt(readOption(list, '--mad-agents', readOption(list, '--mad-swarm-agents', process.env.SKS_MAD_SWARM_AGENTS || opts.agents || 5)), 1, 20);
     const workItems = clampInt(readOption(list, '--mad-swarm-work-items', process.env.SKS_MAD_SWARM_WORK_ITEMS || opts.workItems || agents), agents, 100);
     const backend = defaultMadSwarmBackend(list, opts);
     return {
         enabled: !disabled,
-        disabled_reason: disabled ? 'operator_disabled_mad_native_swarm' : null,
+        disabled_reason: operatorDisabled
+            ? 'operator_disabled_mad_native_swarm'
+            : glmNativeSwarmDisabled ? 'glm_mad_native_swarm_disabled_to_block_gpt_fallback' : null,
         agents,
         workItems,
         backend,
@@ -516,12 +635,14 @@ async function activateMadZellijPermissionState(cwd = process.cwd(), args = [])
     const root = await sksRoot();
     if (!(await exists(path.join(root, '.sneakoscope'))))
         await initProject(root, {});
+    const rawArgs = (args || []).map((arg) => String(arg));
+    const activatedBy = rawArgs.includes('--glm') ? 'sks --mad --glm' : 'sks --mad';
     const flags = parseMadSksFlags(['--mad-sks', ...args].filter(Boolean));
-    const permission = buildMadSksPermissionModel({ targetRoot: cwd, userIntent: 'sks --mad Zellij scoped high-power maintenance session', flags });
+    const permission = buildMadSksPermissionModel({ targetRoot: cwd, userIntent: `${activatedBy} Zellij scoped high-power maintenance session`, flags });
     const allowedScopes = new Set(permission.allowed_scopes || []);
     const has = (scope) => allowedScopes.has(scope);
     const dbWriteAllowed = has('db_write');
-    const { id, dir } = await createMission(root, { mode: 'mad-sks', prompt: 'sks --mad Zellij scoped high-power maintenance session' });
+    const { id, dir } = await createMission(root, { mode: 'mad-sks', prompt: `${activatedBy} Zellij scoped high-power maintenance session` });
     await writeCodex0138CapabilityArtifacts(root, { missionId: id }).catch(() => null);
     await writeCodex0139CapabilityArtifacts(root, { missionId: id }).catch(() => null);
     const codexNativeInvocation = await resolveCodexNativeInvocationPlan({
@@ -582,7 +703,7 @@ async function activateMadZellijPermissionState(cwd = process.cwd(), args = [])
             warnings: codexNativeInvocation.warnings,
             artifact_path: 'mad-codex-native-invocation.json'
         } : null,
-        activated_by: 'sks --mad',
+        activated_by: activatedBy,
         cwd: path.resolve(cwd || process.cwd())
     };
     await writeJsonAtomic(path.join(dir, 'mad-sks-gate.json'), gate);
@@ -616,11 +737,12 @@ async function activateMadZellijPermissionState(cwd = process.cwd(), args = [])
     });
     return { mission_id: id, dir, gate, root };
 }
-function madLaunchOnlyFlags() {
+function baseMadLaunchOnlyFlags() {
     return new Set([
         '--mad',
         '--MAD',
         '--mad-sks',
+        '--glm',
         '--high',
         '--attach',
         '--no-attach',
@@ -662,8 +784,26 @@ function madLaunchOnlyFlags() {
         '--ack'
     ]);
 }
-function madLaunchValueFlags() {
+function glmMadLaunchOnlyFlags() {
     return new Set([
+        '--deep',
+        '--xhigh',
+        '--strict',
+        '--trace',
+        '--ttft',
+        '--exact-provider'
+    ]);
+}
+function madLaunchOnlyFlags(includeGlmFlags = false) {
+    const flags = baseMadLaunchOnlyFlags();
+    if (includeGlmFlags) {
+        for (const flag of glmMadLaunchOnlyFlags())
+            flags.add(flag);
+    }
+    return flags;
+}
+function madLaunchValueFlags(includeGlmFlags = false) {
+    const flags = new Set([
         '--mad-agents',
         '--mad-swarm-agents',
         '--mad-swarm-work-items',
@@ -671,6 +811,20 @@ function madLaunchValueFlags() {
         '--mad-swarm-prompt',
         '--ack'
     ]);
+    if (includeGlmFlags)
+        flags.add('--exact-provider');
+    return flags;
+}
+export function findGlmOnlyMadFlagBlockers(args = [], glmMadLaunch = false) {
+    if (glmMadLaunch)
+        return [];
+    const blockers = [];
+    const glmOnly = new Set([...glmMadLaunchOnlyFlags(), '--bench']);
+    for (const arg of args) {
+        if (glmOnly.has(String(arg)))
+            blockers.push(`glm_flag_requires_--glm:${arg}`);
+    }
+    return blockers;
 }
 export function defaultMadSwarmBackend(args = [], opts = {}) {
     const list = (args || []).map((arg) => String(arg));
@@ -687,9 +841,9 @@ export function defaultMadSwarmBackend(args = [], opts = {}) {
         return 'codex-sdk';
     return 'zellij';
 }
-function stripMadLaunchOnlyArgs(args = []) {
-    const flags = madLaunchOnlyFlags();
-    const valueFlags = madLaunchValueFlags();
+export function stripMadLaunchOnlyArgs(args = [], opts = {}) {
+    const flags = madLaunchOnlyFlags(Boolean(opts.includeGlmFlags));
+    const valueFlags = madLaunchValueFlags(Boolean(opts.includeGlmFlags));
     const out = [];
     for (let i = 0; i < args.length; i += 1) {
         const arg = String(args[i]);

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '4.0.3';
+export const PACKAGE_VERSION = '4.0.5';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/perf/lru-cache.js

@@ -0,0 +1,33 @@
+export class SksLruCache {
+    maxEntries;
+    map = new Map();
+    constructor(maxEntries = 128) {
+        this.maxEntries = Math.max(1, Math.floor(maxEntries));
+    }
+    get size() {
+        return this.map.size;
+    }
+    get(key) {
+        const entry = this.map.get(key);
+        if (!entry)
+            return null;
+        this.map.delete(key);
+        this.map.set(key, entry);
+        return entry.value;
+    }
+    set(key, value, createdAt = Date.now()) {
+        if (this.map.has(key))
+            this.map.delete(key);
+        this.map.set(key, { key, value, createdAt });
+        while (this.map.size > this.maxEntries) {
+            const oldest = this.map.keys().next().value;
+            if (!oldest)
+                break;
+            this.map.delete(oldest);
+        }
+    }
+    clear() {
+        this.map.clear();
+    }
+}
+//# sourceMappingURL=lru-cache.js.map

package/dist/core/providers/glm/glm-52-profile.js

@@ -1,7 +1,9 @@
-import { GLM_52_DEFAULT_REQUEST_SETTINGS, GLM_52_OPENROUTER_MODEL, GLM_MAD_MODE } from './glm-52-settings.js';
+import { GLM_52_OPENROUTER_MODEL, GLM_MAD_MODE } from './glm-52-settings.js';
+import { profileFromConst } from './glm-profile-resolver.js';
 export const GLM_CODEX_APP_PROFILE_ID = 'sks/glm-5.2-mad';
-export const GLM_CODEX_APP_PROFILE_LABEL = 'GLM 5.2 (MAD / OpenRouter)';
+export const GLM_CODEX_APP_PROFILE_LABEL = 'GLM 5.2 (MAD XHigh Speed / OpenRouter)';
 export function buildGlmCodexAppModelProfile() {
+    const speed = profileFromConst('speed');
     return {
         schema: 'sks.codex-app-model-profile.v1',
         id: GLM_CODEX_APP_PROFILE_ID,
@@ -12,12 +14,17 @@ export function buildGlmCodexAppModelProfile() {
         strictModelLock: true,
         gptFallbackAllowed: false,
         requiresSecret: 'openrouter-api-key',
+        defaultProfile: 'speed',
         defaultSettings: {
-            temperature: GLM_52_DEFAULT_REQUEST_SETTINGS.temperature,
-            top_p: GLM_52_DEFAULT_REQUEST_SETTINGS.top_p,
-            reasoning_effort: 'high',
-            tool_choice: 'auto',
-            parallel_tool_calls: false
+            temperature: speed.temperature,
+            top_p: speed.top_p,
+            reasoning_effort: 'xhigh',
+            tool_choice: speed.tool_choice,
+            parallel_tool_calls: speed.parallel_tool_calls,
+            max_tokens: speed.max_tokens,
+            provider_sort: speed.provider.sort || 'throughput',
+            provider_allow_fallbacks: false,
+            provider_require_parameters: speed.provider.require_parameters
         },
         codexCompatibility: {
             target: 'rust-v0.141.0',

package/dist/core/providers/glm/glm-52-request.js

@@ -1,34 +1,62 @@
 import { GLM_52_DEFAULT_REQUEST_SETTINGS, GLM_52_OPENROUTER_MODEL, clampGlm52MaxTokens } from './glm-52-settings.js';
+import { buildDeepReasoningConfig } from './glm-reasoning-policy.js';
+import { profileFromConst, resolveGlmProfileFromArgs } from './glm-profile-resolver.js';
 export function buildGlm52Request(input) {
+    const profile = resolveInputProfile(input.profile, input.args, input.reasoningEffort);
+    if (profile.blockers.length) {
+        throw new Error(`GLM request profile blocked: ${profile.blockers.join(', ')}`);
+    }
+    const strictOrDeepEffort = profile.reasoning_effort || (input.reasoningEffort === 'high' || input.reasoningEffort === 'xhigh' ? input.reasoningEffort : undefined);
+    const reasoning = profile.name === 'speed'
+        ? buildDeepReasoningConfig('xhigh')
+        : buildDeepReasoningConfig(strictOrDeepEffort || 'high');
     const request = {
         model: GLM_52_OPENROUTER_MODEL,
         messages: input.messages,
-        stream: input.stream ?? GLM_52_DEFAULT_REQUEST_SETTINGS.stream,
-        temperature: GLM_52_DEFAULT_REQUEST_SETTINGS.temperature,
-        top_p: GLM_52_DEFAULT_REQUEST_SETTINGS.top_p,
-        reasoning: { effort: input.reasoningEffort ?? 'high' },
-        max_tokens: clampGlm52MaxTokens(input.maxTokens),
-        tool_choice: input.toolChoice ?? 'auto',
-        parallel_tool_calls: input.parallelToolCalls ?? false,
+        stream: input.stream ?? profile.stream,
+        temperature: profile.temperature,
+        top_p: profile.top_p,
+        ...(reasoning ? { reasoning } : {}),
+        max_tokens: clampGlm52MaxTokens(input.maxTokens ?? profile.max_tokens),
+        tool_choice: input.toolChoice ?? profile.tool_choice,
+        parallel_tool_calls: input.parallelToolCalls ?? profile.parallel_tool_calls,
+        ...(profile.stop && profile.name === 'speed' ? { stop: profile.stop } : {}),
         provider: {
             allow_fallbacks: false,
-            require_parameters: true,
-            sort: input.providerSort ?? 'throughput'
-        }
+            require_parameters: profile.provider.require_parameters,
+            ...(profile.provider.sort || input.providerSort ? { sort: input.providerSort ?? profile.provider.sort } : {}),
+            ...(profile.provider.preferred_min_throughput ? { preferred_min_throughput: profile.provider.preferred_min_throughput } : {}),
+            ...(profile.provider.preferred_max_latency ? { preferred_max_latency: profile.provider.preferred_max_latency } : {}),
+            ...(profile.provider.order ? { order: profile.provider.order } : {})
+        },
+        ...(input.responseFormat || profile.response_format ? { response_format: input.responseFormat ?? profile.response_format } : {})
     };
     return {
         ...request,
-        ...(input.tools ? { tools: input.tools } : {}),
-        ...(input.responseFormat ? { response_format: input.responseFormat } : {})
+        ...(input.tools && request.tool_choice !== 'none' ? { tools: input.tools } : {})
     };
 }
 export function buildGlm52KeyValidationRequest() {
     return buildGlm52Request({
         messages: [{ role: 'user', content: 'Reply with OK.' }],
+        profile: 'speed',
         stream: false,
         maxTokens: 1,
         toolChoice: 'none',
         parallelToolCalls: false
     });
 }
+function resolveInputProfile(profile, args, reasoningEffort) {
+    if (profile && typeof profile === 'object')
+        return profile;
+    if (profile)
+        return profileFromConst(profile);
+    if (args)
+        return resolveGlmProfileFromArgs(args);
+    if (reasoningEffort === 'xhigh')
+        return profileFromConst('xhigh');
+    if (reasoningEffort === 'high')
+        return profileFromConst('deep');
+    return profileFromConst(GLM_52_DEFAULT_REQUEST_SETTINGS.mode === 'mad-glm-speed' ? 'speed' : 'speed');
+}
 //# sourceMappingURL=glm-52-request.js.map

package/dist/core/providers/glm/glm-52-response-guard.js

@@ -11,8 +11,7 @@ export function assertGlm52ActualModel(responseModel) {
     }
     const normalized = responseModel.toLowerCase();
     if (normalized === GLM_52_OPENROUTER_MODEL ||
-        normalized.startsWith(`${GLM_52_OPENROUTER_MODEL}-`) ||
-        normalized.includes('glm-5.2')) {
+        normalized.startsWith(`${GLM_52_OPENROUTER_MODEL}-`)) {
         return {
             ok: true,
             code: 'ok',