sneakoscope 2.0.4 → 2.0.5

package/dist/scripts/naruto-concurrency-governor-check.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const governorMod = await importDist('core/naruto/naruto-concurrency-governor.js');
+const normal = governorMod.decideNarutoConcurrency({
+    requestedClones: 200,
+    totalWorkItems: 340,
+    pendingWorkQueueSize: 340,
+    backend: 'codex-sdk',
+    zellijVisiblePaneCap: 12,
+    hardware: {
+        cores: 32,
+        freeMemoryBytes: 48 * 1024 * 1024 * 1024,
+        totalMemoryBytes: 64 * 1024 * 1024 * 1024,
+        fileDescriptorLimit: 4096,
+        localLlmMaxParallelRequests: 4,
+        remoteApiRateLimitBudget: 32,
+        terminalRows: 40,
+        terminalColumns: 140
+    }
+});
+const pressure = governorMod.decideNarutoConcurrency({
+    requestedClones: 200,
+    totalWorkItems: 340,
+    pendingWorkQueueSize: 340,
+    backend: 'codex-sdk',
+    zellijVisiblePaneCap: 12,
+    hardware: {
+        cores: 8,
+        loadAverage: [16, 16, 16],
+        freeMemoryBytes: 256 * 1024 * 1024,
+        totalMemoryBytes: 4 * 1024 * 1024 * 1024,
+        fileDescriptorLimit: 128,
+        localLlmMaxParallelRequests: 4,
+        remoteApiRateLimitBudget: 32,
+        zellijPaneCount: 12,
+        diskIoPressure: 0.9
+    }
+});
+assertGate(normal.safe_active_workers <= 32, 'requested_clones=200 fixture must cap active workers safely', { normal });
+assertGate(normal.safe_zellij_visible_panes === 12 && normal.headless_workers === normal.safe_active_workers - 12, 'zellij visible panes must stay within UI cap', { normal });
+assertGate(normal.local_llm_parallel <= 4, 'local LLM active requests must respect max_parallel_requests=4', { normal });
+assertGate(pressure.safe_active_workers < normal.safe_active_workers, 'memory/load pressure fixture must decrease active workers', { normal: normal.safe_active_workers, pressure: pressure.safe_active_workers });
+assertGate(pressure.backpressure === 'saturated' || pressure.backpressure === 'throttled', 'pressure fixture must report backpressure', { pressure });
+emitGate('naruto:concurrency-governor', {
+    requested_clones: normal.requested_clones,
+    total_work_items: normal.total_work_items,
+    safe_active_workers: normal.safe_active_workers,
+    safe_zellij_visible_panes: normal.safe_zellij_visible_panes,
+    pressure_safe_active_workers: pressure.safe_active_workers
+});
+//# sourceMappingURL=naruto-concurrency-governor-check.js.map

package/dist/scripts/naruto-gpt-final-pack-check.js

@@ -0,0 +1,34 @@
+#!/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 roles = await importDist('core/naruto/naruto-role-policy.js');
+const packMod = await importDist('core/naruto/naruto-gpt-final-pack.js');
+const graph = workGraph.buildNarutoWorkGraph({ requestedClones: 100, totalWorkItems: 120, writeCapable: true });
+const roleDistribution = roles.buildNarutoRoleDistribution(graph.work_items);
+const patchEnvelopes = Array.from({ length: 120 }, (_, index) => ({ id: index, token: 'sk-testsecret1234567890', file: `f-${index}.ts` }));
+const logs = Array.from({ length: 40 }, (_, index) => `log ${index} api_key=secret-${index}`);
+const pack = packMod.buildNarutoGptFinalPack({
+    missionId: 'M-naruto-pack',
+    graph,
+    roleDistribution,
+    changedFiles: ['src/a.ts', 'src/a.ts', 'src/b.ts'],
+    patchEnvelopes,
+    verificationResults: [{ ok: true }],
+    failedShards: [{ id: 'failed-1' }],
+    conflictMap: [{ path: 'src/a.ts' }],
+    rollbackPlan: { token: 'sk-abc12345678901234567' },
+    logs
+});
+const serialized = JSON.stringify(pack);
+assertGate(pack.bounded === true && pack.secrets_redacted === true, 'GPT final pack must be bounded and redacted', pack);
+assertGate(pack.patch_envelopes.length === 100, '100 worker results must compress to bounded patch envelope count', { count: pack.patch_envelopes.length });
+assertGate(pack.representative_logs.length === 12, 'representative logs must be bounded', { count: pack.representative_logs.length });
+assertGate(!serialized.includes('secret-') && !serialized.includes('sk-testsecret'), 'secrets must be redacted from final pack', pack);
+assertGate(pack.role_distribution.ok === true && pack.work_graph_summary.write_allowed_count > 0, 'final pack must include role distribution and write work summary', pack);
+emitGate('naruto:gpt-final-pack', {
+    patch_envelopes: pack.patch_envelopes.length,
+    representative_logs: pack.representative_logs.length,
+    changed_files: pack.changed_files
+});
+//# sourceMappingURL=naruto-gpt-final-pack-check.js.map

package/dist/scripts/naruto-parallel-patch-apply-check.js

@@ -0,0 +1,41 @@
+#!/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 patchApply = await importDist('core/naruto/naruto-parallel-patch-apply.js');
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-naruto-patch-'));
+const envelopes = Array.from({ length: 10 }, (_, index) => {
+    const file = `file-${index}.txt`;
+    return envelope(index + 1, file, `after-${index}`);
+});
+const result = await patchApply.applyNarutoPatchEnvelopes(root, envelopes, { dryRun: false });
+assertGate(result.ok === true, 'non-overlapping patch fixture must apply', result);
+assertGate(result.batch_count === 1 && result.parallel_apply_count === 1, 'non-overlapping patch fixture must group into a parallel batch', result);
+assertGate(result.results.every((row) => row.changed_files.length === 1 && Object.keys(row.before_hashes).length === 1 && Object.keys(row.after_hashes).length === 1), 'patch results must include before/after hashes and changed files', result);
+const rollback = await patchApply.rollbackNarutoPatchResult(root, result.results[0]);
+assertGate(rollback.ok === true && rollback.restored.length === 1, 'rollback must restore before content for a patch result', rollback);
+const conflict = await patchApply.applyNarutoPatchEnvelopes(root, [envelope(99, 'same.txt', 'a'), envelope(100, 'same.txt', 'b')], { dryRun: true });
+assertGate(conflict.conflicts.length >= 1, 'overlapping patch fixture must serialize or mark conflict', conflict);
+emitGate('naruto:parallel-patch-apply', {
+    batch_count: result.batch_count,
+    parallel_apply_count: result.parallel_apply_count,
+    conflict_count: conflict.conflicts.length,
+    rollback_restored: rollback.restored.length
+});
+function envelope(index, file, content) {
+    return {
+        schema: 'sks.agent-patch-envelope.v1',
+        source: 'fixture',
+        agent_id: `naruto-${index}`,
+        session_id: `session-${index}`,
+        slot_id: `slot-${index}`,
+        generation_index: 1,
+        task_slice_id: `NW-${index}`,
+        lease_id: `lease-${index}`,
+        allowed_paths: [file],
+        operations: [{ op: 'write', path: file, content }]
+    };
+}
+//# sourceMappingURL=naruto-parallel-patch-apply-check.js.map

