sneakoscope 7.0.2 → 7.0.5

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

@@ -1,82 +0,0 @@
-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 Speed / OpenRouter)';
-export const GLM_CODEX_CONFIG_PROVIDER_ID = 'openrouter';
-export const GLM_CODEX_CONFIG_PROFILE_ID = 'sks-glm-52-mad';
-export const GLM_CODEX_SELECTABLE_REASONING_EFFORTS = [
-    'none',
-    'minimal',
-    'low',
-    'medium',
-    'high',
-    'xhigh',
-];
-export const GLM_CODEX_CONFIG_REASONING_PROFILES = [
-    {
-        id: GLM_CODEX_CONFIG_PROFILE_ID,
-        label: 'GLM 5.2 MAD Speed',
-        reasoning_effort: 'none',
-    },
-    {
-        id: 'sks-glm-52-minimal',
-        label: 'GLM 5.2 Minimal',
-        reasoning_effort: 'minimal',
-    },
-    {
-        id: 'sks-glm-52-low',
-        label: 'GLM 5.2 Low',
-        reasoning_effort: 'low',
-    },
-    {
-        id: 'sks-glm-52-medium',
-        label: 'GLM 5.2 Medium',
-        reasoning_effort: 'medium',
-    },
-    {
-        id: 'sks-glm-52-high',
-        label: 'GLM 5.2 High',
-        reasoning_effort: 'high',
-    },
-    {
-        id: 'sks-glm-52-xhigh',
-        label: 'GLM 5.2 XHigh',
-        reasoning_effort: 'xhigh',
-    },
-];
-export function buildGlmCodexAppModelProfile() {
-    const speed = profileFromConst('speed');
-    return {
-        schema: 'sks.codex-app-model-profile.v1',
-        id: GLM_CODEX_APP_PROFILE_ID,
-        label: GLM_CODEX_APP_PROFILE_LABEL,
-        provider: 'openrouter',
-        model: GLM_52_OPENROUTER_MODEL,
-        codexConfigProvider: GLM_CODEX_CONFIG_PROVIDER_ID,
-        codexConfigProfile: GLM_CODEX_CONFIG_PROFILE_ID,
-        supportedReasoningEfforts: GLM_CODEX_SELECTABLE_REASONING_EFFORTS,
-        reasoningProfiles: GLM_CODEX_CONFIG_REASONING_PROFILES,
-        mode: GLM_MAD_MODE,
-        strictModelLock: true,
-        gptFallbackAllowed: false,
-        requiresSecret: 'openrouter-api-key',
-        defaultProfile: 'speed',
-        defaultSettings: {
-            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',
-            selectedExecutorPluginMcp: 'defer-to-codex-native',
-            duplicateAppMcpDeclarations: 'dedupe-by-codex',
-            cwdShellPathSemantics: 'preserve-codex-native'
-        }
-    };
-}

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

@@ -1,73 +0,0 @@
-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, reasoningEffortFromGlmSlashModelArgs, 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 selectedReasoningEffort = input.reasoningEffort || (input.args ? reasoningEffortFromGlmSlashModelArgs(input.args) || undefined : undefined);
-    const reasoning = profile.name === 'speed'
-        ? buildSpeedReasoningConfig(selectedReasoningEffort, 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 ?? 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: 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 && 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');
-}
-function buildSpeedReasoningConfig(reasoningEffort, reasoningMeta) {
-    if (reasoningEffort === 'none')
-        return { exclude: true };
-    if (reasoningEffort === 'minimal' || reasoningEffort === 'low' || reasoningEffort === 'medium') {
-        return { effort: reasoningEffort, exclude: true };
-    }
-    return buildFastReasoningConfig(reasoningMeta);
-}

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

@@ -1,32 +0,0 @@
-import { GLM_52_OPENROUTER_MODEL } from './glm-52-settings.js';
-export function assertGlm52ActualModel(responseModel) {
-    if (!responseModel) {
-        return {
-            ok: false,
-            code: 'glm_model_missing',
-            requestedModel: GLM_52_OPENROUTER_MODEL,
-            strictModelLock: true,
-            gptFallbackAllowed: false
-        };
-    }
-    const normalized = responseModel.toLowerCase();
-    if (normalized === GLM_52_OPENROUTER_MODEL ||
-        normalized.startsWith(`${GLM_52_OPENROUTER_MODEL}-`)) {
-        return {
-            ok: true,
-            code: 'ok',
-            actualModel: responseModel,
-            requestedModel: GLM_52_OPENROUTER_MODEL,
-            strictModelLock: true,
-            gptFallbackAllowed: false
-        };
-    }
-    return {
-        ok: false,
-        code: 'glm_model_mismatch',
-        actualModel: responseModel,
-        requestedModel: GLM_52_OPENROUTER_MODEL,
-        strictModelLock: true,
-        gptFallbackAllowed: false
-    };
-}

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

@@ -1,67 +0,0 @@
-export { OPENROUTER_CHAT_COMPLETIONS_URL } from '../openrouter/openrouter-types.js';
-export const GLM_52_OPENROUTER_MODEL = 'z-ai/glm-5.2';
-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_SPEED_PROFILE = {
-    model: GLM_52_OPENROUTER_MODEL,
-    mode: GLM_SPEED_MODE,
-    temperature: 0.2,
-    top_p: 0.85,
-    stream: true,
-    provider: {
-        allow_fallbacks: false,
-        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_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));
-}

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

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

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

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

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

