sneakoscope 4.0.4 → 4.0.5

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.5',
+        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-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 'xhigh';
+}
 //# 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 || 'xhigh',
+        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

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

@@ -0,0 +1,104 @@
+import { readOption } from '../../../cli/args.js';
+import { GLM_DEEP_MODE, GLM_DEEP_PROFILE, GLM_SPEED_MODE, GLM_SPEED_PROFILE, GLM_STRICT_MODE, GLM_STRICT_PROFILE, GLM_XHIGH_MODE, GLM_XHIGH_PROFILE } from './glm-52-settings.js';
+export function resolveGlmProfileFromArgs(args = []) {
+    const list = args.map(String);
+    const exactProvider = readOption(list, '--exact-provider', null);
+    const providerBlockers = exactProvider && !isValidOpenRouterProviderSlug(exactProvider)
+        ? [`invalid_openrouter_provider_slug:${exactProvider}`]
+        : [];
+    const base = list.includes('--xhigh')
+        ? profileFromConst('xhigh')
+        : list.includes('--strict')
+            ? profileFromConst('strict')
+            : list.includes('--deep')
+                ? profileFromConst('deep')
+                : profileFromConst('speed');
+    const provider = exactProvider && !providerBlockers.length
+        ? {
+            allow_fallbacks: false,
+            require_parameters: base.provider.require_parameters,
+            order: [exactProvider]
+        }
+        : list.includes('--ttft')
+            ? {
+                ...base.provider,
+                sort: 'latency',
+                preferred_max_latency: { p50: 1.5, p90: 4 }
+            }
+            : base.provider;
+    return {
+        ...base,
+        provider,
+        blockers: providerBlockers
+    };
+}
+export function profileFromConst(name) {
+    if (name === 'deep') {
+        return {
+            name,
+            mode: GLM_DEEP_MODE,
+            stream: GLM_DEEP_PROFILE.stream,
+            max_tokens: GLM_DEEP_PROFILE.max_tokens,
+            temperature: GLM_DEEP_PROFILE.temperature,
+            top_p: GLM_DEEP_PROFILE.top_p,
+            tool_choice: GLM_DEEP_PROFILE.tool_choice,
+            parallel_tool_calls: GLM_DEEP_PROFILE.parallel_tool_calls,
+            provider: GLM_DEEP_PROFILE.provider,
+            reasoning_effort: GLM_DEEP_PROFILE.reasoning_effort,
+            blockers: []
+        };
+    }
+    if (name === 'xhigh') {
+        return {
+            ...profileFromConst('deep'),
+            name,
+            mode: GLM_XHIGH_MODE,
+            max_tokens: GLM_XHIGH_PROFILE.max_tokens,
+            reasoning_effort: GLM_XHIGH_PROFILE.reasoning_effort,
+            blockers: []
+        };
+    }
+    if (name === 'strict') {
+        return {
+            ...profileFromConst('deep'),
+            name,
+            mode: GLM_STRICT_MODE,
+            response_format: {
+                type: 'json_schema',
+                json_schema: {
+                    name: 'sks_glm_strict_proof',
+                    strict: true,
+                    schema: {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            summary: { type: 'string' },
+                            patch: { type: 'string' },
+                            proof: { type: 'object' }
+                        },
+                        required: ['summary', 'patch', 'proof']
+                    }
+                }
+            },
+            blockers: []
+        };
+    }
+    return {
+        name,
+        mode: GLM_SPEED_MODE,
+        stream: GLM_SPEED_PROFILE.stream,
+        max_tokens: GLM_SPEED_PROFILE.max_tokens,
+        temperature: GLM_SPEED_PROFILE.temperature,
+        top_p: GLM_SPEED_PROFILE.top_p,
+        tool_choice: GLM_SPEED_PROFILE.tool_choice,
+        parallel_tool_calls: GLM_SPEED_PROFILE.parallel_tool_calls,
+        provider: GLM_SPEED_PROFILE.provider,
+        reasoning_effort: GLM_SPEED_PROFILE.reasoning_effort,
+        stop: ['</sks_patch>'],
+        blockers: []
+    };
+}
+export function isValidOpenRouterProviderSlug(value) {
+    return /^(?!.*(?:^|\/)\.\.?(?:\/|$))[a-z0-9][a-z0-9._-]{0,63}(?:\/[a-z0-9][a-z0-9._-]{0,63}){0,3}$/i.test(value);
+}
+//# sourceMappingURL=glm-profile-resolver.js.map

