sneakoscope 2.0.18 → 3.0.1

package/README.md

@@ -1,10 +1,31 @@
-# Sneakoscope Codex
+<div align="center">
 
-Fast legacy-free proof-first Codex trust layer with image-based Voxel TriWiki.
+# 🔭 Sneakoscope Codex
 
-Sneakoscope Codex (`sks`) is a Codex CLI/App harness that makes repeatable Codex work auditable.
+**Proof-first Codex orchestration — massive parallel agent swarms you can actually watch, audit, and trust.**
 
-SKS does not try to clone every other harness. It focuses on one thing: making Codex work auditable, visual-evidence-bound, safety-gated, and reproducible through Completion Proof.
+[![npm version](https://img.shields.io/npm/v/sneakoscope?color=cb3837&logo=npm)](https://www.npmjs.com/package/sneakoscope)
+[![node](https://img.shields.io/badge/node-%3E%3D20.11-339933?logo=node.js&logoColor=white)](#requirements)
+[![license](https://img.shields.io/badge/license-MIT-blue)](#license)
+[![zellij](https://img.shields.io/badge/UI-Zellij%20stacked%20panes-1e90ff)](#mad-zellij-launch)
+
+`npm i -g sneakoscope` → `sks --mad` → watch up to **100 shadow-clone workers** code in parallel,<br/>each in a live Zellij pane, every claim backed by Completion Proof.
+
+</div>
+
+---
+
+Sneakoscope Codex (`sks`) is a Codex CLI/App harness that makes repeatable Codex work **auditable**. It does not try to clone every other harness. It focuses on one thing relentlessly: Codex work becomes visual-evidence-bound, safety-gated, and reproducible through Completion Proof.
+
+| | What you get |
+| --- | --- |
+| 🍥 **`$Naruto` swarm** | Up to 100 parallel clone workers behind a hardware-safe concurrency governor, lease-based parallel writes, and a scheduler that backfills idle slots while runnable work remains |
+| 🖥️ **Live Zellij cockpit** | Workers stack vertically as native Zellij stacked panes; each pane streams heartbeat, current file, tool events, and stdout tails every second |
+| 🧾 **Completion Proof** | Every serious route ends with schema-backed proof artifacts — no "trust me, it's done" |
+| 🛡️ **Safety gates** | DB/migration/destructive operations stay gated, 190+ release gate scripts, Honest Mode |
+| 🖼️ **Visual evidence** | Image Voxel TriWiki plus `$imagegen`/`gpt-image-2`-bound visual review flows |
+
+![Sneakoscope Codex Trust Layer](docs/assets/sneakoscope-architecture-pipeline.jpg)
 
 ## LLM Init Prompt for Hermes / OpenClaw Agent Builders
 
@@ -12,22 +33,20 @@ SKS does not try to clone every other harness. It focuses on one thing: making C
 Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-Codex](https://github.com/mandarange/Sneakoscope-Codex)] as the repo reference and [npm i -g sneakoscope] as the recommended global install command, then run the appropriate `sks` setup, doctor, Codex App, and proof checks for this repo. Keep generated SKS state out of source control unless documented, and record every version-facing change in CHANGELOG.md.
 ```
 
-![Sneakoscope Codex Trust Layer](docs/assets/sneakoscope-architecture-pipeline.jpg)
+## 🚀 Current Release
 
-## Current Release
+SKS **3.0.1** tracks Codex CLI `rust-v0.139.0`: capability detection for code-mode web search, preserved `oneOf`/`allOf` tool schemas, plugin marketplace `source`/cached catalog, the `-P` sandbox profile alias, and the multi-agent v2 `interrupt_agent` rename (accepted alongside `close_agent` in cockpit event classification). See [docs/codex-0.139-compat.md](docs/codex-0.139-compat.md).
 
-SKS **2.0.18** is the Codex 0.138 integration release: capability artifacts, Desktop `/app` handoff, plugin JSON inventory, image saved-path contracts, model-advertised effort order, account usage budget policy, and startup doctor checks.
+SKS 3.0.0 was the parallel-runtime stabilization release. The whole live-swarm experience — what you actually *see* while 5, 20, or 100 workers run — was rebuilt and proven end-to-end.
 
-What changed:
+What changed in 3.0.0:
 
-- `sks doctor` now reports Codex 0.138 feature readiness, plugin JSON inventory, candidate-only remote MCP servers, unavailable app templates, and repairable plugin discovery cache state.
-- QA-LOOP can write a Codex Desktop `/app` handoff artifact with `--app-handoff` or require it with `--app-handoff-required`; this never substitutes for Codex Chrome Extension web UI evidence.
-- Zellij slot panes and the right-column anchor surface pending QA `/app` handoffs so desktop review is visible during long native-agent runs.
-- Codex plugin detail JSON is normalized into `.sneakoscope/codex-plugin-inventory.json`, and plugin-provided remote MCP servers remain candidate-only until explicitly enabled under DB/Mad-DB safety policy.
-- Imagegen and QA image flows write `image-artifact-path-contract.json` with exact saved file paths and follow-up edit hints.
-- Effort routing now understands the fallback order `minimal < low < medium < high < xhigh`, records model capability, and escalates QA effort after repeated failures.
-- Codex account token usage can be recorded from an app-server usage endpoint, and QA budget policy reduces remote concurrency near limits while preserving GPT final review.
-- Naruto final pass status now depends on the parallel runtime proof, and Mad-DB post-tool lifecycle recording handles MCP `isError` failures.
+- **Slot panes are finally alive.** The watch renderer froze for entire missions because the telemetry snapshot cache never invalidated; snapshot reads are now mtime-aware, multi-process flushes merge instead of clobbering each other, and the disk `updated_at` stays authoritative for stale detection.
+- **One SLOTS column, vertical stack.** Concurrent workers used to race anchor creation and split the screen into N side-by-side columns. Anchor + worker pane creation is serialized per session, and workers join a native Zellij stacked-pane group (`new-pane --stacked`, opt out with `SKS_ZELLIJ_WORKER_STACKED=0`).
+- **Live renderer is the default worker pane.** `full-debug` showed nothing until worker exit (workers run with `--json`); the default `compact-slots` renderer streams heartbeat, current file, tool events, and stdout tails every second.
+- **Zellij stays current like Codex does.** `sks --mad` / `sks naruto run` offer a `[Y/n]` upgrade to the latest stable Zellij (GitHub releases lookup, 6h cache), plus an explicit `sks zellij update [--yes]` subcommand and `SKS_SKIP_ZELLIJ_UPDATE` escape.
+- **Faster, honest dispatch.** Scheduler batch telemetry writes run concurrently per batch instead of serializing two file writes per worker; naruto backpressure throttling (50%/25% under host pressure) is reported in the run header instead of staying silent.
+- **Wired, not decorative.** The naruto finalizer gate and the agent message bus now run in production paths; dead swarm code (`naruto-work-stealing`, `zellij-right-column-layout-proof`) was removed.
 
 Quick checks:
 
@@ -62,7 +81,7 @@ npm run codex-control:all-pipelines
 
 Broader release checks still live behind `npm run release:check`. Detailed release history is in [CHANGELOG.md](CHANGELOG.md), and release readiness is tracked in [docs/release-readiness.md](docs/release-readiness.md).
 
-## Parallelism, UX, And Integrations
+## 🍥 Parallelism, UX, And Integrations
 
 - **Extreme parallel fan-out (`$Naruto` / native agents).** Each clone is a separate CLI worker that spends almost all of its wall-clock awaiting the Codex API, so live concurrency scales by **memory and the provider rate limit, not CPU cores** — a capable host can run up to 100 workers in parallel. The 429/rate-limit backoff is handled by the centralized responses retry policy. Tune it with `SKS_NARUTO_MAX_CONCURRENCY` (hard cap, 1–100), `SKS_NARUTO_GB_PER_WORKER` (memory budget per worker), and `SKS_NARUTO_MIN_CONCURRENCY` (low-free-memory floor).
 
@@ -88,7 +107,7 @@ Broader release checks still live behind `npm run release:check`. Detailed relea
 
 - **CLI-only SKS update notices.** Codex App hooks no longer stop normal work to ask for an SKS update. CLI launch surfaces such as `sks --mad` print a non-blocking latest-version notice, `sks update-check` / `sks update check` show the explicit status, and `sks doctor --fix` runs the guarded global SKS update path before repair.
 
-## Retention And Cleanup
+## 🧹 Retention And Cleanup
 
 SKS keeps durable learning context separate from disposable route work files. Durable context includes `.sneakoscope/memory/**`, shared TriWiki records, `.sneakoscope/wiki/context-pack.json`, wrongness memory, image voxels, avoidance rules, route Completion Proof, trust reports, evidence indexes, reflections, and agent proof summaries. These files are treated as the long-term learning and audit chain.
 
@@ -103,68 +122,105 @@ npm run retention:cleanup-safety
 
 The cleanup contract is policy-backed in `.sneakoscope/policy.json`, but the default posture is now immediate cleanup for short-lived temp files while preserving long-term SKS learning and proof artifacts.
 
-## Documentation
+## 📚 Documentation
+
+<details>
+<summary><b>Core concepts & architecture</b> — proof, trust, pipeline design</summary>
 
 - Completion Proof: [docs/completion-proof.md](docs/completion-proof.md)
-- TypeScript architecture: [docs/typescript-architecture.md](docs/typescript-architecture.md)
 - Trust Kernel: [docs/trust-kernel.md](docs/trust-kernel.md)
+- Pipeline architecture: [docs/pipeline-architecture.md](docs/pipeline-architecture.md)
+- TypeScript architecture: [docs/typescript-architecture.md](docs/typescript-architecture.md)
+- Runtime truth matrix: [docs/runtime-truth-matrix.md](docs/runtime-truth-matrix.md)
+- Fake vs real proof policy: [docs/fake-vs-real-proof-policy.md](docs/fake-vs-real-proof-policy.md)
+- Core dominance: [docs/core-dominance.md](docs/core-dominance.md)
+- Permission kernel: [docs/permission-kernel.md](docs/permission-kernel.md)
+- Immutable harness guard: [docs/immutable-harness-guard.md](docs/immutable-harness-guard.md)
+- Package boundary: [docs/package-boundary.md](docs/package-boundary.md)
+- Managed paths: [docs/managed-paths.md](docs/managed-paths.md)
+- Performance budgets: [docs/performance-budgets.md](docs/performance-budgets.md)
+- Route finalization: [docs/route-finalization.md](docs/route-finalization.md)
+- Rust accelerator: [docs/rust-accelerator.md](docs/rust-accelerator.md)
+
+</details>
+
+<details>
+<summary><b>Agents & parallelism</b> — Naruto swarm, worker panes, parallel writes</summary>
+
+- Naruto massive parallel swarm: [docs/naruto.md](docs/naruto.md)
+- Native Agent Kernel: [docs/native-agent-kernel.md](docs/native-agent-kernel.md)
+- Native agent engines: [docs/native-agent-engines.md](docs/native-agent-engines.md)
+- Native CLI Session Swarm: [docs/native-cli-session-swarm.md](docs/native-cli-session-swarm.md)
+- No-subagent scaling: [docs/no-subagent-scaling.md](docs/no-subagent-scaling.md)
+- Parallel write agents: [docs/parallel-write-agents.md](docs/parallel-write-agents.md)
+- Agent patch queue: [docs/agent-patch-queue.md](docs/agent-patch-queue.md)
+- Strategy-first parallel write: [docs/strategy-first-parallel-write.md](docs/strategy-first-parallel-write.md)
+- Intelligent work graph: [docs/intelligent-work-graph.md](docs/intelligent-work-graph.md)
+- Agent terminal lanes: [docs/agent-terminal-lanes.md](docs/agent-terminal-lanes.md)
+- Agent cleanup executor: [docs/agent-cleanup-executor.md](docs/agent-cleanup-executor.md)
+- MCP readOnly scheduler: [docs/mcp-readonly-scheduler.md](docs/mcp-readonly-scheduler.md)
+- MAD-SKS: [docs/mad-sks.md](docs/mad-sks.md)
+- MAD-SKS rollback: [docs/mad-sks-rollback.md](docs/mad-sks-rollback.md)
+- ADHD orchestration gate: [docs/adhd-orchestrating-gate.md](docs/adhd-orchestrating-gate.md)
+- Zellij migration: [docs/migration/tmux-to-zellij.md](docs/migration/tmux-to-zellij.md)
+
+</details>
+
+<details>
+<summary><b>Memory & learning</b> — TriWiki, wrongness memory, fixtures</summary>
+
 - TriWiki Wrongness Memory: [docs/triwiki-wrongness-memory.md](docs/triwiki-wrongness-memory.md)
-- Git collaboration: [docs/git-collaboration.md](docs/git-collaboration.md)
-- Git hygiene: [docs/git-hygiene.md](docs/git-hygiene.md)
 - Shared TriWiki: [docs/shared-triwiki.md](docs/shared-triwiki.md)
 - Shared Wrongness Memory: [docs/shared-wrongness-memory.md](docs/shared-wrongness-memory.md)
-- Git policy: [docs/git-policy.md](docs/git-policy.md)
 - Wrongness Learning Loop: [docs/wrongness-learning-loop.md](docs/wrongness-learning-loop.md)
-- Package boundary: [docs/package-boundary.md](docs/package-boundary.md)
-- Black-box package tests: [docs/black-box-package-tests.md](docs/black-box-package-tests.md)
-- Codex CLI compatibility: [docs/codex-cli-compat.md](docs/codex-cli-compat.md)
-- MAD-SKS rollback: [docs/mad-sks-rollback.md](docs/mad-sks-rollback.md)
-- MAD-SKS: [docs/mad-sks.md](docs/mad-sks.md)
-- Permission kernel: [docs/permission-kernel.md](docs/permission-kernel.md)
-- Immutable harness guard: [docs/immutable-harness-guard.md](docs/immutable-harness-guard.md)
+- Image Voxel TriWiki: [docs/image-voxel-ledger.md](docs/image-voxel-ledger.md)
+- Image Wrongness: [docs/image-wrongness.md](docs/image-wrongness.md)
+- Feature fixtures: [docs/feature-fixtures.md](docs/feature-fixtures.md)
+
+</details>
+
+<details>
+<summary><b>Codex integration</b> — App, CLI compat, codex-lb, hooks</summary>
+
 - Codex App: [docs/codex-app.md](docs/codex-app.md)
-- Core dominance: [docs/core-dominance.md](docs/core-dominance.md)
-- Performance budgets: [docs/performance-budgets.md](docs/performance-budgets.md)
-- Native Agent Kernel: [docs/native-agent-kernel.md](docs/native-agent-kernel.md)
+- Codex CLI compatibility: [docs/codex-cli-compat.md](docs/codex-cli-compat.md)
+- Codex official Goal mode: [docs/codex-official-goal-mode.md](docs/codex-official-goal-mode.md)
+- Codex App Hooks/PAT: [docs/hooks-pat.md](docs/hooks-pat.md)
+- codex-lb: [docs/codex-lb.md](docs/codex-lb.md)
 - Source Intelligence Layer: [docs/source-intelligence-layer.md](docs/source-intelligence-layer.md)
 - X AI / Context7 / Codex Web policy: [docs/xai-context7-codex-web-policy.md](docs/xai-context7-codex-web-policy.md)
 - Main no-Scout / worker Scout policy: [docs/main-no-scout-worker-scout-policy.md](docs/main-no-scout-worker-scout-policy.md)
-- Agent terminal lanes: [docs/agent-terminal-lanes.md](docs/agent-terminal-lanes.md)
-- Zellij migration: [docs/migration/tmux-to-zellij.md](docs/migration/tmux-to-zellij.md)
 - Real Codex dynamic smoke: [docs/real-codex-dynamic-smoke.md](docs/real-codex-dynamic-smoke.md)
-- Agent cleanup executor: [docs/agent-cleanup-executor.md](docs/agent-cleanup-executor.md)
-- Intelligent work graph: [docs/intelligent-work-graph.md](docs/intelligent-work-graph.md)
-- Fake vs real proof policy: [docs/fake-vs-real-proof-policy.md](docs/fake-vs-real-proof-policy.md)
-- Runtime truth matrix: [docs/runtime-truth-matrix.md](docs/runtime-truth-matrix.md)
-- ADHD orchestration gate: [docs/adhd-orchestrating-gate.md](docs/adhd-orchestrating-gate.md)
-- Strategy-first parallel write: [docs/strategy-first-parallel-write.md](docs/strategy-first-parallel-write.md)
 - Appshots pipeline: [docs/appshots-pipeline.md](docs/appshots-pipeline.md)
 - Appshots thread attachments: [docs/appshots-thread-attachments.md](docs/appshots-thread-attachments.md)
-- MCP readOnly scheduler: [docs/mcp-readonly-scheduler.md](docs/mcp-readonly-scheduler.md)
-- Parallel write agents: [docs/parallel-write-agents.md](docs/parallel-write-agents.md)
-- Agent patch queue: [docs/agent-patch-queue.md](docs/agent-patch-queue.md)
-- Native CLI Session Swarm: [docs/native-cli-session-swarm.md](docs/native-cli-session-swarm.md)
-- No-subagent scaling: [docs/no-subagent-scaling.md](docs/no-subagent-scaling.md)
 - Fast mode default and `$Fast-On`/`$Fast-Off` toggles: [docs/fast-mode-default.md](docs/fast-mode-default.md)
-- Migration 1.18.7 to 1.18.8: [docs/migration-1.18.7-to-1.18.8.md](docs/migration-1.18.7-to-1.18.8.md)
-- Codex official Goal mode: [docs/codex-official-goal-mode.md](docs/codex-official-goal-mode.md)
+
+</details>
+
+<details>
+<summary><b>Git & collaboration</b></summary>
+
+- Git collaboration: [docs/git-collaboration.md](docs/git-collaboration.md)
+- Git hygiene: [docs/git-hygiene.md](docs/git-hygiene.md)
+- Git policy: [docs/git-policy.md](docs/git-policy.md)
+
+</details>
+
+<details>
+<summary><b>Quality & release</b> — gates, E2E, migrations, gaps</summary>
+
+- Release readiness: [docs/release-readiness.md](docs/release-readiness.md)
 - Release parallel full coverage: [docs/release-parallel-full-coverage.md](docs/release-parallel-full-coverage.md)
 - Priority closure P0-P4: [docs/priority-closure-p0-p4.md](docs/priority-closure-p0-p4.md)
-- Image Voxel TriWiki: [docs/image-voxel-ledger.md](docs/image-voxel-ledger.md)
-- Image Wrongness: [docs/image-wrongness.md](docs/image-wrongness.md)
-- Route finalization: [docs/route-finalization.md](docs/route-finalization.md)
-- Feature fixtures: [docs/feature-fixtures.md](docs/feature-fixtures.md)
-- Managed paths: [docs/managed-paths.md](docs/managed-paths.md)
+- Black-box package tests: [docs/black-box-package-tests.md](docs/black-box-package-tests.md)
+- Hermetic E2E: [docs/testing-hermetic-e2e.md](docs/testing-hermetic-e2e.md)
 - Rollback: [docs/rollback.md](docs/rollback.md)
 - Known gaps: [docs/known-gaps.md](docs/known-gaps.md)
-- Native agent engines: [docs/native-agent-engines.md](docs/native-agent-engines.md)
-- Hermetic E2E: [docs/testing-hermetic-e2e.md](docs/testing-hermetic-e2e.md)
-- Pipeline architecture: [docs/pipeline-architecture.md](docs/pipeline-architecture.md)
-- Rust accelerator: [docs/rust-accelerator.md](docs/rust-accelerator.md)
-- Codex App Hooks/PAT: [docs/hooks-pat.md](docs/hooks-pat.md)
-- codex-lb: [docs/codex-lb.md](docs/codex-lb.md)
+- Migration 1.18.7 to 1.18.8: [docs/migration-1.18.7-to-1.18.8.md](docs/migration-1.18.7-to-1.18.8.md)
+
+</details>
 
-## 60-second start
+## ⚡ 60-Second Start
 
 Recommended install: use the global npm package so `sks` and the Codex App `$` skills are refreshed together.
 
@@ -183,13 +239,13 @@ sks selftest --mock
 sks rust smoke --json
 ```
 
-## Three core promises
+## 🤝 Three Core Promises
 
 1. Completion Proof for every serious route
 2. Image Voxel TriWiki anchors and relations for every visual route
 3. Route contracts, evidence indexes, wrongness memory, trust reports, Codex App, codex-lb, hooks, Rust fallback parity, DB, route modularity, and generated fixtures verified by release gates
 
-## Install
+## 📦 Install
 
 Recommended path:
 
@@ -234,7 +290,7 @@ sks commit --json
 sks selftest --mock
 ```
 
-## What Sneakoscope Adds
+## 🎁 What Sneakoscope Adds
 
 `sks` adds a Zellij-backed Codex CLI runtime, Codex App `$` commands, Team/QA/PPT/Research/DB/GX/Wiki routes, OpenClaw and Hermes skill generation, Context7-gated current docs, TriWiki context packs, DB safety, design SSOT policy, skill dreaming, release checks, and Honest Mode.
 
@@ -270,7 +326,7 @@ Project setup writes shared `.gitignore` entries for generated SKS files: `.snea
 
 During npm postinstall, SKS installs generated Codex App skills and tries `skills add MohtashamMurshid/getdesign` when the `skills` CLI is available. Design work still flows through one authority: `design.md`.
 
-## Terminal CLI Usage
+## 💻 Terminal CLI Usage
 
 Use terminal commands when you want to inspect, set up, verify, or start a CLI-first workspace.
 
@@ -478,7 +534,7 @@ $PPT create a customer proposal deck as HTML/PDF
 
 `$PPT` seals presentation context before artifact work and grounds design in `design.md`, getdesign inputs, and source material. The route loads `imagegen`; when the sealed deck needs generated raster assets or generated slide visual critique, use Codex App `$imagegen`/`gpt-image-2` and record the real output path in the PPT image/review ledgers.
 
-## Codex App Usage
+## 🧩 Codex App Usage
 
 Sneakoscope has two surfaces:
 
@@ -562,7 +618,7 @@ SKS does not install Git pre-commit hooks. Release metadata is changed only by e
 
 TriWiki is intentionally sparse: `sks wiki sweep` records demote, soft-forget, archive, delete, promote-to-skill, and promote-to-rule candidates instead of injecting every old claim into future prompts. `sks harness fixture` validates the broader Harness Growth Factory contract: deliberate forgetting fixtures, skill card metadata, experiment schema, tool-error taxonomy, permission profiles, MultiAgentV2 defaults, and tmux cockpit view coverage. `sks code-structure scan` flags handwritten files above 1000/2000/3000-line thresholds so new logic can be extracted before command files become harder to maintain.
 
-## OpenClaw And Hermes Agent Usage
+## 🤖 OpenClaw And Hermes Agent Usage
 
 Sneakoscope can generate an OpenClaw skill package for agents that need to operate SKS-enabled repositories.
 
@@ -600,7 +656,7 @@ SKS_HERMES=1 sks dollar-commands --json
 SKS_HERMES=1 sks status --json
 ```
 
-## Prompt `$` Commands
+## 💬 Prompt `$` Commands
 
 Use these inside Codex App or another agent prompt. They are prompt commands, not terminal commands.
 
@@ -608,7 +664,7 @@ Common prompts: `$Team`, `$From-Chat-IMG`, `$with-local-llm-on`, `$with-local-ll
 
 `$MAD-DB` is the prompt-visible Mad-DB alias for one-cycle DB break-glass work. It maps to the same guarded MAD-SKS permission route, while the terminal lifecycle remains `sks mad-db status|enable|revoke`; it is not a permanent DB unlock and catastrophic DB safeguards remain active.
 
-## Common Workflows
+## 🔁 Common Workflows
 
 First install:
 
@@ -637,7 +693,7 @@ sks wiki refresh
 sks wiki validate .sneakoscope/wiki/context-pack.json
 ```
 
-## Safety Model
+## 🛡️ Safety Model
 
 Sneakoscope intentionally treats these as high-risk:
 
@@ -649,7 +705,7 @@ Sneakoscope intentionally treats these as high-risk:
 
 By default, SKS favors inspection, local files, branch-safe changes, explicit confirmation for destructive DB operations, and completion claims backed by tests or artifacts.
 
-## Troubleshooting
+## 🔧 Troubleshooting
 
 ### `sks` points to an old version
 
@@ -735,7 +791,7 @@ sks wiki validate .sneakoscope/wiki/context-pack.json
 
 Finalization requires evidence, valid Team cleanup artifacts, reflection when required, and Honest Mode.
 
-## Development And Release
+## 🏗️ Development And Release
 
 Run local checks:
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "2.0.18"
+version = "3.0.1"
 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 2.0.18"),
+        Some("--version") => println!("sks-rs 3.0.1"),
         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": "2.0.18",
-  "source_digest": "3c246288e22bf5f29b5ba20a2a05b3f15a6afb9e6d680c531f7e78ef996c8c33",
-  "source_file_count": 2238,
-  "built_at_source_time": 1780992531184
+  "package_version": "3.0.1",
+  "source_digest": "5c97e638daf3eab1aeac1eaa644b771787a9d8cfd1a9756e7ab4e76a7aba523e",
+  "source_file_count": 2265,
+  "built_at_source_time": 1781080652355
 }

package/dist/bin/sks.js

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

package/dist/commands/mad-sks.js

@@ -1,10 +1,12 @@
 import { madHighCommand } from '../core/commands/mad-sks-command.js';
 import { ensureMadLaunchDependencies, formatMadLaunchDependencyAction, maybePromptCodexUpdateForLaunch, maybePromptCodexLbSetupForLaunch, maybePromptSksUpdateForLaunch } from '../cli/install-helpers.js';
+import { maybePromptZellijUpdateForLaunch } from '../core/zellij/zellij-update.js';
 import { PACKAGE_VERSION } from '../core/fsx.js';
 export async function run(_command, args = []) {
     return madHighCommand(['--mad-sks', ...args], {
         maybePromptSksUpdateForLaunch,
         maybePromptCodexUpdateForLaunch,
+        maybePromptZellijUpdateForLaunch,
         ensureMadLaunchDependencies,
         printDepsInstallAction: (action) => console.error(formatMadLaunchDependencyAction(action)),
         maybePromptCodexLbSetupForLaunch,

package/dist/commands/zellij.js

@@ -4,6 +4,7 @@ import { projectRoot, readJson } from '../core/fsx.js';
 import { flag } from '../cli/args.js';
 import { printJson } from '../cli/output.js';
 import { checkZellijCapability } from '../core/zellij/zellij-capability.js';
+import { checkZellijUpdateNotice, upgradeZellijToLatest } from '../core/zellij/zellij-update.js';
 import { runZellij } from '../core/zellij/zellij-command.js';
 import { appendZellijLaneCommand, normalizeZellijSlot } from '../core/zellij/zellij-lane-runtime.js';
 import { buildZellijDashboardSnapshot, renderZellijDashboardText } from '../core/zellij/zellij-dashboard-renderer.js';
@@ -22,6 +23,8 @@ export async function run(_command = 'zellij', args = []) {
     const root = await projectRoot();
     if (sub === 'help')
         return printHelp(json);
+    if (sub === 'update' || sub === 'upgrade')
+        return zellijUpdate(args, json);
     if (sub === 'repair')
         return zellijRepair(root, args, json);
     if (sub === 'dispatch' || sub === 'send')
@@ -73,6 +76,58 @@ async function zellijStatus(root, args, json) {
     if (!result.ok)
         process.exitCode = 1;
 }
+async function zellijUpdate(args, json) {
+    const apply = flag(args, '--yes') || flag(args, '-y') || flag(args, '--apply');
+    const notice = await checkZellijUpdateNotice({});
+    if (!apply || !notice.update_available) {
+        const result = {
+            schema: 'sks.zellij-update-command.v1',
+            subcommand: 'update',
+            ok: !notice.error,
+            mode: apply ? 'apply' : 'check',
+            current_version: notice.current_version,
+            latest_version: notice.latest_version,
+            update_available: notice.update_available,
+            zellij_missing: notice.zellij_missing,
+            source: notice.source,
+            upgrade_command: notice.upgrade_command,
+            message: notice.message,
+            next_actions: notice.update_available ? ['Apply with: sks zellij update --yes'] : [],
+            error: notice.error || null
+        };
+        if (json)
+            printJson(result);
+        else {
+            console.log(notice.message);
+            if (notice.update_available)
+                console.log('Apply with: sks zellij update --yes');
+        }
+        if (notice.error && !notice.latest_version)
+            process.exitCode = 1;
+        return;
+    }
+    const upgraded = await upgradeZellijToLatest({});
+    const result = {
+        schema: 'sks.zellij-update-command.v1',
+        subcommand: 'update',
+        ok: upgraded.status === 'upgraded' || upgraded.status === 'installed' || upgraded.status === 'noop',
+        mode: 'apply',
+        status: upgraded.status,
+        before_version: upgraded.before_version,
+        after_version: upgraded.after_version,
+        latest_version: upgraded.latest_version,
+        command: upgraded.command,
+        error: upgraded.error || null
+    };
+    if (json)
+        printJson(result);
+    else if (result.ok)
+        console.log(`Zellij ${upgraded.before_version || 'unknown'} -> ${upgraded.after_version || upgraded.latest_version || 'latest'} (${upgraded.command})`);
+    else
+        console.log(`Zellij update ${upgraded.status}: ${upgraded.error || upgraded.command}`);
+    if (!result.ok)
+        process.exitCode = 1;
+}
 async function zellijFocusWorker(root, args, json) {
     const missionId = resolveMissionId(root, readOption(args, '--mission', readOption(args, '--mission-id', 'latest') || 'latest') || 'latest');
     const slotId = normalizeZellijSlot(readOption(args, '--slot', positionalAfter(args, 'focus-worker') || 'slot-001'));
@@ -265,9 +320,10 @@ function printHelp(json) {
         schema: ZELLIJ_COMMAND_SCHEMA,
         subcommand: 'help',
         ok: true,
-        usage: 'sks zellij status|repair|dispatch|send|focus-worker|worker-logs|dashboard|close-drained [--json]',
+        usage: 'sks zellij status|update|repair|dispatch|send|focus-worker|worker-logs|dashboard|close-drained [--json]',
         subcommands: {
             status: 'Report Zellij runtime capability and interactive-route readiness.',
+            update: 'Check the latest stable Zellij release; apply the upgrade with --yes (Homebrew).',
             repair: 'Explain how to install/repair Zellij (no automatic install).',
             dispatch: 'Append a nonblocking JSONL command for a lane; optionally write to a reconciled pane id with --write-pane.',
             send: 'Alias for dispatch.',
@@ -283,6 +339,7 @@ function printHelp(json) {
     else {
         console.log('sks zellij — inspect and repair the Zellij interactive runtime');
         console.log('  sks zellij status [--require-real] [--json]');
+        console.log('  sks zellij update [--yes] [--json]');
         console.log('  sks zellij repair [--explain] [--json]');
         console.log('  sks zellij dispatch --mission M --slot slot-001 --text "..." [--write-pane] [--json]');
         console.log('  sks zellij focus-worker slot-001 [--mission M] [--json]');

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

@@ -144,30 +144,38 @@ export async function runAgentScheduler(input) {
                 batch_id: batchId,
                 meta: { launch_count: launches.length, active_count_before: active.size }
             }).catch(() => undefined);
+            // Telemetry appends run concurrently across launches (per-slot ordering
+            // preserved inside each async chain). Awaiting these file writes in
+            // series before each dispatch serialized worker launch by 2 disk writes
+            // per slot — with 20 slots that is 40 sequential appends before the last
+            // worker even started.
+            const dispatchTelemetryWrites = [];
             for (const launch of launches) {
                 const { slot, openedSlot, generation, agent, workItem } = launch;
-                await appendParallelRuntimeEvent(input.root, input.missionId, {
-                    event_type: 'slot_reserved',
-                    slot_id: slot.slot_id,
-                    generation_index: generation.generation_index,
-                    session_id: generation.session_id,
-                    pid: null,
-                    backend: 'scheduler',
-                    placement: 'unknown',
-                    batch_id: batchId,
-                    meta: { work_item_id: workItem.id }
-                }).catch(() => undefined);
-                await appendParallelRuntimeEvent(input.root, input.missionId, {
-                    event_type: 'worker_launch_invoked',
-                    slot_id: slot.slot_id,
-                    generation_index: generation.generation_index,
-                    session_id: generation.session_id,
-                    pid: null,
-                    backend: 'scheduler',
-                    placement: 'unknown',
-                    batch_id: batchId,
-                    meta: { work_item_id: workItem.id }
-                }).catch(() => undefined);
+                dispatchTelemetryWrites.push((async () => {
+                    await appendParallelRuntimeEvent(input.root, input.missionId, {
+                        event_type: 'slot_reserved',
+                        slot_id: slot.slot_id,
+                        generation_index: generation.generation_index,
+                        session_id: generation.session_id,
+                        pid: null,
+                        backend: 'scheduler',
+                        placement: 'unknown',
+                        batch_id: batchId,
+                        meta: { work_item_id: workItem.id }
+                    }).catch(() => undefined);
+                    await appendParallelRuntimeEvent(input.root, input.missionId, {
+                        event_type: 'worker_launch_invoked',
+                        slot_id: slot.slot_id,
+                        generation_index: generation.generation_index,
+                        session_id: generation.session_id,
+                        pid: null,
+                        backend: 'scheduler',
+                        placement: 'unknown',
+                        batch_id: batchId,
+                        meta: { work_item_id: workItem.id }
+                    }).catch(() => undefined);
+                })());
                 const promise = Promise.resolve()
                     .then(() => input.launchSession({ agent, workItem, generation, slot: openedSlot, queue, state }))
                     .then((result) => ({
@@ -212,14 +220,14 @@ export async function runAgentScheduler(input) {
                 accumulateActiveSlotTime();
                 active.set(generation.session_id, { slot_id: slot.slot_id, work_item_id: workItem.id, session_id: generation.session_id, promise });
             }
+            await Promise.all(dispatchTelemetryWrites);
             await appendAgentWorkQueueEvent(input.root, 'batch_work_items_dispatched', {
                 batch_id: batchId,
                 launch_count: launches.length,
                 session_ids: launches.map((launch) => launch.generation.session_id),
                 work_item_ids: launches.map((launch) => launch.workItem.id)
             });
-            for (const launch of launches)
-                await appendAgentWorkQueueEvent(input.root, 'work_item_dispatched', { work_item_id: launch.workItem.id, session_id: launch.generation.session_id, slot_id: launch.slot.slot_id });
+            await Promise.all(launches.map((launch) => appendAgentWorkQueueEvent(input.root, 'work_item_dispatched', { work_item_id: launch.workItem.id, session_id: launch.generation.session_id, slot_id: launch.slot.slot_id })));
             if (backfill) {
                 const firstLaunch = launches[0];
                 const refillLatencyMs = Math.max(0, Date.now() - backfill.closed_at_ms);

package/dist/core/agents/native-cli-session-swarm.js

@@ -11,6 +11,7 @@ import { buildZellijSlotPaneCommand } from '../zellij/zellij-slot-pane-renderer.
 import { resolveZellijWorkerPaneUiMode } from '../zellij/zellij-ui-mode.js';
 import { appendZellijSlotTelemetry } from '../zellij/zellij-slot-telemetry.js';
 import { appendParallelRuntimeEvent } from './parallel-runtime-proof.js';
+import { appendAgentMessage } from './agent-message-bus.js';
 export const NATIVE_CLI_SESSION_SWARM_SCHEMA = 'sks.agent-native-cli-session-swarm.v1';
 export function createNativeCliSessionSwarmRecorder(root, input) {
     return new NativeCliSessionSwarmRecorder(root, input);
@@ -625,6 +626,15 @@ class NativeCliSessionSwarmRecorder {
             log_tail: input.logTail || '',
             blockers: input.blockers || []
         }).catch(() => undefined);
+        if (input.eventType === 'worker_completed' || input.eventType === 'worker_failed') {
+            await appendAgentMessage(this.root, {
+                from: String(ctx.agent?.slot_id || ctx.agent?.id || 'worker'),
+                session_id: ctx.agent?.session_id == null ? '' : String(ctx.agent.session_id),
+                to: 'orchestrator',
+                type: input.eventType,
+                body: input.logTail || input.eventType
+            }).catch(() => undefined);
+        }
         const parallelEvent = mapTelemetryToParallelEvent(input.eventType);
         if (parallelEvent) {
             await appendParallelRuntimeEvent(this.root, this.input.missionId, {
@@ -653,6 +663,12 @@ class NativeCliSessionSwarmRecorder {
     summary() {
         const closed = this.records.filter((row) => row.status === 'closed');
         const processIds = this.records.map((row) => row.pid).filter((pid) => Number.isFinite(Number(pid)));
+        // Both pane-backed primitives count as zellij pane worker sessions: the
+        // worker command can run inside the pane (full-debug) or headless behind a
+        // live slot renderer pane (compact-slots default). Counting only the
+        // former under-reported pane sessions as 0 in the default UI mode.
+        const paneBackedRecords = this.records.filter((row) => row.scaling_primitive === 'native_cli_process_in_zellij_worker_pane'
+            || row.scaling_primitive === 'native_cli_process_with_zellij_slot_renderer');
         return {
             schema: NATIVE_CLI_SESSION_SWARM_SCHEMA,
             generated_at: nowIso(),
@@ -660,8 +676,12 @@ class NativeCliSessionSwarmRecorder {
             mission_id: this.input.missionId,
             route: this.input.route,
             backend: this.input.backend,
-            scaling_primitive: this.records.some((row) => row.scaling_primitive === 'native_cli_process_in_zellij_worker_pane') ? 'native_cli_process_in_zellij_worker_pane' : 'native_cli_process',
-            zellij_pane_worker_sessions: this.records.filter((row) => row.scaling_primitive === 'native_cli_process_in_zellij_worker_pane').length,
+            scaling_primitive: this.records.some((row) => row.scaling_primitive === 'native_cli_process_in_zellij_worker_pane')
+                ? 'native_cli_process_in_zellij_worker_pane'
+                : paneBackedRecords.length
+                    ? 'native_cli_process_with_zellij_slot_renderer'
+                    : 'native_cli_process',
+            zellij_pane_worker_sessions: paneBackedRecords.length,
             requested_agents: this.input.requestedAgents,
             target_active_slots: this.input.targetActiveSlots,
             spawned_worker_process_count: this.records.length,