sneakoscope 4.0.13 → 4.0.14

package/dist/core/providers/glm/naruto/glm-naruto-requirement-coverage.js

@@ -0,0 +1,92 @@
+export function enrichGlmNarutoCandidateRequirementCoverage(input) {
+    const coverage = inferCandidateRequirementCoverage(input);
+    return {
+        ...input.envelope,
+        requirements_satisfied: coverage.requirements_satisfied,
+        requirements_risk: coverage.requirements_risk,
+        assumptions: coverage.assumptions
+    };
+}
+export function inferCandidateRequirementCoverage(input) {
+    const satisfied = [];
+    const risk = [];
+    const missing = [];
+    const assumptions = [];
+    const touched = new Set(input.envelope.target_paths);
+    const patch = input.envelope.patch.toLowerCase();
+    for (const requirement of input.ledger.requirements) {
+        const relatedPaths = extractPaths(requirement.text);
+        const pathCovered = relatedPaths.some((file) => touched.has(file) || patch.includes(file.toLowerCase()));
+        const lower = requirement.text.toLowerCase();
+        const preservationClause = /\b(preserve|do not|don't|without|never|no fallback|no fake|보존|금지|없이)\b/.test(lower);
+        const onlyClause = /\bonly\b|만\b/.test(lower);
+        if (relatedPaths.length > 0 && pathCovered && (!onlyClause || input.envelope.target_paths.every((file) => relatedPaths.includes(file)))) {
+            satisfied.push(requirement.id);
+            continue;
+        }
+        if (onlyClause && relatedPaths.length > 0 && input.envelope.target_paths.some((file) => !relatedPaths.includes(file))) {
+            risk.push(requirement.id);
+            missing.push(requirement.id);
+            continue;
+        }
+        if (preservationClause) {
+            risk.push(requirement.id);
+            missing.push(requirement.id);
+            assumptions.push(`manual_preservation_evidence_required:${requirement.id}`);
+            continue;
+        }
+        if (input.envelope.patch.trim()) {
+            satisfied.push(requirement.id);
+        }
+        else {
+            missing.push(requirement.id);
+        }
+    }
+    return {
+        schema: 'sks.glm-naruto-candidate-requirement-coverage.v1',
+        mission_id: input.envelope.mission_id,
+        worker_id: input.envelope.worker_id,
+        patch_id: input.envelope.patch_sha256,
+        requirements_satisfied: [...new Set(satisfied)],
+        requirements_risk: [...new Set(risk)],
+        requirements_missing: [...new Set(missing)],
+        assumptions: [...new Set(assumptions)]
+    };
+}
+export function buildGlmNarutoRequirementCoverageSummary(input) {
+    const selected = input.selectedPatchIds.length
+        ? input.envelopes.filter((env) => input.selectedPatchIds.includes(env.worker_id))
+        : input.envelopes;
+    const rows = input.ledger.requirements.map((requirement) => {
+        const satisfiedBy = selected
+            .filter((env) => env.requirements_satisfied?.includes(requirement.id))
+            .map((env) => env.worker_id);
+        const riskBy = selected
+            .filter((env) => env.requirements_risk?.includes(requirement.id))
+            .map((env) => env.worker_id);
+        const covered = satisfiedBy.length > 0 && riskBy.length === 0;
+        return {
+            requirement_id: requirement.id,
+            required: requirement.required,
+            covered,
+            satisfied_by: satisfiedBy,
+            risk_by: riskBy
+        };
+    });
+    const uncovered = rows
+        .filter((row) => row.required && !row.covered)
+        .map((row) => row.requirement_id);
+    return {
+        schema: 'sks.glm-naruto-requirement-coverage-summary.v1',
+        mission_id: input.missionId,
+        required_total: input.ledger.requirements.filter((req) => req.required).length,
+        required_covered: rows.filter((row) => row.required && row.covered).length,
+        uncovered_required_requirements: uncovered,
+        passed: uncovered.length === 0,
+        requirements: rows
+    };
+}
+function extractPaths(text) {
+    return [...new Set(text.match(/[A-Za-z0-9_.-]+\/[A-Za-z0-9_./-]+\.[A-Za-z0-9]+/g) ?? [])];
+}
+//# sourceMappingURL=glm-naruto-requirement-coverage.js.map

package/dist/core/providers/glm/naruto/glm-naruto-requirement-ledger.js

@@ -0,0 +1,42 @@
+export function buildGlmNarutoRequirementLedger(input) {
+    const requirements = [];
+    const seen = new Set();
+    const add = (text, source, required = true) => {
+        const clean = text.replace(/\s+/g, ' ').trim();
+        if (!clean || seen.has(`${source}:${clean.toLowerCase()}`))
+            return;
+        seen.add(`${source}:${clean.toLowerCase()}`);
+        requirements.push({
+            id: `REQ-${String(requirements.length + 1).padStart(3, '0')}`,
+            text: clean,
+            source,
+            required
+        });
+    };
+    for (const clause of splitRequirementClauses(input.task)) {
+        const lower = clause.toLowerCase();
+        if (/\b(must|without|do not|don't|preserve|only|never|no fallback|no fake|금지|필수|보존|없이|만)\b/.test(lower)) {
+            add(clause, 'user_task', true);
+        }
+    }
+    for (const file of input.mentionedPaths ?? []) {
+        add(`Touch or preserve mentioned path: ${file}`, 'user_task', true);
+    }
+    if (input.gitStatus && input.gitStatus.trim()) {
+        add('Preserve pre-existing dirty worktree changes unless explicitly selected.', 'git_status', true);
+    }
+    if (requirements.length === 0)
+        add(input.task, 'user_task', true);
+    return {
+        schema: 'sks.glm-naruto-requirement-ledger.v1',
+        mission_id: input.missionId,
+        requirements
+    };
+}
+function splitRequirementClauses(task) {
+    return task
+        .split(/\r?\n|[.;]|(?:\s+-\s+)/g)
+        .map((part) => part.replace(/^[-*\d.)\s]+/, '').trim())
+        .filter(Boolean);
+}
+//# sourceMappingURL=glm-naruto-requirement-ledger.js.map

package/dist/core/providers/glm/naruto/glm-naruto-stage-scheduler.js

@@ -0,0 +1,85 @@
+export async function runGlmNarutoStageScheduler(input) {
+    const started = Date.now();
+    const queue = input.jobs.map((job, index) => ({ job, index }));
+    const running = new Map();
+    const results = new Array(input.jobs.length);
+    const events = [];
+    const maxActive = Math.max(1, Math.min(Math.max(1, input.max_active), Math.max(1, input.jobs.length)));
+    let nextKey = 0;
+    let maxObservedActive = 0;
+    let sumJobDurationMs = 0;
+    while (queue.length > 0 || running.size > 0) {
+        while (queue.length > 0 && running.size < maxActive) {
+            const next = queue.shift();
+            const key = nextKey++;
+            const active = running.size + 1;
+            maxObservedActive = Math.max(maxObservedActive, active);
+            await emit({
+                schema: 'sks.glm-naruto-stage-event.v1',
+                stage: input.stage,
+                job_id: next.job.id,
+                phase: 'start',
+                active,
+                timestamp_ms: Date.now()
+            });
+            running.set(key, runOne(key, next.index, next.job, input));
+        }
+        if (running.size === 0)
+            continue;
+        const completed = await Promise.race([...running.values()]);
+        running.delete(completed.key);
+        const duration = Math.max(0, Date.now() - completed.started_ms);
+        sumJobDurationMs += duration;
+        results[completed.index] = completed.settled;
+        await emit({
+            schema: 'sks.glm-naruto-stage-event.v1',
+            stage: input.stage,
+            job_id: completed.job.id,
+            phase: 'end',
+            active: running.size,
+            timestamp_ms: Date.now(),
+            duration_ms: duration,
+            status: completed.settled.status
+        });
+    }
+    const wallClockMs = Math.max(0, Date.now() - started);
+    return {
+        stage: input.stage,
+        results: results.map((row) => row),
+        max_observed_active: maxObservedActive,
+        wall_clock_ms: wallClockMs,
+        sum_job_duration_ms: sumJobDurationMs,
+        overlap_ratio: wallClockMs > 0 ? sumJobDurationMs / wallClockMs : input.jobs.length > 1 ? input.jobs.length : 1,
+        events
+    };
+    async function emit(event) {
+        events.push(event);
+        if (input.onEvent)
+            await input.onEvent(event);
+    }
+}
+async function runOne(key, index, job, input) {
+    const startedMs = Date.now();
+    try {
+        const value = await withTimeout(input.runJob(job), input.timeout_ms);
+        return { key, index, job, started_ms: startedMs, settled: { status: 'fulfilled', value } };
+    }
+    catch (reason) {
+        return { key, index, job, started_ms: startedMs, settled: { status: 'rejected', reason } };
+    }
+}
+function withTimeout(promise, timeoutMs) {
+    if (!timeoutMs || timeoutMs <= 0)
+        return promise;
+    let timer;
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error('glm_stage_job_timeout')), timeoutMs);
+        })
+    ]).finally(() => {
+        if (timer)
+            clearTimeout(timer);
+    });
+}
+//# sourceMappingURL=glm-naruto-stage-scheduler.js.map

