sneakoscope 7.0.2 → 7.0.5

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

@@ -1,269 +0,0 @@
-import readline from 'node:readline/promises';
-import path from 'node:path';
-import { stdin as input, stdout as output } from 'node:process';
-import { printJson } from '../../../cli/output.js';
-import { flag } from '../../../cli/args.js';
-import { nowIso, writeJsonAtomic } from '../../fsx.js';
-import {} from '../openrouter/openrouter-types.js';
-import { sendOpenRouterChatCompletion } from '../openrouter/openrouter-client.js';
-import { resolveOpenRouterApiKey, writeStoredOpenRouterKey } from '../openrouter/openrouter-secret-store.js';
-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, 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 (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)
-                await runtime.writeSecret(key);
-            const validation = skipValidation
-                ? { ok: true, value: validationValue(null) }
-                : await runtime.validateOpenRouterKey(key);
-            result = validation.ok
-                ? baseResult({
-                    status: 'ready',
-                    ...(validation.value.actual_model ? { actual_model: validation.value.actual_model } : {}),
-                    openrouter_key_source: noSaveKey ? 'prompt' : 'user-secret-store',
-                    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 {
-        const resolved = await resolveOpenRouterApiKey({ env: runtime.env });
-        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: [] }, selectedProfile);
-            }
-            else {
-                const save = noSaveKey ? false : await runtime.promptConfirm('Save this key for future SKS GLM runs? [Y/n] ', true);
-                if (save)
-                    await runtime.writeSecret(key);
-                result = baseResult({
-                    status: 'ready',
-                    openrouter_key_source: save ? 'user-secret-store' : 'prompt',
-                    key_preview: redactOpenRouterKey(key),
-                    blockers: [],
-                    warnings: save ? [] : ['openrouter_key_not_saved']
-                }, selectedProfile);
-            }
-        }
-        else if (!resolved.key) {
-            result = baseResult({
-                status: 'blocked',
-                blockers: resolved.blockers,
-                warnings: ['set_OPENROUTER_API_KEY_or_run_sks_--mad_--glm_--repair']
-            }, selectedProfile);
-        }
-        else {
-            result = baseResult({
-                status: 'ready',
-                ...(resolved.source ? { openrouter_key_source: resolved.source } : {}),
-                key_preview: resolved.key_preview,
-                blockers: [],
-                warnings: resolved.warnings
-            }, selectedProfile);
-        }
-    }
-    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
-        printHumanGlmResult(result, runtime.log);
-    if (!result.ok)
-        process.exitCode = 1;
-    return result;
-}
-function baseResult(input, profile) {
-    const result = {
-        schema: 'sks.glm-mode-result.v1',
-        ok: input.blockers.length === 0 && input.status !== 'failed',
-        status: input.status,
-        mode: profile.mode,
-        profile: profile.name,
-        provider: 'openrouter',
-        model: GLM_52_OPENROUTER_MODEL,
-        requested_model: GLM_52_OPENROUTER_MODEL,
-        strict_model_lock: true,
-        gpt_fallback_allowed: false,
-        codex_app_profile_id: 'sks/glm-5.2-mad',
-        blockers: input.blockers,
-        warnings: input.warnings
-    };
-    return {
-        ...result,
-        ...(input.actual_model ? { actual_model: input.actual_model } : {}),
-        ...(input.openrouter_key_source ? { openrouter_key_source: input.openrouter_key_source } : {}),
-        ...(input.key_preview !== undefined ? { key_preview: input.key_preview } : {})
-    };
-}
-function buildDefaultAdapters(overrides) {
-    return {
-        nowIso: overrides.nowIso || nowIso,
-        env: overrides.env || process.env,
-        cwd: overrides.cwd || process.cwd(),
-        promptSecret: overrides.promptSecret || promptLine,
-        promptConfirm: overrides.promptConfirm || promptConfirmLine,
-        writeSecret: overrides.writeSecret || (async (value) => {
-            await writeStoredOpenRouterKey(value);
-        }),
-        validateOpenRouterKey: overrides.validateOpenRouterKey || validateOpenRouterKey,
-        sendOpenRouterRequest: overrides.sendOpenRouterRequest || (async (request, key) => sendOpenRouterChatCompletion({ request, apiKey: key })),
-        log: overrides.log || ((message) => console.log(message))
-    };
-}
-async function validateOpenRouterKey(key) {
-    const response = await sendOpenRouterChatCompletion({
-        apiKey: key,
-        request: buildGlm52KeyValidationRequest()
-    });
-    if (!response.ok)
-        return response;
-    const guard = assertGlm52ActualModel(response.value.model);
-    if (!guard.ok) {
-        return {
-            ok: false,
-            error: {
-                code: guard.code,
-                message: 'GLM model lock violated.',
-                severity: 'blocked'
-            }
-        };
-    }
-    return { ok: true, value: validationValue(response.value.model || null) };
-}
-function validationValue(actualModel) {
-    return {
-        schema: 'sks.openrouter-key-validation.v1',
-        ok: true,
-        requested_model: GLM_52_OPENROUTER_MODEL,
-        actual_model: actualModel,
-        strict_model_lock: true,
-        gpt_fallback_allowed: false
-    };
-}
-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,
-        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,
-        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,
-        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
-    });
-    await writeJsonAtomic(path.join(dir, 'model-guard.json'), {
-        schema: 'sks.glm-model-guard.v1',
-        generated_at: generatedAt,
-        requested_model: GLM_52_OPENROUTER_MODEL,
-        actual_model: result.actual_model || null,
-        accepted: result.actual_model ? assertGlm52ActualModel(result.actual_model).ok : result.ok,
-        strict_model_lock: true,
-        gpt_fallback_allowed: false,
-        blockers: result.blockers
-    });
-}
-function printHumanGlmResult(result, log) {
-    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)
-        log(`OpenRouter key: ${result.openrouter_key_source} ${result.key_preview || ''}`.trim());
-    for (const blocker of result.blockers)
-        log(`- blocker: ${blocker}`);
-    for (const warning of result.warnings)
-        log(`- warning: ${warning}`);
-}
-async function promptLine(prompt) {
-    if (!process.stdin.isTTY)
-        return null;
-    const rl = readline.createInterface({ input, output });
-    try {
-        const answer = await rl.question(prompt);
-        return answer.trim() || null;
-    }
-    finally {
-        rl.close();
-    }
-}
-async function promptConfirmLine(prompt, defaultYes) {
-    if (!process.stdin.isTTY)
-        return defaultYes;
-    const answer = await promptLine(prompt);
-    if (!answer)
-        return defaultYes;
-    return !/^n(o)?$/i.test(answer);
-}
-export function buildGlmModeDryRunRequest() {
-    return buildGlm52Request({
-        messages: [{ role: 'user', content: 'SKS GLM dry run.' }],
-        profile: 'speed',
-        stream: false,
-        maxTokens: 1,
-        toolChoice: 'none',
-        parallelToolCalls: false
-    });
-}

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

