@dzhechkov/cloudru-hub 0.1.14 → 0.1.15

package/.dz-manifest.json

@@ -5,7 +5,7 @@
     "files": [
       {
         "path": "CHANGELOG.md",
-        "sha256": "4d6d0e6f47b09b017a32e4f3287c0669821e61569835c397245e5077435f5b15"
+        "sha256": "2b0dbd83deb813844a658814b9a6fa1640f1e5255c676210e61dceaa6b42195b"
       },
       {
         "path": "LICENSE",
@@ -13,7 +13,7 @@
       },
       {
         "path": "README.md",
-        "sha256": "2c25bbd9659f1a02e2a7a5413de8673e8735d67e583458fdede75dfd032b6106"
+        "sha256": "4f6a2d5928fec42f021eb10471677b902e831b99d53096661a821f6460bd55a6"
       },
       {
         "path": "THIRD_PARTY_NOTICES.md",
@@ -39,6 +39,10 @@
         "path": "data/tools-list-snapshot.json",
         "sha256": "dff98bb859dfbbf8ed2fb6f16f17b767444cc2172ecc7684ca3df8188c95707c"
       },
+      {
+        "path": "docs/COST-COMPARE.md",
+        "sha256": "80b4d7ac3868f17d93565274cd6736fe5f2bd7fb059cbed0c2f0afe3f4924317"
+      },
       {
         "path": "docs/HERMES-CODEX.md",
         "sha256": "3605797972f9a7c79c13fbcce0cd9ac8b8fb3a8249abbab938f2b1a45f515420"
@@ -47,9 +51,13 @@
         "path": "docs/LOCAL-TESTING.md",
         "sha256": "de6f709e820fbb831f390e274238b28ba938644670a8db04fd50d1fa0d86da75"
       },
+      {
+        "path": "docs/cost-compare.example.json",
+        "sha256": "7eafb1ff555fb5443ded1a2c578b17eae6e73e3056efb9cbb5129b424c8c5097"
+      },
       {
         "path": "package.json",
-        "sha256": "d906ed1871af834274d77dbd3a345b168604456b15360f009a9474778273b11f"
+        "sha256": "1b355df670fb092da7ce8956141e702f9f78e1e2f2724c6aaba61bbab2acd8c8"
       },
       {
         "path": "src/classification.js",
@@ -57,7 +65,11 @@
       },
       {
         "path": "src/cli.js",
-        "sha256": "a22f3fcced6e9970e7bed6b935fc03637b6d4b8d3cd6cc65a2685595a6549c1c"
+        "sha256": "b1bd4a0ce7f1ca869c2873ca1979a74630483ee2909ff8b4f91189622f5aa2a7"
+      },
+      {
+        "path": "src/cost-compare.js",
+        "sha256": "6084ecd7f7fc53bbd441fb9e91dcd7c7bd5c409d1d4e95613fad0fd0735b7b05"
       },
       {
         "path": "src/credentials.js",
@@ -107,6 +119,10 @@
         "path": "test/classification.test.mjs",
         "sha256": "026e3031180ce9227b4d31775b9c886b10ad0cb418ed0754aed75b12ded84e31"
       },
+      {
+        "path": "test/cost-compare.test.mjs",
+        "sha256": "b354913220bf725ec6b8a708b7851e2f5779a3c594cd411732d19acad9001870"
+      },
       {
         "path": "test/deploy-approval.test.mjs",
         "sha256": "d72e4363fd50d0fcc65fd23b40601516bd73368c3659f2a55a394c4d1ed3f85c"
@@ -149,5 +165,5 @@
       }
     ]
   },
-  "signature": "l3G7HKnPVq9k2pUtMFbeaNybS7PUSGnlJAn3dSZvcXRKKQ4TEFmxYfgO4Urjw2spCra9M3UAkRVSJfkUX7zYCw=="
+  "signature": "dwHxhW1FRdiGNeOrlmZDXpWHEV3i/V9QenSrenI7+SvF6HNfxc1cM++fUKzWXZKRvTfbreooCqZHfcipil4vAw=="
 }

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog — @dzhechkov/cloudru-hub
 
+## Unreleased — staged, no version change
+
+- Add `cost-compare --input <json> [--json]`, an offline VM/Kubernetes cost worksheet
+  with explicit topology, dated tariff provenance, exact decimal sums and per-node
+  normal/failure capacity bounds. Incomplete prices, insufficient capacity or unknown
+  architecture equivalence suppress a winner. The packaged official-rate example
+  leaves traffic and equivalence unknown. See `docs/COST-COMPARE.md` for the schema
+  and limits. No engine or MCP tool changes are included.
+
 ## 0.1.14 — 2026-10-20
 
 - Prepare an exact optional dependency on `@dzhechkov/cloudru-vm-linux-x64@0.2.6`.

package/README.md

@@ -1,6 +1,6 @@
 # @dzhechkov/cloudru-hub
 
-Site: https://aicoding.space · Source: https://github.com/djd1m/dz-harness/tree/main/packages/@dzhechkov/cloudru-hub
+Site: https://aicoding.space · Source: https://github.com/djd1m/dz-harness/tree/main/packages/cloudru-hub
 
 > **Linux/x64 distribution:** version 0.1.14 installs the exact optional engine
 > package `@dzhechkov/cloudru-vm-linux-x64@0.2.6`. The `dz guard` `licence-hold`
@@ -42,12 +42,14 @@ The JS launcher remains MIT-licensed; its archive contains no Go engine bytes.
 | Target integration | `src/install.js`, `src/safe-mcp.js` | Codex, OpenCode and Pi get project MCP configs using a pinned proxy; Hermes gets a guarded `$HERMES_HOME/config.yaml` entry with a verified engine path. Claude Code's general install keeps its permissions and hook probe. The opt-in `vm-deploy` profile requires an exact-plan approval and confines remote commands to the returned VM. Codex, Hermes, OpenCode and Pi each completed both live static-site scenarios on 2026-10-20 with HTTP byte checks and exact resource cleanup. The `k8s-deploy` profile uses a separate exact-manifest approval and create-only Kubernetes operation; the same four hosts completed live Kubernetes deployment, readiness, exact-byte HTTP and cleanup checks. Claude Code has installer/registration checks but no live inference pass. |
 | Skill dialect compiler (ADR-006) | `src/dialects.js`, `data/dialects.json` | generates per-target variants of the canonical skill tree (which is NOT shipped — point `--canonical` at an engine distribution); hard-fails if any Hermes-dialect token survives AND if the engine codename survives in any case in any emitted file (positive invariant, not just the enumerated denylist); unlinks dangling links; enforces the 12 000-char router cap on lossy layouts; byte-deterministic |
 | Golden classification | `data/tools-classification.json` | every engine tool → allow/ask/deny; `allow` requires a BEHAVIOUR audit of the handler (read-only proven at the pinned baseline, engine file:line cited per entry). The previous `stack_status` behavior was unsafe; the imported engine now makes it observational and tests that invariant. A live tool unknown to the classifier is a drift finding. |
+| Offline cost worksheet | `src/cost-compare.js`, `docs/cost-compare.example.json` | compares supplied VM and Kubernetes topology, capacity and dated tariff lines with exact decimal arithmetic; needs no engine, credentials or network access |
 
 ## Usage
 
 ```bash
 cloudru-hub resolve                 # where is the engine, which sha256, is it the pinned baseline
 cloudru-hub self-test               # resolve → sha256 → engine version → live tools/list → coverage
+cloudru-hub cost-compare --input docs/cost-compare.example.json --json  # offline cost worksheet
 cloudru-hub mcp                     # run the engine as an MCP stdio server (what .mcp.json points at)
 cloudru-hub mcp-safe --toolsets inventory   # pinned MCP proxy with a small allow-classified surface
 cloudru-hub install --target codex --toolsets billing  # read-only balance, consumption and FinOps
@@ -65,6 +67,12 @@ cloudru-hub install --target agents-md     # pointer-only section (no tools, no
 cloudru-hub compile-skill --canonical <engine>/skill/cloudru-hub --target claude-code --out ./skill-out
 ```
 