package/dist/core/providers/glm/glm-reasoning-policy.js

@@ -0,0 +1,15 @@
+const FAST_REASONING_ORDER = ['none', 'minimal', 'low'];
+export function buildFastReasoningConfig(meta = null) {
+    if (meta?.mandatory === true)
+        return { exclude: true };
+    const supported = new Set(meta?.supported_efforts || []);
+    for (const effort of FAST_REASONING_ORDER) {
+        if (supported.has(effort))
+            return { effort, exclude: true };
+    }
+    return { exclude: true };
+}
+export function buildDeepReasoningConfig(effort) {
+    return { effort, exclude: true };
+}
+//# sourceMappingURL=glm-reasoning-policy.js.map

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

@@ -0,0 +1,47 @@
+import crypto from 'node:crypto';
+import { SksLruCache } from '../../perf/lru-cache.js';
+export function createGlmEncodedRequestCache(maxEntries = 128) {
+    return new SksLruCache(maxEntries);
+}
+export function encodeGlmRequestWithCache(request, cache = defaultEncodedRequestCache) {
+    const key = digestRequestForCache(request);
+    const hit = cache.get(key);
+    if (hit)
+        return { entry: hit, cacheHit: true };
+    const body = JSON.stringify(request);
+    const entry = {
+        key,
+        bodySha256: crypto.createHash('sha256').update(body).digest('hex'),
+        byteLength: Buffer.byteLength(body),
+        createdAt: Date.now(),
+        bodyStored: false
+    };
+    cache.set(key, entry);
+    return { entry, cacheHit: false };
+}
+export function digestRequestForCache(request) {
+    const safe = {
+        model: request.model,
+        messages: request.messages,
+        tools: request.tools || null,
+        response_format: request.response_format || null,
+        provider: request.provider || null,
+        max_tokens: request.max_tokens || null,
+        temperature: request.temperature || null,
+        top_p: request.top_p || null,
+        tool_choice: request.tool_choice || null,
+        parallel_tool_calls: request.parallel_tool_calls || null,
+        reasoning: request.reasoning || null
+    };
+    return crypto.createHash('sha256').update(stableStringify(safe)).digest('hex');
+}
+function stableStringify(value) {
+    if (!value || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(',')}]`;
+    const object = value;
+    return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(object[key])}`).join(',')}}`;
+}
+const defaultEncodedRequestCache = createGlmEncodedRequestCache();
+//# sourceMappingURL=glm-request-cache.js.map

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

@@ -0,0 +1,82 @@
+import crypto from 'node:crypto';
+import path from 'node:path';
+import { estimateGlmTokens, GLM_SPEED_CONTEXT_HARD_CAP_TOKENS, GLM_SPEED_CONTEXT_TARGET_TOKENS, trimToEstimatedTokens } from './glm-context-budget.js';
+const GENERATED_PATH = /(^|\/)(dist|node_modules|coverage|\.git)(\/|$)|(\.generated\.|\.map$)/;
+const DEFAULT_MAX_FILE_BYTES = 64 * 1024;
+export async function buildGlmSpeedContext(input) {
+    const maxTokens = Math.min(input.maxTokens || GLM_SPEED_CONTEXT_TARGET_TOKENS, GLM_SPEED_CONTEXT_HARD_CAP_TOKENS);
+    const maxFileBytes = Math.max(1024, input.maxFileBytes || DEFAULT_MAX_FILE_BYTES);
+    const sections = [];
+    const omitted = [];
+    addSection(sections, 'task', input.task);
+    addSection(sections, 'constraints', 'GLM speed mode: compact context, one-shot patch, no GPT/OpenAI fallback, no full TriWiki/proof-bank/repo dump.');
+    if (input.gitStatus)
+        addSection(sections, 'git_status', input.gitStatus);
+    if (input.lastError)
+        addSection(sections, 'error', trimToEstimatedTokens(input.lastError, 2000));
+    const readFile = input.readFile || (async () => null);
+    for (const mentioned of input.mentionedPaths || []) {
+        const normalized = mentioned.replace(/\\/g, '/');
+        if (GENERATED_PATH.test(normalized)) {
+            omitted.push({ kind: 'generated_or_large_path', path: mentioned, reason: 'speed_context_excludes_generated_or_vendor_paths' });
+            continue;
+        }
+        const absolute = path.isAbsolute(mentioned) ? mentioned : path.join(input.cwd, mentioned);
+        const rawText = input.readFileSnippet ? await input.readFileSnippet(absolute, maxFileBytes) : await readFile(absolute);
+        const text = rawText === null ? null : trimToUtf8Bytes(rawText, maxFileBytes);
+        if (text === null) {
+            omitted.push({ kind: 'file_snippet', path: mentioned, reason: 'unreadable_or_missing' });
+            continue;
+        }
+        if (Buffer.byteLength(rawText || '', 'utf8') > maxFileBytes) {
+            omitted.push({ kind: 'file_snippet_tail', path: mentioned, reason: 'speed_context_file_byte_budget' });
+        }
+        addSection(sections, 'file_snippet', trimToEstimatedTokens(text, 2400), path.relative(input.cwd, absolute) || mentioned);
+    }
+    const compact = enforceBudget(sections, omitted, maxTokens);
+    return {
+        schema: 'sks.glm-speed-context.v1',
+        digest: digestJson({ sections: compact.sections, omitted: compact.omitted }),
+        estimatedTokens: compact.sections.reduce((sum, section) => sum + section.tokenEstimate, 0),
+        sections: compact.sections,
+        omitted: compact.omitted
+    };
+}
+function addSection(sections, kind, content, sectionPath) {
+    sections.push({
+        kind,
+        ...(sectionPath ? { path: sectionPath } : {}),
+        content,
+        tokenEstimate: estimateGlmTokens(content)
+    });
+}
+function enforceBudget(sections, omitted, maxTokens) {
+    const kept = [];
+    const nextOmitted = [...omitted];
+    let total = 0;
+    for (const section of sections) {
+        if (total + section.tokenEstimate <= maxTokens) {
+            kept.push(section);
+            total += section.tokenEstimate;
+            continue;
+        }
+        nextOmitted.push({
+            kind: section.kind,
+            ...(section.path ? { path: section.path } : {}),
+            reason: 'speed_context_token_budget'
+        });
+    }
+    return { sections: kept, omitted: nextOmitted };
+}
+function digestJson(value) {
+    return crypto.createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+function trimToUtf8Bytes(text, maxBytes) {
+    if (Buffer.byteLength(text, 'utf8') <= maxBytes)
+        return text;
+    let end = Math.min(text.length, maxBytes);
+    while (end > 0 && Buffer.byteLength(text.slice(0, end), 'utf8') > maxBytes)
+        end -= 1;
+    return text.slice(0, end);
+}
+//# sourceMappingURL=glm-speed-context.js.map

package/dist/core/providers/glm/glm-speed-gate.js

@@ -0,0 +1,40 @@
+import { parseGlmSpeedOutput } from './glm-speed-output-parser.js';
+const FORBIDDEN_TOUCHED_PATH = /(^|\/)(\.github|dist|node_modules)(\/|$)/;
+export function evaluateGlmSpeedGate(output) {
+    const started = Date.now();
+    const checks = [];
+    const parsed = parseGlmSpeedOutput(output);
+    checks.push(check('patch_parse', parsed.kind === 'patch', parsed.kind === 'patch' ? undefined : parsed.reason || parsed.kind));
+    const paths = parsed.kind === 'patch' ? touchedPaths(parsed.content) : [];
+    checks.push(check('touched_path_allowlist', paths.every((file) => !FORBIDDEN_TOUCHED_PATH.test(file)), paths.find((file) => FORBIDDEN_TOUCHED_PATH.test(file))));
+    checks.push(check('patch_apply_dry_run_ready', parsed.kind === 'patch' && /^diff --git /m.test(parsed.content), parsed.kind === 'patch' ? undefined : 'no_patch'));
+    const ok = checks.every((row) => row.ok);
+    return {
+        schema: 'sks.glm-speed-gate.v1',
+        ok,
+        gate_ms: Date.now() - started,
+        deterministic: true,
+        checks,
+        requiresDeepEscalation: !ok
+    };
+}
+function touchedPaths(patch) {
+    const paths = [];
+    for (const line of patch.split(/\r?\n/)) {
+        const match = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+        if (match?.[1])
+            paths.push(match[1]);
+        if (match?.[2])
+            paths.push(match[2]);
+    }
+    return [...new Set(paths)];
+}
+function check(id, ok, reason) {
+    return {
+        id,
+        ok,
+        ms: 0,
+        ...(reason ? { reason } : {})
+    };
+}
+//# sourceMappingURL=glm-speed-gate.js.map

package/dist/core/providers/glm/glm-speed-output-parser.js

@@ -0,0 +1,40 @@
+const ENVELOPES = {
+    patch: ['<sks_patch>', '</sks_patch>'],
+    need_context: ['<sks_need_context>', '</sks_need_context>'],
+    blocked: ['<sks_blocked>', '</sks_blocked>']
+};
+export function parseGlmSpeedOutput(text) {
+    for (const kind of ['patch', 'need_context', 'blocked']) {
+        const extracted = extractEnvelope(text, ENVELOPES[kind][0], ENVELOPES[kind][1]);
+        if (extracted !== null) {
+            return {
+                kind,
+                content: extracted,
+                ...(kind === 'need_context' ? { paths: parsePaths(extracted) } : {}),
+                ...(kind === 'blocked' ? { reason: parseReason(extracted) } : {})
+            };
+        }
+    }
+    const cleaned = text.trim();
+    return { kind: 'malformed', content: cleaned, reason: 'missing_glm_speed_output_envelope' };
+}
+function extractEnvelope(text, start, end) {
+    const startIndex = text.indexOf(start);
+    if (startIndex < 0)
+        return null;
+    const contentStart = startIndex + start.length;
+    const endIndex = text.indexOf(end, contentStart);
+    if (endIndex < 0)
+        return null;
+    return text.slice(contentStart, endIndex).trim();
+}
+function parsePaths(content) {
+    return content
+        .split(/\r?\n/)
+        .map((line) => line.match(/^\s*-\s*(.+?)\s*$/)?.[1])
+        .filter((value) => Boolean(value));
+}
+function parseReason(content) {
+    return content.match(/reason:\s*(.+)/i)?.[1]?.trim() || content.trim();
+}
+//# sourceMappingURL=glm-speed-output-parser.js.map

package/dist/core/providers/glm/glm-tool-schema-cache.js

@@ -0,0 +1,19 @@
+import crypto from 'node:crypto';
+import { SksLruCache } from '../../perf/lru-cache.js';
+export function createGlmToolSchemaCache(maxEntries = 64) {
+    const cache = new SksLruCache(maxEntries);
+    return {
+        get(toolsetVersion) {
+            return cache.get(toolsetVersion);
+        },
+        set(toolsetVersion, tools) {
+            const entry = { key: toolsetVersion, tools, createdAt: Date.now() };
+            cache.set(toolsetVersion, entry);
+            return entry;
+        }
+    };
+}
+export function digestToolset(tools) {
+    return crypto.createHash('sha256').update(JSON.stringify(tools)).digest('hex');
+}
+//# sourceMappingURL=glm-tool-schema-cache.js.map

package/dist/core/version.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "4.0.4",
+  "version": "4.0.5",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",