@@ -1,18 +0,0 @@
-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;
-        }
-    };
-}

package/dist/core/providers/glm/glm-patch-apply.js

@@ -1,72 +0,0 @@
-import { spawn } from 'node:child_process';
-import { parseUnifiedDiffPatch } from './glm-patch-parser.js';
-const PROTECTED_PATH = /(^|\/)(\.github|dist|node_modules)(\/|$)/;
-export async function checkAndApplyGlmPatch(input) {
-    const parsed = parseUnifiedDiffPatch(input.patch);
-    if (parsed.empty) {
-        return issue('glm_patch_empty', 'GLM output did not contain a non-empty unified diff.');
-    }
-    const blockedPath = parsed.touchedPaths.find((file) => PROTECTED_PATH.test(file));
-    if (blockedPath) {
-        return issue('glm_patch_protected_path', `GLM patch touched protected path: ${blockedPath}`);
-    }
-    const check = await runGitApply(input.cwd, input.patch, ['apply', '--check', '--whitespace=nowarn', '-']);
-    if (check.code !== 0) {
-        return issue('glm_patch_gate_failed', check.stderr || check.stdout || 'git apply --check failed.');
-    }
-    if (!input.apply) {
-        return {
-            ok: true,
-            value: {
-                checked: true,
-                applied: false,
-                touchedPaths: parsed.touchedPaths,
-                stdout: check.stdout,
-                stderr: check.stderr
-            }
-        };
-    }
-    const applied = await runGitApply(input.cwd, input.patch, ['apply', '--whitespace=nowarn', '-']);
-    if (applied.code !== 0) {
-        return issue('glm_patch_apply_failed', applied.stderr || applied.stdout || 'git apply failed.');
-    }
-    return {
-        ok: true,
-        value: {
-            checked: true,
-            applied: true,
-            touchedPaths: parsed.touchedPaths,
-            stdout: applied.stdout,
-            stderr: applied.stderr
-        }
-    };
-}
-function issue(code, message) {
-    return { ok: false, error: { code, message, severity: 'blocked' } };
-}
-function runGitApply(cwd, patch, args) {
-    return new Promise((resolve) => {
-        const child = spawn('git', [...args], { cwd, stdio: ['pipe', 'pipe', 'pipe'] });
-        let stdout = '';
-        let stderr = '';
-        let settled = false;
-        const finish = (code) => {
-            if (settled)
-                return;
-            settled = true;
-            resolve({ code, stdout, stderr });
-        };
-        child.stdout.on('data', (chunk) => { stdout += String(chunk); });
-        child.stderr.on('data', (chunk) => { stderr += String(chunk); });
-        child.stdin.on('error', (error) => {
-            if (error.code !== 'EPIPE')
-                stderr += `${stderr ? '\n' : ''}${error.message}`;
-        });
-        child.on('error', (error) => {
-            stderr += `${stderr ? '\n' : ''}${error.message}`;
-            finish(null);
-        });
-        child.on('close', finish);
-        child.stdin.end(patch);
-    });
-}

