sneakoscope 1.21.2 → 1.21.4

package/README.md

@@ -16,11 +16,11 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-SKS **1.21.2** fixes the `sks --mad` Zellij launch regression from 1.21.1: Zellij rejects `--copy-command` when it is paired with the OSC52-only `--copy-clipboard` flag, so SKS now passes only `--copy-command pbcopy` and `--copy-on-select true` on the launch CLI while keeping the generated clipboard config for attach-time behavior. It carries forward the 1.21.1 launch-speed and Codex legacy-profile fixes.
+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.
 
-SKS **1.20.3** added the macOS Zellij launch fallback and project-local Fast mode control. SKS supplies a short per-user `ZELLIJ_SOCKET_DIR` by default, caps generated session names safely, records `*_command_with_env` attach commands, and classifies `IPC socket path is too long` as `zellij_socket_path_too_long` instead of a generic launch failure. It also adds `sks fast-mode on|off|status|clear`, `$Fast-On`, `$Fast-Off`, and `$Fast-Mode`; saved project preferences are used only when no explicit `--fast`, `--no-fast`, or `--service-tier` flag is present.
+SKS **1.20.3** added the macOS Zellij launch fallback and project-local Fast mode control. SKS supplies a short per-user `ZELLIJ_SOCKET_DIR` by default, caps generated session names safely, records `*_command_with_env` attach commands, and classifies `IPC socket path is too long` as `zellij_socket_path_too_long` instead of a generic launch failure. It also adds `sks fast-mode on|off|status|clear`, `$Fast-On`, `$Fast-Off`, and `$Fast-Mode`; saved project preferences are used only when no explicit `--fast`, `--no-fast`, or `--service-tier` flag is present. In 1.21.3 and newer, the explicit `on` action also restores Codex App/CLI Fast mode defaults in `~/.codex/config.toml` when they were disabled.
 
 It carries forward the **1.20.2** stabilization layer: **Mutation Guard** routes genuinely-risky global/config/permission/package mutations through the Requested-Scope Contract + Mutation Ledger (`safety:mutation-callsite-coverage` fails any unguarded, unallowlisted risky call site); `release:check:dynamic:execute` is the real **caching gate runner** (schema v2, real/heavy gates deferred to `release:real-check`, dynamic-only cannot authorize publish); the **Core Skill** deployed snapshot is read by the route runtime and recorded in `agent-proof-evidence.json` (`selected_core_skill`), with promotions written to the mutation ledger; and `sks doctor` exposes an explicit **`zellij_readiness`** block (`zellij:doctor-readiness`). See `docs/dynamic-release-pipeline.md`.
 
@@ -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.2"
+version = "1.21.4"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "1.21.2"
+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.2"),
+        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.2",
-  "source_digest": "c2de07d5136a6b0feccf10d8b647ffc2fcbc322e738bafd6cea43efdd3da1225",
-  "source_file_count": 1752,
-  "built_at_source_time": 1780308857966
+  "package_version": "1.21.4",
+  "source_digest": "70780332db02a19044731adecdb06abcf7d9efdc8b128627be712ca33b3c6881",
+  "source_file_count": 1755,
+  "built_at_source_time": 1780318491834
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '1.21.2';
+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,16 +1,16 @@
 {
   "schema": "sks.dist-build.v2",
-  "version": "1.21.2",
-  "package_version": "1.21.2",
+  "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": "c2de07d5136a6b0feccf10d8b647ffc2fcbc322e738bafd6cea43efdd3da1225",
-  "source_file_count": 1752,
-  "source_files_hash": "6b8e7de7bcab2c6ddd83d31e15d7219e9d3f595813a1ec8173936208d3c877ef",
-  "source_list_hash": "6b8e7de7bcab2c6ddd83d31e15d7219e9d3f595813a1ec8173936208d3c877ef",
+  "source_digest": "70780332db02a19044731adecdb06abcf7d9efdc8b128627be712ca33b3c6881",
+  "source_file_count": 1755,
+  "source_files_hash": "e6487058a1a0894c6b8a629b64319d45be1ad9a0658ab422a39969c1e39ad7e3",
+  "source_list_hash": "e6487058a1a0894c6b8a629b64319d45be1ad9a0658ab422a39969c1e39ad7e3",
   "src_mjs_runtime_files": 0,
   "dist_stamp_schema": "sks.dist-build-stamp.v1",
   "files": [

package/dist/cli/install-helpers.d.ts

@@ -336,7 +336,7 @@ export declare function ensureGlobalCodexFastModeDuringInstall(opts?: any): Prom
     backup_path?: never;
     parse_smoke?: never;
 }>;
-export declare function normalizeCodexFastModeUiConfig(text?: any): string;
+export declare function normalizeCodexFastModeUiConfig(text?: any, opts?: any): string;
 export declare function safeWriteCodexConfigToml(configPath: string, current: string, next: string, tag?: string): Promise<{
     ok: boolean;
     status: string;

package/dist/cli/install-helpers.js

@@ -1479,7 +1479,7 @@ export async function ensureGlobalCodexFastModeDuringInstall(opts = {}) {
                 return { status: 'unparseable_config_preserved', config_path: configPath, backup_path: backupPath, parse_smoke: currentSmoke };
             }
         }
-        const next = normalizeCodexFastModeUiConfig(current);
+        const next = normalizeCodexFastModeUiConfig(current, { forceFastMode: opts.forceFastMode === true });
         if (next === ensureTrailingNewline(current))
             return { status: 'present', config_path: configPath };
         // Safety gate 2: never WRITE a config that would not parse.
@@ -1495,12 +1495,12 @@ export async function ensureGlobalCodexFastModeDuringInstall(opts = {}) {
         return { status: 'failed', config_path: configPath, error: err.message };
     }
 }
