substratum-cli 0.1.0__tar.gz

substratum_cli-0.1.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: substratum-cli
+Version: 0.1.0
+Summary: Substratum: verified-or-refused code, with provenance. The terminal over the comprehension engine.
+Author: Substratum
+License: LicenseRef-Proprietary
+Project-URL: Homepage, https://substratum-api.fly.dev
+Keywords: code-generation,verification,deterministic,provenance,developer-tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Provides-Extra: engine
+Requires-Dist: numpy>=1.24; extra == "engine"
+
+# Substratum
+
+**Verified-or-refused code, with provenance.** Substratum is a deterministic comprehension engine
+for code. It never streams tokens and hopes — it produces a change only when that change passes a
+gate, and otherwise returns an honest, actionable refusal. Every result carries a run id you can
+replay byte-for-byte.
+
+```
+pip install substratum-cli
+```
+
+Then, in any repository:
+
+```
+substratum                      # open the interactive session (warms, then drives)
+```
+
+## What it does
+
+- **`summarize`** — describe the codebase in plain English, grounded in its real symbols (not a guess).
+- **`failing`** — run the suite and list the failing tests; each becomes a ready fix target.
+- **`verify`** — gate a diff (stdin, `--staged`, `--commit`): PASS / FAIL / per-hunk. The wedge — point
+  it at any tool's diff and it tells you, deterministically, whether the change is real.
+- **`fix`** — produce a verified fix for a failing test, or a named refusal.
+- **`write`** — greenfield code from plain intent (derive-or-refuse; no test required).
+- **`runs` / `show` / `replay` / `undo` / `apply` / `commit`** — a proof-carrying memory of every run.
+
+`summarize`, `failing`, and `verify` run **entirely on your machine** — no account, no network, no code
+leaves your repo. They work air-gapped.
+
+## The hosted engine (optional)
+
+`fix` and `write` draw on a large mined library. During the demo that library is hosted:
+
+```
+substratum login                # GitHub device flow; connects to the hosted engine
+```
+
+When logged in, `write` sends only your intent + signature, and `fix` receives a *candidate* that your
+machine then gates locally — so your code and your tests never leave your machine. `substratum logout`
+returns to fully-local operation.
+
+## The law
+
+Never render unproven code. A refusal is a deliverable, not an error. Determinism is a button you
+press to catch us: run the same request twice and get the same run id, or `replay` any run and get a
+byte-identical result.
+
+Coverage grows with data. Today the engine refuses more than it resolves, by design — the surface is
+built to feel complete at thin coverage, and the same commands silently resolve more as the library
+scales, with zero change on your end.

substratum_cli-0.1.0/README.md

