sneakoscope 0.9.13 → 0.9.15

package/README.md

@@ -1,8 +1,29 @@
 # Sneakoscope Codex
 
-Fast proof-first Codex trust layer with image-based Voxel TriWiki.
+Fast legacy-free proof-first Codex trust layer with image-based Voxel TriWiki.
 
-Sneakoscope Codex (`sks`) is a Codex CLI/App harness for repeatable workflows. It adds terminal commands, Codex App `$` commands, tmux workspaces, Team/QA/Research routes, pipeline plans, Computer Use, imagegen UI/UX review, Goal, Context7, DB safety, Voxel TriWiki, design-system routing, skill dreaming, completion proof, and Honest Mode.
+Sneakoscope Codex (`sks`) is a Codex CLI/App harness that makes repeatable Codex work auditable. `0.9.15` runs through split command modules, automatically seals serious routes with Completion Proof, binds visual/UI claims to Image Voxel TriWiki anchors and relations, and release-gates hooks, codex-lb, executable fixtures, Rust parity, and DB safety evidence.
+
+## 0.9.15 Current Release
+
+`0.9.15` preserves the 0.9.14 legacy-free trust layer and fixes global npm postinstall auto-bootstrap.
+
+`0.9.14` turned SKS into a legacy-free proof-first trust layer for Codex work:
+
+- Command registry entries load independent command modules without runtime fallback to archived 0.9.13 CLI bundles.
+- Serious routes write Completion Proof through the central route finalizer before completion is claimed.
+- Visual/UI routes require Image Voxel TriWiki anchors, with before/after relations for visual fix claims.
+- Executable feature fixtures validate expected artifact existence and schema contracts.
+- Hook replay strictly matches decision, reason, gate, issues, continuation, and redaction policy.
+- codex-lb launch failures feed both global and active-project circuit health; stateless `previous_response_not_found` stays a warning.
+- Rust `image-hash` and semantic `voxel-validate` commands match JS fallback behavior.
+- `$Commit` and `$Commit-And-Push` provide a simple git-only route for staging, committing, and optionally pushing without the full SKS pipeline.
+
+Learn more:
+- Completion Proof: [docs/completion-proof.md](docs/completion-proof.md)
+- Image Voxel TriWiki: [docs/image-voxel-ledger.md](docs/image-voxel-ledger.md)
+- Codex App Hooks/PAT: [docs/hooks-pat.md](docs/hooks-pat.md)
+- codex-lb: [docs/codex-lb.md](docs/codex-lb.md)
 
 ## 60-second start
 
@@ -16,28 +37,20 @@ sks selftest --mock
 
 ## Three core promises
 
-1. Image-based Voxel TriWiki memory
-2. Codex App / codex-lb operational readiness
-3. Completion proof for every serious route
+1. Completion Proof for every serious route
+2. Image Voxel TriWiki anchors and relations for every visual route
+3. Codex App, codex-lb, hooks, Rust, DB, and fixtures verified by release gates
 
-## Quick Start
+## Install Options
 
 Install globally, then run `sks` from either a project or any global shell location:
 
 ```sh
 npm i -g sneakoscope
 sks root
-sks
+sks doctor
 ```
 
-`0.9.13` connects serious routes to Completion Proof, visual routes to image voxel anchors, hook replay to shared runtime policy, codex-lb launch failures to circuit health, and Rust accelerator commands to JS fallback parity. Rust accelerator source is included in the npm package; until prebuilt binaries ship, SKS uses JS fallbacks unless `SKS_RS_BIN` or a source-checkout `sks-rs` binary is available.
-
-Learn more:
-- Completion Proof: [docs/completion-proof.md](docs/completion-proof.md)
-- Image Voxel TriWiki: [docs/image-voxel-ledger.md](docs/image-voxel-ledger.md)
-- Codex App Hooks/PAT: [docs/hooks-pat.md](docs/hooks-pat.md)
-- codex-lb: [docs/codex-lb.md](docs/codex-lb.md)
-
 `npm i -g sneakoscope` automatically refreshes the `sks` command shim, global Codex App `$` skills, and SKS bootstrap surface. When the install is run from a project, postinstall bootstraps that project. When it is run outside a repo/project marker, postinstall bootstraps the per-user global runtime root instead of writing `.sneakoscope` into a random current directory. `sks root` tells you which root SKS will use.
 
 If you only want a one-shot run without keeping `sks` installed globally:
@@ -59,6 +72,7 @@ Check that the install is usable:
 sks deps check
 sks codex-app check
 sks dollar-commands
+sks commit --json
 sks selftest --mock
 ```
 
@@ -66,32 +80,11 @@ sks selftest --mock
 
 `sks` adds a tmux Codex CLI runtime, Codex App `$` commands, Team/QA/PPT/Research/DB/GX/Wiki routes, OpenClaw skill generation, Context7-gated current docs, TriWiki context packs, DB safety, design SSOT policy, skill dreaming, release checks, and Honest Mode.
 
-## 0.8.0 Massive Upgrade
-
-Sneakoscope 0.8.0 introduces the RecallPulse planning spine: a report-only active-recall layer that records what the pipeline should remember before a stage proceeds. RecallPulse maps TriWiki into L1/L2/L3 cache behavior, writes durable status ledgers instead of relying on ephemeral hook text, suppresses duplicate reminder loops, and emits RouteProofCapsule plus EvidenceEnvelope artifacts for later gate comparison. These artifacts are evidence surfaces first; speed or accuracy gains remain benchmark-gated until scored evals prove them.
-
-Inspect the new report-only artifacts with:
-
-```sh
-sks recallpulse run latest
-sks recallpulse status latest --json
-sks recallpulse eval latest --json
-sks recallpulse governance latest --json
-sks recallpulse checklist latest --json
-sks recallpulse checklist latest --task T001 --apply --evidence src/core/recallpulse.mjs
-```
-
-Research scouts now use named persona-inspired cognitive lenses: Einstein Scout, Feynman Scout, Turing Scout, von Neumann Scout, and Skeptic Scout. They are not impersonations; each scout ledger row must carry `display_name`, `persona`, `persona_boundary`, `reasoning_effort=xhigh`, a literal `Eureka!` idea, falsifiers, cheap probes, and debate participation evidence.
-
-For existing 0.7.x users, the visible change is new report-only evidence, not a route personality rewrite. Team still feels like Team, DFix stays ultralight, DB remains conservative, QA-LOOP still dogfoods, PPT stays information-first, imagegen still requires real raster evidence, and Honest Mode remains the final truth pass. The original strong reminder idea became neutral RecallPulse so user-facing prompts stay short, professional, and non-repetitive; hook messages can point at status, but `mission-status-ledger.json` is the durable source when app-visible text disappears. The planning source is `docs/RECALLPULSE_0_8_0_TASKS.md`, and implementation is designed to land in safe task-sized slices before any enforcement promotion.
-
-## 0.9.0 Report-Only Decision Lattice
-
-Sneakoscope 0.9.0 adds a report-only Decision Lattice planner that uses A* over proof-debt signals to explain which route or verification path the pipeline would prefer. It is an evidence and planning surface, not a runtime shortcut: SKS must not claim speedup, fast-lane accuracy, or reduced verification cost from the lattice until replay or scored eval evidence demonstrates those outcomes.
+## Report-Only Planning Surfaces
 
-The lattice integrates with the existing proof-field and `sks pipeline plan` surfaces. Its reports are expected to show the explored frontier, the selected path, and rejected paths with their proof-debt reasons, so reviewers can audit why a route stayed on the full Team/Honest path or why a smaller verification plan was only proposed. Like RecallPulse, this is designed to land as report-only evidence first; route enforcement and performance claims remain gated by later validation.
+Decision Lattice and RecallPulse remain report-only planning and evidence surfaces. They can explain route choices and proof-debt signals, but SKS does not claim speedup, fast-lane accuracy, or reduced verification cost from them until scored evals prove those outcomes.
 
-Quick checks:
+Useful checks:
 
 ```bash
 sks proof-field scan --json --intent "small CLI change"

package/crates/sks-core/Cargo.lock

@@ -2,6 +2,104 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
 [[package]]
 name = "sks-core"