package/dist/scripts/naruto-real-local-gpt-final-smoke.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const finalizer = await importDist('core/naruto/naruto-finalizer.js');
+const draft = finalizer.evaluateNarutoFinalizer({ localParticipated: true, gptFinalStatus: null, applyPatches: true });
+const approved = finalizer.evaluateNarutoFinalizer({ localParticipated: true, gptFinalStatus: 'approved', applyPatches: true });
+const deterministic = finalizer.evaluateNarutoFinalizer({ localParticipated: false, applyPatches: true });
+assertGate(draft.ok === false && draft.blockers.includes('naruto_local_worker_output_needs_gpt_final_arbiter'), 'local worker patch must be blocked until GPT final arbiter', draft);
+assertGate(approved.ok === true && approved.final_patch_source === 'gpt_final_arbiter', 'GPT-approved local output must become final patch source', approved);
+assertGate(deterministic.ok === true && deterministic.gpt_final_required === false, 'no-local deterministic run must not require GPT final', deterministic);
+emitGate('naruto:real-local-gpt-final-smoke', {
+    require_real_env: process.env.SKS_REQUIRE_LOCAL_LLM === '1' || process.env.SKS_REQUIRE_GPT_FINAL === '1',
+    draft_status: draft.final_status,
+    approved_status: approved.final_status
+});
+//# sourceMappingURL=naruto-real-local-gpt-final-smoke.js.map

package/dist/scripts/naruto-role-distribution-check.js

@@ -0,0 +1,23 @@
+#!/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 roles = await importDist('core/naruto/naruto-role-policy.js');
+const roster = await importDist('core/agents/agent-roster.js');
+const graph = workGraph.buildNarutoWorkGraph({ requestedClones: 30, totalWorkItems: 30, writeCapable: true });
+const distribution = roles.buildNarutoRoleDistribution(graph.work_items);
+const cloneRoster = roster.buildNarutoCloneRoster({ clones: 30, prompt: 'implement, modify, test, verify, document, and resolve conflicts' });
+const writeCapableRoster = cloneRoster.roster.filter((row) => row.write_allowed === true);
+assertGate(distribution.ok === true, 'write-capable Naruto role distribution must pass', distribution);
+assertGate(distribution.verifier_only === false, 'default Naruto must not be verifier-only', distribution);
+assertGate(distribution.implementation_like_ratio >= 0.4, 'default Naruto must keep at least 40% implementation/modification/test roles', distribution);
+assertGate(writeCapableRoster.length >= Math.floor(cloneRoster.roster.length * 0.4), 'Naruto roster must include write-capable clone roles by default', { writeCapableRoster: writeCapableRoster.length, total: cloneRoster.roster.length });
+const readonlyGraph = workGraph.buildNarutoWorkGraph({ requestedClones: 8, readonly: true, writeCapable: false });
+const readonlyDistribution = roles.buildNarutoRoleDistribution(readonlyGraph.work_items, { readonly: true });
+assertGate(readonlyDistribution.ok === true, 'readonly Naruto route may use read-only verifier/research roles', readonlyDistribution);
+emitGate('naruto:role-distribution', {
+    implementation_like_ratio: distribution.implementation_like_ratio,
+    entries: distribution.entries,
+    write_capable_roster_count: writeCapableRoster.length
+});
+//# sourceMappingURL=naruto-role-distribution-check.js.map

package/dist/scripts/naruto-shadow-clone-swarm-check.js

