sneakoscope 2.0.4 → 2.0.5

package/dist/core/naruto/naruto-work-item.js

@@ -0,0 +1,40 @@
+export const NARUTO_WORK_KINDS = [
+    'implementation',
+    'code_modification',
+    'refactor',
+    'test_generation',
+    'test_execution',
+    'verification',
+    'research',
+    'documentation',
+    'ux_review',
+    'ppt_review',
+    'image_review',
+    'conflict_resolution',
+    'patch_rebase',
+    'rollback_preparation',
+    'integration_support',
+    'final_review_input_pack'
+];
+export const NARUTO_WRITE_WORK_KINDS = new Set([
+    'implementation',
+    'code_modification',
+    'refactor',
+    'test_generation',
+    'documentation',
+    'conflict_resolution',
+    'patch_rebase',
+    'rollback_preparation',
+    'integration_support'
+]);
+export function isNarutoWriteKind(kind) {
+    return NARUTO_WRITE_WORK_KINDS.has(kind);
+}
+export function normalizeNarutoWorkKind(value, fallback = 'verification') {
+    const text = String(value || '');
+    return NARUTO_WORK_KINDS.includes(text) ? text : fallback;
+}
+export function normalizeNarutoPath(value) {
+    return String(value || '').replace(/\\/g, '/').replace(/^\.\/+/, '').split('/').filter((part) => part && part !== '.').join('/');
+}
+//# sourceMappingURL=naruto-work-item.js.map

package/dist/core/naruto/naruto-work-stealing.js

@@ -0,0 +1,11 @@
+export function stealNarutoWork(queue, input = {}) {
+    const item = queue.shift() || null;
+    return {
+        schema: 'sks.naruto-work-stealing.v1',
+        stolen: Boolean(item),
+        work_item_id: item?.id || null,
+        from_queue: input.fromQueue || 'pending',
+        to_slot: input.toSlot || 'idle-slot'
+    };
+}
+//# sourceMappingURL=naruto-work-stealing.js.map

package/dist/core/naruto/resource-pressure-monitor.js

@@ -0,0 +1,32 @@
+export function monitorNarutoResourcePressure(probe, input = {}) {
+    const activeWorkers = Math.max(1, Math.floor(Number(input.activeWorkers || 1)));
+    const zellijCap = Math.max(1, Math.floor(Number(input.zellijVisiblePaneCap || 12)));
+    const memoryPressure = 1 - (probe.free_memory_bytes / Math.max(1, probe.total_memory_bytes));
+    const cpuPressure = Math.min(1, (probe.current_load_average[0] || 0) / Math.max(1, probe.cpu_core_count));
+    const fdPressure = Math.min(1, (activeWorkers * 6 + probe.process_count) / Math.max(1, probe.file_descriptor_limit));
+    const zellijPressure = Math.min(1, probe.zellij_pane_count / zellijCap);
+    const diskIoPressure = probe.disk_io_pressure;
+    const reasons = [
+        ...(memoryPressure > 0.8 ? ['memory_cap'] : []),
+        ...(cpuPressure > 0.9 ? ['cpu_load_cap'] : []),
+        ...(fdPressure > 0.75 ? ['file_descriptor_budget'] : []),
+        ...(zellijPressure > 0.9 ? ['zellij_ui_pane_budget'] : []),
+        ...(diskIoPressure > 0.75 ? ['disk_io_pressure'] : [])
+    ];
+    const maxPressure = Math.max(memoryPressure, cpuPressure, fdPressure, zellijPressure, diskIoPressure);
+    const state = maxPressure >= 0.92 ? 'saturated' : maxPressure >= 0.72 ? 'throttled' : 'normal';
+    return {
+        schema: 'sks.naruto-resource-pressure.v1',
+        state,
+        memory_pressure: round(memoryPressure),
+        cpu_pressure: round(cpuPressure),
+        fd_pressure: round(fdPressure),
+        zellij_pressure: round(zellijPressure),
+        disk_io_pressure: round(diskIoPressure),
+        reasons
+    };
+}
+function round(value) {
+    return Math.round(Math.max(0, Math.min(1, value)) * 1000) / 1000;
+}
+//# sourceMappingURL=resource-pressure-monitor.js.map

