sneakoscope 4.0.4 → 4.0.6

package/dist/core/providers/glm/glm-bench.js

@@ -0,0 +1,127 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../../fsx.js';
+import { profileFromConst } from './glm-profile-resolver.js';
+import { createEmptyGlmLatencyTrace, writeGlmLatencyTrace } from './glm-latency-trace.js';
+const SYNTHETIC_CASES = Object.freeze([
+    benchCase('small doc edit', 'doc_edit', 420, 980),
+    benchCase('small TS function edit', 'small_edit', 460, 1100),
+    benchCase('failing test fix from small error', 'test_fix', 520, 1220),
+    benchCase('simple config edit', 'config_edit', 390, 930)
+]);
+export async function runGlmBench(root, args = []) {
+    const live = args.includes('--live');
+    const execute = args.includes('--execute');
+    if (execute && !live) {
+        const blocked = {
+            schema: 'sks.glm-bench-result.v1',
+            version: '4.0.6',
+            generated_at: nowIso(),
+            status: 'blocked',
+            dry_run: true,
+            cases: [],
+            summary: {
+                speed_p50_total_ms: 0,
+                speed_p90_total_ms: 0,
+                speed_p50_ttft_ms: null
+            },
+            warnings: ['execute_requested_but_live_openrouter_bench_not_implemented']
+        };
+        await writeJsonAtomic(path.join(root, '.sneakoscope', 'glm', 'bench-blocked.json'), blocked);
+        return blocked;
+    }
+    if (live) {
+        const blocked = {
+            schema: 'sks.glm-bench-result.v1',
+            version: '4.0.6',
+            generated_at: nowIso(),
+            status: 'blocked',
+            dry_run: false,
+            cases: [],
+            summary: {
+                speed_p50_total_ms: 0,
+                speed_p90_total_ms: 0,
+                speed_p50_ttft_ms: null
+            },
+            warnings: ['live_openrouter_bench_requires_explicit_network_runner_not_enabled_in_this_build']
+        };
+        await writeJsonAtomic(path.join(root, '.sneakoscope', 'glm', 'bench-live-blocked.json'), blocked);
+        return blocked;
+    }
+    if (execute) {
+        const blocked = {
+            schema: 'sks.glm-bench-result.v1',
+            version: '4.0.6',
+            generated_at: nowIso(),
+            status: 'blocked',
+            dry_run: true,
+            cases: [],
+            summary: {
+                speed_p50_total_ms: 0,
+                speed_p90_total_ms: 0,
+                speed_p50_ttft_ms: null
+            },
+            warnings: ['execute_requested_without_live_flag_uses_no_network_dry_run_policy']
+        };
+        await writeJsonAtomic(path.join(root, '.sneakoscope', 'glm', 'bench-blocked.json'), blocked);
+        return blocked;
+    }
+    const speedTotals = SYNTHETIC_CASES.map((row) => row.speed.total_ms);
+    const deepTotals = SYNTHETIC_CASES.map((row) => row.deep.total_ms);
+    const result = {
+        schema: 'sks.glm-bench-result.v1',
+        version: '4.0.6',
+        generated_at: nowIso(),
+        status: 'dry_run',
+        dry_run: true,
+        cases: SYNTHETIC_CASES,
+        summary: {
+            speed_p50_total_ms: percentile(speedTotals, 50),
+            speed_p90_total_ms: percentile(speedTotals, 90),
+            speed_p50_ttft_ms: null,
+            deep_p50_total_ms: percentile(deepTotals, 50),
+            speed_vs_deep_ratio: Number((percentile(speedTotals, 50) / percentile(deepTotals, 50)).toFixed(3))
+        },
+        warnings: ['synthetic_dry_run_no_network_no_gpt_key_required']
+    };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'glm', 'bench-result.json'), result);
+    await writeGlmLatencyTrace(root, {
+        ...createEmptyGlmLatencyTrace('speed'),
+        total_ms: result.summary.speed_p50_total_ms,
+        context_estimated_tokens: 16_000,
+        request_encode_ms: 1,
+        encoded_request_cache_hit: true
+    });
+    return result;
+}
+function benchCase(name, taskKind, speedMs, deepMs) {
+    return {
+        name,
+        task_kind: taskKind,
+        speed: {
+            mode: 'speed',
+            synthetic: true,
+            llm_calls: 1,
+            max_tokens: profileFromConst('speed').max_tokens,
+            context_target_tokens: 16_000,
+            total_ms: speedMs,
+            ttft_ms: null
+        },
+        deep: {
+            mode: 'deep',
+            synthetic: true,
+            llm_calls: 1,
+            max_tokens: profileFromConst('deep').max_tokens,
+            context_target_tokens: 64_000,
+            total_ms: deepMs,
+            ttft_ms: null
+        }
+    };
+}
+function percentile(values, p) {
+    const sorted = [...values].sort((a, b) => a - b);
+    if (!sorted.length)
+        return 0;
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil((p / 100) * sorted.length) - 1));
+    return sorted[index] || 0;
+}
+//# sourceMappingURL=glm-bench.js.map