-version = "0.9.13"
+version = "0.9.15"
+dependencies = [
+ "serde_json",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"

package/crates/sks-core/Cargo.toml

@@ -1,9 +1,10 @@
 [package]
 name = "sks-core"
-version = "0.9.13"
+version = "0.9.15"
 edition = "2021"
 
 [dependencies]
+serde_json = "1"
 
 [[bin]]
 name = "sks-rs"

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 0.9.13"),
+        Some("--version") => println!("sks-rs 0.9.15"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);
@@ -40,9 +40,15 @@ fn main() {
         }
         Some("voxel-validate") => {
             let path = args.next().unwrap_or_default();
+            let mut require_anchors = false;
+            let mut require_relations = false;
+            while let Some(arg) = args.next() {
+                if arg == "--require-anchors" { require_anchors = true; }
+                if arg == "--require-relations" { require_relations = true; }
+            }
             match std::fs::read_to_string(&path) {
                 Ok(text) => {
-                    let report = voxel_validate(&text);
+                    let report = voxel_validate(&text, require_anchors, require_relations);
                     println!("{}", report);
                     if report.contains("\"ok\":false") { std::process::exit(1); }
                 }
@@ -139,52 +145,80 @@ fn sha256_hex(data: &[u8]) -> String {
     h.iter().map(|x| format!("{:08x}", x)).collect::<String>()
 }
 
-fn voxel_validate(text: &str) -> String {
-    let mut issues: Vec<&str> = Vec::new();
-    if !text.contains("\"schema\"") || !text.contains("sks.image-voxel-ledger.v1") { issues.push("schema"); }
-    if !text.contains("\"images\"") { issues.push("missing_images"); }
-    if !text.contains("\"anchors\"") { issues.push("missing_anchors"); }
-    let image_count = count_object_entries(text, "images");
-    let anchor_count = count_object_entries(text, "anchors");
-    if image_count == 0 { issues.push("missing_images"); }
-    if anchor_count == 0 { issues.push("missing_anchors"); }
-    issues.sort();
-    issues.dedup();
-    let ok = issues.is_empty();
-    let issue_json = issues.iter().map(|x| format!("\"{}\"", json_escape(x))).collect::<Vec<_>>().join(",");
-    format!("{{\"ok\":{},\"engine\":\"rust\",\"schema\":\"sks.image-voxel-ledger.v1\",\"images\":{},\"anchors\":{},\"issues\":[{}]}}", if ok { "true" } else { "false" }, image_count, anchor_count, issue_json)
-}
-
-fn count_object_entries(text: &str, key: &str) -> usize {
-    let marker = format!("\"{}\"", key);
-    let Some(start) = text.find(&marker) else { return 0; };
-    let Some(open) = text[start..].find('[').map(|i| start + i) else { return 0; };
-    let mut depth = 0i32;
-    let mut entries = 0usize;
-    let mut in_string = false;
-    let mut escape = false;
-    for ch in text[open..].chars() {
-        if escape {
-            escape = false;
-            continue;
+fn voxel_validate(text: &str, require_anchors: bool, require_relations: bool) -> String {
+    let parsed: serde_json::Value = match serde_json::from_str(text) {
+        Ok(value) => value,
+        Err(err) => {
+            return format!("{{\"ok\":false,\"engine\":\"rust\",\"schema\":\"sks.image-voxel-ledger.v1\",\"images\":0,\"anchors\":0,\"relations\":0,\"issues\":[\"json_parse\"],\"error\":\"{}\"}}", json_escape(&err.to_string()));
         }
-        if ch == '\\' && in_string {
-            escape = true;
-            continue;
+    };
+    let mut issues: Vec<String> = Vec::new();
+    if parsed.get("schema").and_then(|v| v.as_str()) != Some("sks.image-voxel-ledger.v1") { issues.push("schema".to_string()); }
+    let images = parsed.get("images").and_then(|v| v.as_array()).cloned().unwrap_or_default();
+    let anchors = parsed.get("anchors").and_then(|v| v.as_array()).cloned().unwrap_or_default();
+    let relations = parsed.get("relations").and_then(|v| v.as_array()).cloned().unwrap_or_default();
+    if !parsed.get("images").map(|v| v.is_array()).unwrap_or(false) { issues.push("missing_images".to_string()); }
+    if !parsed.get("anchors").map(|v| v.is_array()).unwrap_or(false) { issues.push("missing_anchors".to_string()); }
+    if require_anchors && anchors.is_empty() { issues.push("missing_anchors:visual-route".to_string()); }
+    if require_relations && relations.is_empty() { issues.push("missing_relations:visual-route".to_string()); }
+    let mut image_ids: Vec<String> = Vec::new();
+    let mut anchor_ids: Vec<String> = Vec::new();
+    for image in &images {
+        let id = image.get("id").and_then(|v| v.as_str()).unwrap_or("");
+        if id.is_empty() { issues.push("image_id".to_string()); }
+        if !id.is_empty() && image_ids.iter().any(|x| x == id) { issues.push(format!("duplicate_image:{}", id)); }
+        if !id.is_empty() { image_ids.push(id.to_string()); }
+        if image.get("path").and_then(|v| v.as_str()).unwrap_or("").is_empty() { issues.push(format!("image_path:{}", if id.is_empty() { "unknown" } else { id })); }
+        if image.get("sha256").and_then(|v| v.as_str()).unwrap_or("").is_empty() { issues.push(format!("image_sha256:{}", if id.is_empty() { "unknown" } else { id })); }
+        let w = image.get("width").and_then(|v| v.as_f64());
+        let h = image.get("height").and_then(|v| v.as_f64());
+        if !w.map(|n| n.is_finite()).unwrap_or(false) || !h.map(|n| n.is_finite()).unwrap_or(false) {
+            issues.push(format!("image_dimensions:{}", if id.is_empty() { "unknown" } else { id }));
         }
-        if ch == '"' {
-            in_string = !in_string;
-            continue;
+    }
+    for anchor in &anchors {
+        let id = anchor.get("id").and_then(|v| v.as_str()).unwrap_or("");
+        if id.is_empty() { issues.push("anchor_id".to_string()); }
+        if !id.is_empty() && anchor_ids.iter().any(|x| x == id) { issues.push(format!("duplicate_anchor:{}", id)); }
+        if !id.is_empty() { anchor_ids.push(id.to_string()); }
+        let image_id = anchor.get("image_id").and_then(|v| v.as_str()).unwrap_or("");
+        if image_id.is_empty() || !image_ids.iter().any(|x| x == image_id) { issues.push(format!("anchor_image_ref:{}", if id.is_empty() { "unknown" } else { id })); }
+        let image = images.iter().find(|img| img.get("id").and_then(|v| v.as_str()) == Some(image_id));
+        let w = image.and_then(|img| img.get("width")).and_then(|v| v.as_f64()).unwrap_or(f64::NAN);
+        let h = image.and_then(|img| img.get("height")).and_then(|v| v.as_f64()).unwrap_or(f64::NAN);
+        match anchor.get("bbox").and_then(|v| v.as_array()) {
+            Some(bbox) if bbox.len() == 4 => {
+                let vals: Vec<f64> = bbox.iter().map(|v| v.as_f64().unwrap_or(f64::NAN)).collect();
+                if vals.iter().any(|n| !n.is_finite()) { issues.push(format!("bbox_number:{}", if id.is_empty() { "unknown" } else { id })); }
+                if vals[2] <= 0.0 || vals[3] <= 0.0 { issues.push(format!("bbox_positive:{}", if id.is_empty() { "unknown" } else { id })); }
+                if w.is_finite() && vals[0] + vals[2] > w {
+                    issues.push(format!("bbox_width_out_of_bounds:{}", if id.is_empty() { "unknown" } else { id }));
+                }
+                if h.is_finite() && vals[1] + vals[3] > h {
+                    issues.push(format!("bbox_height_out_of_bounds:{}", if id.is_empty() { "unknown" } else { id }));
+                }
+            }
+            Some(_) => issues.push(format!("bbox_shape:{}", if id.is_empty() { "unknown" } else { id })),
+            None => issues.push(format!("anchor_bbox:{}", if id.is_empty() { "unknown" } else { id })),
+        }
+    }
+    for relation in &relations {
+        if let Some(before) = relation.get("before_image_id").and_then(|v| v.as_str()) {
+            if !image_ids.iter().any(|x| x == before) { issues.push(format!("relation_before:{}", before)); }
+        }
+        if let Some(after) = relation.get("after_image_id").and_then(|v| v.as_str()) {
+            if !image_ids.iter().any(|x| x == after) { issues.push(format!("relation_after:{}", after)); }
         }
-        if in_string { continue; }
-        if ch == '[' { depth += 1; }
-        else if ch == ']' {
-            depth -= 1;
-            if depth == 0 { break; }
+        let changed = relation.get("changed_anchor_ids").or_else(|| relation.get("anchors")).and_then(|v| v.as_array()).cloned().unwrap_or_default();
+        for anchor_id in changed.iter().filter_map(|v| v.as_str()) {
+            if !anchor_ids.iter().any(|x| x == anchor_id) { issues.push(format!("relation_anchor:{}", anchor_id)); }
         }
-        else if ch == '{' && depth == 1 { entries += 1; }
     }
-    entries
+    issues.sort();
+    issues.dedup();
+    let ok = issues.is_empty();
+    let issue_json = issues.iter().map(|x| format!("\"{}\"", json_escape(x))).collect::<Vec<_>>().join(",");
+    format!("{{\"ok\":{},\"engine\":\"rust\",\"schema\":\"sks.image-voxel-ledger.v1\",\"images\":{},\"anchors\":{},\"relations\":{},\"issues\":[{}]}}", if ok { "true" } else { "false" }, images.len(), anchors.len(), relations.len(), issue_json)
 }
 
 fn json_escape(value: &str) -> String {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "0.9.13",
+  "version": "0.9.15",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -37,22 +37,25 @@
     "postinstall": "node ./bin/sks.mjs postinstall",
     "selftest": "node ./bin/sks.mjs selftest --mock",
     "doctor": "node ./bin/sks.mjs doctor",
-    "packcheck": "find bin src scripts -name '*.mjs' -print0 | xargs -0 -n1 node --check",
+    "packcheck": "find bin src scripts test -name '*.mjs' -print0 | xargs -0 -n1 node --check",
     "changelog:check": "node ./scripts/changelog-check.mjs",
     "cli-entrypoint:check": "node ./scripts/check-cli-entrypoint.mjs",
-    "legacy-budget:check": "node ./scripts/check-legacy-budget.mjs",
+    "legacy-free:check": "node ./scripts/check-legacy-free.mjs",
     "sizecheck": "node ./scripts/sizecheck.mjs",
     "registry:check": "node ./scripts/release-registry-check.mjs",
     "feature:check": "node ./bin/sks.mjs features check --json",
     "all-features:selftest": "node ./bin/sks.mjs all-features selftest --mock --json",
-    "all-features:execute-fixtures": "node ./bin/sks.mjs all-features selftest --mock --execute-fixtures --json",
+    "all-features:execute-fixtures": "node ./bin/sks.mjs all-features selftest --mock --execute-fixtures --strict-artifacts --json",
     "perf:cold-start": "node ./bin/sks.mjs perf cold-start --json",
     "perf:gate": "node ./scripts/perf-gate.mjs",
     "test": "node --test \"test/**/*.test.mjs\"",
     "test:unit": "node --test \"test/unit/**/*.test.mjs\"",
     "test:integration:mock": "node --test \"test/integration/**/*.test.mjs\"",
+    "test:e2e:mock": "node --test \"test/e2e/**/*.test.mjs\"",
+    "rust:check": "cargo check --manifest-path crates/sks-core/Cargo.toml",
+    "rust:smoke": "node ./scripts/rust-smoke.mjs",
     "coverage": "node --experimental-test-coverage --test \"test/**/*.test.mjs\"",
-    "release:check": "npm run repo-audit && npm run changelog:check && npm run cli-entrypoint:check && npm run legacy-budget:check && npm run packcheck && npm run feature:check && npm run all-features:selftest && npm run all-features:execute-fixtures && npm run selftest && npm run test:unit && npm run test:integration:mock && npm run perf:gate && npm run sizecheck && npm run registry:check",
+    "release:check": "npm run repo-audit && npm run changelog:check && npm run cli-entrypoint:check && npm run legacy-free:check && npm run packcheck && npm run feature:check && npm run all-features:selftest && npm run all-features:execute-fixtures && npm run selftest && npm run test:unit && npm run test:integration:mock && npm run test:e2e:mock && npm run rust:check && npm run rust:smoke && npm run perf:gate && npm run sizecheck && npm run registry:check",
     "publish:dry": "npm run release:check && npm --cache /tmp/sks-npm-cache publish --dry-run --registry https://registry.npmjs.org/ --access public",
     "publish:npm": "npm --cache /tmp/sks-npm-cache publish --registry https://registry.npmjs.org/ --access public",
     "prepublishOnly": "npm run release:check && node ./scripts/release-registry-check.mjs --require-unpublished"