+The [cost worksheet guide](docs/COST-COMPARE.md) describes the versioned input, supported
+units, exact calculations and limits. The packaged example uses checked official
+VAT-inclusive tariff rows but leaves traffic unpriced and architecture equivalence
+unknown; it therefore reports known subtotals with no winner. Supplied quantities
+and tariff applicability remain operator assumptions, not verified inventory or a live bill.
+
 ## Using an owner-supplied engine instead
 
 ```bash

package/docs/COST-COMPARE.md

@@ -0,0 +1,21 @@
+# Offline VM / Kubernetes cost worksheet
+
+Run from an installed package or this directory:
+
+```bash
+cloudru-hub cost-compare --input docs/cost-compare.example.json --json
+```
+
+The command reads one local JSON file and does not resolve the engine, request credentials, call Cloud.ru, create resources or refresh tariffs. `--json` prints exact line, category and known-subtotal decimal strings plus two-decimal display strings. Without it, the command prints a compact human summary. Invalid input exits nonzero and emits no partial JSON. Only `--input <path>` and one optional `--json` are accepted. The file must be a regular, non-symlink file of at most 128 KiB.
+
+The [runnable example](cost-compare.example.json) models 24 active hours. Its listed official tariff rows were checked on 2026-10-21 and are pinned as supplied metadata, not live prices or an applicability guarantee. It calculates known subtotals of **251.6616 RUB for VM** and **466.1376 RUB for Kubernetes**. Both leave traffic unpriced and architecture/HA equivalence unknown, so `winner` and `savingsRubExact` are `null`. The 60GB/80GB SSD allocations, IP counts, one Kubernetes SNAT and absence of load balancers are declared scenario assumptions. The worksheet cannot establish whether root, worker or control-plane volumes are separately charged for a real deployment.
+
+The v1 input has `schemaVersion: 1`, one decimal-string `horizonHours` (greater than zero, at most 8760), `currency: "RUB"`, and `vatBasis: "included"`. `workload` supplies integer `replicas`, `survivingReplicas` and `failedNodes`, plus decimal-string `cpuPerReplica` and `ramGBPerReplica`. Both scenarios share those targets. Raw JSON numeric tokens must be canonical non-negative safe integers; fractional, exponent, negative and oversized tokens are rejected before parsing. Decimal values belong in strings. Duplicate object member names are rejected at every depth, including escaped spellings of the same name. `equivalence` is either `{ "status": "unknown", "reason": "...", "assumptions": [...] }` or `{ "status": "assumed", "assumptions": ["..."] }`. An assumed comparison remains conditional; this tool has no verified-equivalence state.
+
+Exactly one `vm` and one `k8s` scenario are required, each with a unique `id`. Each declares homogeneous `nodes` (`count`, `cpu`, `ramGB`, `cpuShare`, `reservedCpu`, `reservedRamGB`), `controlPlaneCount`, `resources`, and all seven `categories`. CPU reservations are in guaranteed-core units: usable CPU is `cpu × cpuShare − reservedCpu`. Usable RAM is `ramGB − reservedRamGB`. Per-node replica slots are the smaller of the two exact decimal floors. Normal slots use all worker nodes; survival slots subtract the declared failed worker-node count. Control-plane instances are excluded from workload capacity. This is a numerical homogeneous packing bound, not proof of placement, scheduling, service performance, availability or SLA. Kubernetes requires a positive billed control-plane service count; VM requires zero.
+
+`resources` declares `storageGB`, `publicIpCount`, `snatGatewayCount`, `loadBalancerCount` and `trafficGB`. Storage and traffic are decimal strings; IP, SNAT and load-balancer counts are integers. `trafficGB` alone may be `null`, meaning usage is unknown and its category must be `unpriced` with a reason. Zero is an explicit declaration and requires `not-used`, never an implicit free charge. Every other positive or unknown declared quantity must be `priced` or `unpriced` with a reason. Compute cannot be `not-used`; VM control-plane must be `not-used`.
+
+Every category is `{ "status": "priced", "items": [...] }`, `{ "status": "not-used", "reason": "..." }`, or `{ "status": "unpriced", "reason": "..." }`. Priced items need a unique `id`, description, positive decimal-string `quantity` and `rateRub`, exact category unit, and tariff provenance `{ "url": "https://...", "version": "...", "asOf": "YYYY-MM-DD", "vatBasis": "included", "pageOrRow": "..." }` with optional lowercase SHA-256. The tariff URL and metadata are user assertions; they are checked for format and consistency, not fetched or certified. Supported units are `instance-hour` for compute/control-plane, `GB-hour` for storage, `IP-hour`, `gateway-hour`, `LB-hour`, and `traffic-GB`. Worker and control-plane instance counts and every other priced category quantity must sum exactly to their declared scenario counts or allocations. Traffic is charged once over the whole horizon; time units multiply by the common horizon. Monthly, tiered, stopped-resource and scheduled rates are outside v1.
+
+Exact decimal multiplication and summation precede display rounding. Each input decimal has at most nine fractional places, and file, topology, line-count, quantity, rate and result magnitudes are bounded. `knownSubtotalRubExact` is only a sum of priced lines, not a guaranteed lower bound on an actual bill. A winner appears only when both scenarios have all categories resolved, sufficient normal and declared node-failure capacity, and explicit assumed equivalence. It identifies the lower **modeled infrastructure cost under supplied assumptions**, with a tie reported separately. It is not a deployment recommendation. Discounts, taxes beyond the common VAT-inclusive basis, heterogeneous fleets, autoscaling, live billing, network traffic tariffs and real resource inventory need separate evidence.

package/docs/cost-compare.example.json

@@ -0,0 +1,84 @@
+{
+  "schemaVersion": 1,
+  "horizonHours": "24",
+  "currency": "RUB",
+  "vatBasis": "included",
+  "workload": {
+    "replicas": 3,
+    "cpuPerReplica": "1",
+    "ramGBPerReplica": "1",
+    "survivingReplicas": 2,
+    "failedNodes": 1
+  },
+  "equivalence": {
+    "status": "unknown",
+    "reason": "Application placement, availability and performance equivalence have not been verified.",
+    "assumptions": ["Both scenarios run the same three replicas for the full 24-hour horizon."]
+  },
+  "scenarios": [
+    {
+      "id": "vm",
+      "kind": "vm",
+      "nodes": { "count": 3, "cpu": "2", "ramGB": "4", "reservedCpu": "0", "reservedRamGB": "0", "cpuShare": "1" },
+      "controlPlaneCount": 0,
+      "resources": { "storageGB": "60", "publicIpCount": 3, "snatGatewayCount": 0, "loadBalancerCount": 0, "trafficGB": null },
+      "categories": {
+        "compute": { "status": "priced", "items": [{
+          "id": "vm-2cpu-4gb", "description": "Three active 2vCPU/4GB VM instances",
+          "quantity": "3", "unit": "instance-hour", "rateRub": "2.9707",
+          "tariff": { "url": "https://cdn.cloud.ru/docs/legal/tariffs/evolution/current-version/evolution-compute.pdf", "version": "261014", "asOf": "2026-10-21", "vatBasis": "included", "pageOrRow": "VM 2vCPU/4GB row 18", "sha256": "a459226e73c8db4dc650307f3f07d99d9f17be31e0e22cd65c7a360dc1685dc5" }
+        }] },
+        "controlPlane": { "status": "not-used", "reason": "VM scenario has no separately billed control-plane service." },
+        "storage": { "status": "priced", "items": [{
+          "id": "ssd-60gb", "description": "Assumed 60GB billed SSD allocation across the VM scenario",
+          "quantity": "60", "unit": "GB-hour", "rateRub": "0.01586",
+          "tariff": { "url": "https://cdn.cloud.ru/docs/legal/tariffs/evolution/current-version/evolution-compute.pdf", "version": "261014", "asOf": "2026-10-21", "vatBasis": "included", "pageOrRow": "SSD row 85", "sha256": "a459226e73c8db4dc650307f3f07d99d9f17be31e0e22cd65c7a360dc1685dc5" }
+        }] },
+        "publicIp": { "status": "priced", "items": [{
+          "id": "vm-public-ip", "description": "Three assumed active public IP allocations",
+          "quantity": "3", "unit": "IP-hour", "rateRub": "0.2074",
+          "tariff": { "url": "https://cdn.cloud.ru/docs/legal/tariffs/evolution/current-version/evolution-compute.pdf", "version": "261014", "asOf": "2026-10-21", "vatBasis": "included", "pageOrRow": "Public IP row 2", "sha256": "a459226e73c8db4dc650307f3f07d99d9f17be31e0e22cd65c7a360dc1685dc5" }
+        }] },
+        "snat": { "status": "not-used", "reason": "No SNAT gateway is declared in this VM scenario." },
+        "loadBalancer": { "status": "not-used", "reason": "No load balancer is declared; direct public IP exposure is assumed." },
+        "traffic": { "status": "unpriced", "reason": "Traffic quantity and applicable tariff are unknown; do not assume zero traffic cost." }
+      }
+    },
+    {
+      "id": "k8s",
+      "kind": "k8s",
+      "nodes": { "count": 3, "cpu": "2", "ramGB": "4", "reservedCpu": "0", "reservedRamGB": "0", "cpuShare": "1" },
+      "controlPlaneCount": 1,
+      "resources": { "storageGB": "80", "publicIpCount": 2, "snatGatewayCount": 1, "loadBalancerCount": 0, "trafficGB": null },
+      "categories": {
+        "compute": { "status": "priced", "items": [{
+          "id": "worker-2cpu-4gb", "description": "Three active 2vCPU/4GB Kubernetes workers",
+          "quantity": "3", "unit": "instance-hour", "rateRub": "2.9768",
+          "tariff": { "url": "https://cdn.cloud.ru/docs/legal/tariffs/evolution/current-version/managed-kubernetes.pdf", "version": "260918", "asOf": "2026-10-21", "vatBasis": "included", "pageOrRow": "Worker 2vCPU/4GB row 6", "sha256": "5493f6da595b67482277ca420512db8f7f953375536a6169db8d1b282f24f345" }
+        }] },
+        "controlPlane": { "status": "priced", "items": [{
+          "id": "zonal-master", "description": "One billed zonal control-plane service instance",
+          "quantity": "1", "unit": "instance-hour", "rateRub": "8.601",
+          "tariff": { "url": "https://cdn.cloud.ru/docs/legal/tariffs/evolution/current-version/managed-kubernetes.pdf", "version": "260918", "asOf": "2026-10-21", "vatBasis": "included", "pageOrRow": "Zonal master 2vCPU/4GB row 42", "sha256": "5493f6da595b67482277ca420512db8f7f953375536a6169db8d1b282f24f345" }
+        }] },
+        "storage": { "status": "priced", "items": [{
+          "id": "ssd-80gb", "description": "Assumed 80GB billed SSD allocation across the Kubernetes scenario",
+          "quantity": "80", "unit": "GB-hour", "rateRub": "0.01586",
+          "tariff": { "url": "https://cdn.cloud.ru/docs/legal/tariffs/evolution/current-version/managed-kubernetes.pdf", "version": "260918", "asOf": "2026-10-21", "vatBasis": "included", "pageOrRow": "SSD row 39", "sha256": "5493f6da595b67482277ca420512db8f7f953375536a6169db8d1b282f24f345" }
+        }] },
+        "publicIp": { "status": "priced", "items": [{
+          "id": "k8s-public-ip", "description": "Two assumed active public IP allocations",
+          "quantity": "2", "unit": "IP-hour", "rateRub": "0.2074",
+          "tariff": { "url": "https://cdn.cloud.ru/docs/legal/tariffs/evolution/current-version/managed-kubernetes.pdf", "version": "260918", "asOf": "2026-10-21", "vatBasis": "included", "pageOrRow": "Public IP row 40", "sha256": "5493f6da595b67482277ca420512db8f7f953375536a6169db8d1b282f24f345" }
+        }] },
+        "snat": { "status": "priced", "items": [{
+          "id": "public-snat", "description": "One assumed active public SNAT gateway",
+          "quantity": "1", "unit": "gateway-hour", "rateRub": "0.2074",
+          "tariff": { "url": "https://cdn.cloud.ru/docs/legal/tariffs/evolution/current-version/evolution-compute.pdf", "version": "261014", "asOf": "2026-10-21", "vatBasis": "included", "pageOrRow": "Public SNAT row 3", "sha256": "a459226e73c8db4dc650307f3f07d99d9f17be31e0e22cd65c7a360dc1685dc5" }
+        }] },
+        "loadBalancer": { "status": "not-used", "reason": "No load balancer is declared; the assumed application architecture avoids it." },
+        "traffic": { "status": "unpriced", "reason": "Traffic quantity and applicable tariff are unknown; do not assume zero traffic cost." }
+      }
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/cloudru-hub",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "licenseHold": {
     "adr": "features/hermes-claude-adaptation/03_adr/001-licence-and-provenance-precondition.md",
     "note": "SATISFIED hold. Timur is credited for substantial Cloud.ru API testing. The 2026-10-20 correction is in the historical grant record. This field keeps the dz guard licence-hold rule checking LICENSE, THIRD_PARTY_NOTICES and SPDX on every publish."
@@ -61,7 +61,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/djd1m/dz-harness.git",
-    "directory": "packages/@dzhechkov/cloudru-hub"
+    "directory": "packages/cloudru-hub"
   },
   "homepage": "https://aicoding.space",
   "bugs": {

package/sbom.json

@@ -15,7 +15,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "4d6d0e6f47b09b017a32e4f3287c0669821e61569835c397245e5077435f5b15"
+          "content": "2b0dbd83deb813844a658814b9a6fa1640f1e5255c676210e61dceaa6b42195b"
         }
       ]
     },
@@ -35,7 +35,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "2c25bbd9659f1a02e2a7a5413de8673e8735d67e583458fdede75dfd032b6106"
+          "content": "4f6a2d5928fec42f021eb10471677b902e831b99d53096661a821f6460bd55a6"
         }
       ]
     },
@@ -99,6 +99,16 @@
         }
       ]
     },
+    {
+      "type": "file",
+      "name": "docs/COST-COMPARE.md",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "80b4d7ac3868f17d93565274cd6736fe5f2bd7fb059cbed0c2f0afe3f4924317"
+        }
+      ]
+    },
     {
       "type": "file",
       "name": "docs/HERMES-CODEX.md",
@@ -119,6 +129,16 @@
         }
       ]
     },
+    {
+      "type": "file",
+      "name": "docs/cost-compare.example.json",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "7eafb1ff555fb5443ded1a2c578b17eae6e73e3056efb9cbb5129b424c8c5097"
+        }
+      ]
+    },
     {
       "type": "file",
       "name": "package.json",
@@ -129,7 +149,7 @@
         },
         {
           "name": "dz:canonical-json-sha256-v2",
-          "value": "d906ed1871af834274d77dbd3a345b168604456b15360f009a9474778273b11f"
+          "value": "1b355df670fb092da7ce8956141e702f9f78e1e2f2724c6aaba61bbab2acd8c8"
         }
       ]
     },
@@ -149,7 +169,17 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "a22f3fcced6e9970e7bed6b935fc03637b6d4b8d3cd6cc65a2685595a6549c1c"
+          "content": "b1bd4a0ce7f1ca869c2873ca1979a74630483ee2909ff8b4f91189622f5aa2a7"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "src/cost-compare.js",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "6084ecd7f7fc53bbd441fb9e91dcd7c7bd5c409d1d4e95613fad0fd0735b7b05"
         }
       ]
     },
@@ -273,6 +303,16 @@
         }
       ]
     },
+    {
+      "type": "file",
+      "name": "test/cost-compare.test.mjs",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "b354913220bf725ec6b8a708b7851e2f5779a3c594cd411732d19acad9001870"
+        }
+      ]
+    },
     {
       "type": "file",
       "name": "test/deploy-approval.test.mjs",

package/src/cli.js

@@ -3,14 +3,21 @@
 // Zero dependencies, CommonJS, boots from any cwd (dz release smoke contract).
 
 const { spawn, spawnSync } = require('child_process');
-const { resolveEngine } = require('./resolve');
-const { loadClassification, loadSnapshot, coverageGaps } = require('./classification');
-const { install } = require('./install');
-const { runSafeMcp } = require('./safe-mcp');
-const { issueApproval } = require('./deploy-approval');
-const { issueK8sApproval } = require('./k8s-approval');
-const { compileSkill, writeCompiled } = require('./dialects');
 const PKG = require('../package.json');
+let resolveEngine, loadClassification, loadSnapshot, coverageGaps, install, runSafeMcp;
+let issueApproval, issueK8sApproval, compileSkill, writeCompiled;
+let legacyLoaded = false;
+function loadLegacyCommands() {
+  if (legacyLoaded) return;
+  ({ resolveEngine } = require('./resolve'));
+  ({ loadClassification, loadSnapshot, coverageGaps } = require('./classification'));
+  ({ install } = require('./install'));
+  ({ runSafeMcp } = require('./safe-mcp'));
+  ({ issueApproval } = require('./deploy-approval'));
+  ({ issueK8sApproval } = require('./k8s-approval'));
+  ({ compileSkill, writeCompiled } = require('./dialects'));
+  legacyLoaded = true;
+}
 
 function showHelp(write) {
   write(`cloudru-hub ${PKG.version} — unofficial Cloud.ru Evolution launcher (NOT affiliated with Cloud.ru)