package/dist/core/providers/glm/glm-context-budget.js

@@ -0,0 +1,15 @@
+export const GLM_SPEED_CONTEXT_TARGET_TOKENS = 16_000;
+export const GLM_SPEED_CONTEXT_HARD_CAP_TOKENS = 32_000;
+export const GLM_DEEP_CONTEXT_TARGET_TOKENS = 64_000;
+export function estimateGlmTokens(text) {
+    if (!text)
+        return 0;
+    return Math.ceil(text.length / 4);
+}
+export function trimToEstimatedTokens(text, maxTokens) {
+    const maxChars = Math.max(0, Math.floor(maxTokens) * 4);
+    if (text.length <= maxChars)
+        return text;
+    return text.slice(0, maxChars);
+}
+//# sourceMappingURL=glm-context-budget.js.map

package/dist/core/providers/glm/glm-context-cache.js

@@ -0,0 +1,9 @@
+import { SksLruCache } from '../../perf/lru-cache.js';
+export function createGlmContextCache(maxEntries = 64) {
+    const cache = new SksLruCache(maxEntries);
+    return {
+        getByDigest: (digest) => cache.get(digest),
+        set: (context) => cache.set(context.digest, context)
+    };
+}
+//# sourceMappingURL=glm-context-cache.js.map

package/dist/core/providers/glm/glm-direct-run.js