-export function normalizeCodexFastModeUiConfig(text = '') {
+export function normalizeCodexFastModeUiConfig(text = '', opts = {}) {
     // Run to a fixed point so a second install is a true no-op (idempotent). The per-pass
     // table/whitespace normalization converges within one extra pass.
-    return normalizeCodexFastModeUiConfigOnce(normalizeCodexFastModeUiConfigOnce(text));
+    return normalizeCodexFastModeUiConfigOnce(normalizeCodexFastModeUiConfigOnce(text, opts), opts);
 }
-function normalizeCodexFastModeUiConfigOnce(text = '') {
+function normalizeCodexFastModeUiConfigOnce(text = '', opts = {}) {
     // Preserve user-owned top-level scalars (model / service_tier / model_reasoning_effort):
     // SKS only supplies a default when the user has not chosen one, and never strips the
     // user's own reasoning effort. SKS continues to manage its own namespaced tables below
@@ -1509,7 +1509,9 @@ function normalizeCodexFastModeUiConfigOnce(text = '') {
     next = removeTomlTableKey(next, 'notice', 'fast_default_opt_out');
     next = removeTomlTableKey(next, 'features', 'codex_hooks');
     next = upsertTopLevelTomlStringIfAbsent(next, 'model', 'gpt-5.5');
-    next = upsertTopLevelTomlStringIfAbsent(next, 'service_tier', 'fast');
+    next = opts.forceFastMode === true
+        ? upsertTopLevelTomlString(next, 'service_tier', 'fast')
+        : upsertTopLevelTomlStringIfAbsent(next, 'service_tier', 'fast');
     // Codex App feature flags / fast-mode UI / suppress-warning are SET-IF-ABSENT: a fresh
     // config still gets SKS's defaults, but SKS NEVER overrides (re-enables) a feature the
     // user disabled in the App, and never rejects-then-hides UI by forcing an unrecognized
@@ -1522,9 +1524,16 @@ function normalizeCodexFastModeUiConfigOnce(text = '') {
         'guardian_approval = true', 'tool_suggest = true', 'apps = true', 'plugins = true'
     ])
         next = upsertTomlTableKeyIfAbsent(next, 'features', featureLine);
-    next = upsertTomlTableKeyIfAbsent(next, 'user.fast_mode', 'visible = true');
-    next = upsertTomlTableKeyIfAbsent(next, 'user.fast_mode', 'enabled = true');
-    next = upsertTomlTableKeyIfAbsent(next, 'user.fast_mode', 'default_profile = "sks-fast-high"');
+    if (opts.forceFastMode === true) {
+        next = upsertTomlTableKey(next, 'user.fast_mode', 'visible = true');
+        next = upsertTomlTableKey(next, 'user.fast_mode', 'enabled = true');
+        next = upsertTomlTableKey(next, 'user.fast_mode', 'default_profile = "sks-fast-high"');
+    }
+    else {
+        next = upsertTomlTableKeyIfAbsent(next, 'user.fast_mode', 'visible = true');
+        next = upsertTomlTableKeyIfAbsent(next, 'user.fast_mode', 'enabled = true');
+        next = upsertTomlTableKeyIfAbsent(next, 'user.fast_mode', 'default_profile = "sks-fast-high"');
+    }
     // Keep ONLY the sks-fast-high config-profile table: the Codex App fast-mode
     // (`[user.fast_mode] default_profile = "sks-fast-high"`) and the
     // codex-app:ui-preservation gate still expect it. The other SKS config profiles are

package/dist/commands/image-ux-review.d.ts

@@ -511,6 +511,7 @@ export declare function run(command: any, args?: any): Promise<void | {
                 status: string;
                 blockers: string[];
             };
+            visual_lane_count?: never;
             native_cli_session_proof?: never;
             no_subagent_scaling_policy?: never;
             fast_mode_policy?: never;
@@ -578,6 +579,7 @@ export declare function run(command: any, args?: any): Promise<void | {
             requested_work_items: number;
             actual_total_work_items: any;
             target_active_slots: number;
+            visual_lane_count: number;
             minimum_work_items: number;
             scheduler: {
                 schema: string;
@@ -974,6 +976,7 @@ export declare function run(command: any, args?: any): Promise<void | {
                 all_generations_closed: boolean;
                 scheduler_state: string;
                 target_active_slots: number;
+                visual_lane_count: number;
                 requested_work_items: number;
                 actual_total_work_items: number;
                 minimum_work_items: number;

package/dist/commands/mad-sks.d.ts

@@ -29,6 +29,7 @@ export declare function run(_command: any, args?: any): Promise<void | {
     zellij_socket_dir_source: import("../core/zellij/zellij-command.js").ZellijSocketDirSource;
     clipboard_config_path: string;
     clipboard_copy_command: string;
+    clipboard_mouse_mode: boolean;
     pane_proof_path: string;
     pane_proof: {
         schema: string;

package/dist/commands/ppt.d.ts

@@ -360,6 +360,7 @@ export declare function run(command: any, args?: any): Promise<void | {
                 status: string;
                 blockers: string[];
             };
+            visual_lane_count?: never;
             native_cli_session_proof?: never;
             no_subagent_scaling_policy?: never;
             fast_mode_policy?: never;
@@ -427,6 +428,7 @@ export declare function run(command: any, args?: any): Promise<void | {
             requested_work_items: number;
             actual_total_work_items: any;
             target_active_slots: number;
+            visual_lane_count: number;
             minimum_work_items: number;
             scheduler: {
                 schema: string;
@@ -823,6 +825,7 @@ export declare function run(command: any, args?: any): Promise<void | {
                 all_generations_closed: boolean;
                 scheduler_state: string;
                 target_active_slots: number;
+                visual_lane_count: number;
                 requested_work_items: number;
                 actual_total_work_items: number;
                 minimum_work_items: number;

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

@@ -6,6 +6,7 @@ export declare function readAgentGateStatus(root: string, missionId: string): Pr
     source: string;
     proof: any;
     gate: any;
+    expected_agent_count: number;
     all_sessions_closed: boolean;
 }>;
 //# sourceMappingURL=agent-gate.d.ts.map

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

@@ -1,6 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { AGENT_INTAKE_STAGE_ID } from './agent-schema.js';
+import { AGENT_INTAKE_STAGE_ID, DEFAULT_AGENT_COUNT } from './agent-schema.js';
 async function exists(file) {
     try {
         await fs.access(file);
@@ -22,8 +22,16 @@ export async function readAgentGateStatus(root, missionId) {
     const dir = path.join(root, '.sneakoscope', 'missions', missionId);
     const proofPath = path.join(dir, 'agents', 'agent-proof-evidence.json');
     const gatePath = path.join(dir, 'agent-gate.json');
+    const policyPath = path.join(dir, 'agents', 'agent-concurrency-policy.json');
+    const teamPlanPath = path.join(dir, 'team-plan.json');
     const proof = await readJson(proofPath, null);
     const gate = await readJson(gatePath, null);
+    const policy = await readJson(policyPath, null);
+    const teamPlan = await readJson(teamPlanPath, null);
+    const expectedAgentCount = Math.max(DEFAULT_AGENT_COUNT, Number(gate?.expected_agent_count ||
+        teamPlan?.bundle_size ||
+        policy?.agents ||
+        DEFAULT_AGENT_COUNT) || DEFAULT_AGENT_COUNT);
     const missing = [];
     if (!(await exists(proofPath)))
         missing.push('agents/agent-proof-evidence.json');
@@ -32,8 +40,11 @@ export async function readAgentGateStatus(root, missionId) {
         blockers.push('agent_proof_not_ok');
     if (proof?.status !== 'passed')
         blockers.push('agent_proof_status_not_passed');
-    if (Number(proof?.agent_count || 0) < 5)
+    const agentCount = Number(proof?.agent_count || 0);
+    if (agentCount < DEFAULT_AGENT_COUNT)
         blockers.push('agent_count_below_5');
+    if (agentCount < expectedAgentCount)
+        blockers.push('agent_count_below_expected');
     if (proof?.no_overlap_ok !== true)
         blockers.push('agent_no_overlap_not_ok');
     if (proof?.ledger_hash_chain_ok !== true)
@@ -52,6 +63,7 @@ export async function readAgentGateStatus(root, missionId) {
         source: proofPath,
         proof,
         gate,
+        expected_agent_count: expectedAgentCount,
         all_sessions_closed: sessionsClosed
     };
 }

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

@@ -127,6 +127,7 @@ export declare function runNativeAgentOrchestrator(opts?: AgentRunOptions): Prom
         status: string;
         blockers: string[];
     };
+    visual_lane_count?: never;
     native_cli_session_proof?: never;
     no_subagent_scaling_policy?: never;
     fast_mode_policy?: never;
@@ -194,6 +195,7 @@ export declare function runNativeAgentOrchestrator(opts?: AgentRunOptions): Prom
     requested_work_items: number;
     actual_total_work_items: any;
     target_active_slots: number;
+    visual_lane_count: number;
     minimum_work_items: number;
     scheduler: {
         schema: string;
@@ -590,6 +592,7 @@ export declare function runNativeAgentOrchestrator(opts?: AgentRunOptions): Prom
         all_generations_closed: boolean;
         scheduler_state: string;
         target_active_slots: number;
+        visual_lane_count: number;
         requested_work_items: number;
         actual_total_work_items: number;
         minimum_work_items: number;

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

@@ -79,6 +79,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         })
     }));
     const targetActiveSlots = normalizeTargetActiveSlots(opts.targetActiveSlots ?? opts.agents ?? roster.agent_count, maxAgentCount);
+    const visualLaneCount = normalizeVisualLaneCount(opts.visualLaneCount ?? opts.clones ?? opts.agents ?? roster.agent_count, roster.agent_count, maxAgentCount);
     const desiredWorkItemCount = normalizeDesiredWorkItemCount(opts.desiredWorkItemCount, opts.minimumWorkItems, targetActiveSlots);
     const minimumWorkItems = normalizeMinimumWorkItems(opts.minimumWorkItems, targetActiveSlots);
     const sourceIntelligence = await runSourceIntelligence({ root, missionDir: dir, route, query: prompt, offline: true, context7Available: true });
@@ -195,7 +196,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
     await writeIntelligentWorkGraphArtifacts(ledgerRoot, partition.intelligent_work_graph);
     await writeScoutPolicyArtifact(ledgerRoot);
     await writeZellijRightLaneCockpit(ledgerRoot, { missionId, sessionName: `sks-${missionId}`, agents: roster.roster });
-    await initializeZellijLaneSupervisor(ledgerRoot, { missionId, sessionName: `sks-${missionId}`, targetActiveSlots, launchRealZellij: realZellij });
+    await initializeZellijLaneSupervisor(ledgerRoot, { missionId, sessionName: `sks-${missionId}`, targetActiveSlots: visualLaneCount, launchRealZellij: realZellij });
     await writeZellijPaneProof(root, { missionId, require: realZellijProofRequired, phase: 'initial', ledgerRoot });
     await writeAgentCodexCockpitArtifacts(dir, { missionId, projectHash: namespace.root_hash });
     await writeJsonAtomic(path.join(ledgerRoot, 'agent-no-overlap-proof.json'), partition.no_overlap_proof || { schema: 'sks.agent-no-overlap-proof.v1', ok: false, blockers: ['missing_no_overlap_proof'] });
@@ -209,6 +210,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         concurrency: roster.concurrency,
         batch_count: 0,
         target_active_slots: targetActiveSlots,
+        visual_lane_count: visualLaneCount,
         desired_work_items: desiredWorkItemCount,
         minimum_work_items: minimumWorkItems,
         requested_work_items: desiredWorkItemCount,
@@ -404,6 +406,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         minimumWorkItems,
         targetActiveSlots,
         realParallel: backend === 'codex-exec' && opts.mock !== true,
+        visualLaneCount,
         roster,
         partition,
         consensus,
@@ -442,6 +445,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         requested_work_items: desiredWorkItemCount,
         actual_total_work_items: partition.task_graph?.total_work_items || partition.slices.length,
         target_active_slots: targetActiveSlots,
+        visual_lane_count: visualLaneCount,
         minimum_work_items: minimumWorkItems,
         scheduler,
         source_intelligence: sourceIntelligenceRef,
@@ -724,6 +728,16 @@ function normalizeMinimumWorkItems(value, targetActiveSlots) {
         return Math.max(1, Math.floor(targetActiveSlots));
     return Math.max(1, Math.floor(parsed));
 }
+function normalizeVisualLaneCount(value, fallback, maxAgentCount) {
+    const parsed = Number(value);
+    const fallbackCount = Number(fallback);
+    const raw = Number.isFinite(parsed) && parsed > 0
+        ? parsed
+        : Number.isFinite(fallbackCount) && fallbackCount > 0
+            ? fallbackCount
+            : 1;
+    return Math.max(1, Math.min(maxAgentCount, Math.floor(raw)));
+}
 function isWriteCapableRun(opts) {
     return opts.applyPatches === true || opts.dryRunPatches === true || (opts.writeMode !== undefined && opts.writeMode !== 'off');
 }

package/dist/core/agents/agent-proof-evidence.d.ts

@@ -7,6 +7,7 @@ export declare function writeAgentProofEvidence(root: string, input: {
     requestedWorkItems?: number;
     minimumWorkItems?: number;
     targetActiveSlots?: number;
+    visualLaneCount?: number;
     realParallel?: boolean;
     roster?: any;
     partition?: any;
@@ -97,6 +98,7 @@ export declare function writeAgentProofEvidence(root: string, input: {
     all_generations_closed: boolean;
     scheduler_state: string;
     target_active_slots: number;
+    visual_lane_count: number;
     requested_work_items: number;
     actual_total_work_items: number;
     minimum_work_items: number;

package/dist/core/agents/agent-proof-evidence.js

@@ -47,6 +47,7 @@ export async function writeAgentProofEvidence(root, input) {
     const workQueueTotalWorkItems = Number(workQueue?.total_work_items || 0);
     const schedulerTotalWorkItems = Number(scheduler?.total_work_items || 0);
     const targetActiveSlots = Number(input.targetActiveSlots || scheduler?.target_active_slots || taskGraph?.target_active_slots || input.roster?.agent_count || 0);
+    const visualLaneCount = Number(input.visualLaneCount || zellijLanes?.lane_count || laneSupervisor?.lane_count || targetActiveSlots || 0);
     const minimumWorkItems = Number(input.minimumWorkItems || taskGraph?.minimum_work_items || targetActiveSlots || 0);
     const taskGraphMatchesCliOptions = Boolean(taskGraph) && requestedWorkItems === taskGraphTotalWorkItems && targetActiveSlots === Number(taskGraph.target_active_slots || 0);
     const workQueueMatchesTaskGraph = Boolean(workQueue && taskGraph) && workQueueTotalWorkItems === taskGraphTotalWorkItems;
@@ -111,6 +112,7 @@ export async function writeAgentProofEvidence(root, input) {
         ...(terminalCloseReportCount < generationCount ? ['terminal_close_report_count_below_generation_count'] : []),
         ...(slots && slots.all_slots_closed_after_drain !== true ? ['agent_worker_slots_not_closed_after_drain'] : []),
         ...(!laneSupervisor ? ['zellij_lane_supervisor_missing'] : []),
+        ...(laneSupervisor && visualLaneCount > 0 && Number(laneSupervisor.lane_count || 0) < visualLaneCount ? ['zellij_lane_count_below_visual_lane_count'] : []),
         ...(laneSupervisor && laneSupervisor.no_flicker_verified !== true ? ['zellij_lane_no_flicker_not_verified'] : []),
         ...(laneSupervisor && laneSupervisor.pane_survival_checked !== true ? ['zellij_lane_survival_not_checked'] : []),
         ...(laneSupervisor && Number(laneSupervisor.unexpected_close_count || 0) > 0 ? ['zellij_lane_unexpected_close_before_drain'] : []),
@@ -206,6 +208,7 @@ export async function writeAgentProofEvidence(root, input) {
         all_generations_closed: generations.ok,
         scheduler_state: 'agent-scheduler-state.json',
         target_active_slots: targetActiveSlots,
+        visual_lane_count: visualLaneCount,
         requested_work_items: requestedWorkItems,
         actual_total_work_items: taskGraphTotalWorkItems || schedulerTotalWorkItems,
         minimum_work_items: minimumWorkItems,

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/agent-schema.d.ts

@@ -96,6 +96,7 @@ export interface AgentRunOptions {
     noFast?: boolean;
     nativeCliSwarm?: boolean;
     maxAgentCount?: number;
+    visualLaneCount?: number;
     clones?: number;
     narutoMode?: boolean;
 }

package/dist/core/agents/route-collaboration-ledger.d.ts

@@ -186,6 +186,7 @@ export declare function writeRouteCollaborationArtifacts(root: string, opts: {
             status: string;
             blockers: string[];
         };
+        visual_lane_count?: never;
         native_cli_session_proof?: never;
         no_subagent_scaling_policy?: never;
         fast_mode_policy?: never;
@@ -253,6 +254,7 @@ export declare function writeRouteCollaborationArtifacts(root: string, opts: {
         requested_work_items: number;
         actual_total_work_items: any;
         target_active_slots: number;
+        visual_lane_count: number;
         minimum_work_items: number;
         scheduler: {
             schema: string;
@@ -649,6 +651,7 @@ export declare function writeRouteCollaborationArtifacts(root: string, opts: {
             all_generations_closed: boolean;
             scheduler_state: string;
             target_active_slots: number;
+            visual_lane_count: number;
             requested_work_items: number;
             actual_total_work_items: number;
             minimum_work_items: number;

package/dist/core/agents/zellij-lane-supervisor.js

@@ -34,9 +34,13 @@ export async function updateZellijLaneSupervisorFromSlots(root, input) {
             targetActiveSlots: Math.max(1, input.slots.length || input.state?.target_active_slots || 1)
         });
     }
-    const laneBySlot = new Map(supervisor.lanes.map((lane) => [lane.slot_id, lane]));
-    const lanes = input.slots.map((slot, index) => {
-        const previous = laneBySlot.get(slot.slot_id) || createLane(input.missionId, supervisor.session_name, index + 1, nowIso());
+    const slotById = new Map(input.slots.map((slot) => [slot.slot_id, slot]));
+    const laneCount = Math.max(supervisor.lanes.length, input.slots.length);
+    const lanes = Array.from({ length: laneCount }, (_, index) => {
+        const previous = supervisor.lanes[index] || createLane(input.missionId, supervisor.session_name, index + 1, nowIso());
+        const slot = slotById.get(previous.slot_id);
+        if (!slot)
+            return previous;
         return {
             ...previous,
             current_session_id: slot.current_session_id,

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/fast-mode-command.d.ts

@@ -12,6 +12,57 @@ export declare function fastModeCommand(args?: string[]): Promise<void | {
     fast_mode: boolean;
     service_tier: import("../agents/fast-mode-policy.js").AgentServiceTier;
     disabled_by: "none" | "no-fast" | "service-tier-standard" | "preference-standard";
+    codex_fast_mode_repair: {
+        status: string;
+        reason: string;
+        config_path?: never;
+        backup_path?: never;
+        parse_smoke?: never;
+        error?: never;
+    } | {
+        status: string;
+        config_path: any;
+        backup_path: string | null;
+        parse_smoke: {
+            ok: boolean;
+            unterminated_multiline_string: boolean;
+            invalid_table_header: string | null;
+        };
+        reason?: never;
+        error?: never;
+    } | {
+        status: string;
+        config_path: any;
+        reason?: never;
+        backup_path?: never;
+        parse_smoke?: never;
+        error?: never;
+    } | {
+        status: string;
+        config_path: any;
+        parse_smoke: {
+            ok: boolean;
+            unterminated_multiline_string: boolean;
+            invalid_table_header: string | null;
+        };
+        reason?: never;
+        backup_path?: never;
+        error?: never;
+    } | {
+        status: string;
+        config_path: any;
+        backup_path: string | null;
+        reason?: never;
+        parse_smoke?: never;
+        error?: never;
+    } | {
+        status: string;
+        config_path: any;
+        error: any;
+        reason?: never;
+        backup_path?: never;
+        parse_smoke?: never;
+    } | null;
     policy: import("../agents/fast-mode-policy.js").FastModePolicy;
     dollar_commands: {
         on: string;