package/dist/core/providers/glm/glm-patch-parser.js

@@ -1,18 +0,0 @@
-export function parseUnifiedDiffPatch(patch) {
-    const touched = new Set();
-    for (const line of patch.split(/\r?\n/)) {
-        const diff = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
-        if (diff?.[1])
-            touched.add(diff[1]);
-        if (diff?.[2])
-            touched.add(diff[2]);
-        const file = line.match(/^(?:---|\+\+\+) [ab]\/(.+)$/);
-        if (file?.[1] && file[1] !== '/dev/null')
-            touched.add(file[1]);
-    }
-    return {
-        patch,
-        touchedPaths: [...touched],
-        empty: !patch.trim() || !/^diff --git /m.test(patch)
-    };
-}

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

@@ -1,168 +0,0 @@
-import { readOption } from '../../../cli/args.js';
-import { GLM_DEEP_MODE, GLM_DEEP_PROFILE, GLM_52_OPENROUTER_MODEL, 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 slashSelection = parseGlmSlashModelSelection(list);
-    const providerBlockers = exactProvider && !isValidOpenRouterProviderSlug(exactProvider)
-        ? [`invalid_openrouter_provider_slug:${exactProvider}`]
-        : [];
-    const base = slashSelection.reasoning_effort === 'xhigh' || list.includes('--xhigh')
-        ? profileFromConst('xhigh')
-        : list.includes('--strict')
-            ? profileFromConst('strict')
-            : slashSelection.reasoning_effort === 'high' || 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, ...slashSelection.blockers]
-    };
-}
-export function reasoningEffortFromGlmSlashModelArgs(args = []) {
-    return parseGlmSlashModelSelection(args).reasoning_effort;
-}
-export function stripGlmSlashModelArgs(args = []) {
-    const consumed = new Set(parseGlmSlashModelSelection(args).consumed_indexes);
-    return args.map(String).filter((_arg, index) => !consumed.has(index));
-}
-export function parseGlmSlashModelSelection(args = []) {
-    const list = args.map(String);
-    const consumed = new Set();
-    const values = [];
-    for (let i = 0; i < list.length; i += 1) {
-        const arg = list[i] || '';
-        if (arg === '/model') {
-            consumed.add(i);
-            for (let j = i + 1; j < list.length && values.length < 2; j += 1) {
-                const candidate = list[j] || '';
-                if (candidate.startsWith('--') || candidate.startsWith('/'))
-                    break;
-                consumed.add(j);
-                values.push(candidate);
-                if (values.length === 1 && isSelectableGlmReasoningEffort(candidate.trim().toLowerCase()))
-                    break;
-            }
-            break;
-        }
-        const inline = arg.match(/^\/model(?::|=)(.+)$/)?.[1];
-        if (inline) {
-            consumed.add(i);
-            values.push(...inline.split(/[,:]/).map((value) => value.trim()).filter(Boolean).slice(0, 2));
-            break;
-        }
-    }
-    let model = null;
-    let reasoning = null;
-    const blockers = [];
-    for (const value of values) {
-        const normalized = value.trim().toLowerCase();
-        if (isSelectableGlmReasoningEffort(normalized)) {
-            reasoning = normalized;
-            continue;
-        }
-        if (!model) {
-            model = value;
-            if (!isAllowedGlmSlashModel(value))
-                blockers.push(`glm_slash_model_mismatch:${value}`);
-            continue;
-        }
-        blockers.push(`glm_slash_model_unrecognized:${value}`);
-    }
-    return {
-        model,
-        reasoning_effort: reasoning,
-        consumed_indexes: [...consumed].sort((a, b) => a - b),
-        blockers
-    };
-}
-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);
-}
-function isSelectableGlmReasoningEffort(value) {
-    return value === 'none' || value === 'minimal' || value === 'low' || value === 'medium' || value === 'high' || value === 'xhigh';
-}
-function isAllowedGlmSlashModel(value) {
-    const normalized = value.trim().toLowerCase();
-    return normalized === GLM_52_OPENROUTER_MODEL || normalized === 'glm-5.2' || normalized === 'glm5.2';
-}

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