@@ -0,0 +1,369 @@
+# Substratum
+
+**Private repository. Confidential under NDA.**
+
+Substratum is the production codebase for the Cognitive Substrate Framework (CSF):
+a Born-rule inference engine on a projector-based knowledge substrate, augmented
+with a claim-layered record architecture, a projection+filter query interface,
+and a four-code refuse taxonomy. Zero language models in the input path from
+user query to substrate answer. Structural non-hallucination preserved end to end.
+
+The canonical architectural reference is the white paper
+`Substratum v2.2.tex` (shared separately under NDA). This README documents the
+codebase: what is here, how it runs, what verifies it.
+
+## Architecture
+
+Two substrates under one algebraic schema:
+
+1. **CSF substrate** (`backend/core/`). Sparse density-operator rho on a
+   factored Hilbert space. Born-rule measurement, Lindblad coherence evolution,
+   Davies gradient-flow generative dynamics, A13 observation-vs-intervention
+   counts, A14 noise correction, A15 compositional inference.
+
+2. **Claim-layered substrate** (`backend/substratum_v2/`). ClaimRecord schema
+   with UTTERANCE / WORLD / COLLAPSED layers, warrant taxonomy
+   (AUTHORITATIVE_DOCUMENT / COLLAPSED_SELF_STATE / CONVERGENT_SOURCES /
+   SINGLE_SOURCE), source-identity non-aliasing, layer collapse rule.
+   Structured extractor, projection+filter query parser, four-code refuse
+   taxonomy, four response patterns.
+
+### One door, one answer
+
+Every capability flows through `POST /api/answer` and produces a
+`SubstratumAnswer` envelope (closed-class status enum, closed-class mode
+enum, source pills, claim cards, warrant, layer, trace). The router at
+`backend/substratum_v2/answer/router.py` fans out to nine dispatchers in
+parallel (claim, advice, philosophical chat, composition contradiction,
+legal case treatment, code generation, code review, code completion, code
+refactoring) and merges by status precedence + cascade order. Each
+dispatcher self-gates and returns None when its intent does not latch.
+The frontend renders one panel per answer; no branching by mode.
+
+### Shipped capability surfaces
+
+- **Claim and advice** dispatchers serve factual lookup, multi-hop
+  composition, and multi-source advice synthesis with calibrated confidence
+  and clarification.
+- **Philosophical chat** dispatcher handles philosophical inquiry with
+  attribution-first rendering and engagement signals.
+- **Composition** (`backend/substratum_v2/composition/` +
+  `composition_wiring/`): generalized passage composer, contradiction
+  detection across substrates, claim-diff detection, counterfactual
+  application. Refuses on no-topic, ambiguous-topic, no-records, and
+  no-contradiction with structural reasons.
+- **Legal vertical** (`backend/substratum_v2/legal/`): first
+  regulated-vertical registration. Native slip-opinion ingestion derives
+  every per-case property from raw text (deciding court, citation, year,
+  source id) by closed-class Bluebook + caption parsers. Case-treatment
+  dispatcher answers "did X overrule / distinguish / follow / extend /
+  limit / affirm / reverse / vacate / remand Y" with VERIFIED, REFUTED,
+  NO_RECORD, ACTOR_UNKNOWN, OBJECT_UNKNOWN, and AMBIGUOUS outcomes. 37
+  SCOTUS cases ingested (Fourth Amendment + criminal procedure).
+- **Code intelligence triad**, all deterministic and refuse-when-uncertain:
+  - **Autocomplete** (`backend/substratum_v2/autocomplete/`): substrate-
+    driven completion engine + LSP server, shipped as the
+    `vscode-substratum-autocomplete` extension.
+  - **Refactoring** (`backend/substratum_v2/refactoring/`): local rename,
+    module-level rename, cross-module workspace-aware rename, wired into
+    LSP `textDocument/rename` + `prepareRename`.
+  - **Code review** (`backend/substratum_v2/code_review/`): static bug
+    detector with provably-real findings only, diff analyzer for breaking-
+    change risk, `substratum-check` CLI for pre-commit and PR hooks,
+    GitHub Action for PR auto-comment, zero-FP gate report.
+
+## Layout
+
+```
+backend/
+  core/                     CSF substrate: rho, Born rule, dynamics
+    data.py                 TripleStore with A13 observation/intervention counts
+    substrate.py            Substrate manager with evolve_coherence + relax_toward
+    sparse_rho.py           Sparse dictionary rho (OP-embedB cascade locality)
+    inference.py            InferenceEngine: query, verify, compose, observe
+    coherences.py           Off-diagonal coherence store
+    perspectives.py         R3 perspective discovery
+    noise.py                A14 confusion-matrix inversion
+  substratum_v2/            Claim-layered substrate
+    claims.py               ClaimRecord / NoClaimRecord schemas + enums
+    ingestion.py            IngestionContext, CORPUS_POLICY, source identity
+    linguistic_features.py  Token-level closed-class feature registry
+    claim_extractor.py      Deterministic sentence -> ClaimRecord extractor
+    claim_substrate.py      Factored-Hilbert family per (IngestionType, Layer, Force)
+    query_parser_v2.py      Projection + filter parser, four refuse codes
+    substrate_filter.py     Match records against FilterSpec (linear + indexed)
+    projection.py           Apply projection spec to matches
+    inflection_index.py     Substrate-derived verb morphology
+    entity_canon.py         Entity canonicalization
+    queries.py              Query primitives: what_did_X_say, is_Y_true,
+                            self_state, causal_chains, attribution_projection,
+                            interpretations_of, prob_marginal/conditional/distribution
+    query_router.py         Claim-pipeline shape detection
+    triple_ingest.py        Structured-triple ingestion (separate from prose)
+    triple_ontologies/      Per-ontology PredicateSpec registries (Wikidata, etc.)
+    build_claim_store.py    Build claim_store.pkl from corpus
+    answer/                 Unified /api/answer router + SubstratumAnswer envelope
+      router.py             Nine-dispatcher fan-out, status precedence merge
+      types.py              AnswerStatus, ResponseMode, SourcePill, ClaimCard
+      adapters.py           Pipeline-dict -> SubstratumAnswer normalizers
+      prose.py              Surface prose rendering
+    advice/                 Multi-source advice dispatcher
+      advice_dispatcher.py  Orchestrates parse -> evidence -> synthesis
+      conclusion_synthesizer.py  Final advice synthesis
+      calibration_engine.py Confidence calibration
+      frame_state.py        Per-session multi-turn state
+      production_substrate_adapter.py  Indexed candidate narrowing + slow-path filter
+    philosophical_chat/     Philosophical inquiry dispatcher with attribution
+    composition/            Generalized passage composer + contradiction detector
+                            + claim diff + counterfactual + citation styles
+    composition_wiring/     CONTRADICTION dispatcher into /api/answer
+    legal/                  Legal-vertical substrate. Native slip-opinion
+                            ingestion (Bluebook + caption parsers), 15-predicate
+                            closed-class catalog, case-treatment dispatcher
+    alias_store/            DECLARED + DERIVED alias records; one-hop warranted
+                            expansion at filter time (XBRL, SEC, user-asserted)
+    code_generation/        Code-gen v1 (legacy goal composition + pattern lookup)
+    code_generation_v2/     Code-gen v2 (delta handlers + bug-fix synthesis;
+                            v1 falls back to v2 first via handle_v2_g9_bug_fix)
+    code_review/            Static bug detector + diff analyzer + CLI + Action
+    autocomplete/           Substrate-driven completion engine + LSP server
+    refactoring/            Local + module + cross-module rename, LSP-wired
+    profile/                Per-session conversation frame + drift detection
+    indexes/                Inverted index (referent-keyed candidate narrowing,
+                            equivalence-tested vs full scan), citation graph,
+                            source relationships, temporal clustering
+    parser/                 Closed-class grammar + handlers
+    table_ingest/           Table -> ClaimRecord synthesis (RDF, CSV, financial)
+    rendering/              Mode-specific renderers under one rendering context
+    reasoning/              Reasoning chain capture, rule store, composition engine
+    SCHEMA.md               Claim schema spec with refuse-code documentation
+    AUDIT.md                Hand-labeled extraction ground truth (30 sentences)
+    _run_audit{1..10}.py    Independent audit gates (claim extraction,
+                            queries, axioms, probability, adversarial,
+                            response patterns, parser structural, reverse-
+                            lookup, adversarial parser, table ingest)
+  text_ingest/              Non-LLM text-to-observation pattern extractor
+    patterns.py             Pattern store with substrate alignment
+    r3_patterns.py          R3 applied to patterns
+    structural.py           Closed-class function-word analysis
+  app.py                    FastAPI: dispatcher + all endpoints
+  nl_parser.py              Legacy CSF parser (coupling-based)
+  llm_compare.py            Anthropic streaming for side-by-side demo
+  ingest/                   Wikidata ingestion scripts
+
+frontend/                   React + TypeScript + Vite + Tailwind
+  src/components/           SubstratumPanel, GraphCanvas, QueryBar, ...
+  src/components/claim/     ClaimCard, SourcePill, LayerBadge,
+                            ProvenanceChain, ReverseMatchesPanel, GapPanel
+  src/types/api.ts          Contract with backend SubstratumAnswer shape
+
+extensions/
+  vscode-substratum-autocomplete/  VS Code LSP client for autocomplete + rename
+
+tests/                      pytest suite, all green
+  test_falsification_predictions.py  Reciprocity, interference, Guppy
+  test_inference.py         Born-rule query/verify/compose
+  test_invariant.py         Structural non-hallucination
+  test_coherence_evolution.py  Lindblad semigroup/Markov/CPTP
+  test_relaxation.py        Davies generative relaxation
+  test_noise.py             A14 noise correction
+  test_adaptive_prior.py    A12 adaptive similarity prior
+  test_intervention.py      A13 observation vs intervention
+  test_demo_response_shape.py    Frontend contract for shipped demo queries
+  test_demo_regression_catalog.py  Permanent regression catalog
+  answer/                   /api/answer router + adapter + index equivalence
+  advice/                   Advice dispatcher and synthesis
+  philosophical_chat/       Philosophical pipeline + dialogue frame
+  composition/              Composer + contradiction + counterfactual + diff
+  composition_wiring/       CONTRADICTION routing into /api/answer
+  legal/                    Legal parser + slip-opinion captions + dispatcher
+  code_generation/          Code-gen v1 pipeline
+  code_generation_v2/       Code-gen v2 delta handlers + synthesis
+  code_review/              Static detector + diff analyzer
+  autocomplete/             Completion engine + LSP
+  refactoring/              Rename engine + LSP wiring
+  rendering/                Mode-specific renderers
+  reasoning/                Reasoning chain capture, rule eval, composition
+  indexes/                  Inverted index + cross-backend equivalence
+  integration/              End-to-end pipelines
+  profile/                  Drift detection + active constraints
+  text_ingest/              Pattern extraction
+  conversation/             Multi-turn session state
+  fixtures/                 Test data including quality_corpus.jsonl
+
+scripts/                    Build, benchmark, and quality pipelines
+  quality/                  1,403-query end-to-end sweep against /api/answer
+  benchmark/                Performance harnesses
+  swe_bench/                SWE-Bench Lite integration
+  real_engineer_bench/      Real-engineer head-to-head benchmark
+  code_review/              Code review benchmark + zero-FP validation
+  refactoring/              Refactoring benchmark + binding-safety harness
+  autocomplete/             Completion benchmark, held-out stdlib
+  code_corpus/              Code corpus curation (multi-language OSS reference)
+  philosophical_chat_corpus/  Philosophical dialogue corpus
+  derived/                  Derived artifact generation
+
+fly.toml                    Fly.io deploy config (substratum-api)
+vercel.json                 Vercel frontend deploy config
+Dockerfile                  Backend container
+requirements.txt            Python dependencies
+```
+
+## Quick start
+
+### Backend (local)
+
+```bash
+pip install -r requirements.txt
+python -m backend         # starts FastAPI on http://localhost:8000
+```
+
+Environment variables (see `.env.example`):
+
+- `ANTHROPIC_API_KEY` - for `/api/llm-stream` Claude streaming (comparison
+  panel only; never in the substrate query path)
+- `SUBSTRATUM_ALLOWED_ORIGINS` - comma-separated CORS allowlist (defaults
+  to localhost + `*.vercel.app`)
+- `SUBSTRATUM_DEMO_TAG` - public demo-tag header for rate-limited endpoints
+- `SUBSTRATUM_RATE_PER_MINUTE` - per-IP rate limit (default 60)
+
+### Frontend (local)
+
+```bash
+cd frontend
+npm install
+npm run dev                # vite dev server on http://localhost:5173
+```
+
+Environment (build time):
+
+- `VITE_API_BASE_URL` - backend origin (unset in dev, set in prod)
+- `VITE_DEMO_TAG` - public demo-tag sent as X-Demo-Tag header
+
+### VS Code extension
+
+```bash
+cd extensions/vscode-substratum-autocomplete
+npm install
+# Press F5 in VS Code to launch the extension host
+```
+
+The extension spawns the LSP server at
+`backend/substratum_v2/autocomplete/lsp_server.py`. Configurable via
+`substratum.*` settings in VS Code.
+
+### Build the claim store (optional, for claim-pipeline queries)
+
+```bash
+python -m backend.substratum_v2.build_claim_store
+```
+
+Reads `backend/substratum_v2/data/corpus_cache_30k.pkl`, runs the claim
+extractor, builds the entity canon and source index, pickles
+`claim_store.pkl`. Not tracked in git; regenerated locally.
+
+## Testing and audits
+
+### pytest suite
+
+```bash
+python3 -m pytest tests/ --no-header
+# Full green; slow tests (-m slow) cover production-substrate equivalence
+```
+
+### Independent audit gates
+
+Each audit is self-contained, prints a pass/fail line per case, and exits
+non-zero on any failure.
+
+```bash
+python3 -m backend.substratum_v2._run_audit1   # 30 claim-extraction cases
+python3 -m backend.substratum_v2._run_audit2   # 20 query-primitive cases
+python3 -m backend.substratum_v2._run_audit3   # 60 substrate-axiom checks
+python3 -m backend.substratum_v2._run_audit4   # 10 probability queries
+python3 -m backend.substratum_v2._run_audit5   # 14 adversarial surface-form
+python3 -m backend.substratum_v2._run_audit6   # 4 response patterns
+python3 -m backend.substratum_v2._run_audit7   # 137 parser structural cases
+python3 -m backend.substratum_v2._run_audit8   # 11 reverse-lookup cases
+python3 -m backend.substratum_v2._run_audit9   # 55 adversarial parser cases
+python3 -m backend.substratum_v2._run_audit10  # 15 table-ingest ground truth
+```
+
+### Quality sweep
+
+```bash
+python3 -m scripts.quality.run_quality_sweep \
+    --base-url http://127.0.0.1:8000 \
+    --workers 12 \
+    --report scripts/quality/last_sweep.json
+```
+
+End-to-end sweep against `/api/answer`. Validates every response is
+graceful, structurally well-formed (SubstratumAnswer shape, closed-class
+status + mode), free of audit-metadata leakage, and under the 25s router
+budget. Corpus combines synthesized adversarial cases with real-world
+queries from a multi-source corpus.
+
+## Deployment
+
+### Backend (Fly.io)
+
+```bash
+flyctl deploy                        # from repo root
+# fly.toml: substratum-api in iad, 8000, shared-cpu-2x, 3 GB
+```
+
+Health check: `GET /api/stats` every 30s. The Docker image bakes in the
+pre-built completion index pickle so the autocomplete pipeline is ready
+on first request.
+
+### Frontend (Vercel)
+
+Connected to GitHub main. A deploy hook URL is held separately and fired
+after each push to bypass the Hobby-plan commit-author gate. The Vercel
+build proxies `/api/*` to the Fly backend; one POST to `/api/answer`
+serves every capability.
+
+## Key references
+
+- `backend/substratum_v2/SCHEMA.md` - claim schema, layer rules, warrant
+  taxonomy, refuse-code documentation
+- `backend/substratum_v2/AUDIT.md` - extraction audit design
+- `Substratum v2.2.tex` - white paper (shared separately under NDA)
+
+## Status summary
+
+- pytest suite green (claim, advice, philosophical, composition,
+  composition_wiring, legal, code generation v1+v2, code review,
+  autocomplete, refactoring, rendering, reasoning, indexes, profile,
+  text ingest, conversation, integration)
+- 10 independent audit gates green (claim extraction, queries, axioms,
+  probability, adversarial surface-form, response patterns, parser
+  structural, reverse-lookup, adversarial parser, table ingest)
+- 10/10 falsification predictions with live tests
+- Code intelligence triad shipped: autocomplete + refactoring + code review,
+  all wired through `/api/answer` and the VS Code extension
+- Composition shipped: contradiction detection + claim-diff + counterfactual
+  composer, multi-substrate union (philosophical + legal), CONTRADICTION
+  intent routed through `/api/answer`
+- Legal vertical shipped (Ship LG.1): 37 SCOTUS cases ingested natively
+  from raw slip-opinion text, case-treatment dispatcher with VERIFIED /
+  REFUTED / NO_RECORD / ACTOR_UNKNOWN / OBJECT_UNKNOWN / AMBIGUOUS
+  outcomes, opposition pairs registered for circuit-split detection
+- Unified `/api/answer` router with `SubstratumAnswer` envelope; one panel
+  at the surface
+- Inverted-index candidate narrowing for the production substrate adapter
+  (1700x speedup, equivalence-proven against full scan)
+- 1,403-query end-to-end quality sweep against `/api/answer`
+- Zero language models in the query pipeline
+- Zero hardcoded content in the parser source
+- Deterministic: same input produces byte-equal response
+- Ingestion derives every per-document property from raw text; no filename
+  mappings, no metadata sidecars, no human curation
+- Deployed on Fly.io (backend) + Vercel (frontend)
+
+## Confidentiality
+
+This repository is private. Access implies NDA. Do not share the source,
+the white paper, or any architectural specifics without explicit written
+authorization from the author.