@@ -0,0 +1,140 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../../fsx.js';
+import { resolveOpenRouterApiKey } from '../openrouter/openrouter-secret-store.js';
+import { sendOpenRouterChatCompletionStream } from '../openrouter/openrouter-stream.js';
+import { assertGlm52ActualModel } from './glm-52-response-guard.js';
+import { GLM_52_OPENROUTER_MODEL } from './glm-52-settings.js';
+import { buildGlm52Request } from './glm-52-request.js';
+import { buildGlmSpeedContext } from './glm-speed-context.js';
+import { parseGlmSpeedOutput } from './glm-speed-output-parser.js';
+import { evaluateGlmSpeedGate } from './glm-speed-gate.js';
+import { checkAndApplyGlmPatch } from './glm-patch-apply.js';
+import { createGlmRunController, writeGlmRunArtifacts } from './glm-run-controller.js';
+import { GLM_SPEED_LIMITS } from './glm-run-timeout.js';
+import { recordGlmLoopIteration } from './glm-loop-guard.js';
+export async function runGlmDirectSpeedRun(input) {
+    if (process.env.SKS_GLM_WRAPPER_ACTIVE === '1') {
+        return blocked('glm-recursive-blocked', input.task, 'glm_recursive_launch_blocked', ['glm_recursive_launch_blocked']);
+    }
+    const controller = createGlmRunController({ limits: GLM_SPEED_LIMITS });
+    controller.transition('preflight');
+    const key = await resolveOpenRouterApiKey({ env: process.env });
+    if (!key.key) {
+        const termination = controller.terminate('blocked', 'glm_patch_gate_failed', key.blockers, [
+            'set_OPENROUTER_API_KEY_or_run_sks_--mad_--glm_--repair'
+        ]);
+        const artifactDir = await writeGlmRunArtifacts({ cwd: input.cwd, state: controller.state(), termination });
+        return result('blocked', controller.state().run_id, input.task, termination.reason, artifactDir, [], key.blockers, termination.warnings);
+    }
+    controller.transition('context');
+    const gitStatus = await readGitStatus(input.cwd);
+    const context = await buildGlmSpeedContext({
+        cwd: input.cwd,
+        task: input.task,
+        mentionedPaths: extractMentionedPaths(input.task),
+        readFile: async (file) => fs.readFile(file, 'utf8').catch(() => null),
+        ...(gitStatus ? { gitStatus } : {})
+    });
+    controller.transition('request');
+    const request = buildGlm52Request({
+        profile: 'speed',
+        messages: [
+            { role: 'system', content: 'Return only <sks_patch>, <sks_need_context>, or <sks_blocked>. Use unified diff for patches.' },
+            { role: 'user', content: JSON.stringify({ task: input.task, context }) }
+        ],
+        maxTokens: 4096
+    });
+    const response = await sendOpenRouterChatCompletionStream({
+        apiKey: key.key,
+        request: {
+            ...request,
+            session_id: `sks-${controller.state().run_id}`
+        },
+        timeoutMs: GLM_SPEED_LIMITS.request_timeout_ms
+    });
+    if (!response.ok) {
+        const reason = response.error.code === 'glm_request_timeout' ? 'glm_request_timeout' : 'glm_patch_gate_failed';
+        const termination = controller.terminate(reason === 'glm_request_timeout' ? 'timeout' : 'failed', reason, [response.error.code]);
+        const artifactDir = await writeGlmRunArtifacts({ cwd: input.cwd, state: controller.state(), termination, contextOmissions: context.omitted });
+        return result(reason === 'glm_request_timeout' ? 'timeout' : 'failed', controller.state().run_id, input.task, termination.reason, artifactDir, [], [response.error.code], []);
+    }
+    controller.transition('model_guard');
+    const modelGuard = assertGlm52ActualModel(response.value.model || GLM_52_OPENROUTER_MODEL);
+    if (!modelGuard.ok) {
+        const termination = controller.terminate('blocked', 'glm_model_mismatch', [modelGuard.code]);
+        const artifactDir = await writeGlmRunArtifacts({ cwd: input.cwd, state: controller.state(), termination, contextOmissions: context.omitted });
+        return result('blocked', controller.state().run_id, input.task, termination.reason, artifactDir, [], [modelGuard.code], []);
+    }
+    controller.transition('parse_output');
+    const parsed = parseGlmSpeedOutput(response.value.content);
+    const guard = recordGlmLoopIteration({
+        state: controller.state(),
+        limits: GLM_SPEED_LIMITS,
+        output: response.value.content,
+        madeProgress: parsed.kind === 'patch',
+        nowIso: nowIso()
+    });
+    if (!guard.ok) {
+        const termination = controller.terminate('blocked', guard.reason === 'glm_loop_repeated_output' ? 'glm_loop_repeated_output' : 'glm_loop_no_progress', [guard.reason || 'glm_loop_blocked']);
+        const artifactDir = await writeGlmRunArtifacts({ cwd: input.cwd, state: controller.state(), termination, loopGuard: guard, contextOmissions: context.omitted });
+        return result('blocked', controller.state().run_id, input.task, termination.reason, artifactDir, [], termination.blockers, []);
+    }
+    if (parsed.kind === 'blocked' || parsed.kind === 'need_context' || parsed.kind === 'malformed') {
+        const termination = controller.terminate('blocked', parsed.kind === 'malformed' ? 'glm_loop_no_progress' : 'completed_noop', [parsed.reason || parsed.kind]);
+        const artifactDir = await writeGlmRunArtifacts({ cwd: input.cwd, state: controller.state(), termination, loopGuard: guard, contextOmissions: context.omitted });
+        return result('blocked', controller.state().run_id, input.task, termination.reason, artifactDir, [], termination.blockers, []);
+    }
+    controller.transition('patch_gate');
+    const gate = evaluateGlmSpeedGate(response.value.content);
+    if (!gate.ok) {
+        const termination = controller.terminate('blocked', 'glm_patch_gate_failed', gate.checks.filter((row) => !row.ok).map((row) => row.reason || row.id));
+        const artifactDir = await writeGlmRunArtifacts({ cwd: input.cwd, state: controller.state(), termination, loopGuard: guard, contextOmissions: context.omitted });
+        return result('blocked', controller.state().run_id, input.task, termination.reason, artifactDir, [], termination.blockers, []);
+    }
+    controller.transition('apply_patch');
+    const applied = await checkAndApplyGlmPatch({ cwd: input.cwd, patch: parsed.content, apply: !input.dryRun });
+    if (!applied.ok) {
+        const termination = controller.terminate('blocked', 'glm_patch_gate_failed', [applied.error.code]);
+        const artifactDir = await writeGlmRunArtifacts({ cwd: input.cwd, state: controller.state(), termination, loopGuard: guard, contextOmissions: context.omitted });
+        return result('blocked', controller.state().run_id, input.task, termination.reason, artifactDir, [], termination.blockers, []);
+    }
+    controller.transition('verify');
+    const termination = controller.terminate('completed', input.dryRun ? 'completed_noop' : 'completed_patch_applied');
+    const artifactDir = await writeGlmRunArtifacts({ cwd: input.cwd, state: controller.state(), termination, loopGuard: guard, contextOmissions: context.omitted });
+    await writeJsonAtomic(path.join(artifactDir, 'direct-run.json'), { request_model: request.model, stream: true, gate, applied: applied.value });
+    return result('completed', controller.state().run_id, input.task, termination.reason, artifactDir, applied.value.touchedPaths, [], []);
+}
+function result(status, runId, task, terminationReason, artifactDir, touchedPaths, blockers, warnings) {
+    return {
+        schema: 'sks.glm-direct-run-result.v1',
+        ok: status === 'completed',
+        status,
+        run_id: runId,
+        task,
+        model: GLM_52_OPENROUTER_MODEL,
+        gpt_fallback_allowed: false,
+        termination_reason: terminationReason,
+        ...(artifactDir ? { artifact_dir: artifactDir } : {}),
+        touched_paths: touchedPaths,
+        blockers,
+        warnings
+    };
+}
+function blocked(runId, task, reason, blockers) {
+    return result('blocked', runId, task, reason, undefined, [], blockers, []);
+}
+async function readGitStatus(cwd) {
+    const { spawn } = await import('node:child_process');
+    return new Promise((resolve) => {
+        const child = spawn('git', ['status', '--short'], { cwd, stdio: ['ignore', 'pipe', 'ignore'] });
+        let stdout = '';
+        child.stdout.on('data', (chunk) => { stdout += String(chunk); });
+        child.on('close', () => resolve(stdout.trim() || undefined));
+    });
+}
+function extractMentionedPaths(task) {
+    const matches = task.match(/(?:^|\s|[`"'])([A-Za-z0-9_.-]+\/[A-Za-z0-9_./-]+\.[A-Za-z0-9]+)(?:\s|[`"']|$)/g) || [];
+    return [...new Set(matches.map((value) => value.trim().replace(/^[`"']|[`"']$/g, '')))];
+}
+//# sourceMappingURL=glm-direct-run.js.map

package/dist/core/providers/glm/glm-interactive-launch.js

@@ -0,0 +1,5 @@
+import { madHighCommand } from '../../commands/mad-sks-command.js';
+export async function runGlmInteractiveLaunch(args, readiness) {
+    return madHighCommand(['--glm', '--no-swarm', ...args], { glmReadiness: readiness, glmArgs: args });
+}
+//# sourceMappingURL=glm-interactive-launch.js.map

package/dist/core/providers/glm/glm-latency-trace.js

@@ -0,0 +1,40 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../../fsx.js';
+export function createEmptyGlmLatencyTrace(mode) {
+    return {
+        schema: 'sks.glm-latency-trace.v1',
+        version: '4.0.6',
+        mode,
+        total_ms: 0,
+        preflight_ms: 0,
+        key_resolve_ms: 0,
+        model_meta_ms: 0,
+        task_classify_ms: 0,
+        context_build_ms: 0,
+        context_estimated_tokens: 0,
+        context_cache_hit: false,
+        tool_schema_build_ms: 0,
+        tool_schema_cache_hit: false,
+        request_build_ms: 0,
+        request_encode_ms: 0,
+        encoded_request_cache_hit: false,
+        openrouter_ttft_ms: null,
+        openrouter_total_ms: null,
+        output_parse_ms: 0,
+        model_guard_ms: 0,
+        patch_apply_ms: 0,
+        deterministic_gate_ms: 0,
+        proof_write_ms: 0
+    };
+}
+export async function writeGlmLatencyTrace(root, trace) {
+    const safeTrace = redactTrace(trace);
+    const filename = `${nowIso().replace(/[:.]/g, '-')}-glm-${trace.mode}-trace.json`;
+    const out = path.join(root, '.sneakoscope', 'glm', 'traces', filename);
+    await writeJsonAtomic(out, safeTrace);
+    return out;
+}
+function redactTrace(trace) {
+    return JSON.parse(JSON.stringify(trace).replace(/sk-or-[A-Za-z0-9_-]+/g, 'sk-or-...redacted...'));
+}
+//# sourceMappingURL=glm-latency-trace.js.map

package/dist/core/providers/glm/glm-loop-guard.js

@@ -0,0 +1,31 @@
+import crypto from 'node:crypto';
+import { isGlmTerminalPhase } from './glm-run-state.js';
+export function recordGlmLoopIteration(input) {
+    if (isGlmTerminalPhase(input.state.phase) || input.state.terminal) {
+        return { ok: false, reason: 'terminal_state', state: input.state };
+    }
+    const outputDigest = input.output ? digestNormalizedOutput(input.output) : input.state.last_output_digest;
+    const repeated = Boolean(outputDigest && outputDigest === input.state.last_output_digest);
+    const nextState = {
+        ...input.state,
+        updated_at: input.nowIso,
+        turn_count: input.state.turn_count + 1,
+        no_progress_count: input.madeProgress ? 0 : input.state.no_progress_count + 1,
+        repeated_output_count: repeated ? input.state.repeated_output_count + 1 : 0,
+        ...(outputDigest ? { last_output_digest: outputDigest } : {})
+    };
+    if (nextState.turn_count > input.limits.max_turns) {
+        return { ok: false, reason: 'glm_loop_max_turns', state: nextState };
+    }
+    if (nextState.repeated_output_count >= input.limits.max_repeated_output) {
+        return { ok: false, reason: 'glm_loop_repeated_output', state: nextState };
+    }
+    if (nextState.no_progress_count > input.limits.max_no_progress_iterations) {
+        return { ok: false, reason: 'glm_loop_no_progress', state: nextState };
+    }
+    return { ok: true, state: nextState };
+}
+export function digestNormalizedOutput(output) {
+    return crypto.createHash('sha256').update(output.replace(/\s+/g, ' ').trim()).digest('hex');
+}
+//# sourceMappingURL=glm-loop-guard.js.map

package/dist/core/providers/glm/glm-mad-launch.js

@@ -3,14 +3,19 @@ import path from 'node:path';
 import { nowIso, writeTextAtomic } from '../../fsx.js';
 import { resolveOpenRouterApiKey, openRouterSecretPaths } from '../openrouter/openrouter-secret-store.js';
 import { GLM_52_OPENROUTER_MODEL } from './glm-52-settings.js';
+import { resolveGlmProfileFromArgs } from './glm-profile-resolver.js';
 export const GLM_MAD_PROFILE_ID = 'sks/glm-5.2-mad';
 export const OPENROUTER_CODEX_PROVIDER = 'openrouter';
-export function buildMadGlmLaunchProfileNoWrite() {
+export function buildMadGlmLaunchProfileNoWrite(args = []) {
+    const profile = resolveGlmProfileFromArgs(args);
+    const effort = codexReasoningEffortForProfile(profile);
     return {
         schema: 'sks.glm-mad-launch-profile.v1',
         profile_name: GLM_MAD_PROFILE_ID,
         provider: OPENROUTER_CODEX_PROVIDER,
         model: GLM_52_OPENROUTER_MODEL,
+        glm_profile: profile.name,
+        glm_mode: profile.mode,
         launch_args: [
             '--sandbox',
             'danger-full-access',
@@ -19,7 +24,7 @@ export function buildMadGlmLaunchProfileNoWrite() {
             '-c',
             'service_tier=fast',
             '-c',
-            'model_reasoning_effort=high',
+            `model_reasoning_effort=${effort}`,
             '-c',
             'model_provider="openrouter"',
             '-c',
@@ -37,7 +42,7 @@ export function buildMadGlmLaunchProfileNoWrite() {
         ],
         sandbox_mode: 'danger-full-access',
         approval_policy: 'never',
-        model_reasoning_effort: 'high',
+        model_reasoning_effort: effort,
         service_tier: 'fast',
         gpt_fallback_allowed: false,
         writes_user_codex_config: false
@@ -94,6 +99,9 @@ export function buildMadGlmLaunchArtifact(input) {
         mission_id: input.missionId,
         provider: profile.provider,
         model: profile.model,
+        glm_profile: profile.glm_profile,
+        glm_mode: profile.glm_mode,
+        model_reasoning_effort: profile.model_reasoning_effort,
         profile_name: profile.profile_name,
         strict_model_lock: true,
         gpt_fallback_allowed: false,
@@ -110,4 +118,11 @@ export function buildMadGlmLaunchArtifact(input) {
 function shellQuote(value) {
     return `'${String(value).replace(/'/g, `'\\''`)}'`;
 }
+function codexReasoningEffortForProfile(profile) {
+    if (profile.name === 'xhigh')
+        return 'xhigh';
+    if (profile.name === 'deep' || profile.name === 'strict')
+        return 'high';
+    return 'low';
+}
 //# sourceMappingURL=glm-mad-launch.js.map

package/dist/core/providers/glm/glm-mad-mode.js

@@ -11,23 +11,33 @@ import { redactOpenRouterKey } from '../../security/redact-secrets.js';
 import { buildGlmCodexAppModelProfile } from './glm-52-profile.js';
 import { buildGlm52KeyValidationRequest, buildGlm52Request } from './glm-52-request.js';
 import { assertGlm52ActualModel } from './glm-52-response-guard.js';
-import { GLM_52_OPENROUTER_MODEL, GLM_MAD_MODE, OPENROUTER_CHAT_COMPLETIONS_URL } from './glm-52-settings.js';
+import { GLM_52_OPENROUTER_MODEL, OPENROUTER_CHAT_COMPLETIONS_URL } from './glm-52-settings.js';
+import { resolveGlmProfileFromArgs } from './glm-profile-resolver.js';
+import { createEmptyGlmLatencyTrace, writeGlmLatencyTrace } from './glm-latency-trace.js';
 export async function runMadGlmMode(args = [], adapters = {}) {
     const runtime = buildDefaultAdapters(adapters);
     const repair = flag(args, '--repair');
     const noSaveKey = flag(args, '--no-save-key');
     const skipValidation = flag(args, '--skip-validation');
     const json = flag(args, '--json');
+    const selectedProfile = resolveGlmProfileFromArgs(args);
     const profile = buildGlmCodexAppModelProfile();
     let result;
-    if (repair) {
+    if (selectedProfile.blockers.length) {
+        result = baseResult({
+            status: 'blocked',
+            blockers: selectedProfile.blockers,
+            warnings: []
+        }, selectedProfile);
+    }
+    else if (repair) {
         const key = await runtime.promptSecret('OpenRouter API key is required for GLM 5.2 mode.\nEnter OpenRouter API key: ');
         if (!key) {
             result = baseResult({
                 status: 'blocked',
                 blockers: ['glm_key_prompt_cancelled'],
                 warnings: []
-            });
+            }, selectedProfile);
         }
         else {
             if (!noSaveKey)
@@ -43,14 +53,14 @@ export async function runMadGlmMode(args = [], adapters = {}) {
                     key_preview: redactOpenRouterKey(key),
                     blockers: [],
                     warnings: noSaveKey ? ['openrouter_key_not_saved'] : []
-                })
+                }, selectedProfile)
                 : baseResult({
                     status: 'blocked',
                     openrouter_key_source: noSaveKey ? 'prompt' : 'user-secret-store',
                     key_preview: redactOpenRouterKey(key),
                     blockers: [validation.error.code],
                     warnings: []
-                });
+                }, selectedProfile);
         }
     }
     else {
@@ -58,7 +68,7 @@ export async function runMadGlmMode(args = [], adapters = {}) {
         if (!resolved.key && process.stdin.isTTY) {
             const key = await runtime.promptSecret('OpenRouter API key is required for GLM 5.2 mode.\nEnter OpenRouter API key: ');
             if (!key) {
-                result = baseResult({ status: 'blocked', blockers: ['glm_key_prompt_cancelled'], warnings: [] });
+                result = baseResult({ status: 'blocked', blockers: ['glm_key_prompt_cancelled'], warnings: [] }, selectedProfile);
             }
             else {
                 const save = noSaveKey ? false : await runtime.promptConfirm('Save this key for future SKS GLM runs? [Y/n] ', true);
@@ -70,7 +80,7 @@ export async function runMadGlmMode(args = [], adapters = {}) {
                     key_preview: redactOpenRouterKey(key),
                     blockers: [],
                     warnings: save ? [] : ['openrouter_key_not_saved']
-                });
+                }, selectedProfile);
             }
         }
         else if (!resolved.key) {
@@ -78,7 +88,7 @@ export async function runMadGlmMode(args = [], adapters = {}) {
                 status: 'blocked',
                 blockers: resolved.blockers,
                 warnings: ['set_OPENROUTER_API_KEY_or_run_sks_--mad_--glm_--repair']
-            });
+            }, selectedProfile);
         }
         else {
             result = baseResult({
@@ -87,10 +97,19 @@ export async function runMadGlmMode(args = [], adapters = {}) {
                 key_preview: resolved.key_preview,
                 blockers: [],
                 warnings: resolved.warnings
-            });
+            }, selectedProfile);
         }
     }
-    await writeGlmModeArtifacts(runtime.cwd, result, profile, runtime.nowIso()).catch(() => undefined);
+    await writeGlmModeArtifacts(runtime.cwd, result, profile, selectedProfile, runtime.nowIso()).catch(() => undefined);
+    if (flag(args, '--trace')) {
+        await writeGlmLatencyTrace(runtime.cwd, {
+            ...createEmptyGlmLatencyTrace(selectedProfile.name),
+            context_estimated_tokens: selectedProfile.name === 'speed' ? 16_000 : 64_000,
+            request_encode_ms: 1,
+            encoded_request_cache_hit: false,
+            provider: 'openrouter'
+        }).catch(() => undefined);
+    }
     if (json)
         printJson(result);
     else
@@ -99,12 +118,13 @@ export async function runMadGlmMode(args = [], adapters = {}) {
         process.exitCode = 1;
     return result;
 }
-function baseResult(input) {
+function baseResult(input, profile) {
     const result = {
         schema: 'sks.glm-mode-result.v1',
         ok: input.blockers.length === 0 && input.status !== 'failed',
         status: input.status,
-        mode: GLM_MAD_MODE,
+        mode: profile.mode,
+        profile: profile.name,
         provider: 'openrouter',
         model: GLM_52_OPENROUTER_MODEL,
         requested_model: GLM_52_OPENROUTER_MODEL,
@@ -166,25 +186,32 @@ function validationValue(actualModel) {
         gpt_fallback_allowed: false
     };
 }
-async function writeGlmModeArtifacts(cwd, result, profile, generatedAt) {
+async function writeGlmModeArtifacts(cwd, result, profile, selectedProfile, generatedAt) {
     const dir = path.join(cwd, '.sneakoscope', 'glm');
     await writeJsonAtomic(path.join(dir, 'mad-glm-session.json'), {
         schema: 'sks.glm-mad-session.v1',
         generated_at: generatedAt,
         result,
-        profile_id: profile.id
+        profile_id: profile.id,
+        selected_profile: selectedProfile.name
     });
     await writeJsonAtomic(path.join(dir, 'openrouter-request-summary.json'), {
         schema: 'sks.openrouter-request-summary.v1',
         generated_at: generatedAt,
         endpoint: OPENROUTER_CHAT_COMPLETIONS_URL,
         model: GLM_52_OPENROUTER_MODEL,
-        temperature: 1,
-        top_p: 0.95,
-        reasoning_effort: 'high',
-        stream: true,
+        mode: selectedProfile.mode,
+        profile: selectedProfile.name,
+        temperature: selectedProfile.temperature,
+        top_p: selectedProfile.top_p,
+        reasoning_effort: selectedProfile.reasoning_effort || null,
+        max_tokens: selectedProfile.max_tokens,
+        tool_choice: selectedProfile.tool_choice,
+        parallel_tool_calls: selectedProfile.parallel_tool_calls,
+        stream: selectedProfile.stream,
         provider_allow_fallbacks: false,
-        require_parameters: true,
+        provider_sort: selectedProfile.provider.sort || null,
+        require_parameters: selectedProfile.provider.require_parameters,
         key_source: result.openrouter_key_source || null,
         key_preview: result.key_preview || null
     });
@@ -200,7 +227,7 @@ async function writeGlmModeArtifacts(cwd, result, profile, generatedAt) {
     });
 }
 function printHumanGlmResult(result, log) {
-    log(`GLM 5.2 MAD mode: ${result.ok ? result.status : 'blocked'}`);
+    log(`GLM 5.2 MAD mode: ${result.ok ? result.status : 'blocked'} (${result.profile})`);
     log(`Model: ${result.model}`);
     log(`GPT fallback: ${result.gpt_fallback_allowed ? 'allowed' : 'blocked'}`);
     if (result.openrouter_key_source)
@@ -233,6 +260,7 @@ async function promptConfirmLine(prompt, defaultYes) {
 export function buildGlmModeDryRunRequest() {
     return buildGlm52Request({
         messages: [{ role: 'user', content: 'SKS GLM dry run.' }],
+        profile: 'speed',
         stream: false,
         maxTokens: 1,
         toolChoice: 'none',

package/dist/core/providers/glm/glm-model-meta-cache.js

@@ -0,0 +1,19 @@
+import { SksLruCache } from '../../perf/lru-cache.js';
+const DAY_MS = 24 * 60 * 60 * 1000;
+export function createGlmModelMetaCache(maxEntries = 16, ttlMs = DAY_MS) {
+    const cache = new SksLruCache(maxEntries);
+    return {
+        get(model, now = Date.now()) {
+            const entry = cache.get(model);
+            if (!entry || entry.expiresAt <= now)
+                return null;
+            return entry;
+        },
+        set(model, reasoning, now = Date.now()) {
+            const entry = { model, reasoning, createdAt: now, expiresAt: now + ttlMs };
+            cache.set(model, entry, now);
+            return entry;
+        }
+    };
+}
+//# sourceMappingURL=glm-model-meta-cache.js.map