@@ -1,140 +0,0 @@
-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',
-        ...(input.args ? { args: input.args } : {}),
-        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);
-    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, '')))];
-}

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

@@ -1,4 +0,0 @@
-import { madHighCommand } from '../../commands/mad-sks-command.js';
-export async function runGlmInteractiveLaunch(args, readiness) {
-    return madHighCommand(['--glm', ...args], { glmReadiness: readiness, glmArgs: args });
-}

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

@@ -1,39 +0,0 @@
-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.9',
-        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...'));
-}

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

@@ -1,30 +0,0 @@
-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');
-}

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

@@ -1,128 +0,0 @@
-import fs from 'node:fs/promises';
-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(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',
-            '--ask-for-approval',
-            'never',
-            '-c',
-            'service_tier=fast',
-            '-c',
-            `model_reasoning_effort=${effort}`,
-            '-c',
-            'model_provider="openrouter"',
-            '-c',
-            `model="${GLM_52_OPENROUTER_MODEL}"`,
-            '-c',
-            'model_providers.openrouter.name="OpenRouter"',
-            '-c',
-            'model_providers.openrouter.base_url="https://openrouter.ai/api/v1"',
-            '-c',
-            'model_providers.openrouter.env_key="OPENROUTER_API_KEY"',
-            '-c',
-            'model_providers.openrouter.wire_api="responses"',
-            '-c',
-            'model_providers.openrouter.requires_openai_auth=false'
-        ],
-        sandbox_mode: 'danger-full-access',
-        approval_policy: 'never',
-        model_reasoning_effort: effort,
-        service_tier: 'fast',
-        gpt_fallback_allowed: false,
-        writes_user_codex_config: false,
-        blockers: profile.blockers
-    };
-}
-export async function resolveMadGlmLaunchKey(env = process.env) {
-    return resolveOpenRouterApiKey({ env });
-}
-export async function writeMadGlmCodexWrapper(input) {
-    const env = input.env || process.env;
-    const paths = openRouterSecretPaths(env);
-    const realCodexBin = String(input.realCodexBin || env.SKS_CODEX_BIN || 'codex');
-    const wrapperPath = path.join(input.missionDir, 'sks-glm-codex-wrapper.sh');
-    await writeTextAtomic(wrapperPath, buildMadGlmCodexWrapperScript({
-        realCodexBin,
-        secretKeyPath: paths.keyPath
-    }));
-    await fs.chmod(wrapperPath, 0o700).catch(() => undefined);
-    return {
-        wrapper_path: wrapperPath,
-        real_codex_bin: realCodexBin,
-        secret_key_path: paths.keyPath,
-        raw_key_written_to_wrapper: false
-    };
-}
-export function buildMadGlmCodexWrapperScript(input) {
-    return [
-        '#!/bin/sh',
-        'set -eu',
-        '# Generated by SKS GLM MAD launch. This wrapper reads the key at runtime',
-        '# so Zellij layout artifacts never contain the raw OpenRouter secret.',
-        'if [ -z "${OPENROUTER_API_KEY:-}" ] && [ -n "${SKS_OPENROUTER_API_KEY:-}" ]; then',
-        '  OPENROUTER_API_KEY="$SKS_OPENROUTER_API_KEY"',
-        '  export OPENROUTER_API_KEY',
-        'fi',
-        `if [ -z "\${OPENROUTER_API_KEY:-}" ] && [ -r ${shellQuote(input.secretKeyPath)} ]; then`,
-        `  OPENROUTER_API_KEY="$(cat ${shellQuote(input.secretKeyPath)})"`,
-        '  export OPENROUTER_API_KEY',
-        'fi',
-        'if [ -z "${OPENROUTER_API_KEY:-}" ]; then',
-        '  echo "SKS GLM MAD blocked: OPENROUTER_API_KEY is missing. Run sks --mad --glm --repair or export OPENROUTER_API_KEY." >&2',
-        '  exit 66',
-        'fi',
-        `exec ${shellQuote(input.realCodexBin)} "$@"`,
-        ''
-    ].join('\n');
-}
-export function buildMadGlmLaunchArtifact(input) {
-    const profile = input.profile || buildMadGlmLaunchProfileNoWrite();
-    return {
-        schema: 'sks.glm-mad-launch.v1',
-        generated_at: nowIso(),
-        ok: Boolean(input.keyResolution.key),
-        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,
-        openrouter_key_source: input.keyResolution.source || null,
-        key_preview: input.keyResolution.key_preview || null,
-        wrapper_path: input.wrapper.wrapper_path,
-        real_codex_bin: input.wrapper.real_codex_bin,
-        raw_key_written_to_wrapper: false,
-        codex_args: profile.launch_args,
-        blockers: [...profile.blockers, ...(input.keyResolution.key ? [] : input.keyResolution.blockers)],
-        warnings: input.keyResolution.warnings || []
-    };
-}
-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';
-}