sneakoscope 4.0.4 → 4.0.6

package/README.md

@@ -35,16 +35,16 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **4.0.4** makes the GLM 5.2 MAD launch path real: `sks --mad --glm` now resolves the OpenRouter key, opens the MAD Zellij launch flow with Codex configured for `z-ai/glm-5.2`, blocks GPT fallback panes, and records launch proof; `sks --mad --glm --repair` still rotates the OpenRouter API key outside project files.
+SKS **4.0.6** makes the GLM 5.2 MAD path bounded by default: `sks --mad --glm` now returns readiness/status and exits when no task is supplied, while task forms use a direct GLM-only speed path with loop guards, request timeouts, and deterministic patch gates. Ordinary `sks --mad`, Naruto/Team, and non-GLM Codex paths keep their existing defaults.
 
-What changed in 4.0.4:
+What changed in 4.0.6:
 
-- **GLM MAD actually launches.** `sks --mad --glm` no longer stops after the readiness banner; it continues into the MAD launcher with a GLM/OpenRouter Codex profile.
-- **No leaked OpenRouter key.** The Zellij pane uses a mission-local `sks-glm-codex-wrapper.sh` that reads the key at runtime, so layout artifacts do not contain the raw secret.
-- **No GPT fallback panes.** GLM MAD disables the existing GPT/codex-sdk native swarm by default until a GLM worker backend exists, preserving the no-fallback guarantee.
-- **Launch proof.** Each GLM MAD launch writes `mad-glm-launch.json` with provider/model/profile/wrapper evidence and records disabled fallback status.
-- **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.
-- **4.0.3 GLM request safeguards remain.** GLM requests still use `provider.allow_fallbacks: false`, omit fallback `models`, and reject non-GLM response model ids before mutation.
+- **No default long-lived GLM launch.** Bare `sks --mad --glm` no longer falls through to MAD/Zellij; `--interactive`, `--zellij`, or `session` is required for that path.
+- **Fast GLM speed profile.** Speed mode keeps OpenRouter locked to `z-ai/glm-5.2`, disables GPT/model fallback, avoids high/xhigh reasoning by default, and uses `provider.require_parameters: false` with throughput-first routing.
+- **Bounded direct task runs.** `sks --mad --glm run "task"` and `sks --mad --glm "task"` use a one-shot GLM speed run with max-turn, wall-clock, request-timeout, no-progress, repeated-output, and terminal-state guards.
+- **Deterministic mutation gate.** GLM still returns patch envelopes; SKS parses the unified diff, blocks protected paths, runs `git apply --check`, and applies only after the gate passes.
+- **OpenRouter speed plumbing.** Encoded request bodies are cached without Authorization headers, request timeout/abort is wired, streaming TTFT/usage capture is scaffolded, and synthetic `--bench` remains network-free by default.
+- **Loop regression tests.** Routing, speed-profile, cache, loop-guard, patch-gate, and OpenRouter key handling are covered by targeted tests.
 
 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.
 
@@ -396,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.4"
+version = "4.0.6"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "4.0.4"
+version = "4.0.6"
 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.4"),
+        Some("--version") => println!("sks-rs 4.0.6"),
         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.4';
+const FAST_PACKAGE_VERSION = '4.0.6';
 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,10 +1,55 @@