package/dist/core/pipeline/finalize-pipeline-result.js

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { runGptFinalArbiter } from '../codex-control/gpt-final-arbiter.js';
+import { gptFinalRequiredForPipeline } from './gpt-final-required.js';
+export async function finalizePipelineResult(input) {
+    const cwd = path.resolve(input.cwd || process.cwd());
+    const root = path.resolve(input.mutationLedgerRoot || path.join(cwd, '.sneakoscope', 'tmp', 'pipeline-finalize', safeName(input.missionId)));
+    const requirement = gptFinalRequiredForPipeline({
+        localParticipated: input.localParticipated,
+        candidateResults: input.candidateResults
+    });
+    let arbiter = null;
+    let blockers = [];
+    if (requirement.gpt_final_required) {
+        arbiter = await runGptFinalArbiter({
+            schema: 'sks.gpt-final-arbiter-input.v1',
+            route: input.route,
+            mission_id: input.missionId,
+            local_mode: 'local-parallel-gpt-final',
+            local_outputs: input.candidateResults,
+            candidate_patch_envelopes: input.candidatePatchEnvelopes
+        }, {
+            cwd,
+            mutationLedgerRoot: path.join(root, 'gpt-final-arbiter'),
+            ...(typeof input.forceGptFinalUnavailable === 'boolean' ? { forceUnavailable: input.forceGptFinalUnavailable } : {})
+        });
+        blockers = [
+            ...(arbiter.ok ? [] : ['gpt_final_arbiter_required_not_passed']),
+            ...(Array.isArray(arbiter.blockers) ? arbiter.blockers.map(String) : [])
+        ];
+    }
+    const result = {
+        schema: 'sks.pipeline-finalize-result.v1',
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        route: input.route,
+        mission_id: input.missionId,
+        local_participated: requirement.local_participated,
+        gpt_final_required: requirement.gpt_final_required,
+        gpt_final_arbiter: arbiter,
+        final_status: blockers.length ? 'blocked' : 'accepted',
+        apply_allowed: blockers.length === 0 && input.applyPatches === true,
+        final_patch_source: requirement.gpt_final_required ? 'gpt_final_arbiter' : 'deterministic_finalize',
+        candidate_results_count: input.candidateResults.length,
+        candidate_patch_envelope_count: input.candidatePatchEnvelopes.length,
+        verification_results_count: input.verificationResults.length,
+        side_effect_report: input.sideEffectReport,
+        mutation_ledger: input.mutationLedger,
+        rollback_plan: input.rollbackPlan,
+        blockers
+    };
+    await writeJsonAtomic(path.join(root, 'pipeline-finalize-result.json'), result);
+    return result;
+}
+function safeName(value) {
+    return String(value || 'unknown').replace(/[^a-zA-Z0-9_.-]+/g, '-').slice(0, 80);
+}
+//# sourceMappingURL=finalize-pipeline-result.js.map

package/dist/core/pipeline/gpt-final-required.js

@@ -0,0 +1,12 @@
+import { localCollaborationParticipated } from '../local-llm/local-collaboration-policy.js';
+export function gptFinalRequiredForPipeline(input) {
+    const localParticipated = input.localParticipated === true
+        || localCollaborationParticipated(Array.isArray(input.candidateResults) ? input.candidateResults : []);
+    return {
+        schema: 'sks.gpt-final-required.v1',
+        local_participated: localParticipated,
+        gpt_final_required: localParticipated,
+        reason: localParticipated ? 'local_llm_outputs_are_drafts' : 'no_local_participation'
+    };
+}
+//# sourceMappingURL=gpt-final-required.js.map

package/dist/core/prompt/prompt-placeholder-guard.js

@@ -0,0 +1,30 @@
+const PLACEHOLDER_PATTERNS = [
+    /@filename\b/i,
+    /<file>/i,
+    /\bTODO_PATH\b/i,
+    /\bINSERT_PATH_HERE\b/i,
+    /\/path\/to\/file\b/i
+];
+export function checkPromptPlaceholders(input = {}) {
+    const prompt = String(input.prompt || '');
+    const writeCapable = input.writeCapable === true;
+    const placeholders = PLACEHOLDER_PATTERNS
+        .filter((pattern) => pattern.test(prompt))
+        .map((pattern) => pattern.source);
+    const emptyTargetPaths = writeCapable && (!Array.isArray(input.targetPaths) || input.targetPaths.length === 0);
+    const blockers = writeCapable ? [
+        ...placeholders.map((placeholder) => `unresolved_prompt_placeholder:${placeholder}`),
+        ...(emptyTargetPaths ? ['write_capable_prompt_target_paths_empty'] : [])
+    ] : [];
+    const warnings = writeCapable ? [] : placeholders.map((placeholder) => `readonly_prompt_placeholder_warning:${placeholder}`);
+    return {
+        schema: 'sks.prompt-placeholder-guard.v1',
+        ok: blockers.length === 0,
+        write_capable: writeCapable,
+        placeholders,
+        empty_target_paths: emptyTargetPaths,
+        blockers,
+        warnings
+    };
+}
+//# sourceMappingURL=prompt-placeholder-guard.js.map