package/dist/core/providers/glm/naruto/glm-naruto-task-size-classifier.js

@@ -0,0 +1,12 @@
+export function classifyGlmTaskSize(task) {
+    const paths = [...new Set(task.match(/[A-Za-z0-9_.-]+\/[A-Za-z0-9_./-]+\.[A-Za-z0-9]+/g) ?? [])];
+    const lower = task.toLowerCase();
+    if (paths.length === 1 && /\b(tiny|small|simple|copy|spacing|label|one file|single-file)\b/.test(lower)) {
+        return { kind: 'tiny_single_file', confidence: 0.82, reasons: ['one_mentioned_file', 'tiny_task_language'] };
+    }
+    if (paths.length > 1 || /\b(parallel|multi-file|refactor|route|scheduler|coverage|benchmark)\b/.test(lower)) {
+        return { kind: 'parallelizable_multi_file', confidence: 0.78, reasons: paths.length > 1 ? ['multiple_mentioned_files'] : ['parallelizable_task_language'] };
+    }
+    return { kind: 'unknown', confidence: 0.4, reasons: ['insufficient_task_shape_evidence'] };
+}
+//# sourceMappingURL=glm-naruto-task-size-classifier.js.map

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

@@ -67,6 +67,10 @@ export async function writeMissionArtifacts(input) {
                 shard_id: env.shard_id,
                 model: env.model || null,
                 provider: 'openrouter',
+                gpt_fallback_allowed: false,
+                fallback_models_count: 0,
+                openai_key_used: false,
+                authorization_source: 'openrouter',
                 request_body_size: env.request_body_size ?? null,
                 cached: env.cached ?? false,
                 created_at: nowIso(),

package/dist/core/providers/glm/naruto/glm-naruto-verifier-output.js

@@ -12,6 +12,11 @@ export function parseGlmNarutoVerifierOutput(content) {
             issues.push('risk_score');
         if (typeof parsed.confidence !== 'number' || parsed.confidence < 0 || parsed.confidence > 1)
             issues.push('confidence');
+        for (const key of ['requirements_satisfied', 'requirements_missing', 'detail_loss_risks']) {
+            if (parsed[key] !== undefined && (!Array.isArray(parsed[key]) || parsed[key].some((item) => typeof item !== 'string'))) {
+                issues.push(key);
+            }
+        }
         if (issues.length)
             return { ok: false, issues: issues.map((issue) => `invalid_${issue}`) };
         return { ok: true, output: parsed, issues: [] };

package/dist/core/providers/glm/naruto/glm-naruto-worker-pool.js

@@ -8,11 +8,15 @@ import { writeGlmNarutoWorkerArtifacts } from './glm-naruto-worker-artifacts.js'
 import { materializePatchViaWorktree } from './glm-naruto-worktree-worker.js';
 import { createProviderHealthTracker } from '../../openrouter/openrouter-provider-health.js';
 import { runGlmNarutoWorkerScheduler } from './glm-naruto-worker-scheduler.js';
+import { runGlmNarutoStageScheduler } from './glm-naruto-stage-scheduler.js';
+import { createStageParallelismMetric, metricFromStageResult } from './glm-naruto-parallelism-summary.js';
 export async function runPatchWorkerPool(input) {
     const envelopes = [];
     const traces = [];
     const failedShardIds = [];
     const concurrencyDecisions = [];
+    const stageMetrics = [];
+    const stageEvents = [];
     const mutableShards = input.shards.filter((s) => s.mutable);
     const decision = decideConcurrency({
         requestedClones: input.maxWorkers,
@@ -33,6 +37,7 @@ export async function runPatchWorkerPool(input) {
         }
     }
     const health = input.health ?? createProviderHealthTracker();
+    const patchGenerationStarted = Date.now();
     const schedulerResult = await runGlmNarutoWorkerScheduler({
         jobs,
         initial_active_workers: decision.target_active_workers,
@@ -52,23 +57,56 @@ export async function runPatchWorkerPool(input) {
             timeoutMs: input.workerTimeoutMs
         })
     });
+    const patchGenerationWallClockMs = Date.now() - patchGenerationStarted;
     await writeSchedulerArtifacts(input.cwd, input.missionId, schedulerResult).catch(() => undefined);
     const results = schedulerResult.results;
+    stageMetrics.push(createStageParallelismMetric({
+        stage: input.stageName ?? 'patch_generation',
+        job_count: jobs.length,
+        max_observed_active: schedulerResult.max_observed_active_workers,
+        wall_clock_ms: patchGenerationWallClockMs,
+        sum_job_duration_ms: schedulerResult.results.reduce((sum, result) => (result.status === 'fulfilled' ? sum + Math.max(0, result.value.trace.total_ms) : sum + input.workerTimeoutMs), 0),
+        overlap_ratio: 1
+    }));
+    const successfulCandidates = [];
     for (const result of results) {
         if (result.status === 'fulfilled' && result.value.ok && result.value.envelope) {
-            const isolationMode = input.isolationMode ?? 'patch-envelope-only';
-            let candidateEnvelope = result.value.envelope;
-            let worktreeRecord;
-            if (isolationMode === 'git-worktree') {
+            successfulCandidates.push({ envelope: result.value.envelope, trace: result.value.trace });
+        }
+        else if (result.status === 'fulfilled') {
+            traces.push(result.value.trace);
+            failedShardIds.push(result.value.trace.shard_id);
+        }
+        else {
+            // rejected promise
+            failedShardIds.push('unknown');
+        }
+    }
+    const isolationMode = input.isolationMode ?? 'patch-envelope-only';
+    let materializedCandidates = successfulCandidates.map((candidate) => ({
+        envelope: candidate.envelope,
+        trace: candidate.trace,
+        gateEligible: true
+    }));
+    if (isolationMode === 'git-worktree' && materializedCandidates.length > 0) {
+        const worktreeStage = await runGlmNarutoStageScheduler({
+            stage: 'worktree_materialization',
+            jobs: materializedCandidates.map((candidate) => ({
+                id: candidate.envelope.worker_id,
+                stage: 'worktree_materialization',
+                input: candidate
+            })),
+            max_active: Math.min(4, materializedCandidates.length),
+            timeout_ms: input.workerTimeoutMs,
+            runJob: async (job) => {
                 const worktree = await materializePatchViaWorktree({
                     repoRoot: input.cwd,
                     missionId: input.missionId,
-                    envelope: candidateEnvelope,
+                    envelope: job.input.envelope,
                     ...(input.baseCommit !== undefined ? { baseCommit: input.baseCommit } : {}),
                     cleanup: input.cleanupWorktrees !== false
                 });
-                candidateEnvelope = worktree.envelope;
-                worktreeRecord = {
+                const worktreeRecord = {
                     schema: 'sks.glm-naruto-worker-worktree.v1',
                     selected: 'git-worktree',
                     ok: worktree.ok,
@@ -80,34 +118,88 @@ export async function runPatchWorkerPool(input) {
                     applied_patch_was_extracted: worktree.worktree?.applied_patch_was_extracted ?? false,
                     blockers: worktree.blockers
                 };
-                if (!worktree.ok) {
-                    await writeGlmNarutoWorkerArtifacts({
-                        root: input.cwd,
-                        missionId: input.missionId,
-                        workerId: candidateEnvelope.worker_id,
-                        shardId: candidateEnvelope.shard_id,
-                        patchEnvelope: candidateEnvelope,
-                        streamTrace: result.value.trace,
-                        isolation: {
-                            schema: 'sks.glm-naruto-worker-isolation.v1',
-                            selected: isolationMode,
-                            workers_write_main_workspace: false
-                        },
-                        worktree: worktreeRecord,
-                        termination: { status: candidateEnvelope.status, ok: false, blockers: candidateEnvelope.blockers }
-                    }).catch(() => undefined);
-                    envelopes.push(candidateEnvelope);
-                    traces.push(result.value.trace);
-                    failedShardIds.push(candidateEnvelope.shard_id);
-                    continue;
-                }
+                return {
+                    envelope: worktree.ok ? worktree.envelope : { ...worktree.envelope, status: 'gate_failed', blockers: worktree.blockers },
+                    worktreeRecord,
+                    ok: worktree.ok
+                };
             }
-            const gate = await evaluateGlmNarutoPatchCandidateGate({
+        });
+        stageMetrics.push(metricFromStageResult(worktreeStage));
+        stageEvents.push(...worktreeStage.events);
+        materializedCandidates = materializedCandidates.map((candidate, index) => {
+            const result = worktreeStage.results[index];
+            if (result?.status === 'fulfilled') {
+                return {
+                    envelope: result.value.envelope,
+                    trace: candidate.trace,
+                    gateEligible: result.value.ok,
+                    worktreeRecord: result.value.worktreeRecord
+                };
+            }
+            return {
+                envelope: { ...candidate.envelope, status: 'gate_failed', blockers: ['worktree_materialization_failed'] },
+                trace: candidate.trace,
+                gateEligible: false
+            };
+        });
+    }
+    for (const candidate of materializedCandidates.filter((item) => !item.gateEligible)) {
+        await writeGlmNarutoWorkerArtifacts({
+            root: input.cwd,
+            missionId: input.missionId,
+            workerId: candidate.envelope.worker_id,
+            shardId: candidate.envelope.shard_id,
+            patchEnvelope: candidate.envelope,
+            streamTrace: candidate.trace,
+            isolation: {
+                schema: 'sks.glm-naruto-worker-isolation.v1',
+                selected: isolationMode,
+                workers_write_main_workspace: false
+            },
+            ...(candidate.worktreeRecord ? { worktree: candidate.worktreeRecord } : {}),
+            termination: { status: candidate.envelope.status, ok: false, blockers: candidate.envelope.blockers }
+        }).catch(() => undefined);
+        envelopes.push(candidate.envelope);
+        traces.push(candidate.trace);
+        failedShardIds.push(candidate.envelope.shard_id);
+    }
+    const gateCandidates = materializedCandidates.filter((item) => item.gateEligible);
+    if (gateCandidates.length > 0) {
+        const gateStage = await runGlmNarutoStageScheduler({
+            stage: 'candidate_gate',
+            jobs: gateCandidates.map((candidate) => ({
+                id: candidate.envelope.worker_id,
+                stage: 'candidate_gate',
+                input: candidate
+            })),
+            max_active: Math.min(8, gateCandidates.length),
+            timeout_ms: Math.min(60_000, input.workerTimeoutMs),
+            runJob: (job) => evaluateGlmNarutoPatchCandidateGate({
                 cwd: input.cwd,
-                envelope: candidateEnvelope,
+                envelope: job.input.envelope,
                 apply: false
-            });
-            let envelope = candidateEnvelope;
+            })
+        });
+        stageMetrics.push(metricFromStageResult(gateStage));
+        stageEvents.push(...gateStage.events);
+        for (let index = 0; index < gateCandidates.length; index += 1) {
+            const candidate = gateCandidates[index];
+            const result = gateStage.results[index];
+            const gate = result?.status === 'fulfilled'
+                ? result.value
+                : {
+                    schema: 'sks.glm-naruto-patch-candidate-gate.v1',
+                    ok: false,
+                    worker_id: candidate.envelope.worker_id,
+                    shard_id: candidate.envelope.shard_id,
+                    patch_id: candidate.envelope.patch_sha256,
+                    extracted_patch: '',
+                    touched_paths: [],
+                    checks: [],
+                    blockers: ['candidate_gate_failed']
+                };
+            let envelope = candidate.envelope;
             if (gate.ok) {
                 envelope = createPatchEnvelope({
                     missionId: envelope.mission_id,
@@ -135,25 +227,17 @@ export async function runPatchWorkerPool(input) {
                 shardId: envelope.shard_id,
                 patchEnvelope: envelope,
                 gateResult: gate,
-                streamTrace: result.value.trace,
+                streamTrace: candidate.trace,
                 isolation: {
                     schema: 'sks.glm-naruto-worker-isolation.v1',
                     selected: isolationMode,
                     workers_write_main_workspace: false
                 },
-                ...(worktreeRecord ? { worktree: worktreeRecord } : {}),
+                ...(candidate.worktreeRecord ? { worktree: candidate.worktreeRecord } : {}),
                 termination: { status: envelope.status, ok: gate.ok, blockers: envelope.blockers }
             }).catch(() => undefined);
             envelopes.push(envelope);
-            traces.push(result.value.trace);
-        }
-        else if (result.status === 'fulfilled') {
-            traces.push(result.value.trace);
-            failedShardIds.push(result.value.trace.shard_id);
-        }
-        else {
-            // rejected promise
-            failedShardIds.push('unknown');
+            traces.push(candidate.trace);
         }
     }
     return {
@@ -165,7 +249,9 @@ export async function runPatchWorkerPool(input) {
             max_observed_active_workers: schedulerResult.max_observed_active_workers,
             backpressure_events: schedulerResult.backpressure_events,
             queue_drained: true
-        }
+        },
+        stageMetrics,
+        stageEvents
     };
 }
 async function writeSchedulerArtifacts(root, missionId, schedulerResult) {

package/dist/core/providers/glm/naruto/glm-naruto-worker-runtime.js

@@ -65,6 +65,10 @@ export async function runPatchWorker(input) {
             request_body_size: encoded.entry.byteLength,
             request_body_stored: encoded.entry.bodyStored,
             cache_hit: encoded.cacheHit,
+            gpt_fallback_allowed: false,
+            fallback_models_count: Array.isArray(requestWithSession.models) ? requestWithSession.models?.length ?? 0 : 0,
+            openai_key_used: false,
+            authorization_source: 'openrouter',
             stable_prefix_digest: stablePrefixDigest,
             shard_suffix_digest: shardSuffixDigest
         }
@@ -239,8 +243,8 @@ export async function runVerifierWorker(input) {
     const started = Date.now();
     const sessionId = normalizeGlmNarutoSessionId(`sks-glm-naruto-verify-${input.missionId}-${input.workerId}`);
     const messages = [
-        { role: 'system', content: `You are a SKS GLM Naruto verifier. Model: ${GLM_52_OPENROUTER_MODEL}. No GPT fallback. Return only JSON with schema "sks.glm-naruto-verifier-output.v1", ok boolean, issues string array, risk_score number 0..1, confidence number 0..1. Do not include markdown.` },
-        { role: 'user', content: JSON.stringify({ patch_sha256: input.envelope.patch_sha256, target_paths: input.envelope.target_paths, patch: input.envelope.patch.slice(0, 4000) }) }
+        { role: 'system', content: `You are a SKS GLM Naruto verifier. Model: ${GLM_52_OPENROUTER_MODEL}. No GPT fallback. Return only JSON with schema "sks.glm-naruto-verifier-output.v1", ok boolean, issues string array, risk_score number 0..1, confidence number 0..1, requirements_satisfied string array, requirements_missing string array, and detail_loss_risks string array. Do not include markdown.` },
+        { role: 'user', content: JSON.stringify({ patch_sha256: input.envelope.patch_sha256, target_paths: input.envelope.target_paths, requirements_satisfied: input.envelope.requirements_satisfied ?? [], requirements_risk: input.envelope.requirements_risk ?? [], patch: input.envelope.patch.slice(0, 4000) }) }
     ];
     const request = buildGlm52Request({
         profile: 'speed',

package/dist/core/routes/model-mode-router.js

@@ -0,0 +1,44 @@
+export function resolveSksModelMode(args = []) {
+    const normalized = args.map(String);
+    const hasGlm = normalized.includes('--glm');
+    const hasMad = normalized.includes('--mad') || normalized.includes('--MAD') || normalized.includes('--mad-sks');
+    const hasNaruto = normalized.includes('--naruto') || normalized.includes('naruto');
+    if (hasGlm && hasNaruto) {
+        return decision('glm-naruto', true, false, 'explicit_--glm_with_naruto', normalized);
+    }
+    if (hasGlm) {
+        return decision('glm-direct', true, false, 'explicit_--glm', normalized);
+    }
+    if (hasMad) {
+        return decision('gpt-mad', false, true, 'mad_without_--glm', normalized);
+    }
+    if (hasNaruto) {
+        return decision('classic-naruto', false, true, 'naruto_without_--glm', normalized);
+    }
+    return decision('unknown', false, false, 'no_model_mode_flags', normalized);
+}
+export function assertGlmRoute(args = []) {
+    const resolved = resolveSksModelMode(args);
+    if (!resolved.glm_enabled) {
+        throw new Error(`sks_glm_route_required:${resolved.mode}`);
+    }
+    return resolved;
+}
+export function assertNonGlmMadRoute(args = []) {
+    const resolved = resolveSksModelMode(args);
+    if (resolved.glm_enabled || resolved.mode !== 'gpt-mad') {
+        throw new Error(`sks_mad_route_glm_leak:${resolved.mode}`);
+    }
+    return resolved;
+}
+function decision(mode, glmEnabled, gptMadPreserved, reason, args) {
+    return {
+        schema: 'sks.model-mode-decision.v1',
+        mode,
+        glm_enabled: glmEnabled,
+        gpt_mad_preserved: gptMadPreserved,
+        reason,
+        args
+    };
+}
+//# sourceMappingURL=model-mode-router.js.map

package/dist/core/version.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "4.0.13",
+  "version": "4.0.14",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -38,6 +38,29 @@
     "!dist/scripts/*-check-lib.js",
     "!dist/scripts/*-report.js",
     "!dist/scripts/release-readiness-report.js",
+    "!dist/scripts/*-smoke.js",
+    "!dist/scripts/*-gate.js",
+    "!dist/scripts/*-lib.js",
+    "!dist/scripts/*-proof.js",
+    "!dist/scripts/blackbox-*.js",
+    "!dist/scripts/check-*.js",
+    "!dist/scripts/*-fixture.js",
+    "!dist/scripts/*-audit.js",
+    "!dist/scripts/*-regression.js",
+    "!dist/scripts/*-helper.js",
+    "!dist/scripts/fixtures/",
+    "!dist/scripts/release-*.js",
+    "!dist/scripts/hooks-*.js",
+    "!dist/scripts/build-*.js",
+    "!dist/scripts/clean-*.js",
+    "!dist/scripts/ensure-*.js",
+    "!dist/scripts/sizecheck.js",
+    "!dist/scripts/perf-*.js",
+    "!dist/scripts/prepublish-*.js",
+    "!dist/scripts/write-*.js",
+    "!dist/scripts/*-inventory.js",
+    "!dist/scripts/*-watch.js",
+    "!dist/scripts/lib/",
     "schemas",
     "crates/sks-core/Cargo.lock",
     "crates/sks-core/Cargo.toml",