@@ -1,4 +0,0 @@
-import { runMadGlmMode } from './glm-mad-mode.js';
-export async function runGlmReadinessAndExit(args = []) {
-    return runMadGlmMode(args);
-}

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

@@ -1,14 +0,0 @@
-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 };
-}

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

@@ -1,65 +0,0 @@
-import path from 'node:path';
-import { nowIso, randomId, writeJsonAtomic } from '../../fsx.js';
-import { GLM_SPEED_LIMITS } from './glm-run-timeout.js';
-import { isGlmTerminalPhase } from './glm-run-state.js';
-export function createGlmRunController(input = {}) {
-    const clock = input.now || nowIso;
-    const startedAt = clock();
-    const startedMs = Date.now();
-    let state = {
-        run_id: input.runId || `glm-${startedAt.replace(/[:.]/g, '-')}-${randomId(6)}`,
-        ...(input.missionId ? { mission_id: input.missionId } : {}),
-        phase: 'idle',
-        started_at: startedAt,
-        updated_at: startedAt,
-        turn_count: 0,
-        tool_round_count: 0,
-        no_progress_count: 0,
-        repeated_output_count: 0,
-        terminal: false
-    };
-    const limits = input.limits || GLM_SPEED_LIMITS;
-    return {
-        state: () => state,
-        transition: (phase, reason) => {
-            if (state.terminal || isGlmTerminalPhase(state.phase))
-                return state;
-            state = {
-                ...state,
-                phase,
-                updated_at: clock(),
-                terminal: isGlmTerminalPhase(phase),
-                ...(reason ? { terminal_reason: reason } : {})
-            };
-            return state;
-        },
-        terminate: (phase, reason, blockers = [], warnings = []) => {
-            state = {
-                ...state,
-                phase,
-                updated_at: clock(),
-                terminal: true,
-                terminal_reason: reason
-            };
-            return {
-                schema: 'sks.glm-run-termination.v1',
-                run_id: state.run_id,
-                terminal: true,
-                phase,
-                reason,
-                turn_count: state.turn_count,
-                wall_clock_ms: Math.min(Date.now() - startedMs, limits.max_wall_clock_ms),
-                blockers,
-                warnings
-            };
-        }
-    };
-}
-export async function writeGlmRunArtifacts(input) {
-    const dir = path.join(input.cwd, '.sneakoscope', 'glm', 'runs', input.state.run_id);
-    await writeJsonAtomic(path.join(dir, 'run-state.json'), input.state);
-    await writeJsonAtomic(path.join(dir, 'termination.json'), input.termination);
-    await writeJsonAtomic(path.join(dir, 'loop-guard.json'), input.loopGuard || { schema: 'sks.glm-loop-guard.v1', ok: true });
-    await writeJsonAtomic(path.join(dir, 'context-omissions.json'), input.contextOmissions || { omitted: [] });
-    return dir;
-}

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

@@ -1,10 +0,0 @@
-export const GLM_TERMINAL_PHASES = new Set([
-    'completed',
-    'blocked',
-    'failed',
-    'cancelled',
-    'timeout'
-]);
-export function isGlmTerminalPhase(phase) {
-    return GLM_TERMINAL_PHASES.has(phase);
-}

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

@@ -1,30 +0,0 @@
-export const GLM_SPEED_LIMITS = {
-    max_turns: 2,
-    max_tool_rounds: 0,
-    max_wall_clock_ms: 90_000,
-    request_timeout_ms: 45_000,
-    idle_timeout_ms: 15_000,
-    max_no_progress_iterations: 1,
-    max_repeated_output: 1,
-    max_patch_retries: 1,
-    max_context_requests: 1
-};
-export const GLM_DEEP_LIMITS = {
-    max_turns: 4,
-    max_tool_rounds: 4,
-    max_wall_clock_ms: 240_000,
-    request_timeout_ms: 120_000,
-    idle_timeout_ms: 30_000,
-    max_no_progress_iterations: 2,
-    max_repeated_output: 2,
-    max_patch_retries: 2,
-    max_context_requests: 2
-};
-export function createRequestAbortController(timeoutMs) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), Math.max(1, timeoutMs));
-    return {
-        controller,
-        clear: () => clearTimeout(timeout)
-    };
-}