substratum_cli-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "substratum-cli"
+version = "0.1.0"
+description = "Substratum: verified-or-refused code, with provenance. The terminal over the comprehension engine."
+readme = "substratum_cli/README.md"
+license = { text = "LicenseRef-Proprietary" }
+authors = [{ name = "Substratum" }]
+keywords = ["code-generation", "verification", "deterministic", "provenance", "developer-tools"]
+requires-python = ">=3.11"
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Topic :: Software Development :: Code Generators",
+]
+
+# CORE is stdlib-only: the CLI and `verify` carry ZERO runtime dependencies (the air-gapped,
+# zero-egress story). The engine extras are the numpy subset the fix path imports.
+dependencies = []
+
+[project.optional-dependencies]
+engine = ["numpy>=1.24"]
+
+[project.scripts]
+substratum = "substratum_cli.cli:main"
+
+[project.urls]
+Homepage = "https://substratum-api.fly.dev"
+
+[tool.setuptools]
+packages = ["substratum_cli", "substratum_cli.commands", "substratum_cli._vendor"]
+
+[tool.pytest.ini_options]
+markers = ["slow: loads the full production library (minutes); excluded from the fast gate"]

substratum_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

substratum_cli-0.1.0/substratum_cli/README.md

@@ -0,0 +1,51 @@
+# Substratum
+
+**Verified-or-refused code, with provenance.** Substratum is a deterministic comprehension engine
+for code. It never streams tokens and hopes — it produces a change only when that change passes a
+gate, and otherwise returns an honest, actionable refusal. Every result carries a run id you can
+replay byte-for-byte.
+
+```
+pip install substratum-cli
+```
+
+Then, in any repository:
+
+```
+substratum                      # open the interactive session (warms, then drives)
+```
+
+## What it does
+
+- **`summarize`** — describe the codebase in plain English, grounded in its real symbols (not a guess).
+- **`failing`** — run the suite and list the failing tests; each becomes a ready fix target.
+- **`verify`** — gate a diff (stdin, `--staged`, `--commit`): PASS / FAIL / per-hunk. The wedge — point
+  it at any tool's diff and it tells you, deterministically, whether the change is real.
+- **`fix`** — produce a verified fix for a failing test, or a named refusal.
+- **`write`** — greenfield code from plain intent (derive-or-refuse; no test required).
+- **`runs` / `show` / `replay` / `undo` / `apply` / `commit`** — a proof-carrying memory of every run.
+
+`summarize`, `failing`, and `verify` run **entirely on your machine** — no account, no network, no code
+leaves your repo. They work air-gapped.
+
+## The hosted engine (optional)
+
+`fix` and `write` draw on a large mined library. During the demo that library is hosted:
+
+```
+substratum login                # GitHub device flow; connects to the hosted engine
+```
+
+When logged in, `write` sends only your intent + signature, and `fix` receives a *candidate* that your
+machine then gates locally — so your code and your tests never leave your machine. `substratum logout`
+returns to fully-local operation.
+
+## The law
+
+Never render unproven code. A refusal is a deliverable, not an error. Determinism is a button you
+press to catch us: run the same request twice and get the same run id, or `replay` any run and get a
+byte-identical result.
+
+Coverage grows with data. Today the engine refuses more than it resolves, by design — the surface is
+built to feel complete at thin coverage, and the same commands silently resolve more as the library
+scales, with zero change on your end.

substratum_cli-0.1.0/substratum_cli/__init__.py

@@ -0,0 +1,6 @@
+"""substratum_cli -- the product surface (CLI + shared object model) over the Substratum engine.
+
+Import budget: this package is stdlib-only; the ONLY module reaching into backend.* is
+`engine.py`, lazily. Importing substratum_cli (or any light command) opens nothing heavy.
+"""
+__version__ = "0.1.0"

substratum_cli-0.1.0/substratum_cli/__main__.py

@@ -0,0 +1,7 @@
+"""python -m substratum_cli -> the CLI."""
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))