@@ -32,6 +39,8 @@ Commands:
                            Static sites require the artifact digest shown by deploy_plan.
   k8s-approve --cluster-id <uuid> --namespace <name> --manifest <file> --manifest-sha256 <digest>
                            Authorize one exact three-resource Snake manifest on an existing cluster.
+  cost-compare --input <json> [--json]
+                           Offline VM vs Kubernetes cost worksheet; no engine or credentials.
   install --target <t>     claude-code: permissions + executed hook probe;
                            codex|opencode|pi: project MCP config using mcp-safe;
                            hermes: guarded $HERMES_HOME/config.yaml entry using mcp-safe;
@@ -139,6 +148,9 @@ function cmdMcp() {
 }
 
 function main(argv, write = (s) => process.stdout.write(s + '\n')) {
+  // This command validates its raw flags before the permissive legacy parser sees them.
+  if (argv[0] === 'cost-compare') return require('./cost-compare').run(argv.slice(1), write);
+  loadLegacyCommands();
   const { flags, opts, positional } = parseArgs(argv);
   const cmd = positional[0] || 'help';
   if (flags.has('help') || flags.has('h') || cmd === 'help') { showHelp(write); return 0; }

package/src/cost-compare.js

@@ -0,0 +1,348 @@
+'use strict';
+
+// Offline worksheet. All money and resource divisions use integer decimal arithmetic.
+const fs = require('fs');
+
+const MAX_INPUT = 128 * 1024;
+const MAX_MONEY = 10n ** 18n;
+const CATEGORIES = Object.freeze({
+  compute: 'instance-hour',
+  controlPlane: 'instance-hour',
+  storage: 'GB-hour',
+  publicIp: 'IP-hour',
+  snat: 'gateway-hour',
+  loadBalancer: 'LB-hour',
+  traffic: 'traffic-GB',
+});
+const TIME_UNITS = new Set(['instance-hour', 'GB-hour', 'IP-hour', 'gateway-hour', 'LB-hour']);
+
+function fail(path, message) { throw new Error(`${path}: ${message}`); }
+function record(value, path, keys) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) fail(path, 'must be an object');
+  for (const key of Object.keys(value)) if (!keys.includes(key)) fail(`${path}.${key}`, 'unknown field');
+  return value;
+}
+function required(obj, key, path) {
+  if (!Object.hasOwn(obj, key)) fail(`${path}.${key}`, 'required');
+  return obj[key];
+}
+function positiveInteger(value, path, max = 1000000, zero = false) {
+  if (!Number.isSafeInteger(value) || value < (zero ? 0 : 1) || value > max) fail(path, `must be an integer from ${zero ? 0 : 1} to ${max}`);
+  return value;
+}
+function words(value, path, max = 500) {
+  if (typeof value !== 'string' || !value.trim() || value.length > max || /[\x00-\x1f\x7f]/.test(value)) fail(path, 'must be a nonempty bounded single-line string');
+  return value;
+}
+function decimal(value, path, { zero = false, max = 1000000000n } = {}) {
+  if (typeof value !== 'string' || !/^(?:0|[1-9]\d{0,12})(?:\.\d{1,9})?$/.test(value)) fail(path, 'must be a non-negative decimal string with at most 9 fractional places');
+  const [whole, fraction = ''] = value.split('.');
+  const coefficient = BigInt(whole + fraction);
+  const scale = 10n ** BigInt(fraction.length);
+  if ((!zero && coefficient === 0n) || coefficient > max * scale) fail(path, `must be ${zero ? 'non-negative' : 'positive'} and at most ${max}`);
+  return { coefficient, scale };
+}
+const integerDecimal = value => ({ coefficient: BigInt(value), scale: 1n });
+const multiply = (a, b) => ({ coefficient: a.coefficient * b.coefficient, scale: a.scale * b.scale });
+const subtract = (a, b) => ({ coefficient: a.coefficient * b.scale - b.coefficient * a.scale, scale: a.scale * b.scale });
+const compare = (a, b) => a.coefficient * b.scale < b.coefficient * a.scale ? -1 : a.coefficient * b.scale > b.coefficient * a.scale ? 1 : 0;
+function add(a, b) { return { coefficient: a.coefficient * b.scale + b.coefficient * a.scale, scale: a.scale * b.scale }; }
+function exact(value) {
+  const whole = value.coefficient / value.scale;
+  const remainder = value.coefficient % value.scale;
+  if (!remainder) return String(whole);
+  return `${whole}.${String(remainder).padStart(String(value.scale).length - 1, '0').replace(/0+$/, '')}`;
+}
+function display(value) {
+  const cents = (value.coefficient * 200n + value.scale) / (2n * value.scale);
+  return `${cents / 100n}.${String(cents % 100n).padStart(2, '0')}`;
+}
+function monetary(value, path) {
+  if (value.coefficient < 0n || value.coefficient > MAX_MONEY * value.scale) fail(path, 'amount exceeds supported RUB magnitude');
+  return value;
+}
+function slots(usable, perReplica, path) {
+  const count = usable.coefficient * perReplica.scale / (usable.scale * perReplica.coefficient);
+  if (count > 1000000n) fail(path, 'per-node capacity exceeds supported bound');
+  return Number(count);
+}
+
+// JSON.parse discards duplicate members and rounds large/fractional numeric tokens.
+// Inspect the bounded original text first, including decoded spellings of object keys.
+function validateJsonLexemes(text) {
+  const number = /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
+  let offset = 0, tokens = 0;
+  const bad = message => fail('--input', message);
+  const space = () => { while (offset < text.length && /[ \t\r\n]/.test(text[offset])) offset++; };
+  const count = () => { if (++tokens > 10000) bad('JSON has too many members or values'); };
+  const string = () => {
+    const start = offset++;
+    while (offset < text.length) {
+      if (text[offset] === '\\') { offset += 2; continue; }
+      if (text[offset++] === '"') {
+        try { return JSON.parse(text.slice(start, offset)); }
+        catch { bad('invalid JSON string'); }
+      }
+    }
+    bad('unterminated JSON string');
+  };
+  const value = depth => {
+    count();
+    if (depth > 64) bad('JSON nesting exceeds 64 levels');
+    space();
+    const marker = text[offset];
+    if (marker === '{') {
+      offset++; space();
+      const seen = new Set();
+      if (text[offset] === '}') { offset++; return; }
+      while (true) {
+        if (text[offset] !== '"') bad('object member must be a JSON string');
+        count();
+        const key = string();
+        if (seen.has(key)) bad('duplicate decoded object member');
+        seen.add(key);
+        space();
+        if (text[offset++] !== ':') bad('object member requires a colon');
+        value(depth + 1); space();
+        const separator = text[offset++];
+        if (separator === '}') return;
+        if (separator !== ',') bad('object member requires a comma or closing brace');
+        space();
+      }
+    }
+    if (marker === '[') {
+      offset++; space();
+      if (text[offset] === ']') { offset++; return; }
+      while (true) {
+        value(depth + 1); space();
+        const separator = text[offset++];
+        if (separator === ']') return;
+        if (separator !== ',') bad('array element requires a comma or closing bracket');
+      }
+    }
+    if (marker === '"') { string(); return; }
+    for (const literal of ['true', 'false', 'null']) if (text.startsWith(literal, offset)) { offset += literal.length; return; }
+    number.lastIndex = offset;
+    const match = number.exec(text);
+    if (!match) bad('invalid JSON value or number');
+    const lexeme = match[0];
+    offset = number.lastIndex;
+    if (!/^(?:0|[1-9]\d*)$/.test(lexeme) || lexeme.length > 16 || BigInt(lexeme) > BigInt(Number.MAX_SAFE_INTEGER)) {
+      bad('numeric tokens must be canonical non-negative safe integers; decimals must be strings');
+    }
+  };
+  space(); value(0); space();
+  if (offset !== text.length) bad('trailing or malformed JSON token');
+}
+
+function readInput(path) {
+  words(path, '--input', 4096);
+  const flags = fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK;
+  const fd = fs.openSync(path, flags);
+  try {
+    const stat = fs.fstatSync(fd);
+    if (!stat.isFile() || stat.size > MAX_INPUT) fail('--input', 'must be a regular file of at most 128 KiB');
+    const chunks = [], buffer = Buffer.alloc(8192);
+    let length = 0, read;
+    while ((read = fs.readSync(fd, buffer, 0, Math.min(buffer.length, MAX_INPUT + 1 - length), null)) > 0) {
+      chunks.push(Buffer.from(buffer.subarray(0, read)));
+      length += read;
+      if (length > MAX_INPUT) fail('--input', 'file exceeds 128 KiB');
+    }
+    const bytes = Buffer.concat(chunks), text = bytes.toString('utf8');
+    if (!Buffer.from(text).equals(bytes)) fail('--input', 'must be valid UTF-8');
+    validateJsonLexemes(text);
+    return JSON.parse(text);
+  } finally { fs.closeSync(fd); }
+}
+
+function tariff(value, path, vatBasis) {
+  record(value, path, ['url', 'version', 'asOf', 'vatBasis', 'pageOrRow', 'sha256']);
+  const url = words(required(value, 'url', path), `${path}.url`, 1000);
+  if (!/^https:\/\/[^\s/@?#]+(?:[/?#][^\s]*)?$/.test(url)) fail(`${path}.url`, 'must be an HTTPS tariff URL');
+  words(required(value, 'version', path), `${path}.version`, 100);
+  const asOf = required(value, 'asOf', path);
+  if (typeof asOf !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(asOf) || Number.isNaN(Date.parse(`${asOf}T00:00:00Z`)) || new Date(`${asOf}T00:00:00Z`).toISOString().slice(0, 10) !== asOf) fail(`${path}.asOf`, 'must be a valid YYYY-MM-DD date');
+  if (required(value, 'vatBasis', path) !== vatBasis) fail(`${path}.vatBasis`, 'must match the common VAT basis');
+  words(required(value, 'pageOrRow', path), `${path}.pageOrRow`, 100);
+  if (value.sha256 !== undefined && (typeof value.sha256 !== 'string' || !/^[a-f0-9]{64}$/.test(value.sha256))) fail(`${path}.sha256`, 'must be lowercase SHA-256');
+  return value;
+}
+
+function category(value, path, name, expected, horizon, vatBasis) {
+  record(value, path, ['status', 'reason', 'items']);
+  const status = required(value, 'status', path);
+  if (!['priced', 'not-used', 'unpriced'].includes(status)) fail(`${path}.status`, 'must be priced, not-used or unpriced');
+  if (status !== 'priced') {
+    if (value.items !== undefined) fail(`${path}.items`, 'allowed only when priced');
+    const reason = words(required(value, 'reason', path), `${path}.reason`);
+    if (status === 'not-used' && (expected === null || expected.coefficient !== 0n)) fail(path, 'not-used requires a declared zero quantity');
+    if (status === 'unpriced' && expected !== null && expected.coefficient === 0n) fail(path, 'declared zero quantity must be not-used');
+    return { status, reason, items: [], totalRubExact: null, totalRubDisplay: null };
+  }
+  if (value.reason !== undefined) fail(`${path}.reason`, 'allowed only when unpriced or not-used');
+  if (expected === null || expected.coefficient === 0n) fail(path, 'priced requires a positive declared quantity');
+  const items = required(value, 'items', path);
+  if (!Array.isArray(items) || !items.length || items.length > 16) fail(`${path}.items`, 'must have 1 to 16 items');
+  const seen = new Set();
+  let quantitySum = integerDecimal(0), total = integerDecimal(0);
+  const result = items.map((item, index) => {
+    const at = `${path}.items[${index}]`;
+    record(item, at, ['id', 'description', 'quantity', 'unit', 'rateRub', 'tariff']);
+    const id = words(required(item, 'id', at), `${at}.id`, 80);
+    if (!/^[a-z][a-z0-9-]*$/.test(id) || seen.has(id)) fail(`${at}.id`, 'must be a unique slug');
+    seen.add(id);
+    words(required(item, 'description', at), `${at}.description`);
+    const q = decimal(required(item, 'quantity', at), `${at}.quantity`);
+    if (required(item, 'unit', at) !== CATEGORIES[name]) fail(`${at}.unit`, `must be ${CATEGORIES[name]}`);
+    if (['compute', 'controlPlane', 'publicIp', 'snat', 'loadBalancer'].includes(name) && q.scale !== 1n) fail(`${at}.quantity`, 'must be an integer service count');
+    const rate = decimal(required(item, 'rateRub', at), `${at}.rateRub`);
+    tariff(required(item, 'tariff', at), `${at}.tariff`, vatBasis);
+    quantitySum = add(quantitySum, q);
+    const amount = monetary(multiply(multiply(q, rate), TIME_UNITS.has(item.unit) ? horizon : integerDecimal(1)), `${at}.amount`);
+    total = monetary(add(total, amount), `${path}.total`);
+    return { ...item, amountRubExact: exact(amount), amountRubDisplay: display(amount), formula: TIME_UNITS.has(item.unit) ? `${item.quantity} ${item.unit.slice(0, -5)} × ${item.rateRub} RUB/${item.unit} × ${exact(horizon)} hours` : `${item.quantity} ${item.unit} × ${item.rateRub} RUB/${item.unit} once` };
+  });
+  if (compare(quantitySum, expected) !== 0) fail(`${path}.items`, `quantities must sum to declared ${exact(expected)} ${CATEGORIES[name]}`);
+  return { status, items: result, totalRubExact: exact(total), totalRubDisplay: display(total), _total: total };
+}
+
+function scenario(value, path, workload, horizon, vatBasis) {
+  record(value, path, ['id', 'kind', 'nodes', 'controlPlaneCount', 'resources', 'categories']);
+  const id = words(required(value, 'id', path), `${path}.id`, 80);
+  if (!/^[a-z][a-z0-9-]*$/.test(id)) fail(`${path}.id`, 'must be a slug');
+  const kind = required(value, 'kind', path);
+  if (!['vm', 'k8s'].includes(kind)) fail(`${path}.kind`, 'must be vm or k8s');
+  const node = record(required(value, 'nodes', path), `${path}.nodes`, ['count', 'cpu', 'ramGB', 'reservedCpu', 'reservedRamGB', 'cpuShare']);
+  const count = positiveInteger(required(node, 'count', `${path}.nodes`), `${path}.nodes.count`, 1000);
+  if (workload.failedNodes > count) fail(`${path}.nodes.count`, 'must be at least the declared failedNodes');
+  const cpu = decimal(required(node, 'cpu', `${path}.nodes`), `${path}.nodes.cpu`, { max: 10000n });
+  const ram = decimal(required(node, 'ramGB', `${path}.nodes`), `${path}.nodes.ramGB`, { max: 1000000n });
+  const share = decimal(required(node, 'cpuShare', `${path}.nodes`), `${path}.nodes.cpuShare`, { max: 1n });
+  const reservedCpu = decimal(required(node, 'reservedCpu', `${path}.nodes`), `${path}.nodes.reservedCpu`, { zero: true, max: 10000n });
+  const reservedRam = decimal(required(node, 'reservedRamGB', `${path}.nodes`), `${path}.nodes.reservedRamGB`, { zero: true, max: 1000000n });
+  const guaranteedCpu = multiply(cpu, share);
+  if (compare(reservedCpu, guaranteedCpu) > 0 || compare(reservedRam, ram) > 0) fail(`${path}.nodes`, 'reservations exceed guaranteed CPU or RAM');
+  const controlPlaneCount = positiveInteger(required(value, 'controlPlaneCount', path), `${path}.controlPlaneCount`, 1000, kind === 'vm');
+  if (kind === 'vm' && controlPlaneCount !== 0) fail(`${path}.controlPlaneCount`, 'VM must declare zero control-plane service instances');
+  const resources = record(required(value, 'resources', path), `${path}.resources`, ['storageGB', 'publicIpCount', 'snatGatewayCount', 'loadBalancerCount', 'trafficGB']);
+  const storage = decimal(required(resources, 'storageGB', `${path}.resources`), `${path}.resources.storageGB`, { zero: true });
+  const publicIp = positiveInteger(required(resources, 'publicIpCount', `${path}.resources`), `${path}.resources.publicIpCount`, 1000000, true);
+  const snat = positiveInteger(required(resources, 'snatGatewayCount', `${path}.resources`), `${path}.resources.snatGatewayCount`, 1000000, true);
+  const lb = positiveInteger(required(resources, 'loadBalancerCount', `${path}.resources`), `${path}.resources.loadBalancerCount`, 1000000, true);
+  const trafficValue = required(resources, 'trafficGB', `${path}.resources`);
+  const traffic = trafficValue === null ? null : decimal(trafficValue, `${path}.resources.trafficGB`, { zero: true });
+  const expected = { compute: integerDecimal(count), controlPlane: integerDecimal(controlPlaneCount), storage, publicIp: integerDecimal(publicIp), snat: integerDecimal(snat), loadBalancer: integerDecimal(lb), traffic };
+  const raw = record(required(value, 'categories', path), `${path}.categories`, Object.keys(CATEGORIES));
+  const categories = {}, unpriced = [];
+  let known = integerDecimal(0);
+  for (const name of Object.keys(CATEGORIES)) {
+    const result = category(required(raw, name, `${path}.categories`), `${path}.categories.${name}`, name, expected[name], horizon, vatBasis);
+    if (result._total) { known = monetary(add(known, result._total), `${path}.knownSubtotal`); delete result._total; }
+    if (result.status === 'unpriced') unpriced.push({ category: name, reason: result.reason });
+    categories[name] = result;
+  }
+  const perNodeCpu = slots(subtract(guaranteedCpu, reservedCpu), workload.cpu, `${path}.nodes.cpu`);
+  const perNodeRam = slots(subtract(ram, reservedRam), workload.ram, `${path}.nodes.ramGB`);
+  const perNodeSlots = Math.min(perNodeCpu, perNodeRam);
+  const normalSlots = count * perNodeSlots;
+  const survivingNodes = Math.max(0, count - workload.failedNodes);
+  const survivingSlots = survivingNodes * perNodeSlots;
+  const feasible = normalSlots >= workload.replicas && survivingSlots >= workload.survivingReplicas;
+  return {
+    id, kind, nodes: node, controlPlaneCount, resources, categories,
+    capacity: { perNodeCpuSlots: perNodeCpu, perNodeRamSlots: perNodeRam, perNodeSlots, normalSlots, survivingNodes, survivingSlots, feasible,
+      formula: 'usable guaranteed CPU = cpu × cpuShare − reservedCpu; usable RAM = ramGB − reservedRamGB; per-node slots = min(floor(usable CPU / cpuPerReplica), floor(usable RAM / ramGBPerReplica)); normal/surviving slots = per-node slots × available nodes' },
+    unpriced, complete: unpriced.length === 0, knownSubtotalRubExact: exact(known), knownSubtotalRubDisplay: display(known), _known: known,
+  };
+}
+
+function calculate(input) {
+  record(input, 'input', ['schemaVersion', 'horizonHours', 'currency', 'vatBasis', 'workload', 'equivalence', 'scenarios']);
+  if (required(input, 'schemaVersion', 'input') !== 1) fail('input.schemaVersion', 'must be 1');
+  const horizon = decimal(required(input, 'horizonHours', 'input'), 'input.horizonHours', { max: 8760n });
+  if (required(input, 'currency', 'input') !== 'RUB') fail('input.currency', 'must be RUB');
+  const vatBasis = required(input, 'vatBasis', 'input');
+  if (vatBasis !== 'included') fail('input.vatBasis', 'must be included');
+  const rawWorkload = record(required(input, 'workload', 'input'), 'input.workload', ['replicas', 'cpuPerReplica', 'ramGBPerReplica', 'survivingReplicas', 'failedNodes']);
+  const workload = {
+    replicas: positiveInteger(required(rawWorkload, 'replicas', 'input.workload'), 'input.workload.replicas'),
+    cpu: decimal(required(rawWorkload, 'cpuPerReplica', 'input.workload'), 'input.workload.cpuPerReplica', { max: 10000n }),
+    ram: decimal(required(rawWorkload, 'ramGBPerReplica', 'input.workload'), 'input.workload.ramGBPerReplica', { max: 1000000n }),
+    survivingReplicas: positiveInteger(required(rawWorkload, 'survivingReplicas', 'input.workload'), 'input.workload.survivingReplicas', 1000000, true),
+    failedNodes: positiveInteger(required(rawWorkload, 'failedNodes', 'input.workload'), 'input.workload.failedNodes', 1000, true),
+  };
+  if (workload.survivingReplicas > workload.replicas) fail('input.workload.survivingReplicas', 'cannot exceed replicas');
+  const equivalence = record(required(input, 'equivalence', 'input'), 'input.equivalence', ['status', 'assumptions', 'reason']);
+  if (!['assumed', 'unknown'].includes(required(equivalence, 'status', 'input.equivalence'))) fail('input.equivalence.status', 'must be assumed or unknown');
+  const assumptions = required(equivalence, 'assumptions', 'input.equivalence');
+  if (!Array.isArray(assumptions) || assumptions.length > 16 || (equivalence.status === 'assumed' && assumptions.length === 0)) fail('input.equivalence.assumptions', 'must have 1 to 16 assumptions when assumed');
+  assumptions.forEach((item, i) => words(item, `input.equivalence.assumptions[${i}]`));
+  if (equivalence.status === 'unknown') words(required(equivalence, 'reason', 'input.equivalence'), 'input.equivalence.reason');
+  else if (equivalence.reason !== undefined) fail('input.equivalence.reason', 'allowed only when unknown');
+  const rawScenarios = required(input, 'scenarios', 'input');
+  if (!Array.isArray(rawScenarios) || rawScenarios.length !== 2) fail('input.scenarios', 'must contain exactly one VM and one K8s scenario');
+  const scenarios = rawScenarios.map((item, i) => scenario(item, `input.scenarios[${i}]`, workload, horizon, vatBasis));
+  if (new Set(scenarios.map(item => item.kind)).size !== 2 || new Set(scenarios.map(item => item.id)).size !== 2) fail('input.scenarios', 'must have unique IDs and one scenario of each kind');
+  const reasons = [];
+  if (equivalence.status === 'unknown') reasons.push('architecture/HA equivalence is unknown');
+  for (const item of scenarios) {
+    if (!item.capacity.feasible) reasons.push(`${item.id}: declared normal or node-failure capacity is insufficient`);
+    if (!item.complete) reasons.push(`${item.id}: unpriced categories remain`);
+  }
+  const eligible = reasons.length === 0;
+  let winner = null, savings = null, tie = false;
+  if (eligible) {
+    const [a, b] = scenarios;
+    const relation = compare(a._known, b._known);
+    tie = relation === 0;
+    if (!tie) { winner = relation < 0 ? a.id : b.id; savings = subtract(relation < 0 ? b._known : a._known, relation < 0 ? a._known : b._known); }
+  }
+  for (const item of scenarios) delete item._known;
+  return {
+    schemaVersion: 1, horizonHours: input.horizonHours, currency: 'RUB', vatBasis,
+    workload: rawWorkload, equivalence,
+    scenarios,
+    comparison: { eligible, reasons, basis: eligible ? 'conditional lower modeled infrastructure cost under supplied assumptions' : null,
+      winner, tie: eligible ? tie : null, savingsRubExact: savings ? exact(savings) : null, savingsRubDisplay: savings ? display(savings) : null },
+    limitations: ['Declared quantities and tariff provenance are user assertions, not verified inventory or live prices.',
+      'Capacity is a homogeneous per-node packing bound, not a placement, performance, HA or SLA proof.',
+      'Static full-horizon resources only; no tiered, monthly, stopped-resource, discount or heterogeneous-fleet modeling.'],
+  };
+}
+
+function parseFlags(argv) {
+  let input = null, json = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--json') { if (json) fail('flags', 'duplicate --json'); json = true; }
+    else if (arg === '--input') { if (input !== null) fail('flags', 'duplicate --input'); input = argv[++i]; if (!input || input.startsWith('--')) fail('flags', '--input requires a path'); }
+    else fail('flags', `unknown argument ${JSON.stringify(arg)}`);
+  }
+  if (input === null) fail('flags', '--input is required');
+  return { input, json };
+}
+
+function run(argv, write = s => process.stdout.write(s + '\n'), error = s => process.stderr.write(s + '\n')) {
+  try {
+    const flags = parseFlags(argv);
+    const result = calculate(readInput(flags.input));
+    if (flags.json) write(JSON.stringify(result, null, 2));
+    else {
+      write(`Offline Cloud.ru cost worksheet — ${result.horizonHours} hours, RUB, VAT included`);
+      for (const item of result.scenarios) {
+        write(`${item.id} (${item.kind}): known subtotal ${item.knownSubtotalRubExact} RUB (${item.knownSubtotalRubDisplay} displayed); capacity ${item.capacity.normalSlots} normal / ${item.capacity.survivingSlots} after ${result.workload.failedNodes} node failure(s): ${item.capacity.feasible ? 'feasible packing bound' : 'INSUFFICIENT'}`);
+        for (const [name, category] of Object.entries(item.categories)) for (const line of category.items) write(`  ${name}/${line.id}: ${line.formula} = ${line.amountRubExact} RUB; tariff ${line.tariff.url} version ${line.tariff.version} as of ${line.tariff.asOf}, ${line.tariff.pageOrRow}, VAT ${line.tariff.vatBasis}`);
+        for (const missing of item.unpriced) write(`  unpriced ${missing.category}: ${missing.reason}`);
+      }
+      write(`Architecture equivalence: ${result.equivalence.status}${result.equivalence.reason ? ` — ${result.equivalence.reason}` : ''}`);
+      for (const assumption of result.equivalence.assumptions) write(`  assumption: ${assumption}`);
+      write(result.comparison.eligible ? (result.comparison.tie ? 'Conditional modeled cost: tie under supplied assumptions' : `Conditional lower modeled infrastructure cost: ${result.comparison.winner}; savings ${result.comparison.savingsRubExact} RUB (${result.comparison.savingsRubDisplay} displayed)`) : `No winner: ${result.comparison.reasons.join('; ')}`);
+      for (const limitation of result.limitations) write(`Limit: ${limitation}`);
+      write(`Formulas and tariff provenance: use --json or inspect ${flags.input}`);
+    }
+    return 0;
+  } catch (e) { error(`cloudru-hub cost-compare: ${e.message}`); return 1; }
+}
+
+module.exports = { run, calculate, readInput };

package/test/cost-compare.test.mjs

@@ -0,0 +1,280 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { after, test } from 'node:test';
+
+const pkg = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const cli = join(pkg, 'bin/cloudru-hub.js');
+const example = join(pkg, 'docs/cost-compare.example.json');
+const exampleText = readFileSync(example, 'utf8');
+const source = JSON.parse(exampleText);
+const dirs = [];
+after(() => { for (const dir of dirs) rmSync(dir, { recursive: true, force: true }); });
+function directory() { const dir = mkdtempSync(join(tmpdir(), 'cloudru-cost-test-')); dirs.push(dir); return dir; }
+function invoke(input, flags = [], env = {}) {
+  const dir = directory(), path = join(dir, 'input.json');
+  writeFileSync(path, JSON.stringify(input));
+  const result = spawnSync(process.execPath, [cli, 'cost-compare', '--input', path, '--json', ...flags], {
+    cwd: dir, env: { ...process.env, CLOUDRU_VM_BIN: join(dir, 'no-engine'), CLOUDRU_HUB_CONFIG: join(dir, 'no-config'), ...env },
+    encoding: 'utf8', timeout: 5000, maxBuffer: 1024 * 1024,
+  });
+  assert.ifError(result.error);
+  return result;
+}
+function invokeRaw(raw) {
+  const dir = directory(), path = join(dir, 'input.json');
+  writeFileSync(path, raw);
+  const result = spawnSync(process.execPath, [cli, 'cost-compare', '--input', path, '--json'], {
+    cwd: dir, encoding: 'utf8', timeout: 5000, maxBuffer: 1024 * 1024,
+  });
+  assert.ifError(result.error);
+  return result;
+}
+function editRaw(from, to) {
+  assert.ok(exampleText.includes(from), `missing fixture anchor ${from}`);
+  return exampleText.replace(from, to);
+}
+function run(input) {
+  const result = invoke(input);
+  assert.equal(result.status, 0, result.stderr);
+  assert.equal(result.stderr, '');
+  return JSON.parse(result.stdout);
+}
+function reject(mutator, pattern) {
+  const input = structuredClone(source);
+  mutator(input);
+  const result = invoke(input);
+  assert.equal(result.status, 1, result.stdout + result.stderr);
+  assert.equal(result.stdout, '', 'invalid input must not emit partial success JSON');
+  assert.match(result.stderr, pattern);
+}
+function complete(input) {
+  input.equivalence = { status: 'assumed', assumptions: ['Only modeled infrastructure cost is compared; application equivalence is an operator assumption.'] };
+  for (const scenario of input.scenarios) {
+    scenario.resources.trafficGB = '7.5';
+    scenario.categories.traffic = { status: 'priced', items: [{
+      id: 'synthetic-traffic', description: 'Test-only invented traffic tariff', quantity: '7.5', unit: 'traffic-GB', rateRub: '0.12',
+      tariff: { url: 'https://example.invalid/test-only-rate', version: 'synthetic-test', asOf: '2026-10-21', vatBasis: 'included', pageOrRow: 'test fixture only' },
+    }] };
+  }
+  return input;
+}
+
+test('packaged official-rate example has independent 24h subtotals, capacity and no winner', () => {
+  const result = run(source);
+  assert.deepEqual(result.scenarios.map(item => item.knownSubtotalRubExact), ['251.6616', '466.1376']);
+  assert.deepEqual(result.scenarios.map(item => item.categories.storage.totalRubExact), ['22.8384', '30.4512']);
+  assert.deepEqual(result.scenarios.map(item => item.capacity.normalSlots), [6, 6]);
+  assert.deepEqual(result.scenarios.map(item => item.capacity.survivingSlots), [4, 4]);
+  assert.deepEqual(result.scenarios.map(item => item.capacity.feasible), [true, true]);
+  assert.deepEqual(result.scenarios.map(item => item.unpriced.map(entry => entry.category)), [['traffic'], ['traffic']]);
+  assert.equal(result.comparison.eligible, false);
+  assert.equal(result.comparison.winner, null);
+  assert.equal(result.comparison.savingsRubExact, null);
+  assert.match(result.scenarios[0].categories.compute.items[0].formula, /24 hours/);
+  assert.equal(result.scenarios[1].categories.compute.items[0].tariff.version, '260918');
+  assert.match(result.scenarios[0].categories.compute.items[0].formula, /3 instance × 2\.9707 RUB\/instance-hour × 24 hours/);
+});
+
+test('human output includes modeled formulas, tariff provenance, unknowns and assumptions', () => {
+  const dir = directory(), path = join(dir, 'input.json'); writeFileSync(path, JSON.stringify(source));
+  const result = spawnSync(process.execPath, [cli, 'cost-compare', '--input', path], { cwd: dir, encoding: 'utf8' });
+  assert.equal(result.status, 0, result.stderr);
+  assert.match(result.stdout, /3 instance × 2\.9707 RUB\/instance-hour × 24 hours/);
+  assert.match(result.stdout, /evolution-compute\.pdf version 261014/);
+  assert.match(result.stdout, /unpriced traffic/);
+  assert.match(result.stdout, /assumption:/);
+  assert.match(result.stdout, /No winner/);
+});
+
+test('fractional horizon keeps exact sums and rounds display only at output', () => {
+  const input = structuredClone(source); input.horizonHours = '1.5';
+  const result = run(input);
+  assert.deepEqual(result.scenarios.map(item => item.knownSubtotalRubExact), ['15.72885', '29.1336']);
+  assert.deepEqual(result.scenarios.map(item => item.categories.storage.totalRubExact), ['1.4274', '1.9032']);
+  assert.deepEqual(result.scenarios.map(item => item.knownSubtotalRubDisplay), ['15.73', '29.13']);
+});
+
+test('test-only traffic is charged once, then conditional lower modeled cost is identified', () => {
+  for (const [horizon, expected, savings] of [
+    ['24', ['252.5616', '467.0376'], '214.476'],
+    ['1.5', ['16.62885', '30.0336'], '13.40475'],
+  ]) {
+    const input = complete(structuredClone(source)); input.horizonHours = horizon;
+    const result = run(input);
+    assert.deepEqual(result.scenarios.map(item => item.knownSubtotalRubExact), expected);
+    assert.deepEqual(result.scenarios.map(item => item.categories.traffic.totalRubExact), ['0.9', '0.9']);
+    assert.equal(result.comparison.eligible, true);
+    assert.equal(result.comparison.winner, 'vm');
+    assert.equal(result.comparison.savingsRubExact, savings);
+    assert.match(result.comparison.basis, /conditional/);
+    assert.deepEqual(result.equivalence.assumptions, input.equivalence.assumptions);
+  }
+});
+
+test('aggregate CPU cannot conceal per-node packing failure', () => {
+  const input = complete(structuredClone(source));
+  input.workload.replicas = 4;
+  input.workload.cpuPerReplica = '1.5';
+  const result = run(input);
+  assert.deepEqual(result.scenarios.map(item => item.capacity.normalSlots), [3, 3]);
+  assert.deepEqual(result.scenarios.map(item => item.capacity.feasible), [false, false]);
+  assert.equal(result.comparison.winner, null);
+});
+
+test('one-node failure capacity is distinct from normal capacity', () => {
+  const input = complete(structuredClone(source));
+  input.workload.replicas = 5;
+  input.workload.survivingReplicas = 5;
+  const failed = run(input);
+  assert.deepEqual(failed.scenarios.map(item => item.capacity.normalSlots), [6, 6]);
+  assert.deepEqual(failed.scenarios.map(item => item.capacity.survivingSlots), [4, 4]);
+  assert.equal(failed.comparison.winner, null);
+  input.workload.survivingReplicas = 4;
+  const fit = run(input);
+  assert.deepEqual(fit.scenarios.map(item => item.capacity.feasible), [true, true]);
+  assert.equal(fit.comparison.winner, 'vm');
+});
+
+test('guaranteed CPU share, reservation and exact decimal floor determine per-node slots', () => {
+  const input = complete(structuredClone(source));
+  for (const scenario of input.scenarios) {
+    scenario.nodes.cpu = '4'; scenario.nodes.cpuShare = '0.5'; scenario.nodes.reservedCpu = '0.5';
+  }
+  input.workload.cpuPerReplica = '0.5';
+  const result = run(input);
+  assert.deepEqual(result.scenarios.map(item => item.capacity.perNodeCpuSlots), [3, 3]);
+  const tenth = complete(structuredClone(source));
+  for (const scenario of tenth.scenarios) { scenario.nodes.cpu = '0.3'; scenario.nodes.cpuShare = '1'; }
+  tenth.workload.cpuPerReplica = '0.1';
+  assert.deepEqual(run(tenth).scenarios.map(item => item.capacity.perNodeCpuSlots), [3, 3]);
+});
+
+test('a tie is explicit and carries no winner or savings', () => {
+  const input = complete(structuredClone(source));
+  const vm = input.scenarios[0];
+  const k8s = input.scenarios[1];
+  // Test-only unit rates: 66 VM hourly units versus 87 K8s hourly units,
+  // a 21 × 24 = 504 RUB difference, offset by 7.5 × (67.32 − 0.12).
+  vm.categories.compute.items[0].rateRub = '1';
+  vm.categories.storage.items[0].rateRub = '1';
+  vm.categories.publicIp.items[0].rateRub = '1';
+  k8s.categories.compute.items[0].rateRub = '1';
+  k8s.categories.controlPlane.items[0].rateRub = '1';
+  k8s.categories.storage.items[0].rateRub = '1';
+  k8s.categories.publicIp.items[0].rateRub = '1';
+  k8s.categories.snat.items[0].rateRub = '1';
+  // VM has 66 hourly units; K8s has 87. Add the same 7.5GB traffic to both; tie via VM traffic premium.
+  vm.categories.traffic.items[0].rateRub = '67.32';
+  k8s.categories.traffic.items[0].rateRub = '0.12';
+  const result = run(input);
+  assert.deepEqual(result.scenarios.map(item => item.knownSubtotalRubExact), ['2088.9', '2088.9']);
+  assert.equal(result.comparison.eligible, true);
+  assert.equal(result.comparison.tie, true);
+  assert.equal(result.comparison.winner, null);
+  assert.equal(result.comparison.savingsRubExact, null);
+});
+
+test('unknown equivalence alone suppresses a winner even with complete prices', () => {
+  const input = complete(structuredClone(source));
+  input.equivalence = source.equivalence;
+  const result = run(input);
+  assert.deepEqual(result.scenarios.map(item => item.complete), [true, true]);
+  assert.equal(result.comparison.winner, null);
+});
+
+test('raw flags reject duplicates, missing values, unknown options and positionals', () => {
+  const dir = directory(), path = join(dir, 'input.json'); writeFileSync(path, JSON.stringify(source));
+  for (const flags of [[], ['--input'], ['--input', path, '--input', path], ['--input', path, '--json', '--json'], ['--input', path, '--rate', '1'], ['--input', path, 'extra']]) {
+    const result = spawnSync(process.execPath, [cli, 'cost-compare', ...flags], { cwd: dir, encoding: 'utf8' });
+    assert.equal(result.status, 1, JSON.stringify(flags)); assert.equal(result.stdout, ''); assert.match(result.stderr, /cost-compare/);
+  }
+});
+
+test('input must be a bounded regular file and cannot be a symlink', () => {
+  const dir = directory();
+  const large = join(dir, 'large.json'); writeFileSync(large, ' '.repeat(128 * 1024 + 1));
+  const link = join(dir, 'link.json'); symlinkSync(example, link);
+  for (const path of [large, link, '/dev/null']) {
+    const result = spawnSync(process.execPath, [cli, 'cost-compare', '--input', path, '--json'], { encoding: 'utf8' });
+    assert.equal(result.status, 1, path); assert.equal(result.stdout, ''); assert.match(result.stderr, /cost-compare/);
+  }
+});
+
+for (const [name, raw, pattern] of [
+  ['top-level duplicate horizon', editRaw('"horizonHours": "24"', '"horizonHours": "8760", "horizonHours": "24"'), /duplicate decoded object member/],
+  ['nested duplicate CPU declaration', editRaw('"cpu": "2", "ramGB": "4"', '"cpu": "4", "cpu": "2", "ramGB": "4"'), /duplicate decoded object member/],
+  ['sibling scenario duplicate id', editRaw('"id": "k8s",', '"id": "other", "id": "k8s",'), /duplicate decoded object member/],
+  ['escaped-equivalent duplicate member', editRaw('"horizonHours": "24"', '"horizonHours": "8760", "horizon\\u0048ours": "24"'), /duplicate decoded object member/],
+  ['rounded fractional replica token', JSON.stringify(source).replace('"replicas":3', '"replicas":3.0000000000000001'), /numeric tokens must be canonical/],
+  ['unsafe integer replica token', JSON.stringify(source).replace('"replicas":3', '"replicas":9007199254740993'), /numeric tokens must be canonical/],
+  ['infinite exponent token', JSON.stringify(source).replace('"replicas":3', '"replicas":1e309'), /numeric tokens must be canonical/],
+  ['malformed exponent token', JSON.stringify(source).replace('"replicas":3', '"replicas":3e+'), /object member requires/],
+  ['excessive JSON nesting', `${'['.repeat(65)}0${']'.repeat(65)}`, /nesting exceeds/],
+  ['raw numeric value for decimal-string horizon', editRaw('"horizonHours": "24"', '"horizonHours": 24'), /horizonHours/],
+]) test(`raw JSON rejects ${name} before accepting a result`, () => {
+  const result = invokeRaw(raw);
+  assert.equal(result.status, 1, result.stdout + result.stderr);
+  assert.equal(result.stdout, '');
+  assert.match(result.stderr, pattern);
+});
+
+test('canonical safe integer tokens and quoted braces/commas remain accepted', () => {
+  const input = structuredClone(source);
+  input.workload.replicas = 3;
+  input.equivalence.reason = 'unknown: text contains "quotes", braces { } and comma, without object members';
+  const result = invokeRaw(JSON.stringify(input));
+  assert.equal(result.status, 0, result.stderr);
+  assert.equal(JSON.parse(result.stdout).workload.replicas, 3);
+});
+
+test('CLI path cannot resolve an engine, spawn, access network or require credentials', () => {
+  const dir = directory(), preload = join(dir, 'forbid.cjs');
+  writeFileSync(preload, `
+const Module = require('module'); const original = Module._load;
+Module._load = function(request, parent, main) {
+  if (parent?.filename.endsWith('/src/cli.js') && ['./resolve','./classification','./install','./safe-mcp','./deploy-approval','./k8s-approval','./dialects'].includes(request)) throw Error('legacy engine/auth module load forbidden');
+  if (request === 'yaml') throw Error('external dependency load forbidden');
+  return original.apply(this, arguments);
+};
+const child = require('child_process'); for (const name of ['spawn','spawnSync','exec','execFile']) child[name] = () => { throw Error('spawn forbidden'); };
+for (const name of ['http','https','net']) { const mod = require(name); for (const key of ['request','get','connect','createConnection']) if (key in mod) mod[key] = () => { throw Error('network forbidden'); }; }
+global.fetch = () => { throw Error('fetch forbidden'); };
+`);
+  const input = join(dir, 'input.json'); writeFileSync(input, JSON.stringify(source));
+  const result = spawnSync(process.execPath, ['--require', preload, cli, 'cost-compare', '--input', input, '--json'], {
+    cwd: dir, env: { PATH: '/nonexistent', CLOUDRU_VM_BIN: '/no-engine', CLOUDRU_HUB_CONFIG: '/no-config' }, encoding: 'utf8', timeout: 5000,
+  });
+  assert.ifError(result.error); assert.equal(result.status, 0, result.stderr);
+  assert.equal(JSON.parse(result.stdout).comparison.winner, null);
+});
+
+for (const [label, mutate, pattern] of [
+  ['unknown schema field', x => { x.hidden = true; }, /unknown field/],
+  ['non-RUB currency', x => { x.currency = 'USD'; }, /currency/],
+  ['different VAT basis', x => { x.vatBasis = 'excluded'; }, /vatBasis/],
+  ['scientific rate', x => { x.scenarios[0].categories.compute.items[0].rateRub = '1e3'; }, /rateRub/],
+  ['monthly unit', x => { x.scenarios[0].categories.compute.items[0].unit = 'instance-month'; }, /unit/],
+  ['wrong unit category', x => { x.scenarios[0].categories.storage.items[0].unit = 'instance-hour'; }, /unit/],
+  ['missing tariff version', x => { delete x.scenarios[0].categories.compute.items[0].tariff.version; }, /version/],
+  ['HTTP tariff URL', x => { x.scenarios[0].categories.compute.items[0].tariff.url = 'http://example.invalid'; }, /url/],
+  ['wrong tariff VAT basis', x => { x.scenarios[0].categories.compute.items[0].tariff.vatBasis = 'excluded'; }, /vatBasis/],
+  ['unbound worker quantity', x => { x.scenarios[0].categories.compute.items[0].quantity = '2'; }, /quantities must sum/],
+  ['unbound storage quantity', x => { x.scenarios[0].categories.storage.items[0].quantity = '59'; }, /quantities must sum/],
+  ['unbound IP quantity', x => { x.scenarios[0].categories.publicIp.items[0].quantity = '2'; }, /quantities must sum/],
+  ['noninteger service count', x => { x.scenarios[0].categories.compute.items[0].quantity = '3.5'; }, /integer service count/],
+  ['missing K8s control plane', x => { x.scenarios[1].controlPlaneCount = 0; }, /controlPlaneCount/],
+  ['unpriced compute with zero declaration', x => { x.scenarios[0].nodes.count = 0; }, /nodes.count/],
+  ['not-used positive storage', x => { x.scenarios[0].categories.storage = { status: 'not-used', reason: 'omitted' }; }, /not-used requires/],
+  ['unknown traffic silently zero', x => { x.scenarios[0].resources.trafficGB = '0'; }, /declared zero quantity/],
+  ['priced unknown traffic', x => { x.scenarios[0].categories.traffic = { status: 'priced', items: [] }; }, /priced requires/],
+  ['oversubscribed reservations', x => { x.scenarios[0].nodes.reservedCpu = '3'; }, /reservations exceed/],
+  ['declared node failure exceeds topology', x => { x.workload.failedNodes = 4; }, /failedNodes/],
+  ['bad CPU share', x => { x.scenarios[0].nodes.cpuShare = '1.1'; }, /cpuShare/],
+  ['survival above replicas', x => { x.workload.survivingReplicas = 4; }, /survivingReplicas/],
+  ['duplicate kinds', x => { x.scenarios[1].kind = 'vm'; x.scenarios[1].controlPlaneCount = 0; x.scenarios[1].categories.controlPlane = { status: 'not-used', reason: 'none' }; }, /one scenario of each kind/],
+  ['missing equivalence assumption', x => { x.equivalence = { status: 'assumed', assumptions: [] }; }, /assumptions/],
+]) test(`rejects ${label} without partial output`, () => reject(mutate, pattern));