@@ -71,6 +71,9 @@ assertGate(bigMemoryHost.cap >= 64, 'a 64 GB host must allow >= 64 parallel code
 const proofClones = 24;
 const cli = path.join(root, 'dist', 'bin', 'sks.js');
 assertGate(exists('dist/bin/sks.js'), 'dist/bin/sks.js missing (build first)');
+const helpRun = spawnSync(process.execPath, [cli, 'naruto', '--help', '--json'], { cwd: root, encoding: 'utf8', timeout: 30000, maxBuffer: 1024 * 1024 });
+const helpParsed = parseJson(helpRun.stdout);
+assertGate(helpRun.status === 0 && helpParsed?.action === 'help', 'sks naruto --help must emit help instead of launching a run', { status: helpRun.status, stdout: tail(helpRun.stdout), stderr: tail(helpRun.stderr) });
 const run = spawnSync(process.execPath, [
     cli, 'naruto', 'run', 'shadow clone swarm gate proof',
     '--clones', String(proofClones),
@@ -94,6 +97,9 @@ assertGate(parsed.target_active_slots <= fakeSafe.cap, 'active slots must be thr
 assertGate(typeof parsed.concurrency_capped === 'boolean', 'naruto run must report concurrency_capped', { concurrency_capped: parsed.concurrency_capped });
 assertGate(parsed.concurrency_capped === (parsed.clones > parsed.target_active_slots), 'concurrency_capped must reflect clones > live slots', { clones: parsed.clones, target_active_slots: parsed.target_active_slots, concurrency_capped: parsed.concurrency_capped });
 assertGate(parsed.system && Number(parsed.system.safe_concurrency) >= 1, 'naruto run must report system safe_concurrency (host-derived cap)', { system: parsed.system });
+assertGate(parsed.work_graph?.write_allowed_count > 0 && parsed.work_graph?.mixed_work_kinds?.length > 1, 'naruto run must report a mixed work graph with write-capable items', { work_graph: parsed.work_graph });
+assertGate(parsed.role_distribution?.verifier_only === false, 'naruto run proof/status must distinguish active worker roles beyond verifier-only', { role_distribution: parsed.role_distribution });
+assertGate(Number(parsed.role_distribution?.implementation_like_ratio || 0) >= 0.4, 'naruto run must include implementation-like role distribution', { role_distribution: parsed.role_distribution });
 const state = parsed.run?.scheduler?.state || parsed.run?.scheduler || {};
 assertGate(Number(state.completed_count) === proofClones, 'all clone work items must complete despite throttling', { completed_count: state.completed_count });
 const explicitConcurrency = spawnSync(process.execPath, [cli, 'naruto', 'run', 'explicit concurrency', '--clones', '6', '--backend', 'fake', '--work-items', '6', '--concurrency', '6', '--json'], { cwd: root, encoding: 'utf8', timeout: 120000, maxBuffer: 4 * 1024 * 1024 });

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

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist, root } 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 verificationDag = await importDist('core/naruto/naruto-verification-dag.js');
+const verificationPool = await importDist('core/naruto/naruto-verification-pool.js');
+const graph = workGraph.buildNarutoWorkGraph({ requestedClones: 8, totalWorkItems: 12, writeCapable: true });
+const governor = governorMod.decideNarutoConcurrency({
+    requestedClones: 8,
+    totalWorkItems: 12,
+    backend: 'fake',
+    hardware: {
+        cores: 4,
+        loadAverage: [0, 0, 0],
+        remoteApiRateLimitBudget: 8,
+        fileDescriptorLimit: 4096,
+        processCount: 1,
+        zellijPaneCount: 0,
+        diskIoPressure: 0,
+        freeMemoryBytes: 8 * 1024 * 1024 * 1024,
+        totalMemoryBytes: 16 * 1024 * 1024 * 1024
+    }
+});
+const dag = verificationDag.buildNarutoVerificationDag(graph, { cwd: root, command: 'node -e "process.exit(0)"' });
+const report = await verificationPool.runNarutoVerificationPool(dag, { ...governor, verification_parallel: 4 }, { cwd: root });
+assertGate(report.ok === true, 'verification pool must pass all fixture shards', report);
+assertGate(report.safe_concurrency === 4, 'verification pool must use its own safe concurrency', report);
+assertGate(report.task_count > 1, 'verification pool must run multiple shards', report);
+assertGate(report.cpu_heavy_cap_respected && report.io_heavy_cap_respected && report.api_rate_cap_respected, 'verification pool must respect resource caps', report);
+emitGate('naruto:verification-pool', {
+    task_count: report.task_count,
+    safe_concurrency: report.safe_concurrency,
+    passed: report.passed
+});
+//# sourceMappingURL=naruto-verification-pool-check.js.map

package/dist/scripts/naruto-work-graph-check.js

@@ -0,0 +1,24 @@
+#!/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 graph = workGraph.buildNarutoWorkGraph({
+    requestedClones: 24,
+    totalWorkItems: 30,
+    writeCapable: true,
+    targetPaths: Array.from({ length: 30 }, (_, index) => `src/fixture-${index}.ts`),
+    maxActiveWorkers: 8
+});
+const validation = workGraph.validateNarutoWorkGraph(graph);
+assertGate(graph.ok === true && validation.ok === true, 'Naruto work graph must validate', { graph_blockers: graph.blockers, validation });
+assertGate(graph.total_work_items >= graph.requested_clones, 'work graph must create at least requested clone count', { total: graph.total_work_items, requested: graph.requested_clones });
+assertGate(graph.mixed_work_kinds.length > 4, 'work graph must contain mixed work kinds, not only verification', { kinds: graph.mixed_work_kinds });
+assertGate(graph.write_allowed_count > 0, 'write-capable Naruto graph must include write_allowed work items', { write_allowed_count: graph.write_allowed_count });
+assertGate(graph.active_waves.every((wave) => wave.conflict_count === 0), 'active waves must not overlap write leases', { waves: graph.active_waves });
+emitGate('naruto:work-graph', {
+    total_work_items: graph.total_work_items,
+    mixed_work_kinds: graph.mixed_work_kinds,
+    write_allowed_count: graph.write_allowed_count,
+    wave_count: graph.active_waves.length
+});
+//# sourceMappingURL=naruto-work-graph-check.js.map

package/dist/scripts/naruto-zellij-massive-ui-check.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const dashboardMod = await importDist('core/zellij/zellij-naruto-dashboard.js');
+const plan = dashboardMod.planNarutoZellijDashboard({
+    targetActiveWorkers: 32,
+    visiblePaneCap: 12,
+    completed: 8,
+    failed: 1,
+    backpressure: 'normal',
+    roles: ['implementer', 'modifier', 'test_writer', 'verifier'],
+    backend: 'codex-sdk'
+});
+assertGate(plan.ok === true, 'Naruto Zellij dashboard plan must pass', plan);
+assertGate(plan.visible_worker_panes === 12, 'targetActiveWorkers=32 and visiblePaneCap=12 must create 12 visible panes', plan);
+assertGate(plan.headless_workers === 20, 'remaining active workers must be listed as headless', plan);
+assertGate(plan.pane_titles.every((title) => /slot-\d+\/gen-1 · .+ · codex-sdk · active/.test(title)), 'pane titles must include slot/gen/role/backend/status', plan);
+emitGate('naruto:zellij-massive-ui', {
+    visible_worker_panes: plan.visible_worker_panes,
+    headless_workers: plan.headless_workers,
+    dashboard: plan.dashboard
+});
+//# sourceMappingURL=naruto-zellij-massive-ui-check.js.map

package/dist/scripts/prompt-placeholder-guard-check.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const guardMod = await importDist('core/prompt/prompt-placeholder-guard.js');
+const blocked = guardMod.checkPromptPlaceholders({
+    prompt: 'Use @filename and INSERT_PATH_HERE to patch the bug',
+    writeCapable: true,
+    targetPaths: ['src/core/example.ts']
+});
+const emptyTarget = guardMod.checkPromptPlaceholders({
+    prompt: 'Patch the bug',
+    writeCapable: true,
+    targetPaths: []
+});
+const pass = guardMod.checkPromptPlaceholders({
+    prompt: 'Patch src/core/example.ts',
+    writeCapable: true,
+    targetPaths: ['src/core/example.ts']
+});
+const readonlyWarn = guardMod.checkPromptPlaceholders({
+    prompt: 'Inspect @filename',
+    writeCapable: false
+});
+assertGate(blocked.ok === false && blocked.blockers.some((item) => String(item).startsWith('unresolved_prompt_placeholder')), 'write-capable Naruto prompt with @filename must block', blocked);
+assertGate(emptyTarget.ok === false && emptyTarget.blockers.includes('write_capable_prompt_target_paths_empty'), 'write-capable Naruto route with empty target paths must block', emptyTarget);
+assertGate(pass.ok === true, 'resolved write-capable prompt must pass placeholder guard', pass);
+assertGate(readonlyWarn.ok === true && readonlyWarn.warnings.length > 0, 'read-only route may warn on placeholders instead of blocking', readonlyWarn);
+emitGate('prompt:placeholder-guard', {
+    blocked_placeholders: blocked.placeholders,
+    empty_target_blockers: emptyTarget.blockers,
+    readonly_warnings: readonlyWarn.warnings
+});
+//# sourceMappingURL=prompt-placeholder-guard-check.js.map

package/dist/scripts/python-codex-sdk-all-pipelines-check.js

@@ -0,0 +1,47 @@
+#!/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, readText } from './lib/codex-sdk-gate-lib.js';
+import { importDist, root } from './lib/codex-sdk-gate-lib.js';
+const plane = readText('src/core/codex-control/codex-control-plane.ts');
+const adapter = readText('src/core/codex-control/python-codex-sdk-adapter.ts');
+assertGate(plane.includes("'python-codex-sdk'"), 'Codex Control backend union must include python-codex-sdk');
+assertGate(adapter.includes('runPythonCodexSdkTask'), 'Python SDK adapter must expose a task runner');
+const mod = await importDist('core/codex-control/codex-control-plane.js');
+const schema = await importDist('core/codex-control/schemas/agent-worker-result.schema.js');
+const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-python-codex-sdk-pipeline-'));
+const oldFake = process.env.SKS_PYTHON_CODEX_SDK_FAKE;
+process.env.SKS_PYTHON_CODEX_SDK_FAKE = '1';
+try {
+    const result = await mod.runCodexTask({
+        route: '$Agent',
+        missionId: 'M-python-sdk-all-pipelines',
+        workItemId: 'python-sdk-fixture',
+        slotId: 'slot-python-fixture',
+        generationIndex: 1,
+        sessionId: 'python-sdk-fixture-session',
+        cwd: root,
+        prompt: 'Hermetic Python Codex SDK backend fixture.',
+        inputFiles: [],
+        inputImages: [],
+        outputSchemaId: schema.CODEX_AGENT_WORKER_RESULT_SCHEMA_ID,
+        outputSchema: schema.codexAgentWorkerResultSchema,
+        sandboxPolicy: 'read-only',
+        requestedScopeContract: { id: 'python-sdk-fixture', read_only: true, allowed_paths: [], write_paths: [] },
+        backendPreference: ['python-codex-sdk'],
+        mutationLedgerRoot: tmp
+    });
+    assertGate(result.ok === true, 'Python SDK backend fixture must pass', result);
+    assertGate(result.backend === 'python-codex-sdk', 'Python SDK backend fixture must select python-codex-sdk', result);
+    assertGate(result.pythonSdkProofPath && result.streamEventCount > 0, 'Python SDK backend fixture must write proof and events', result);
+    emitGate('python-sdk:all-pipelines', { backend: result.backend, backend_family: result.backend_family, stream_event_count: result.streamEventCount });
+}
+finally {
+    if (oldFake === undefined)
+        delete process.env.SKS_PYTHON_CODEX_SDK_FAKE;
+    else
+        process.env.SKS_PYTHON_CODEX_SDK_FAKE = oldFake;
+}
+//# sourceMappingURL=python-codex-sdk-all-pipelines-check.js.map

package/dist/scripts/python-codex-sdk-capability-check.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './lib/codex-sdk-gate-lib.js';
+const mod = await importDist('core/codex-control/python-codex-sdk-adapter.js');
+const cap = await mod.detectPythonCodexSdkCapability();
+assertGate(['codex-app-server', 'openai-codex', 'openai-codex-sdk'].includes(cap.package_name), 'Python Codex SDK package name mismatch');
+assertGate(cap.ok === true || cap.blockers.includes('python_codex_sdk_unavailable') || cap.blockers.includes('python_missing') || cap.blockers.includes('python_version_below_3_10'), 'Python SDK unavailable must be a capability blocker');
+const requireReal = process.env.SKS_REQUIRE_PYTHON_CODEX_SDK === '1' || process.argv.includes('--require-real');
+if (requireReal && !cap.ok) {
+    console.log(JSON.stringify({
+        schema: 'sks.release-gate.v1',
+        ok: false,
+        gate: 'python-sdk:real-smoke',
+        capability_ok: cap.ok,
+        capability_blockers: cap.blockers,
+        setup_action: cap.setup_action,
+        python_bin: cap.python_bin,
+        python_version: cap.python_version,
+        blockers: cap.blockers
+    }, null, 2));
+    process.exit(1);
+}
+if (requireReal) {
+    const plane = await importDist('core/codex-control/codex-control-plane.js');
+    const smokeSchema = {
+        type: 'object',
+        required: ['status', 'summary', 'blockers'],
+        properties: {
+            status: { type: 'string', enum: ['done'] },
+            summary: { type: 'string' },
+            blockers: { type: 'array', items: { type: 'string' } }
+        },
+        additionalProperties: false
+    };
+    const result = await plane.runCodexTask({
+        route: '$Agent',
+        missionId: 'M-python-codex-sdk-real-smoke',
+        workItemId: 'python-real-smoke',
+        slotId: 'slot-python-real',
+        generationIndex: 1,
+        sessionId: 'python-real-smoke-session',
+        cwd: process.cwd(),
+        prompt: 'Read-only Python Codex SDK smoke. Do not edit files. Return exactly JSON: {"status":"done","summary":"python-codex-sdk real smoke passed","blockers":[]}',
+        inputFiles: [],
+        inputImages: [],
+        outputSchemaId: 'sks.python-codex-sdk-real-smoke-result.v1',
+        outputSchema: smokeSchema,
+        sandboxPolicy: 'read-only',
+        requestedScopeContract: { id: 'python-real-smoke', read_only: true, allowed_paths: [], write_paths: [] },
+        backendPreference: ['python-codex-sdk'],
+        mutationLedgerRoot: '.sneakoscope/reports/python-codex-sdk-real-smoke'
+    });
+    assertGate(result.ok === true, 'real Python Codex SDK smoke failed', result);
+    emitGate('python-sdk:real-smoke', {
+        status: 'proven',
+        capability_ok: cap.ok,
+        package_name: cap.package_name,
+        import_name: cap.import_name,
+        python_bin: cap.python_bin,
+        sdk_thread_id: result.sdkThreadId,
+        stream_event_count: result.streamEventCount,
+        backend: result.backend,
+        backend_family: result.backend_family
+    });
+}
+else {
+    emitGate('python-sdk:capability', {
+        capability_ok: cap.ok,
+        capability_blockers: cap.blockers,
+        package_name: cap.package_name,
+        import_name: cap.import_name,
+        setup_action: cap.setup_action
+    });
+}
+//# sourceMappingURL=python-codex-sdk-capability-check.js.map

package/dist/scripts/python-codex-sdk-sandbox-policy-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './lib/codex-sdk-gate-lib.js';
+const adapter = readText('src/core/codex-control/python-codex-sdk-adapter.ts');
+const runner = readText('pytools/codex_sdk_runner.py');
+assertGate(adapter.includes("workspace_write"), 'TS -> Python sandbox mapping must include workspace_write');
+assertGate(adapter.includes("full_access"), 'TS -> Python sandbox mapping must include full_access');
+assertGate(runner.includes('Sandbox.workspace_write'), 'Python runner must use SDK Sandbox presets');
+emitGate('python-sdk:sandbox-policy', { sandboxes: ['read_only', 'workspace_write', 'full_access'] });
+//# sourceMappingURL=python-codex-sdk-sandbox-policy-check.js.map

package/dist/scripts/python-codex-sdk-stream-bridge-check.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './lib/codex-sdk-gate-lib.js';
+const mod = await importDist('core/codex-control/python-codex-sdk-event-translator.js');
+const events = mod.translatePythonCodexSdkEvents([
+    { event: 'thread_started', thread_id: 't' },
+    { event: 'turn_completed', turn_id: 'u', status: 'completed', final_response: '{}' }
+]);
+assertGate(events.length === 2, 'Python SDK event translator must preserve stream events');
+assertGate(events[1].event_type === 'turn_completed', 'Python SDK turn completion event missing');
+emitGate('python-sdk:stream-bridge', { event_count: events.length });
+//# sourceMappingURL=python-codex-sdk-stream-bridge-check.js.map

package/dist/scripts/release-parallel-check.js

@@ -23,7 +23,7 @@ const deterministicReleaseEnv = {
     SKS_REQUIRE_REAL_COMPUTER_USE: '0'
 };
 const tasks = [
-    task('build', 'npm run build --silent', { outputs: ['dist'] }),
+    task('build', 'npm run release:dist-freshness --silent', { outputs: ['dist'] }),
     task('runtime:no-src-mjs', 'npm run runtime:no-src-mjs --silent', { dependencies: ['build'] }),
     task('runtime:ts-source-of-truth', 'npm run runtime:ts-source-of-truth --silent', { dependencies: ['build'] }),
     task('architecture:guard', 'npm run architecture:guard --silent', { dependencies: ['build', 'runtime:ts-source-of-truth'] }),

package/dist/scripts/release-real-check.js

@@ -30,6 +30,7 @@ else {
 }
 for (const [script, extraArgs] of [
     ['codex:actual-config-load-probe', []],
+    ['codex:0.137-compat:require-real', []],
     ['codex:0.136-compat:require-real', []],
     ['codex:0.135-compat:require-real', []],
     ['doctor:codex-doctor-parity:actual', []],
@@ -49,6 +50,10 @@ if (report.environment_required_checks.some((row) => !row.ok))
     finish(false);
 for (const [script, extraArgs] of [
     ['codex-sdk:real-smoke', ['--require-real']],
+    ['local-llm:smoke', ['--require-real']],
+    ['local-llm:throughput', []],
+    ['local-llm:cache-performance', []],
+    ['python-sdk:real-smoke', []],
     ['codex:0.134-runner-truth', []],
     ['agent:real-codex-patch-envelope-smoke', []],
     ['agent:real-codex-parallel-workers', []],

package/dist/scripts/zellij-worker-pane-manager-check.js

@@ -65,7 +65,7 @@ const sourceOk = source.includes("action', 'new-pane'")
     && source.includes('zellij_worker_list_panes')
     && source.includes('provider_context');
 const ok = artifact.ok
-    && artifact.pane_name === 'slot-001/gen-7 · codex-sdk · fast · codex-lb'
+    && artifact.pane_name === 'slot-001/gen-7 · codex-sdk · fast · codex-lb · running'
     && artifact.pane_kind === 'worker_codex_sdk'
     && artifact.provider === 'codex-lb'
     && artifact.service_tier === 'fast'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -288,11 +288,30 @@
     "local-collab:no-local-only-final": "node ./dist/scripts/local-collab-no-local-only-final-check.js",
     "local-collab:gpt-final-availability": "node ./dist/scripts/local-collab-gpt-final-availability-check.js",
     "local-collab:gpt-final-performance": "node ./dist/scripts/gpt-final-arbiter-performance-check.js",
+    "local-llm:capability": "node ./dist/scripts/local-llm-capability-check.js",
+    "local-llm:smoke": "node ./dist/scripts/local-llm-smoke-check.js",
+    "local-llm:structured-output": "node ./dist/scripts/local-llm-structured-output-check.js",
+    "local-llm:tool-call-repair": "node ./dist/scripts/local-llm-tool-call-repair-check.js",
+    "local-llm:throughput": "node ./dist/scripts/local-llm-throughput-check.js",
+    "local-llm:cache-performance": "node ./dist/scripts/local-llm-cache-performance-check.js",
+    "local-llm:warmup": "node ./dist/scripts/local-llm-warmup-check.js",
+    "local-llm:all-pipelines": "node ./dist/scripts/local-llm-all-pipelines-check.js",
+    "local-collab:all-pipelines-final-gpt": "node ./dist/scripts/local-collab-all-pipelines-final-gpt-check.js",
+    "python-sdk:capability": "node ./dist/scripts/python-codex-sdk-capability-check.js",
+    "python-sdk:stream-bridge": "node ./dist/scripts/python-codex-sdk-stream-bridge-check.js",
+    "python-sdk:sandbox-policy": "node ./dist/scripts/python-codex-sdk-sandbox-policy-check.js",
+    "python-sdk:all-pipelines": "node ./dist/scripts/python-codex-sdk-all-pipelines-check.js",
+    "python-sdk:real-smoke": "node ./dist/scripts/python-codex-sdk-capability-check.js --require-real",
+    "codex:0.137-compat": "node ./dist/scripts/codex-0-137-compat-check.js",
+    "codex:0.137-compat:require-real": "node ./dist/scripts/codex-0-137-compat-check.js --require-real",
+    "codex:plugin-list-json": "node ./dist/scripts/codex-plugin-list-json-check.js",
+    "codex:thread-runtime-choice": "node ./dist/scripts/codex-thread-runtime-choice-check.js",
+    "codex:environment-scoped-approvals": "node ./dist/scripts/codex-environment-scoped-approvals-check.js",
     "ultra-router:classification": "node ./dist/scripts/ultra-router-classification-check.js",
     "ultra-router:auto-router": "node ./dist/scripts/ultra-router-auto-router-check.js",
     "coverage": "node --experimental-test-coverage --test \"test/**/*.test.mjs\"",
-    "release:check": "npm run release:check:parallel && npm run mad-sks:app-ui-no-mutation && npm run codex-app:fast-ui-preservation && npm run codex-app:ui-clobber-guard && npm run doctor:fixes-codex-app-fast-ui && npm run provider:badge-context && npm run provider:context-config-toml && npm run codex-app:provider-badge && npm run zellij:spawn-on-demand-layout && npm run zellij:worker-pane-manager && npm run zellij:worker-pane-manager-single-owner && npm run agent:worker-pane-communication-contract && npm run runtime:no-mjs-scripts && npm run runtime:ts-python-boundary && npm run codex-sdk:capability && npm run codex-sdk:no-legacy-fallback && npm run codex-sdk:backend-router && npm run codex-sdk:structured-output && npm run codex-sdk:event-stream-ledger && npm run codex-sdk:thread-registry && npm run codex-sdk:sandbox-policy && npm run codex-sdk:zellij-pane-binding && npm run codex-sdk:all-pipelines && npm run codex-sdk:dfix-pipeline && npm run codex-sdk:qa-pipeline && npm run codex-sdk:research-pipeline && npm run codex-sdk:team-naruto-agent-pipeline && npm run codex-sdk:release-review-pipeline && npm run codex-sdk:ux-ppt-review-pipeline && npm run codex-sdk:core-skill-pipeline && npm run codex-control:capability && npm run codex-control:no-legacy-fallback && npm run codex-control:structured-output && npm run codex-control:event-stream-ledger && npm run codex-control:thread-registry && npm run codex-control:side-effect-scope && npm run codex-control:all-pipelines && npm run codex-control:empty-result-retry && npm run codex-control:stream-idle-watchdog && npm run codex-control:tool-call-sequence-repair && npm run codex-control:keepalive-no-cot-leak && npm run local-collab:policy && npm run local-collab:gpt-final-arbiter && npm run local-collab:no-local-only-final && npm run local-collab:gpt-final-availability && npm run ultra-router:classification && npm run ultra-router:auto-router && npm run release:version-truth && npm run codex:0.136-compat && npm run codex:0.135-compat && npm run doctor:codex-doctor-parity && npm run codex:permission-profiles && npm run codex:legacy-profile-consumers-removed && npm run terminal:keyboard-enhancement-safety && npm run terminal:tui-output-stability && npm run codex:resume-cwd-truth && npm run mcp:tool-naming-parity && npm run responses:retry-policy-centralized && npm run runtime:no-tmux && npm run zellij:layout-valid && npm run agent:zellij-dynamic-backfill-panes && npm run agent:worker-pane-communication-contract && npm run agent:slot-pane-binding-proof && npm run zellij:worker-pane-manager && npm run zellij:spawn-on-demand-layout && npm run zellij:lane-renderer && npm run mad-sks:zellij-launch && npm run mad-sks:zellij-default-pane-worker && npm run agent:zellij-runtime && npm run codex:config-eperm-fixture && npm run doctor:fix-proves-codex-read && npm run mad:preflight-blocks-unreadable-config && npm run fast:codex-service-tier-proof && npm run codex:project-config-policy-splitter && npm run test:no-orphan-dist-imports && npm run agent:patch-envelope-extraction && npm run agent:patch-queue-runtime && npm run agent:strategy-to-lease-wiring && npm run agent:patch-swarm-runtime && npm run agent:patch-transaction-journal && npm run agent:patch-conflict-rebase && npm run agent:strategy-to-patch-strict && npm run agent:patch-swarm-runtime-truth && npm run agent:rollback-command && npm run agent:patch-verification-dag && npm run agent:patch-rollback-dag && npm run agent:patch-proof-runtime && npm run agent:patch-swarm-route-blackbox && npm run team:patch-swarm-route-blackbox && npm run dfix:patch-swarm-route-blackbox && npm run appshots:thread-attachment-discovery && npm run mcp:readonly-runtime-scheduler && npm run codex:0.134-runner-truth && npm run agent:native-cli-session-swarm && npm run agent:native-cli-session-swarm-10 && npm run agent:native-cli-session-swarm-20 && npm run agent:no-subagent-scaling && npm run agent:native-cli-session-proof && npm run agent:worker-backend-router && npm run agent:codex-child-overlap && npm run agent:model-authored-patch-envelope && npm run agent:fast-mode-default && npm run agent:fast-mode-worker-propagation && npm run codex:fast-mode-profile-propagation && npm run mad-sks:fast-mode-propagation && npm run zellij:launch-command-truth && npm run zellij:real-session-heartbeat && npm run zellij:ui-design && npm run zellij:doctor-readiness && npm run legacy:upgrade-zero-break && npm run publish:packlist-performance && npm run postinstall:safe-side-effects && npm run runtime:ts-rust-boundary && npm run core-skill:card-schema && npm run core-skill:rollout-scoring && npm run core-skill:patch && npm run core-skill:heldout-validation && npm run core-skill:deployment-snapshot && npm run core-skill:no-inference-optimizer && npm run core-skill:route-runtime-integration && npm run core-skill:promotion-side-effect-ledger && npm run core-skill:legacy-promotion-api-audit && npm run safety:side-effect-zero && npm run safety:mutation-callsite-coverage && npm run safety:mutation-callsite-coverage:repo-wide && npm run side-effect:runtime-report && npm run release:gate-planner && npm run release:dynamic-performance && npm run release:provenance && npm run release:gate-budget && npm run agent:wiki-context-proof && npm run shared-memory:check && npm run wrongness:check && npm run wrongness:fixtures && npm run trust:check && npm run git-collaboration:e2e && node ./dist/scripts/release-check-stamp.js write && npm run release:readiness --silent && node ./dist/scripts/release-check-stamp.js write",
-    "release:real-check": "node ./dist/scripts/release-real-check.js && npm run codex-control:real-smoke -- --require-real && npm run codex-sdk:real-smoke -- --require-real && npm run zellij:real-session-launch -- --require-real --main-only --mission M-release-real-zellij-extra --session sks-rrz-extra && npm run zellij:pane-proof -- --require-real --mission M-release-real-zellij-extra --session sks-rrz-extra --expected-lanes 0 && npm run zellij:screen-proof -- --require-real --main-only --mission M-release-real-zellij-extra && npm run zellij:real-session-cleanup -- --mission M-release-real-zellij-extra --session sks-rrz-extra && npm run agent:real-codex-in-zellij-worker-pane -- --require-real && SKS_REQUIRE_LOCAL_LLM=1 SKS_REQUIRE_GPT_FINAL=1 npm run local-collab:gpt-final-performance",
+    "release:check": "npm run release:check:parallel && npm run mad-sks:app-ui-no-mutation && npm run codex-app:fast-ui-preservation && npm run codex-app:ui-clobber-guard && npm run doctor:fixes-codex-app-fast-ui && npm run provider:badge-context && npm run provider:context-config-toml && npm run codex-app:provider-badge && npm run zellij:spawn-on-demand-layout && npm run zellij:worker-pane-manager && npm run zellij:worker-pane-manager-single-owner && npm run agent:worker-pane-communication-contract && npm run runtime:no-mjs-scripts && npm run runtime:ts-python-boundary && npm run codex-sdk:capability && npm run codex-sdk:no-legacy-fallback && npm run codex-sdk:backend-router && npm run codex-sdk:structured-output && npm run codex-sdk:event-stream-ledger && npm run codex-sdk:thread-registry && npm run codex-sdk:sandbox-policy && npm run codex-sdk:zellij-pane-binding && npm run codex-sdk:all-pipelines && npm run codex-sdk:dfix-pipeline && npm run codex-sdk:qa-pipeline && npm run codex-sdk:research-pipeline && npm run codex-sdk:team-naruto-agent-pipeline && npm run codex-sdk:release-review-pipeline && npm run codex-sdk:ux-ppt-review-pipeline && npm run codex-sdk:core-skill-pipeline && npm run codex-control:capability && npm run codex-control:no-legacy-fallback && npm run codex-control:structured-output && npm run codex-control:event-stream-ledger && npm run codex-control:thread-registry && npm run codex-control:side-effect-scope && npm run codex-control:all-pipelines && npm run codex-control:empty-result-retry && npm run codex-control:stream-idle-watchdog && npm run codex-control:tool-call-sequence-repair && npm run codex-control:keepalive-no-cot-leak && npm run local-collab:policy && npm run local-collab:gpt-final-arbiter && npm run local-collab:no-local-only-final && npm run local-collab:gpt-final-availability && npm run local-llm:capability && npm run local-llm:structured-output && npm run local-llm:tool-call-repair && npm run local-llm:all-pipelines && npm run local-collab:all-pipelines-final-gpt && npm run python-sdk:capability && npm run python-sdk:stream-bridge && npm run python-sdk:sandbox-policy && npm run python-sdk:all-pipelines && npm run codex:plugin-list-json && npm run codex:thread-runtime-choice && npm run codex:environment-scoped-approvals && npm run ultra-router:classification && npm run ultra-router:auto-router && npm run release:version-truth && npm run codex:0.137-compat && npm run codex:0.136-compat && npm run codex:0.135-compat && npm run doctor:codex-doctor-parity && npm run codex:permission-profiles && npm run codex:legacy-profile-consumers-removed && npm run terminal:keyboard-enhancement-safety && npm run terminal:tui-output-stability && npm run codex:resume-cwd-truth && npm run mcp:tool-naming-parity && npm run responses:retry-policy-centralized && npm run runtime:no-tmux && npm run zellij:layout-valid && npm run agent:zellij-dynamic-backfill-panes && npm run agent:worker-pane-communication-contract && npm run agent:slot-pane-binding-proof && npm run zellij:worker-pane-manager && npm run zellij:spawn-on-demand-layout && npm run zellij:lane-renderer && npm run mad-sks:zellij-launch && npm run mad-sks:zellij-default-pane-worker && npm run agent:zellij-runtime && npm run codex:config-eperm-fixture && npm run doctor:fix-proves-codex-read && npm run mad:preflight-blocks-unreadable-config && npm run fast:codex-service-tier-proof && npm run codex:project-config-policy-splitter && npm run test:no-orphan-dist-imports && npm run agent:patch-envelope-extraction && npm run agent:patch-queue-runtime && npm run agent:strategy-to-lease-wiring && npm run agent:patch-swarm-runtime && npm run agent:patch-transaction-journal && npm run agent:patch-conflict-rebase && npm run agent:strategy-to-patch-strict && npm run agent:patch-swarm-runtime-truth && npm run agent:rollback-command && npm run agent:patch-verification-dag && npm run agent:patch-rollback-dag && npm run agent:patch-proof-runtime && npm run agent:patch-swarm-route-blackbox && npm run team:patch-swarm-route-blackbox && npm run dfix:patch-swarm-route-blackbox && npm run appshots:thread-attachment-discovery && npm run mcp:readonly-runtime-scheduler && npm run naruto:work-graph && npm run naruto:concurrency-governor && npm run naruto:active-pool && npm run naruto:role-distribution && npm run naruto:parallel-patch-apply && npm run naruto:verification-pool && npm run naruto:zellij-massive-ui && npm run naruto:gpt-final-pack && npm run prompt:placeholder-guard && npm run codex:0.134-runner-truth && npm run agent:native-cli-session-swarm && npm run naruto:shadow-clone-swarm && npm run agent:native-cli-session-swarm-10 && npm run agent:native-cli-session-swarm-20 && npm run agent:no-subagent-scaling && npm run agent:native-cli-session-proof && npm run agent:worker-backend-router && npm run agent:codex-child-overlap && npm run agent:model-authored-patch-envelope && npm run agent:fast-mode-default && npm run agent:fast-mode-worker-propagation && npm run codex:fast-mode-profile-propagation && npm run mad-sks:fast-mode-propagation && npm run zellij:launch-command-truth && npm run zellij:real-session-heartbeat && npm run zellij:ui-design && npm run zellij:doctor-readiness && npm run legacy:upgrade-zero-break && npm run publish:packlist-performance && npm run postinstall:safe-side-effects && npm run runtime:ts-rust-boundary && npm run core-skill:card-schema && npm run core-skill:rollout-scoring && npm run core-skill:patch && npm run core-skill:heldout-validation && npm run core-skill:deployment-snapshot && npm run core-skill:no-inference-optimizer && npm run core-skill:route-runtime-integration && npm run core-skill:promotion-side-effect-ledger && npm run core-skill:legacy-promotion-api-audit && npm run safety:side-effect-zero && npm run safety:mutation-callsite-coverage && npm run safety:mutation-callsite-coverage:repo-wide && npm run side-effect:runtime-report && npm run release:gate-planner && npm run release:dynamic-performance && npm run release:provenance && npm run release:gate-budget && npm run agent:wiki-context-proof && npm run shared-memory:check && npm run wrongness:check && npm run wrongness:fixtures && npm run trust:check && npm run git-collaboration:e2e && node ./dist/scripts/release-check-stamp.js write && npm run release:readiness --silent && node ./dist/scripts/release-check-stamp.js write",
+    "release:real-check": "node ./dist/scripts/release-real-check.js && npm run codex-control:real-smoke -- --require-real && npm run codex-sdk:real-smoke -- --require-real && SKS_REQUIRE_LOCAL_LLM=1 npm run local-llm:smoke && SKS_REQUIRE_LOCAL_LLM=1 npm run local-llm:throughput && SKS_REQUIRE_LOCAL_LLM=1 npm run local-llm:cache-performance && SKS_REQUIRE_PYTHON_CODEX_SDK=1 npm run python-sdk:real-smoke && SKS_REQUIRE_CODEX_0137=1 npm run codex:0.137-compat:require-real && npm run zellij:real-session-launch -- --require-real --main-only --mission M-release-real-zellij-extra --session sks-rrz-extra && npm run zellij:pane-proof -- --require-real --mission M-release-real-zellij-extra --session sks-rrz-extra --expected-lanes 0 && npm run zellij:screen-proof -- --require-real --main-only --mission M-release-real-zellij-extra && npm run zellij:real-session-cleanup -- --mission M-release-real-zellij-extra --session sks-rrz-extra && npm run agent:real-codex-in-zellij-worker-pane -- --require-real && SKS_REQUIRE_ZELLIJ=1 npm run naruto:zellij-massive-ui -- --require-real && SKS_REQUIRE_LOCAL_LLM=1 SKS_REQUIRE_GPT_FINAL=1 npm run naruto:real-local-gpt-final-smoke && SKS_REQUIRE_LOCAL_LLM=1 SKS_REQUIRE_GPT_FINAL=1 npm run local-collab:gpt-final-performance",
     "release:publish": "npm run publish:npm",
     "publish:dry": "npm run release:metadata && npm run release:version-truth && npm run publish:packlist-performance && npm run prepublish:release-check-or-fast && node ./dist/scripts/release-check-stamp.js verify && npm run release:provenance -- --publish && npm run release:dist-freshness && npm --cache /tmp/sks-npm-cache publish --dry-run --registry https://registry.npmjs.org/ --access public",
     "publish:npm": "npm --cache /tmp/sks-npm-cache publish --registry https://registry.npmjs.org/ --access public",
@@ -433,6 +452,16 @@
     "agent:rollback-command": "node ./dist/scripts/agent-rollback-command-check.js",
     "agent:native-cli-session-swarm": "node ./dist/scripts/agent-native-cli-session-swarm-check.js",
     "naruto:shadow-clone-swarm": "node ./dist/scripts/naruto-shadow-clone-swarm-check.js",
+    "naruto:work-graph": "node ./dist/scripts/naruto-work-graph-check.js",
+    "naruto:concurrency-governor": "node ./dist/scripts/naruto-concurrency-governor-check.js",
+    "naruto:active-pool": "node ./dist/scripts/naruto-active-pool-check.js",
+    "naruto:role-distribution": "node ./dist/scripts/naruto-role-distribution-check.js",
+    "naruto:parallel-patch-apply": "node ./dist/scripts/naruto-parallel-patch-apply-check.js",
+    "naruto:verification-pool": "node ./dist/scripts/naruto-verification-pool-check.js",
+    "naruto:zellij-massive-ui": "node ./dist/scripts/naruto-zellij-massive-ui-check.js",
+    "naruto:gpt-final-pack": "node ./dist/scripts/naruto-gpt-final-pack-check.js",
+    "naruto:real-local-gpt-final-smoke": "node ./dist/scripts/naruto-real-local-gpt-final-smoke.js",
+    "prompt:placeholder-guard": "node ./dist/scripts/prompt-placeholder-guard-check.js",
     "agent:native-cli-session-swarm-10": "node ./dist/scripts/agent-native-cli-session-swarm-10-check.js",
     "agent:native-cli-session-swarm-20": "node ./dist/scripts/agent-native-cli-session-swarm-20-check.js",
     "agent:worker-backend-router": "node ./dist/scripts/agent-worker-backend-router-check.js",
@@ -512,7 +541,7 @@
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.29.0",
-    "@openai/codex-sdk": "0.136.0",
+    "@openai/codex-sdk": "0.137.0",
     "figlet": "^1.11.0",
     "typescript": "^5.9.3"
   },