sneakoscope 1.21.3 → 1.21.4

package/README.md

@@ -16,7 +16,7 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-SKS **1.21.3** restores macOS native text copy in SKS-launched Zellij sessions: the generated clipboard config and launch options now set `mouse_mode false` alongside `copy_command pbcopy`, so drag-select + `Cmd+C` reaches the terminal/system clipboard instead of being intercepted by Zellij. It also keeps Team/Naruto native agents individually visible in the right-side Zellij UI by separating runtime concurrency (`target_active_slots`) from the visual lane count (`visual_lane_count`). Direct `npm publish` now repairs a stale release-check stamp by running the full authoritative `npm run release:check` once before continuing, instead of failing early in `prepublish:fast-check` after a version bump. Explicit `sks fast-mode on` / `$Fast-On` now repairs Codex's Fast mode UI/default profile as well as the project-local SKS preference. It carries forward the 1.21.2 Zellij launch fix, 1.21.1 launch-speed fix, and Codex legacy-profile cleanup.
+SKS **1.21.4** makes Fast mode state and Naruto clone activity directly visible in SKS Zellij lanes. The lane renderer now resolves the project-local `sks fast-mode on|off` preference even before worker scheduler artifacts arrive, and Naruto launches the right-side Zellij lane stack before clone scheduling starts so each clone slot can show live activity. Naruto's host-capacity model also no longer collapses `codex-exec` concurrency to one slot on capable Macs just because `freemem` is low; use `--concurrency` / `--target-active-slots` or `SKS_NARUTO_MAX_CONCURRENCY` for explicit operator control. SKS-launched interactive Codex panes also use `--no-alt-screen` by default so Mac trackpad/wheel gestures scroll the terminal conversation history instead of the prompt textarea/history; set `SKS_ZELLIJ_CODEX_ALT_SCREEN=1` before launch to opt back into alternate-screen mode. It carries forward the 1.21.3 Zellij clipboard, visual lane count, direct-publish stamp repair, and Codex Fast mode repair fixes.
 
 SKS **1.20.4** is a targeted `sks --mad` / codex-lb Zellij usability patch: when a background MAD Zellij session launches successfully, SKS now prints the exact `Attach with: ZELLIJ_SOCKET_DIR=... zellij attach ...` command so operators can enter the fresh session without manually reconstructing the socket namespace.
 