-import { runMadGlmMode } from '../providers/glm/glm-mad-mode.js';
-import { flag } from '../../cli/args.js';
-import { madHighCommand } from './mad-sks-command.js';
+import { flag, positionalArgs } from '../../cli/args.js';
+import { runGlmBench } from '../providers/glm/glm-bench.js';
+import { printJson } from '../../cli/output.js';
+import { runGlmDirectSpeedRun } from '../providers/glm/glm-direct-run.js';
+import { runGlmReadinessAndExit } from '../providers/glm/glm-readiness.js';
+import { runGlmInteractiveLaunch } from '../providers/glm/glm-interactive-launch.js';
 export async function glmCommand(args = []) {
-    const result = await runMadGlmMode(args);
-    if (!result.ok || flag(args, '--repair') || flag(args, '--json'))
+    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;
-    return madHighCommand(['--glm', ...args], { glmReadiness: result });
+    }
+    const task = extractGlmTask(args);
+    const interactive = flag(args, '--interactive') || flag(args, '--zellij') || positionalArgs(args)[0] === 'session';
+    if (interactive) {
+        const readiness = await runGlmReadinessAndExit(args);
+        if (!readiness.ok)
+            return readiness;
+        return runGlmInteractiveLaunch(args, readiness);
+    }
+    if (!task || flag(args, '--repair') || flag(args, '--status')) {
+        return runGlmReadinessAndExit(args);
+    }
+    const result = await runGlmDirectSpeedRun({
+        cwd: process.cwd(),
+        task,
+        args,
+        dryRun: flag(args, '--dry-run')
+    });
+    if (flag(args, '--json'))
+        printJson(result);
+    else if (result.ok)
+        console.log(`GLM direct run completed: ${result.termination_reason}`);
+    else
+        console.error(`GLM direct run ${result.status}: ${result.blockers.join(', ') || result.termination_reason}`);
+    if (!result.ok)
+        process.exitCode = 1;
+    return result;
+}
+function extractGlmTask(args) {
+    const positional = positionalArgs(args).map(String);
+    if (positional[0] === 'run')
+        return positional.slice(1).join(' ').trim() || null;
+    if (positional[0] === 'session')
+        return null;
+    return positional.join(' ').trim() || null;
 }
 //# sourceMappingURL=glm-command.js.map

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

@@ -30,13 +30,31 @@ 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 (rawArgs.includes('--json') && !dryRun) {
-        const profile = glmMadLaunch ? buildMadGlmLaunchProfileNoWrite() : buildMadHighLaunchProfileNoWrite();
+        const profile = glmMadLaunch ? buildMadGlmLaunchProfileNoWrite(rawArgs) : buildMadHighLaunchProfileNoWrite();
         return console.log(JSON.stringify(profile, null, 2));
     }
     const update = { status: 'notice_only', non_blocking: true };
@@ -176,7 +194,7 @@ export async function madHighCommand(args = [], deps = {}) {
         return launchPreflight;
     }
     const madLaunch = await activateMadZellijPermissionState(process.cwd(), args);
