substratum-cli 0.2.1__tar.gz → 0.2.2__tar.gz

{substratum_cli-0.2.1 → substratum_cli-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: substratum-cli
-Version: 0.2.1
+Version: 0.2.2
 Summary: Substratum: verified-or-refused code, with provenance. The terminal over the comprehension engine.
 Author: Substratum
 License: LicenseRef-Proprietary

{substratum_cli-0.2.1 → substratum_cli-0.2.2}/substratum_cli/__init__.py

@@ -5,4 +5,4 @@ Import budget: this package is stdlib-only; the ONLY module reaching into backen
 """
 # SINGLE SOURCE OF TRUTH for the release version. pyproject reads this (dynamic version), the boot shows
 # it, and the update-check compares against it. To cut a release, bump ONLY this line, then publish.
-__version__ = "0.2.1"
+__version__ = "0.2.2"

{substratum_cli-0.2.1 → substratum_cli-0.2.2}/substratum_cli/_boot.py

@@ -13,9 +13,11 @@ from __future__ import annotations
 
 import hashlib
 
-# The PUBLIC substrate release name -- what the product shows, like a model version (GPT-5.2, Opus 4.8).
-# Decoupled from the internal mining tag (pattern_library_scaled_v15): that tag still drives the seal
-# hash (the seal must certify the ACTUAL build), but users see this. Bump only on a real public release.
+# The PUBLIC name of the first intelligence library -- a model version, like GPT-5.2 or Opus 4.8. Shown
+# ONLY when this library actually backs the session: in AIRGAPPED-LOCAL mode (the engine + library shipped
+# on-prem, present on this machine), or reported by the HOSTED engine once the full corpus is live on it.
+# The boot NEVER shows this from a hardcoded local path -- the label must be a real representation of the
+# intelligence serving the user. The internal mining tag (pattern_library_scaled_v15) stays internal.
 RELEASE = "Substrate 1.0 Preview"
 
 L = "\033[38;5;154m"      # brand lime
@@ -53,18 +55,21 @@ def seal(lib_name: str, version: str) -> tuple[str, str]:
     return sigil, digest
 
 
-def render(name, census, langs, libname, patterns, warm, standing, version,
-           color=True, ascii_mode=False, logged_in=True, update_to="") -> list[str]:
-    """Return the boot lines. `standing` is build_state.standing() (may be {})."""
+def render(name, census, langs, substrate, substrate_note, substrate_ok, standing, version,
+           color=True, ascii_mode=False, logged_in=True, update_to="", seal_key="") -> list[str]:
+    """Return the boot lines. `substrate` is the HONEST name of the intelligence serving this session
+    (the hosted engine version, or 'not connected') -- NEVER a local path. `substrate_note`/`_ok` render
+    the connection state. `seal_key` is the stable identity the self-certificate hashes."""
     def c(code, s):
         return f"{code}{s}{R}" if color else s
 
-    sig, dig = seal(libname, version)
+    sig, dig = seal(seal_key or substrate, version)
     if ascii_mode:
         sig = "#" + dig.split()[0]
     dot = "-" if ascii_mode else "·"          # separators degrade with the glyph set
     if ascii_mode:                            # the renderer guarantees ascii output regardless of input
-        name, census, langs, libname = (str(s).replace("·", "-") for s in (name, census, langs, libname))
+        name, census, langs, substrate, substrate_note = (
+            str(s).replace("·", "-") for s in (name, census, langs, substrate, substrate_note))
     W = 78                                    # certificate inner width
     out = ["", ""]
 
@@ -99,8 +104,9 @@ def render(name, census, langs, libname, patterns, warm, standing, version,
         pad = " " * max(0, W - 1 - _vis(inner_plain))
         return c(CH, v_) + " " + inner_colored + pad + c(CH, v_)
 
-    lamp = (("*" if ascii_mode else "●") + " ready") if warm else (dot + " loading")
-    lampc = c(GR, lamp) if warm else c(CH, lamp)
+    glyph = ("*" if ascii_mode else "●") if substrate_ok else dot
+    lamp = f"{glyph} {substrate_note}"
+    lampc = c(GR if substrate_ok else CH, lamp)
     st = standing or {}
     runs, ver = st.get("runs", 0), st.get("verified", 0)
     unsaved = st.get("unapplied_total", 0)
@@ -114,8 +120,8 @@ def render(name, census, langs, libname, patterns, warm, standing, version,
     box.append(c(CH, v_) + " " + seal_inner_c + pad + right_c + c(CH, v_))
 
     box.append(bar(label="SUBSTRATE"))
-    box.append(rowline(f"  release   {RELEASE}      {lamp}",
-                       c(LAB, "  release   ") + c(DAT, RELEASE) + "      " + lampc))
+    box.append(rowline(f"  engine    {substrate}      {lamp}",
+                       c(LAB, "  engine    ") + c(DAT, substrate) + "      " + lampc))
     box.append(rowline(f"  covers    {langs}", c(LAB, "  covers    ") + c(DAT, langs)))
     box.append(bar(label="REPO"))
     box.append(rowline(f"  project   {name}", c(LAB, "  project   ") + c(DAT, name)))

{substratum_cli-0.2.1 → substratum_cli-0.2.2}/substratum_cli/_update.py

@@ -27,15 +27,25 @@ def _version_tuple(s: str) -> tuple:
     return tuple(out)
 
 
-def available(current: str) -> str:
-    """The newer published version if the cache knows of one, else "". Pure, instant, no network."""
+def _cache() -> dict:
     try:
-        latest = str(json.load(open(_cache_path(), encoding="utf-8")).get("latest") or "")
+        return json.load(open(_cache_path(), encoding="utf-8")) or {}
     except Exception:
-        return ""
+        return {}
+
+
+def available(current: str) -> str:
+    """The newer published version if the cache knows of one, else "". Pure, instant, no network."""
+    latest = str(_cache().get("latest") or "")
     return latest if latest and _version_tuple(latest) > _version_tuple(current) else ""
 
 
+def engine_version() -> str:
+    """The HOSTED engine's substrate version from the last check (cached), or "". This is what actually
+    serves fix/write for a thin client, so the boot shows THIS -- never a local path."""
+    return str(_cache().get("engine") or "")
+
+
 def refresh_async() -> None:
     """Fire-and-forget: ask the server for the latest published client and cache it for next session.
     The server sources this from PyPI, so publishing is all it takes -- no redeploy, no constant to bump."""
@@ -44,12 +54,16 @@ def refresh_async() -> None:
             from . import remote
             info = remote.server_info() or {}
             latest = str(info.get("latest_client") or "")
-            if not latest:
+            engine = str(info.get("engine_version") or "")
+            if not (latest or engine):
                 return
             path = _cache_path()
             os.makedirs(os.path.dirname(path), exist_ok=True)
+            cur = _cache()
+            cur.update({"latest": latest or cur.get("latest", ""),
+                        "engine": engine or cur.get("engine", ""), "t": int(time.time())})
             with open(path, "w", encoding="utf-8") as fh:
-                json.dump({"latest": latest, "t": int(time.time())}, fh)
+                json.dump(cur, fh)
         except Exception:
             pass
     try:

{substratum_cli-0.2.1 → substratum_cli-0.2.2}/substratum_cli/session.py

@@ -108,33 +108,50 @@ class Session:
         pn = S.Painter(self.color)
         name = os.path.basename(self.repo) or self.repo
         langs, files = self._repo_summary()
-        lib = engine.lib_roots.py_library_root()
-        libname = os.path.basename(lib) if lib else "none"
         census = f"{files} files" + ((" · " + langs.replace("  ", " · ")) if langs else "")
         st = build_state.standing(self.repo)
         ascii_mode = S.use_ascii()
         logged_in = account.is_logged_in()
         _update.refresh_async()                    # refresh the update cache in the background (next session)
         update_to = _update.available(_cver)       # instant read from cache; "" if none or unknown
+
+        # HONEST substrate: which intelligence actually serves fix/write this session, and in which mode.
+        # Two real deployment modes: HOSTED (thin client -> engine on Fly) and AIRGAPPED-LOCAL (engine +
+        # library shipped on-prem). Never claim a substrate that is not backing this session.
+        local_present = False
+        try:
+            _p = engine.lib_roots.py_library_root()
+            local_present = bool(_p) and os.path.exists(_p)
+        except Exception:
+            local_present = False                  # a thin client has no local library -- that is fine
+        ev = _update.engine_version()              # hosted engine's reported version (cached), "" if unknown
+        if logged_in:                              # hosted mode: write/fix reach the engine on the server
+            substrate = ev or "hosted engine"
+            sub_note, sub_ok, seal_key = (("hosted · connected", True, ev) if ev else ("connecting", False, "hosted"))
+        elif local_present:                        # airgapped / self-hosted: the on-disk library serves it
+            _warm = engine.is_warm()
+            substrate = _boot.RELEASE
+            sub_note, sub_ok, seal_key = (("local · ready" if _warm else "local · loading"), _warm, _boot.RELEASE)
+        else:                                       # thin client, not connected -> claim nothing
+            substrate, sub_note, sub_ok, seal_key = "not connected", "login to connect", False, "offline"
         # THE PROOF SEAL -- a self-certifying certificate boot: a byte-identical determinism seal (a real
         # hash of engine + substrate + scheme, no time/session input), the struck-plane emblem (the logo),
         # and a structured ledger. The sameness of the seal every boot IS the proof of determinism -- a
         # token-streaming tool cannot draw a stable self-certificate. Needs a wide pane; compact below.
         if S.seal_cols() >= 84:
-            for ln in _boot.render(name, census, "py · go · ts", libname, "", engine.is_warm(),
+            for ln in _boot.render(name, census, "py · go · ts", substrate, sub_note, sub_ok,
                                    st, "0.1.0", color=self.color, ascii_mode=ascii_mode,
-                                   logged_in=logged_in, update_to=update_to):
+                                   logged_in=logged_in, update_to=update_to, seal_key=seal_key):
                 self._say(ln)
             return
         # compact identity (narrow pane): the mark + a lime-railed status
-        state = (pn(S.g("lamp") + " ready", S.PROVEN) if engine.is_warm()
-                 else pn(S.g("dot") + " loading", S.CHROME))
+        state = pn(sub_note, S.PROVEN if sub_ok else S.CHROME)
         rail = ("\033[38;5;154m▌\033[0m" if (self.color and not ascii_mode) else "|")
         brand = (f"\033[38;5;154m{S.g('brand')}\033[0m" if (self.color and not ascii_mode)
                  else pn(S.g("brand"), S.PROVEN))
         self._say(brand + " " + pn("SUBSTRATUM", S.BOLD) + pn("   proof-carrying · deterministic", S.LABEL))
         self._say(f"  {rail} " + pn(name, S.BOLD) + "  " + pn(census, S.LABEL))
-        self._say(f"  {rail} " + pn(_boot.RELEASE, S.LABEL) + "  " + state)
+        self._say(f"  {rail} " + pn(substrate, S.LABEL) + "  " + state)
         if st:
             bits = pn(f"{st['runs']} runs", S.LABEL)
             if st.get("verified"):

{substratum_cli-0.2.1 → substratum_cli-0.2.2}/substratum_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: substratum-cli
-Version: 0.2.1
+Version: 0.2.2
 Summary: Substratum: verified-or-refused code, with provenance. The terminal over the comprehension engine.
 Author: Substratum
 License: LicenseRef-Proprietary