sneakoscope 4.0.13 → 4.0.15

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/release/gate-manifest.js

@@ -47,6 +47,13 @@ export const REQUIRED_FOR_PUBLISH = new Set([
     'side-effect:runtime-report',
     'release:version-truth',
     'release:provenance',
+    'release:codex-current',
+    'codex:0142:manifest',
+    'codex:0142:binary-identity',
+    'codex:0142:policy',
+    'codex:0142:app-server-v2',
+    'codex:0142:thread-store',
+    'codex:0142:capability',
     'publish:packlist-performance',
     'postinstall:safe-side-effects',
     'legacy:upgrade-zero-break',
@@ -102,7 +109,23 @@ export function affectedGlobsFor(id) {
         case 'codex':
         case 'codex-app':
         case 'codex-lb':
-            return ['src/core/codex/**', 'src/core/codex-app.ts', 'src/core/codex-lb-circuit.ts', `src/scripts/${prefix}-*.ts`];
+            return [
+                'src/core/codex/**',
+                'src/core/codex-control/**',
+                'src/core/codex-compat/**',
+                'src/core/codex-runtime/**',
+                'src/core/codex-app-server/**',
+                'src/core/codex-policy/**',
+                'src/commands/codex.ts',
+                'src/cli/install-helpers.ts',
+                'config/codex-releases/**',
+                'schemas/codex-*.json',
+                'package.json',
+                'package-lock.json',
+                'src/core/codex-app.ts',
+                'src/core/codex-lb-circuit.ts',
+                `src/scripts/${prefix}-*.ts`
+            ];
         case 'release':
             return ['src/core/release/**', 'src/scripts/release-parallel-check.ts', 'src/scripts/release-*.ts', 'package.json'];
         default:

package/dist/core/release/gate-pack-manifest.js

@@ -2,7 +2,7 @@ import { buildTriWikiGateImpactMap } from '../triwiki/triwiki-gate-impact-map.js
 export const GATE_PACK_MANIFEST_SCHEMA = 'sks.gate-pack-manifest.v1';
 export const REQUIRED_GATE_PACK_IDS = [
     'release-parity',
-    'codex-0140',
+    'codex-current',
     'doctor-production',
     'startup-mcp',
     'native-capability',
@@ -47,8 +47,8 @@ export function buildGatePackManifest(root, gates) {
 export function packForGateId(id) {
     if (id.startsWith('triwiki:'))
         return 'triwiki';
-    if (id.startsWith('codex:') || id.includes('0140'))
-        return 'codex-0140';
+    if (id.startsWith('codex:') || id.includes('0140') || id.includes('0142'))
+        return 'codex-current';
     if (id.startsWith('doctor:'))
         return 'doctor-production';
     if (id.startsWith('sksd:') || id.startsWith('probes:') || id.includes('mcp'))
@@ -72,7 +72,7 @@ export function packForGateId(id) {
 function descriptionForPack(id) {
     const descriptions = {
         'release-parity': 'Version, DAG, parity, and package release gates.',
-        'codex-0140': 'Codex 0.140 capability and integration checks.',
+        'codex-current': 'Current Codex release capability and integration checks.',
         'doctor-production': 'Doctor repair and production safety checks.',
         'startup-mcp': 'Startup, MCP, daemon, and probe readiness checks.',
         'native-capability': 'Native agent and desktop capability checks.',
@@ -89,7 +89,7 @@ function descriptionForPack(id) {
 function maxParallelForPack(id) {
     if (id === 'secret' || id === 'zellij')
         return 1;
-    if (id === 'qa-research-image' || id === 'codex-0140')
+    if (id === 'qa-research-image' || id === 'codex-current')
         return 2;
     return 4;
 }
@@ -111,7 +111,7 @@ function resourceClassesForPack(id) {
         return ['zellij-real'];
     if (id === 'qa-research-image')
         return ['browser-real', 'cpu-heavy', 'io-heavy'];
-    if (id === 'codex-0140')
+    if (id === 'codex-current')
         return ['remote-model-real'];
     return ['cpu-light', 'fs-read'];
 }

package/dist/core/release/release-gate-affected-selector.js

@@ -2,6 +2,13 @@ import { spawnSync } from 'node:child_process';
 const ALWAYS_KEEP = new Set([
     'release:version-truth',
     'release:dag-full-coverage',
+    'release:codex-current',
+    'codex:0142:manifest',
+    'codex:0142:binary-identity',
+    'codex:0142:policy',
+    'codex:0142:app-server-v2',
+    'codex:0142:thread-store',
+    'codex:0142:capability',
     'runtime:ts-source-of-truth',
     'typecheck',
     'schema:check'
@@ -64,6 +71,10 @@ function gateSelectionReason(gate, changedFiles, preset) {
         if (releaseGate)
             return 'release_gate_system_changed';
     }
+    if (changedFiles.some((file) => isCodexCurrentFile(file))) {
+        if (gate.id.startsWith('codex:0142') || gate.id === 'release:codex-current' || gate.id.startsWith('codex-control:') || gate.id.startsWith('codex-sdk:'))
+            return 'codex_current_surface_changed';
+    }
     const matchingReleaseScript = changedFiles.some((file) => releaseScriptGateCandidates(file).includes(gate.id));
     if (matchingReleaseScript)
         return 'release_script_changed';
@@ -85,6 +96,19 @@ function gateSelectionReason(gate, changedFiles, preset) {
         return 'cache_input_changed';
     return null;
 }
+function isCodexCurrentFile(file) {
+    return file.startsWith('src/core/codex-control/')
+        || file.startsWith('src/core/codex-compat/')
+        || file.startsWith('src/core/codex-runtime/')
+        || file.startsWith('src/core/codex-app-server/')
+        || file.startsWith('src/core/codex-policy/')
+        || file === 'src/commands/codex.ts'
+        || file === 'src/cli/install-helpers.ts'
+        || file.startsWith('config/codex-releases/')
+        || file.startsWith('schemas/codex-')
+        || file === 'package.json'
+        || file === 'package-lock.json';
+}
 function selectionResult(all, selected, changedFiles, mode, reasons, skipped) {
     return {
         gates: selected,

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/routes.js

@@ -636,7 +636,7 @@ export const COMMAND_CATALOG = [
     { name: 'root', usage: 'sks root [--json]', description: 'Show whether SKS is using a project root or the per-user global SKS runtime root.' },
     { name: 'update', usage: 'sks update check|now [--version <version>] [--json] [--dry-run]', description: 'Check for SKS updates or install the requested package version through npm global mode.' },
     { name: 'deps', usage: 'sks deps check [--json] [--yes]', description: 'Check Node/npm, Codex CLI, and Zellij readiness; pass --yes to repair missing Codex CLI/Zellij tooling when supported.' },
-    { name: 'codex', usage: 'sks codex compatibility|version|doctor|schema [--json]', description: 'Check Codex CLI rust-v0.136.0 compatibility, installed version, 0.136 capabilities, inherited 0.135/0.134/0.133 behavior, and vendored hook schema snapshot freshness.' },
+    { name: 'codex', usage: 'sks codex compatibility|version|doctor|schema|0.142 [--json]', description: 'Check Codex CLI rust-v0.142.0 compatibility, installed version, 0.142 manifest/capability evidence, inherited legacy baselines, and vendored hook schema snapshot freshness.' },
     { name: 'codex-app', usage: 'sks codex-app [check|product-design|product-design --check-only|ensure-product-design|chrome-extension|pat status|remote-control]', description: 'Check Codex App install, Product Design plugin auto-install readiness, Codex Chrome Extension web verification readiness, PAT-safe status, first-party MCP/plugin readiness, and Codex CLI 0.130.0+ remote-control availability.' },
     { name: 'codex-native', usage: 'sks codex-native status|feature-broker|invocation-plan|init-deep [--json]', description: 'Inspect Codex Native feature broker readiness, invocation routing, pattern evidence, and managed memory setup.' },
     { name: 'hooks', usage: 'sks hooks explain|status|trust-report|replay|codex-validate|warning-check ... [--json]', description: 'Explain Codex hook events, validate vendored latest 10-event output schemas, replay fixtures, and enforce warning-zero SKS hook policies under the 0.134 compatibility matrix.' },

package/dist/core/version.js

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

package/dist/scripts/agent-ast-aware-work-graph-check.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, importDist, root, readJson } from './sks-1-18-gate-lib.js';
+const inventoryMod = await importDist('core/agents/work-partition/repo-inventory.js');
+const depsMod = await importDist('core/agents/work-partition/dependency-graph.js');
+const graphMod = await importDist('core/agents/intelligent-work-graph.js');
+const inventory = await inventoryMod.collectRepoInventory(root, { maxFiles: 2000 });
+const dependencyGraph = depsMod.buildDependencyGraph(inventory);
+const graph = await graphMod.buildIntelligentWorkGraph({ root, inventory, dependencyGraph, route: '$Team', prompt: '1.18.6 AST-aware work graph release gate' });
+const releaseVersion = readJson('package.json').version;
+assertGate(graph.schema === 'sks.intelligent-work-graph.v2', 'intelligent work graph schema must be v2', graph);
+assertGate(graph.ast_coverage > 0, 'AST-aware work graph must record AST coverage', graph);
+assertGate(Object.keys(graph.file_to_symbols).length > 0, 'AST-aware work graph must build file-to-symbol map', graph);
+assertGate(Object.keys(graph.symbol_to_files).length > 0, 'AST-aware work graph must build symbol-to-file map', graph);
+assertGate(Object.keys(graph.exported_symbols).length > 0, 'AST-aware work graph must build exported symbol map', graph);
+assertGate(Object.keys(graph.imported_symbols).length > 0, 'AST-aware work graph must build imported symbol map', graph);
+assertGate(Object.keys(graph.command_to_module_ownership).length > 0, 'AST-aware work graph must build command ownership map', graph);
+assertGate(graph.test_ownership_confidence >= 0, 'AST-aware work graph must record test ownership confidence', graph);
+assertGate(['proven', 'partial', 'blocked'].includes(graph.proof_level), 'AST-aware work graph must report an honest proof level', graph);
+fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
+fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', `agent-intelligent-work-graph-v2-${releaseVersion}.json`), `${JSON.stringify(graphMod.compactIntelligentWorkGraph(graph), null, 2)}\n`);
+emitGate('agent:ast-aware-work-graph', { score: graph.work_graph_quality_score, ast_coverage: graph.ast_coverage, proof_level: graph.proof_level });
+//# sourceMappingURL=agent-ast-aware-work-graph-check.js.map

package/dist/scripts/agent-backfill-replenishment-check.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { runDynamicPoolFixture } from './agent-dynamic-pool-fixture.js';
+const fixture = await runDynamicPoolFixture({ target: 5, total: 8 });
+const backfills = fixture.events.filter((event) => event.event_type === 'backfill_event');
+const firstSlowCompletionIndex = fixture.events.findIndex((event) => event.event_type === 'session_completed' && /work-00[3-5]/.test(String(event.work_item_id || '')));
+const secondBackfillIndex = fixture.events.findIndex((event, index) => index > fixture.events.findIndex((row) => row.event_type === 'backfill_event') && event.event_type === 'backfill_event');
+assertGate(backfills.length >= 2, 'two early completions must create two backfill events', { backfills });
+assertGate(secondBackfillIndex >= 0 && (firstSlowCompletionIndex < 0 || secondBackfillIndex < firstSlowCompletionIndex), 'replacement sessions must launch before the remaining first wave drains', { firstSlowCompletionIndex, secondBackfillIndex });
+assertGate(fixture.result.state.backfill_count >= fixture.result.state.expected_backfill_count, 'backfill count must satisfy expected backfills', fixture.result.state);
+emitGate('agent:backfill-replenishment', { backfill_count: fixture.result.state.backfill_count, expected_backfill_count: fixture.result.state.expected_backfill_count });
+//# sourceMappingURL=agent-backfill-replenishment-check.js.map

package/dist/scripts/agent-backfill-route-blackbox.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { runRouteBackfillBlackbox } from './agent-route-blackbox-lib.js';
+runRouteBackfillBlackbox('$Agent', 'agent:backfill-route-blackbox');
+//# sourceMappingURL=agent-backfill-route-blackbox.js.map

package/dist/scripts/agent-background-terminals-check.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/agents/agent-terminal-session.js');
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-agent-terminal-'));
+await fs.writeFile(path.join(root, 'agent-sessions.json'), JSON.stringify({ schema: 'sks.agent-sessions.v1', sessions: { agent_1: { agent_id: 'agent_1', session_id: 's1', status: 'closed' } } }, null, 2));
+const agent = { id: 'agent_1', session_id: 's1' };
+await mod.startAgentTerminalSession(root, agent, { backend: 'fake', real: false });
+await mod.closeAgentTerminalSession(root, agent, { exitCode: 0, status: 'done' });
+const closed = await mod.assertAgentTerminalSessionsClosed(root);
+assertGate(closed.ok === true, 'every agent terminal session must have close report', closed);
+emitGate('agent:background-terminals', { terminal_sessions: closed.total_sessions });
+//# sourceMappingURL=agent-background-terminals-check.js.map