-    const glmRuntime = glmMadLaunch ? await prepareMadGlmLaunchRuntime(madLaunch, deps) : null;
+    const glmRuntime = glmMadLaunch ? await prepareMadGlmLaunchRuntime(madLaunch, { ...deps, glmArgs: deps?.glmArgs || rawArgs }) : null;
     if (glmMadLaunch && !glmRuntime?.ok) {
         process.exitCode = 1;
         return glmRuntime;
@@ -325,7 +343,7 @@ function isMadGlmLaunch(args = [], deps = {}) {
 }
 async function prepareMadGlmLaunchRuntime(madLaunch, deps = {}) {
     const keyResolution = await resolveMadGlmLaunchKey(process.env);
-    const profile = buildMadGlmLaunchProfileNoWrite();
+    const profile = buildMadGlmLaunchProfileNoWrite(deps?.glmArgs || []);
     if (!keyResolution.key) {
         const blocked = {
             schema: 'sks.glm-mad-launch.v1',
@@ -334,6 +352,9 @@ async function prepareMadGlmLaunchRuntime(madLaunch, deps = {}) {
             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
@@ -367,6 +388,9 @@ async function prepareMadGlmLaunchRuntime(madLaunch, deps = {}) {
         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
     });
@@ -713,7 +737,7 @@ async function activateMadZellijPermissionState(cwd = process.cwd(), args = [])
     });
     return { mission_id: id, dir, gate, root };
 }
-function madLaunchOnlyFlags() {
+function baseMadLaunchOnlyFlags() {
     return new Set([
         '--mad',
         '--MAD',
@@ -760,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',
@@ -769,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));
@@ -785,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.4';
+export const PACKAGE_VERSION = '4.0.6';
 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 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: speed.reasoning_effort || null,
+            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,65 @@
 import { GLM_52_DEFAULT_REQUEST_SETTINGS, GLM_52_OPENROUTER_MODEL, clampGlm52MaxTokens } from './glm-52-settings.js';
+import { buildDeepReasoningConfig, buildFastReasoningConfig } 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'
+        ? buildFastReasoningConfig(input.reasoningMeta)
+        : buildDeepReasoningConfig(strictOrDeepEffort || 'high');
+    if (profile.name === 'speed' && (reasoning.effort === 'high' || reasoning.effort === 'xhigh')) {
+        throw new Error(`GLM speed profile invariant violated: forbidden reasoning effort ${reasoning.effort}`);
+    }
     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',

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

@@ -1,24 +1,66 @@
 export { OPENROUTER_CHAT_COMPLETIONS_URL } from '../openrouter/openrouter-types.js';
 export const GLM_52_OPENROUTER_MODEL = 'z-ai/glm-5.2';
-export const GLM_MAD_MODE = 'mad-glm';
-export const GLM_52_MAX_TOKENS_DEFAULT = 32768;
+export const GLM_52_MODEL = GLM_52_OPENROUTER_MODEL;
+export const GLM_SPEED_MODE = 'mad-glm-speed';
+export const GLM_DEEP_MODE = 'mad-glm-deep';
+export const GLM_XHIGH_MODE = 'mad-glm-xhigh';
+export const GLM_STRICT_MODE = 'mad-glm-strict';
+export const GLM_MAD_MODE = GLM_SPEED_MODE;
+export const GLM_52_MAX_TOKENS_SPEED = 4096;
+export const GLM_52_MAX_TOKENS_DEFAULT = GLM_52_MAX_TOKENS_SPEED;
+export const GLM_52_MAX_TOKENS_DEEP = 16384;
+export const GLM_52_MAX_TOKENS_XHIGH = 32768;
 export const GLM_52_MAX_TOKENS_LONG = 65536;
 export const GLM_52_MAX_TOKENS_XLONG = 131072;
 export const GLM_52_TOP_PROVIDER_MAX_COMPLETION_TOKENS = 262144;
-export const GLM_52_DEFAULT_REQUEST_SETTINGS = {
+export const GLM_SPEED_PROFILE = {
     model: GLM_52_OPENROUTER_MODEL,
-    temperature: 1,
-    top_p: 0.95,
-    reasoning_effort: 'high',
+    mode: GLM_SPEED_MODE,
+    temperature: 0.2,
+    top_p: 0.85,
     stream: true,
     provider: {
         allow_fallbacks: false,
-        require_parameters: true
+        require_parameters: false,
+        sort: 'throughput',
+        preferred_min_throughput: { p50: 80, p90: 40 },
+        preferred_max_latency: { p50: 2, p90: 5 }
+    },
+    tool_choice: 'none',
+    parallel_tool_calls: false,
+    max_tokens: GLM_52_MAX_TOKENS_SPEED,
+    reasoning_effort: null,
+    reasoning_default: 'off-or-minimal-speed'
+};
+export const GLM_DEEP_PROFILE = {
+    model: GLM_52_OPENROUTER_MODEL,
+    mode: GLM_DEEP_MODE,
+    temperature: 0.3,
+    top_p: 0.9,
+    stream: true,
+    provider: {
+        allow_fallbacks: false,
+        require_parameters: true,
+        sort: 'throughput'
     },
     tool_choice: 'auto',
     parallel_tool_calls: false,
-    max_tokens: GLM_52_MAX_TOKENS_DEFAULT
+    max_tokens: GLM_52_MAX_TOKENS_DEEP,
+    reasoning_effort: 'high'
+};
+export const GLM_XHIGH_PROFILE = {
+    ...GLM_DEEP_PROFILE,
+    mode: GLM_XHIGH_MODE,
+    max_tokens: GLM_52_MAX_TOKENS_XHIGH,
+    reasoning_effort: 'xhigh'
+};
+export const GLM_STRICT_PROFILE = {
+    ...GLM_DEEP_PROFILE,
+    mode: GLM_STRICT_MODE,
+    structured_outputs: true,
+    response_format: 'json_schema'
 };
+export const GLM_52_DEFAULT_REQUEST_SETTINGS = GLM_SPEED_PROFILE;
 export function clampGlm52MaxTokens(value) {
     const numeric = Number.isFinite(value) ? Math.floor(Number(value)) : GLM_52_MAX_TOKENS_DEFAULT;
     return Math.max(1, Math.min(numeric, GLM_52_TOP_PROVIDER_MAX_COMPLETION_TOKENS));