@@ -341,7 +341,7 @@ sks team open-zellij latest
 sks team attach-zellij latest
 ```
 
-Interactive SKS sessions use Zellij layouts. By default SKS launches Codex in Fast service tier with `--model gpt-5.5`, `-c service_tier="fast"`, and the selected `model_reasoning_effort`. SKS always forces the model to `gpt-5.5`; `SKS_CODEX_MODEL` and `SKS_CODEX_FAST_HIGH=0` cannot downgrade or remove that model pin. You can still set `SKS_CODEX_REASONING` to change reasoning effort. Use `sks --mad --workspace <name>` for an explicit MAD session and `sks help` for CLI help.
+Interactive SKS sessions use Zellij layouts. By default SKS launches Codex in Fast service tier with `--model gpt-5.5`, `-c service_tier="fast"`, the selected `model_reasoning_effort`, and `--no-alt-screen` for Zellij-backed interactive panes so terminal scrollback captures the conversation transcript. SKS always forces the model to `gpt-5.5`; `SKS_CODEX_MODEL` and `SKS_CODEX_FAST_HIGH=0` cannot downgrade or remove that model pin. You can still set `SKS_CODEX_REASONING` to change reasoning effort, and `SKS_ZELLIJ_CODEX_ALT_SCREEN=1` restores Codex's alternate-screen UI for the next launch. Use `sks --mad --workspace <name>` for an explicit MAD session and `sks help` for CLI help.
 
 Before opening the interactive runtime, SKS checks the installed Codex CLI against npm `@openai/codex@latest`. If a newer version exists, it asks `Y/n`; answering `y` updates automatically with `npm i -g @openai/codex@latest` and then opens the runtime with the updated Codex CLI.
 

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "1.21.3"
+version = "1.21.4"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "1.21.3"
+version = "1.21.4"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 1.21.3"),
+        Some("--version") => println!("sks-rs 1.21.4"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/.sks-build-stamp.json

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "1.21.3",
-  "source_digest": "fdee4bb2a16e87fbf85b069519a8c545b16b2d6fe64ad9da30b5e765ee555887",
+  "package_version": "1.21.4",
+  "source_digest": "70780332db02a19044731adecdb06abcf7d9efdc8b128627be712ca33b3c6881",
   "source_file_count": 1755,
-  "built_at_source_time": 1780312892629
+  "built_at_source_time": 1780318491834
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '1.21.3';
+const FAST_PACKAGE_VERSION = '1.21.4';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/build-manifest.json

@@ -1,13 +1,13 @@
 {
   "schema": "sks.dist-build.v2",
-  "version": "1.21.3",
-  "package_version": "1.21.3",
+  "version": "1.21.4",
+  "package_version": "1.21.4",
   "typescript": true,
   "mjs_runtime_files": 0,
   "compiled_file_count": 1022,
   "compiled_js_count": 511,
   "compiled_dts_count": 511,
-  "source_digest": "fdee4bb2a16e87fbf85b069519a8c545b16b2d6fe64ad9da30b5e765ee555887",
+  "source_digest": "70780332db02a19044731adecdb06abcf7d9efdc8b128627be712ca33b3c6881",
   "source_file_count": 1755,
   "source_files_hash": "e6487058a1a0894c6b8a629b64319d45be1ad9a0658ab422a39969c1e39ad7e3",
   "source_list_hash": "e6487058a1a0894c6b8a629b64319d45be1ad9a0658ab422a39969c1e39ad7e3",

package/dist/core/agents/agent-roster.d.ts

@@ -1,13 +1,18 @@
 import type { AgentPersona, AgentRosterEntry } from './agent-schema.js';
 export declare function systemSafeNarutoConcurrency(opts?: {
     backend?: string;
+    cores?: number;
+    freeBytes?: number;
+    totalBytes?: number;
 }): {
     cap: number;
     cores: number;
     free_gb: number;
+    total_gb: number;
     backend: string;
     heavy: boolean;
     override_applied: boolean;
+    memory_model: string;
 };
 export declare function normalizeAgentCount(value: unknown, fallback?: number, maxAgentCount?: number): number;
 export declare function normalizeAgentConcurrency(value: unknown, agents: number, maxAgentCount?: number): number;

package/dist/core/agents/agent-roster.js

@@ -7,22 +7,35 @@ import { buildAgentEffortPolicy, decideAgentEffort, decideNarutoCloneEffort } fr
 // host can safely sustain — derived from CPU cores and free memory, heavier-bounded for
 // real child-process backends (codex-exec/zellij/process) than for in-process (fake).
 export function systemSafeNarutoConcurrency(opts = {}) {
-    const cores = Math.max(1, Number(os.cpus()?.length) || 4);
+    const cores = Math.max(1, Number(opts.cores ?? os.cpus()?.length) || 4);
     let freeBytes = 2 * 1024 * 1024 * 1024;
+    let totalBytes = 8 * 1024 * 1024 * 1024;
     try {
-        freeBytes = os.freemem() || freeBytes;
+        freeBytes = Number(opts.freeBytes ?? os.freemem()) || freeBytes;
+    }
+    catch { /* keep fallback */ }
+    try {
+        totalBytes = Number(opts.totalBytes ?? os.totalmem()) || totalBytes;
     }
     catch { /* keep fallback */ }
     const freeGb = freeBytes / (1024 * 1024 * 1024);
+    const totalGb = totalBytes / (1024 * 1024 * 1024);
     const backend = String(opts.backend || 'codex-exec');
     const heavy = backend === 'codex-exec' || backend === 'zellij' || backend === 'process';
     let cap;
     if (heavy) {
-        // Real codex children are heavy (a model call + process). Leave a core free and budget
-        // ~0.6 GB per concurrent worker; clamp to a sane ceiling.
+        // Real codex children are heavier than fake workers, but macOS can report
+        // very low freemem while reclaimable memory is still available. Use a
+        // conservative total-memory floor so Naruto keeps meaningful parallelism
+        // instead of collapsing to one slot on otherwise capable machines.
         const byCpu = Math.max(1, cores - 1);
-        const byMem = Math.max(1, Math.floor(freeGb / 0.6));
-        cap = Math.min(byCpu, byMem, 16);
+        const gbPerWorker = positiveEnvNumber('SKS_NARUTO_GB_PER_WORKER', 0.6);
+        const reclaimableFloorGb = totalGb >= 16 ? 6 : totalGb >= 8 ? 3 : totalGb >= 4 ? 1.5 : freeGb;
+        const budgetGb = Math.max(freeGb, reclaimableFloorGb);
+        const byMem = Math.max(1, Math.floor(budgetGb / gbPerWorker));
+        const minParallelDefault = totalGb >= 16 ? 8 : totalGb >= 8 ? 4 : totalGb >= 4 ? 2 : 1;
+        const minParallel = Math.min(byCpu, Math.floor(positiveEnvNumber('SKS_NARUTO_MIN_CONCURRENCY', minParallelDefault)));
+        cap = Math.min(byCpu, Math.max(byMem, minParallel), 16);
     }
     else {
         // In-process / light workers can pack tighter.
@@ -32,7 +45,20 @@ export function systemSafeNarutoConcurrency(opts = {}) {
     if (Number.isFinite(override) && override >= 1)
         cap = Math.min(Math.floor(override), MAX_NARUTO_AGENT_COUNT);
     cap = Math.max(1, Math.min(cap, MAX_NARUTO_AGENT_COUNT));
-    return { cap, cores, free_gb: Math.round(freeGb * 10) / 10, backend, heavy, override_applied: Number.isFinite(override) && override >= 1 };
+    return {
+        cap,
+        cores,
+        free_gb: Math.round(freeGb * 10) / 10,
+        total_gb: Math.round(totalGb * 10) / 10,
+        backend,
+        heavy,
+        override_applied: Number.isFinite(override) && override >= 1,
+        memory_model: heavy ? 'free_or_reclaimable_floor' : 'light_worker_cpu_bound'
+    };
+}
+function positiveEnvNumber(name, fallback) {
+    const parsed = Number(process.env[name]);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 function resolveMaxAgentCount(value) {
     const parsed = Number(value);

package/dist/core/agents/zellij-right-lane-cockpit.js

@@ -4,7 +4,7 @@ export const ZELLIJ_RIGHT_LANE_LAYOUT_SCHEMA = 'sks.agent-zellij-right-lane-layo
 export const ZELLIJ_RIGHT_LANES_SCHEMA = 'sks.agent-zellij-right-lanes.v1';
 export function buildZellijRightLaneCockpit(input = {}) {
     const agents = input.slots || input.agents || [];
-    const maxVisible = input.maxVisibleLanes || 20;
+    const maxVisible = input.maxVisibleLanes || Math.max(agents.length, 1);
     const lanes = agents.map((agent, index) => ({
         lane_index: index + 1,
         slot_id: String(agent.slot_id || agent.id || agent.agent_id || `slot-${String(index + 1).padStart(3, '0')}`),

package/dist/core/commands/naruto-command.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { findLatestMission, loadMission } from '../mission.js';
+import { createMission, findLatestMission, loadMission } from '../mission.js';
 import { readJson, sksRoot } from '../fsx.js';
 import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
 import { buildNarutoCloneRoster, systemSafeNarutoConcurrency } from '../agents/agent-roster.js';
@@ -30,10 +30,37 @@ async function narutoRun(parsed) {
         maxAgentCount: MAX_NARUTO_AGENT_COUNT
     });
     // The clone roster is the full work fan-out; live concurrency is throttled to a
-    // system-safe number so naruto never spawns the whole count at once.
+    // system-safe number so naruto never spawns the whole count at once unless an
+    // explicit operator override asks for a higher target.
     const safe = systemSafeNarutoConcurrency({ backend: parsed.backend });
-    const activeSlots = Math.max(1, Math.min(roster.agent_count, safe.cap));
+    const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || safe.cap));
+    const mission = await createMission(root, { mode: 'naruto', prompt: parsed.prompt });
+    const ledgerRoot = path.join(mission.dir, 'agents');
+    let liveZellij = null;
+    if (!parsed.json && !parsed.mock && !parsed.noOpenZellij) {
+        liveZellij = await launchZellijLayout({
+            root,
+            missionId: mission.id,
+            ledgerRoot,
+            kind: 'naruto',
+            slotCount: roster.agent_count,
+            dryRun: false,
+            attach: false
+        });
+        if (liveZellij?.ok && liveZellij.capability?.status === 'ok') {
+            console.log('Zellij: prepared ' + roster.agent_count + ' live clone lane(s) in ' + liveZellij.session_name + '. Attach with: ' + (liveZellij.attach_command_with_env || liveZellij.attach_command));
+            if (parsed.attach)
+                attachZellijSessionInteractive(liveZellij.session_name, { cwd: process.cwd(), configPath: liveZellij.clipboard_config_path });
+        }
+        else if (liveZellij?.ok) {
+            console.log('Zellij: optional live panes unavailable (' + ((liveZellij.warnings || []).join('; ') || liveZellij.capability?.status || 'unknown') + ')');
+        }
+        else {
+            console.log('Zellij: blocked (' + Array.from(new Set(liveZellij?.blockers || [])).join('; ') + ')');
+        }
+    }
     const result = await runNativeAgentOrchestrator({
+        missionId: mission.id,
         prompt: parsed.prompt,
         route: NARUTO_ROUTE,
         routeCommand: 'sks naruto run',
@@ -76,22 +103,7 @@ async function narutoRun(parsed) {
         run: result,
         zellij: null
     };
-    if (!parsed.json && !parsed.mock && !parsed.noOpenZellij) {
-        const ledgerRoot = result.ledger_root
-            ? path.join(root, result.ledger_root)
-            : path.join(root, '.sneakoscope', 'missions', result.mission_id, 'agents');
-        summary.zellij = await launchZellijLayout({
-            root,
-            missionId: result.mission_id,
-            ledgerRoot,
-            kind: 'naruto',
-            slotCount: summary.clones,
-            dryRun: false,
-            attach: false
-        });
-        if (summary.zellij?.ok && summary.zellij.capability?.status === 'ok' && parsed.attach)
-            attachZellijSessionInteractive(summary.zellij.session_name, { cwd: process.cwd() });
-    }
+    summary.zellij = liveZellij;
     return emit(parsed, summary, () => {
         console.log('🍥 Shadow Clone Jutsu — Kage Bunshin no Jutsu');
         console.log('Mission: ' + result.mission_id);
@@ -158,6 +170,7 @@ function parseNarutoArgs(args = []) {
     const requestedClones = Number(readOption(args, '--clones', readOption(args, '--agents', DEFAULT_NARUTO_CLONES)));
     const clones = clampClones(requestedClones);
     const workItems = clampWorkItems(Number(readOption(args, '--work-items', clones)), clones);
+    const concurrency = normalizeConcurrency(readOption(args, '--concurrency', readOption(args, '--target-active-slots', null)), clones);
     const backend = String(readOption(args, '--backend', hasFlag(args, '--mock') ? 'fake' : 'codex-exec'));
     const mock = hasFlag(args, '--mock') || backend === 'fake';
     const real = hasFlag(args, '--real');
@@ -167,9 +180,9 @@ function parseNarutoArgs(args = []) {
     const missionId = String(readOption(args, '--mission', readOption(args, '--mission-id', 'latest')));
     const noOpenZellij = hasFlag(args, '--no-open-zellij') || hasFlag(args, '--no-zellij');
     const attach = hasFlag(args, '--attach');
-    const valueFlags = new Set(['--clones', '--agents', '--work-items', '--backend', '--write-mode', '--mission', '--mission-id']);
+    const valueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--mission', '--mission-id']);
     const prompt = positionalArgs(rest, valueFlags).join(' ').trim() || 'Naruto shadow clone swarm run';
-    return { action, prompt, clones, workItems, backend, mock, real, readonly, writeMode, json, missionId, noOpenZellij, attach };
+    return { action, prompt, clones, workItems, concurrency, backend, mock, real, readonly, writeMode, json, missionId, noOpenZellij, attach };
 }
 function clampClones(value) {
     if (!Number.isFinite(value) || value < 1)
@@ -181,6 +194,14 @@ function clampWorkItems(value, clones) {
         return clones;
     return Math.floor(value);
 }
+function normalizeConcurrency(value, clones) {
+    if (value == null || value === '')
+        return null;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 1)
+        return null;
+    return Math.min(Math.floor(parsed), clones, MAX_NARUTO_AGENT_COUNT);
+}
 function hasFlag(args, flag) {
     return args.includes(flag);
 }

package/dist/core/fsx.d.ts

@@ -1,4 +1,4 @@
-export declare const PACKAGE_VERSION = "1.21.3";
+export declare const PACKAGE_VERSION = "1.21.4";
 export declare const DEFAULT_PROCESS_TAIL_BYTES: number;
 export declare const DEFAULT_PROCESS_TIMEOUT_MS: number;
 export interface RunProcessOptions {

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '1.21.3';
+export const PACKAGE_VERSION = '1.21.4';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/version.d.ts

@@ -1,2 +1,2 @@
-export declare const PACKAGE_VERSION = "1.21.3";
+export declare const PACKAGE_VERSION = "1.21.4";
 //# sourceMappingURL=version.d.ts.map

package/dist/core/version.js

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

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

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { appendJsonl, ensureDir, exists, nowIso, readJson, readText, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { resolveFastModePolicy } from '../agents/fast-mode-policy.js';
 export const ZELLIJ_LANE_RENDER_SCHEMA = 'sks.zellij-lane-render.v1';
 // Default render width. Zellij panes are commonly 80/100/120 columns; the frame
 // must stay readable (no wraps, no overflow) across that range.
@@ -289,11 +290,25 @@ async function buildLaneDashboard(root, slot, laneJson) {
         swarm?.mode
     ]) || 'Agent';
     // Fast service tier.
-    const serviceTier = firstString([laneJson?.service_tier, scheduler?.service_tier, swarm?.service_tier]);
-    const fastMode = laneJson?.fast_mode ?? scheduler?.fast_mode ?? swarm?.fast_mode;
+    const projectRoot = inferProjectRootFromLedgerRoot(root);
+    const policy = resolveFastModePolicy({ root: projectRoot });
+    const serviceTier = firstString([
+        laneJson?.service_tier,
+        scheduler?.service_tier,
+        swarm?.service_tier,
+        proof?.fast_mode_policy?.service_tier,
+        policy.service_tier
+    ]);
+    const fastMode = firstDefined([
+        laneJson?.fast_mode,
+        scheduler?.fast_mode,
+        swarm?.fast_mode,
+        proof?.fast_mode_policy?.fast_mode,
+        policy.fast_mode
+    ]);
     const fast = serviceTier === 'fast' || fastMode === true
         ? `on · service_tier=${serviceTier || 'fast'}`
-        : (serviceTier ? `service_tier=${serviceTier}` : 'off');
+        : `off · service_tier=${serviceTier || 'standard'}`;
     // Workers: live active/target + (naruto) clone fan-out.
     const cloneTotal = numberOf([scheduler?.clones, scheduler?.clone_count, swarm?.clones]);
     const cloneActive = numberOf([scheduler?.active_clone, scheduler?.active_slot_count]);
@@ -358,6 +373,21 @@ function firstString(values) {
     }
     return null;
 }
+function firstDefined(values) {
+    for (const value of values.flat()) {
+        if (value !== undefined && value !== null)
+            return value;
+    }
+    return undefined;
+}
+function inferProjectRootFromLedgerRoot(value) {
+    const root = path.resolve(value);
+    const parts = root.split(path.sep);
+    const index = parts.lastIndexOf('.sneakoscope');
+    if (index > 0)
+        return parts.slice(0, index).join(path.sep) || path.sep;
+    return root;
+}
 function numberOf(values) {
     for (const value of values) {
         const n = Number(value);

package/dist/core/zellij/zellij-layout-builder.js

@@ -84,8 +84,8 @@ function shellQuote(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function buildMainPaneCommand(input, sksCommand) {
-    const codexArgs = (input.codexArgs || []).map((arg) => String(arg)).filter(Boolean);
-    const shouldLaunchCodex = input.kind === 'mad' || codexArgs.length > 0;
+    const requestedCodexArgs = (input.codexArgs || []).map((arg) => String(arg)).filter(Boolean);
+    const shouldLaunchCodex = input.kind === 'mad' || requestedCodexArgs.length > 0;
     if (!shouldLaunchCodex) {
         const shell = shellQuote(String(process.env.SHELL || '/bin/zsh'));
         return {
@@ -95,6 +95,7 @@ function buildMainPaneCommand(input, sksCommand) {
             launchEnvKeys: []
         };
     }
+    const codexArgs = withCodexScrollbackArgs(requestedCodexArgs);
     const launchEnv = sanitizeLaunchEnv(input.launchEnv || {});
     const envPrefix = launchEnv.map(([key, value]) => `${key}=${shellQuote(value)}`);
     const codexBin = shellQuote(String(input.codexBin || process.env.SKS_CODEX_BIN || 'codex'));
@@ -105,6 +106,13 @@ function buildMainPaneCommand(input, sksCommand) {
         launchEnvKeys: launchEnv.map(([key]) => key)
     };
 }
+function withCodexScrollbackArgs(args) {
+    if (process.env.SKS_ZELLIJ_CODEX_ALT_SCREEN === '1')
+        return args;
+    if (args.includes('--no-alt-screen'))
+        return args;
+    return ['--no-alt-screen', ...args];
+}
 function sanitizeLaunchEnv(env) {
     return Object.entries(env)
         .filter(([key, value]) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key) && value != null && String(value) !== '')

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

@@ -267,7 +267,7 @@ const tasks = [
     task('docs:truthfulness', 'npm run docs:truthfulness --silent', { dependencies: ['build'] }),
     task('official-docs:compat', 'npm run official-docs:compat --silent', { dependencies: ['build'] }),
     task('blackbox:matrix:contract', 'npm run blackbox:matrix:contract --silent', { dependencies: ['build'] }),
-    task('test:blackbox', 'npm run test:blackbox --silent', { dependencies: ['build'] }),
+    task('test:blackbox', 'npm run test:blackbox --silent', { dependencies: ['build'], timeout_ms: 20 * 60 * 1000 }),
     task('rust:check', 'npm run rust:check --silent', { dependencies: ['build'] }),
     task('rust:smoke', 'npm run rust:smoke --silent', { dependencies: ['build'] }),
     task('release:dist-freshness', 'npm run release:dist-freshness --silent', { dependencies: ['build'] }),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "1.21.3",
+  "version": "1.21.4",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",