package/dist/core/router/capability-card.js

@@ -1,4 +1,17 @@
 export const DEFAULT_CAPABILITY_CARDS = [
+    {
+        id: 'local-llm-worker',
+        tier: 'worker',
+        supports_images: false,
+        supports_write: true,
+        supports_research: false,
+        reliability: 0.78,
+        latency_cost: 1,
+        token_cost: 0,
+        mutation_risk_cost: 2,
+        model_price_cost: 0,
+        queue_pressure_cost: 2
+    },
     {
         id: 'fast-worker',
         tier: 'worker',

package/dist/core/router/route-cache.js

@@ -8,6 +8,9 @@ export function codexRouteCacheKey(input) {
         files: input.inputFiles || [],
         images: (input.inputImages || []).length,
         sandbox: input.sandboxPolicy,
+        allow_local_llm: input.allowLocalLlm === true,
+        backend_preference: input.backendPreference || [],
+        local_llm_policy: input.localLlmPolicy || null,
         write_paths: input.requestedScopeContract?.write_paths || [],
         allowed_paths: input.requestedScopeContract?.allowed_paths || []
     }));

package/dist/core/router/ultra-router.js

@@ -8,7 +8,8 @@ export function routeCodexTask(input, cards = DEFAULT_CAPABILITY_CARDS) {
         return { ...cached, cache_hit: true };
     const classification = classifyCodexTask(input);
     const hardFilters = [];
-    const scored = cards.map((card) => {
+    const availableCards = input.allowLocalLlm === true ? cards : cards.filter((card) => card.id !== 'local-llm-worker');
+    const scored = availableCards.map((card) => {
         const score = scoreCapabilityCard(card, classification);
         if (score === 0)
             hardFilters.push(card.id);

package/dist/core/routes.js

@@ -371,16 +371,16 @@ export const ROUTES = [
         id: 'Naruto',
         command: '$Naruto',
         mode: 'NARUTO',
-        route: 'shadow clone swarm (high-scale parallel agents)',
-        description: 'Shadow Clone Swarm (影分身 / Kage Bunshin no Jutsu): fan out up to 100 parallel clone sessions on the native agent kernel for high-throughput work, with lease-based safe parallel writes, scheduler backfill, and per-clone proof.',
+        route: 'hardware-safe massive parallel work swarm',
+        description: '$Naruto mode launches a hardware-safe massive parallel work swarm. Clones may implement, modify, verify, test, research, document, and resolve conflicts according to role and lease policy; write-capable output is accepted only through patch envelopes, verification DAG, mutation guard, and GPT final arbiter.',
         requiredSkills: ['team', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'],
         dollarAliases: ['$ShadowClone', '$Kagebunshin'],
         appSkillAliases: ['shadow-clone', 'kage-bunshin'],
-        lifecycle: ['clone_roster_build', 'work_partition', 'parallel_clone_scheduling', 'lease_based_write_swarm', 'per_clone_proof', 'session_cleanup', 'honest_mode'],
+        lifecycle: ['clone_roster_build', 'massive_work_graph', 'hardware_safe_governor', 'dynamic_active_pool', 'lease_based_write_swarm', 'parallel_verification_dag', 'gpt_final_arbiter_pack', 'per_clone_proof', 'session_cleanup', 'honest_mode'],
         context7Policy: 'optional',
         reasoningPolicy: 'high',
         stopGate: 'team-gate.json',
-        cliEntrypoint: 'sks naruto run "task" [--clones N] [--backend codex-exec|fake] | sks naruto status',
+        cliEntrypoint: 'sks naruto run "task" [--clones N] [--backend codex-sdk|fake|ollama] [--parallel-write] | sks naruto status',
         examples: ['$Naruto run sweep the codebase for TODO comments with 50 clones', '$ShadowClone --clones 100 fan out and draft tests for every module']
     },
     {

package/dist/core/version.js

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

package/dist/core/zellij/zellij-lane-runtime.js

@@ -176,10 +176,10 @@ export function extractZellijPaneIdFromOutput(text) {
     }
     const lines = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
     for (const line of lines.slice().reverse()) {
-        const direct = line.match(/^(?:pane[_ -]?id[:=]\s*)?([0-9]+)$/i);
+        const direct = line.match(/^(?:pane[_ -]?id[:=]\s*)?([0-9]+|terminal_[0-9]+)$/i);
         if (direct?.[1])
             return direct[1];
-        const embedded = line.match(/\bpane[_ -]?id[:=]\s*([0-9]+)\b/i);
+        const embedded = line.match(/\bpane[_ -]?id[:=]\s*([0-9]+|terminal_[0-9]+)\b/i);
         if (embedded?.[1])
             return embedded[1];
     }

package/dist/core/zellij/zellij-naruto-dashboard.js

@@ -0,0 +1,36 @@
+export function planNarutoZellijDashboard(input) {
+    const targetActiveWorkers = Math.max(1, Math.floor(Number(input.targetActiveWorkers || 1)));
+    const visiblePaneCap = Math.max(1, Math.floor(Number(input.visiblePaneCap || 12)));
+    const visibleWorkerPanes = Math.min(targetActiveWorkers, visiblePaneCap);
+    const headlessWorkers = Math.max(0, targetActiveWorkers - visibleWorkerPanes);
+    const backend = input.backend || 'codex-sdk';
+    const roles = input.roles && input.roles.length ? input.roles : ['implementer', 'modifier', 'verifier', 'test_writer'];
+    const paneTitles = Array.from({ length: visibleWorkerPanes }, (_, index) => {
+        const slot = `slot-${String(index + 1).padStart(3, '0')}`;
+        const role = roles[index % roles.length] || 'worker';
+        return `${slot}/gen-1 · ${role} · ${backend} · active`;
+    });
+    const blockers = [
+        ...(visibleWorkerPanes > visiblePaneCap ? ['naruto_zellij_visible_panes_exceed_cap'] : []),
+        ...(headlessWorkers < 0 ? ['naruto_zellij_headless_negative'] : [])
+    ];
+    return {
+        schema: 'sks.zellij-naruto-dashboard.v1',
+        target_active_workers: targetActiveWorkers,
+        visible_pane_cap: visiblePaneCap,
+        visible_worker_panes: visibleWorkerPanes,
+        headless_workers: headlessWorkers,
+        dashboard: {
+            active: targetActiveWorkers,
+            visible: visibleWorkerPanes,
+            headless: headlessWorkers,
+            completed: Math.max(0, Math.floor(Number(input.completed || 0))),
+            failed: Math.max(0, Math.floor(Number(input.failed || 0))),
+            backpressure: input.backpressure || 'normal'
+        },
+        pane_titles: paneTitles,
+        ok: blockers.length === 0,
+        blockers
+    };
+}
+//# sourceMappingURL=zellij-naruto-dashboard.js.map

package/dist/core/zellij/zellij-worker-pane-manager.js

@@ -9,10 +9,10 @@ export const ZELLIJ_WORKER_PANE_EVENT_SCHEMA = 'sks.zellij-worker-pane-event.v1'
 export function buildWorkerPaneName(slotId, generationIndex) {
     return `${slotId}/gen-${Math.max(1, Math.floor(Number(generationIndex) || 1))}`;
 }
-export function buildWorkerPaneTitle(slotId, generationIndex, context, serviceTier) {
+export function buildWorkerPaneTitle(slotId, generationIndex, context, serviceTier, backend, status) {
     const base = buildWorkerPaneName(slotId, generationIndex);
     const normalized = normalizePaneProviderContext(context, serviceTier);
-    return `${base} · codex-sdk · ${providerPaneLabel(normalized)}`;
+    return `${base} · ${backend || 'codex-sdk'} · ${providerPaneLabel(normalized)} · ${status || 'launching'}`;
 }
 export function isRealZellijWorkerPaneIdSource(value) {
     return value === 'zellij_worker_new_pane_stdout' || value === 'zellij_worker_list_panes';
@@ -22,7 +22,7 @@ export function buildWorkerPaneArtifact(input) {
     const paneIdSource = input.paneIdSource || 'zellij_worker_pane_launch_failed';
     const blockers = input.blockers || [];
     const providerContext = normalizePaneProviderContext(input.providerContext, input.serviceTier);
-    const paneTitle = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier);
+    const paneTitle = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.status || input.statusLabel);
     return {
         schema: ZELLIJ_WORKER_PANE_SCHEMA,
         generated_at: now,
@@ -82,7 +82,7 @@ export async function openWorkerPane(input) {
         timeoutMs: 5000,
         optional: false
     });
-    const paneName = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier);
+    const paneName = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.statusLabel || 'running');
     let launch = createSession.ok
         ? await runZellij(['--session', input.sessionName, 'action', 'new-pane', '--direction', 'right', '--name', paneName, '--', 'sh', '-lc', input.workerCommand], {
             cwd,

package/dist/scripts/blackbox-command-import-smoke.js

@@ -5,6 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { pathToFileURL } from 'node:url';
+import { currentDistFreshness } from './lib/ensure-dist-fresh.js';
 const root = process.cwd();
 const npmBin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
 const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-command-import-smoke-'));
@@ -16,7 +17,15 @@ const rows = [];
 fs.mkdirSync(consumer, { recursive: true });
 fs.writeFileSync(path.join(consumer, 'package.json'), `${JSON.stringify({ name: 'sks-command-smoke-consumer', private: true }, null, 2)}\n`);
 try {
-    run('build', npmBin, ['run', 'build'], { cwd: root });
+    if (process.env.SKS_ENSURE_DIST_NO_REBUILD === '1' || process.env.SKS_RELEASE_DIST_FRESHNESS_NO_REBUILD === '1') {
+        const freshness = currentDistFreshness();
+        rows.push({ label: 'dist_freshness', ok: freshness.ok, status: freshness.ok ? 0 : 1, issues: freshness.issues });
+        if (!freshness.ok)
+            failures.push(`dist_not_fresh:${freshness.issues.join(',')}`);
+    }
+    else {
+        run('build', npmBin, ['run', 'build'], { cwd: root });
+    }
     const pack = run('npm_pack', npmBin, ['pack', '--json', '--ignore-scripts', '--pack-destination', tmp, '--registry', 'https://registry.npmjs.org/'], { cwd: root });
     const info = pack.ok ? JSON.parse(pack.stdout || '[]')[0] : null;
     const tarball = info ? path.join(tmp, info.filename) : null;

package/dist/scripts/check-package-boundary.js

@@ -5,12 +5,21 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { currentDistFreshness } from './lib/ensure-dist-fresh.js';
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
 const npmBin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
 const issues = [];
-const build = spawnSync(npmBin, ['run', 'build'], { cwd: root, encoding: 'utf8', stdio: 'pipe' });
-if (build.status !== 0)
-    issues.push(`build_failed:${tail(build.stderr || build.stdout)}`);
+const noRebuild = process.env.SKS_ENSURE_DIST_NO_REBUILD === '1' || process.env.SKS_RELEASE_DIST_FRESHNESS_NO_REBUILD === '1';
+if (noRebuild) {
+    const freshness = currentDistFreshness();
+    if (!freshness.ok)
+        issues.push(`dist_not_fresh:${freshness.issues.join(',')}`);
+}
+else {
+    const build = spawnSync(npmBin, ['run', 'build'], { cwd: root, encoding: 'utf8', stdio: 'pipe' });
+    if (build.status !== 0)
+        issues.push(`build_failed:${tail(build.stderr || build.stdout)}`);
+}
 const pack = spawnSync(npmBin, ['pack', '--dry-run', '--json', '--ignore-scripts'], {
     cwd: root,
     encoding: 'utf8',

package/dist/scripts/codex-0-137-compat-check.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
+const freshness = ensureDistFresh({ rebuild: true });
+if (!freshness.ok)
+    fail('dist_not_fresh', { freshness });
+const mod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'codex', 'codex-0-137-compat.js')).href);
+const evidence = await mod.collectCodex0137LocalEvidence();
+const matrix = mod.codex0137Matrix({
+    version: evidence.versionText,
+    available: evidence.available,
+    pluginListText: evidence.pluginListText,
+    debugModelsText: evidence.debugModelsText,
+    doctorText: evidence.doctorText,
+    requireReal: process.argv.includes('--require-real') || process.env.SKS_REQUIRE_CODEX_0137 === '1'
+});
+const report = { ...matrix, local_evidence: evidence };
+await fs.mkdir(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
+await fs.writeFile(path.join(root, '.sneakoscope', 'reports', 'codex-0.137-compat.json'), `${JSON.stringify(report, null, 2)}\n`);
+emit(report);
+function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
+    process.exitCode = 1; }
+function fail(blocker, detail) { emit({ schema: 'sks.codex-0.137-compat-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
+//# sourceMappingURL=codex-0-137-compat-check.js.map

package/dist/scripts/codex-environment-scoped-approvals-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './lib/codex-sdk-gate-lib.js';
+const proof = readText('src/core/codex-control/codex-control-proof.ts');
+const sandbox = readText('src/core/codex-control/codex-sdk-sandbox-policy.ts');
+assertGate(proof.includes('sandbox:'), 'Codex control proof must include sandbox scope');
+assertGate(proof.includes('env:'), 'Codex control proof must include environment proof');
+assertGate(sandbox.includes('mad_sks_authorized') || sandbox.includes('user_confirmed_full_access'), 'Sandbox policy must include scoped authorization signals');
+emitGate('codex:environment-scoped-approvals', { proof: ['sandbox', 'env', 'scoped_authorization'] });
+//# sourceMappingURL=codex-environment-scoped-approvals-check.js.map

package/dist/scripts/codex-plugin-list-json-check.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './lib/codex-sdk-gate-lib.js';
+const source = readText('src/core/codex/codex-0-137-compat.ts');
+assertGate(source.includes("run(['plugin', 'list', '--json'])"), '0.137 evidence must run codex plugin list --json');
+assertGate(source.includes('looksLikeJson'), '0.137 plugin list JSON parser missing');
+emitGate('codex:plugin-list-json', { detector: 'codex plugin list --json' });
+//# sourceMappingURL=codex-plugin-list-json-check.js.map

package/dist/scripts/codex-thread-runtime-choice-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './lib/codex-sdk-gate-lib.js';
+const runner = readText('src/core/codex-control/codex-task-runner.ts');
+const registry = readText('src/core/codex-control/codex-thread-registry.ts');
+assertGate(runner.includes('backendPreference'), 'Codex task runner must carry backend/runtime preference');
+assertGate(runner.includes('backend_family'), 'Codex task runner must persist backend family');
+assertGate(registry.includes('recordCodexThread'), 'Codex thread registry missing');
+emitGate('codex:thread-runtime-choice', { runtime_choice: 'backendPreference/backend_family' });
+//# sourceMappingURL=codex-thread-runtime-choice-check.js.map

package/dist/scripts/local-collab-all-pipelines-final-gpt-check.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './lib/codex-sdk-gate-lib.js';
+const finalizer = await importDist('core/pipeline/finalize-pipeline-result.js');
+const blocked = await finalizer.finalizePipelineResult({
+    route: '$Team',
+    missionId: 'M-local-final-gpt',
+    localParticipated: true,
+    candidateResults: [{ backend: 'local-llm', summary: 'draft' }],
+    candidatePatchEnvelopes: [],
+    verificationResults: [],
+    sideEffectReport: {},
+    mutationLedger: {},
+    rollbackPlan: {},
+    applyPatches: true,
+    forceGptFinalUnavailable: true
+});
+assertGate(blocked.ok === false, 'local participation without GPT final must block finalization');
+assertGate(blocked.blockers.includes('gpt_final_arbiter_required_not_passed'), 'missing GPT final blocker required');
+emitGate('local-collab:all-pipelines-final-gpt', { final_status: blocked.final_status, blockers: blocked.blockers.length });
+//# sourceMappingURL=local-collab-all-pipelines-final-gpt-check.js.map

package/dist/scripts/local-llm-all-pipelines-check.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './lib/codex-sdk-gate-lib.js';
+const router = readText('src/core/agents/native-worker-backend-router.ts');
+const control = readText('src/core/codex-control/codex-task-runner.ts');
+const policy = readText('src/core/local-llm/local-worker-eligibility.ts');
+assertGate(router.includes("backend === 'local-llm'"), 'native worker router must support local-llm backend');
+assertGate(control.includes('runLocalLlmTask'), 'Codex Control Plane must call local LLM task adapter');
+assertGate(policy.includes('requires_gpt_final'), 'local worker eligibility must require GPT final');
+emitGate('local-llm:all-pipelines', { local_backend: 'local-llm', requires_gpt_final: true });
+//# sourceMappingURL=local-llm-all-pipelines-check.js.map

package/dist/scripts/local-llm-cache-performance-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './lib/codex-sdk-gate-lib.js';
+const cache = await importDist('core/local-llm/local-llm-prompt-cache.js');
+const a = cache.buildLocalLlmPromptCacheRecord({ routeSystemEnvelopeHash: 'a', localWorkerPolicyHash: 'b', coreSkillSnapshotHash: 'c', triwikiContextPackHash: 'd', repoSummaryHash: 'e', capabilityCardHash: 'f' });
+const b = cache.buildLocalLlmPromptCacheRecord({ routeSystemEnvelopeHash: 'a', localWorkerPolicyHash: 'b', coreSkillSnapshotHash: 'c', triwikiContextPackHash: 'd2', repoSummaryHash: 'e', capabilityCardHash: 'f' });
+assertGate(a.cacheable === true, 'prompt cache record should be cacheable when hashes exist');
+assertGate(a.cache_key !== b.cache_key, 'source hash change must invalidate cache');
+emitGate('local-llm:cache-performance', { cacheable: a.cacheable, invalidates_on_hash_change: true });
+//# sourceMappingURL=local-llm-cache-performance-check.js.map

package/dist/scripts/local-llm-capability-check.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist, readText } from './lib/codex-sdk-gate-lib.js';
+const mod = await importDist('core/agents/ollama-worker-config.js');
+const schemaText = readText('schemas/local-llm/local-model-config.schema.json');
+const config = mod.normalizeLocalModelConfig({ enabled: true, status: 'enabled_unverified' });
+const mlx = mod.normalizeLocalModelConfig({ enabled: true, provider: 'mlx-lm', model: 'mlx-community/Qwen3.6-35B-A3B-4bit', base_url: 'http://127.0.0.1:8080' });
+assertGate(config.schema === 'sks.local-model-config.v2', 'local model config must use v2 schema');
+assertGate(config.status === 'enabled_unverified', 'enabled without smoke must be enabled_unverified');
+assertGate(mlx.provider === 'mlx-lm' && mlx.base_url === 'http://127.0.0.1:8080', 'local model config must preserve MLX LM provider settings');
+assertGate(schemaText.includes('verified'), 'local model schema must include verified status');
+assertGate(schemaText.includes('mlx-lm'), 'local model schema must allow MLX LM provider');
+emitGate('local-llm:capability', { status: config.status, schema: config.schema, mlx_provider: mlx.provider });
+//# sourceMappingURL=local-llm-capability-check.js.map

package/dist/scripts/local-llm-smoke-check.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist, root } from './lib/codex-sdk-gate-lib.js';
+const cfg = await importDist('core/agents/ollama-worker-config.js');
+const smokeMod = await importDist('core/local-llm/local-llm-smoke.js');
+const config = cfg.normalizeLocalModelConfig({ enabled: true, status: 'enabled_unverified' });
+if (process.env.SKS_REQUIRE_LOCAL_LLM !== '1' && !process.argv.includes('--require-real')) {
+    const skipped = cfg.applyLocalLlmSmokeResult(config, { ok: false, skipped: true, status: 'enabled_unverified', reason: 'release_check_no_real_smoke', schema_valid: false });
+    assertGate(skipped.status === 'enabled_unverified', '--skip-smoke or hermetic mode must not verify local LLM');
+    emitGate('local-llm:smoke', { status: 'hermetic_skip', config_status: skipped.status });
+}
+else {
+    const reportPath = `${root}/.sneakoscope/reports/local-llm-smoke-real.json`;
+    const realConfig = await cfg.readLocalModelConfig();
+    const first = await smokeMod.runLocalLlmGenerationSmoke(realConfig, { reportPath, timeoutMs: 60_000 });
+    const shouldRetry = first.ok !== true && String(first.blockers || []).match(/aborted|timeout|local_llm_generate_failed/i);
+    const smoke = shouldRetry
+        ? await smokeMod.runLocalLlmGenerationSmoke(realConfig, { reportPath, timeoutMs: 90_000 })
+        : first;
+    assertGate(smoke.ok === true && smoke.schema_valid === true, 'real local LLM smoke failed', { smoke, retry_count: shouldRetry ? 1 : 0, first_failure_blockers: first.blockers || [] });
+    emitGate('local-llm:smoke', { status: 'real_verified', latency_ms: smoke.latency_ms, tokens_per_second: smoke.tokens_per_second, retry_count: shouldRetry ? 1 : 0 });
+}
+//# sourceMappingURL=local-llm-smoke-check.js.map

package/dist/scripts/local-llm-structured-output-check.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './lib/codex-sdk-gate-lib.js';
+const mod = await importDist('core/local-llm/local-llm-schema-enforcer.js');
+const schema = { type: 'object', required: ['status'], properties: { status: { type: 'string' } }, additionalProperties: false };
+const good = mod.enforceLocalLlmJsonSchema('{"status":"ok"}', schema);
+const bad = mod.enforceLocalLlmJsonSchema('plain words', schema);
+assertGate(good.ok === true && good.schema_valid === true, 'valid local JSON should pass');
+assertGate(bad.ok === false, 'natural language local output must not pass');
+emitGate('local-llm:structured-output', { good: good.ok, bad: bad.ok });
+//# sourceMappingURL=local-llm-structured-output-check.js.map

package/dist/scripts/local-llm-throughput-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './lib/codex-sdk-gate-lib.js';
+const scheduler = await importDist('core/local-llm/local-llm-scheduler.js');
+const plan = scheduler.planLocalLlmSchedule({ workItems: Array.from({ length: 20 }, (_, i) => ({ id: i })), maxParallelRequests: 4 });
+assertGate(plan.ok === true, 'local scheduler must not exceed max parallel requests');
+assertGate(plan.active_requests <= plan.max_parallel_requests, 'active requests exceeded max_parallel_requests');
+assertGate(plan.queued_count === 16, '20 worker fixture should queue work beyond max parallel requests');
+emitGate('local-llm:throughput', { active_requests: plan.active_requests, queued_count: plan.queued_count, backpressure: plan.backpressure });
+//# sourceMappingURL=local-llm-throughput-check.js.map

package/dist/scripts/local-llm-tool-call-repair-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './lib/codex-sdk-gate-lib.js';
+const mod = await importDist('core/local-llm/local-llm-json-repair.js');
+const repaired = mod.parseOrRepairLocalLlmJson('Here is JSON: {"status":"ok","summary":"done"} thanks');
+const failed = mod.parseOrRepairLocalLlmJson('not json at all');
+assertGate(repaired.ok === true && repaired.repaired === true && repaired.attempts === 1, 'bounded JSON repair should recover one object');
+assertGate(failed.ok === false && failed.attempts === 1, 'invalid local JSON must fail after one repair attempt');
+emitGate('local-llm:tool-call-repair', { repaired: repaired.ok, failed: failed.ok });
+//# sourceMappingURL=local-llm-tool-call-repair-check.js.map

package/dist/scripts/local-llm-warmup-check.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './lib/codex-sdk-gate-lib.js';
+const cfg = await importDist('core/agents/ollama-worker-config.js');
+const warmup = await importDist('core/local-llm/local-llm-warmup.js');
+const state = warmup.buildLocalLlmWarmupState(cfg.normalizeLocalModelConfig({ enabled: true, status: 'enabled_unverified' }), { ok: true, ttlMs: 1000 });
+assertGate(state.explicit_only === true, 'local warmup must be explicit only');
+assertGate(state.postinstall_allowed === false, 'postinstall must not run local warmup');
+assertGate(state.release_check_real_warmup_allowed === false, 'release:check must not run real warmup');
+emitGate('local-llm:warmup', { explicit_only: state.explicit_only, expires_at: state.expires_at });
+//# sourceMappingURL=local-llm-warmup-check.js.map

package/dist/scripts/naruto-active-pool-check.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const workGraph = await importDist('core/naruto/naruto-work-graph.js');
+const governorMod = await importDist('core/naruto/naruto-concurrency-governor.js');
+const activePool = await importDist('core/naruto/naruto-active-pool.js');
+const graph = workGraph.buildNarutoWorkGraph({ requestedClones: 20, totalWorkItems: 20, writeCapable: true, maxActiveWorkers: 5 });
+const governor = governorMod.decideNarutoConcurrency({
+    requestedClones: 20,
+    totalWorkItems: 20,
+    pendingWorkQueueSize: 20,
+    backend: 'fake',
+    hardware: { remoteApiRateLimitBudget: 5, fileDescriptorLimit: 4096, freeMemoryBytes: 8 * 1024 * 1024 * 1024, totalMemoryBytes: 16 * 1024 * 1024 * 1024 }
+});
+const report = activePool.simulateNarutoActivePool({ graph, governor: { ...governor, safe_active_workers: 5 } });
+assertGate(report.ok === true, 'active pool must drain cleanly', report);
+assertGate(report.max_observed_active_workers <= 5, 'active pool must never exceed safe cap', report);
+assertGate(report.completed_count >= graph.total_work_items, 'active pool must complete all base work items', report);
+assertGate(report.refill_events >= 5, 'active pool must refill slots as work drains', report);
+assertGate(report.duplicate_execution_count === 0, 'active pool must not duplicate work without retry', report);
+emitGate('naruto:active-pool', {
+    safe_active_workers: report.safe_active_workers,
+    completed_count: report.completed_count,
+    refill_events: report.refill_events,
+    max_observed_active_workers: report.max_observed_active_workers
+});
+//# sourceMappingURL=naruto-active-pool-check.js.map