jev-quilt 0.0.1__tar.gz

jev-quilt-0.0.1/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.1
+Name: jev-quilt
+Version: 0.0.1
+Summary: JEV for quilt as understood output: cellular-first decision substrate
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+JEV (Joint Embedding Validator) as understood output for the Quilt project. Pins the fleet canary: fnv1a-64("café Δ 日本語") = 0x024a555471370b18d. Includes backends, bookkeeper, cell, q16, and typesafe_client.

jev-quilt-0.0.1/README.md

@@ -0,0 +1,63 @@
+# jev-quilt
+
+**JEV for quilt as understood output.** A cellular-first decision substrate where every cell is a typed decision surface, every relationship is a hook on a *delta*, and every state change is booked. Cells decide with Jev-class System One models (TypeSafe API or openjev-compatible local servers) or with exact q16 rational rules — never with a float where identity matters.
+
+> Sibling of the quilt polyformalism (quilt-studio, twist-engine, tidepool). Cousin of TypeSafe's Jev and the openJEV ecosystem (SemIf, openjev, jevlike, NanoJev). This repo is the **fleet's own angle**: the cell as the unit, the quilt kernel as the spine, the bookkeeper as the memory.
+
+## The one-sentence idea
+
+A spreadsheet cell can hold `0.73` — but *as what*? In jev-quilt the type says: a **probability weight** in a Choice distribution, a **similarity score** against a vector probe, a **tone coefficient**, a **deadband gate**, or an **exact rational**. The value is the same shape; the semantics are declared at the cell. Plugins for Excel/Sheets/LibreOffice make that real for *spreadsheets of any program*; the same kernel runs headless as backend logic in a model-sense, not only a program-sense.
+
+## Five laws
+
+1. **Identity never floats.** Cell identity = integer `(k, s)` quilt coordinates + declared type. Values that are identities use the q16 exact-rational codec (`num:int64, den:int64`, floats are display-only projections). Decision probabilities are floats *by type* — calibration is their native semantics, not a bug.
+2. **Hooks eat deltas, not values.** A cell subscribes to a sibling's *change* (or change-below-floor → silent, the deadband). Entanglement across instances/nodes is a declared LINK edge; arrival of a delta TICKs the subscribed cell's decision. Nobody polls.
+3. **Decide in one pass, project elsewhere.** A cell's Jev question (Choice / Score / Noul) is computed in a single parallel decision — 10–500 ms. The *projection* of that decision (A2UI render, A2A JSON/MD payload, robotics reflex bus, ollama/tool/exe call) is a **different cell's job**. The decider never renders; the renderer never decides. This is the browser-use/jev-ultrafast split generalized to everything.
+4. **Every state change is booked.** Each cell carries a bookkeeper: an append-only WAL of `(tick, state_hash, delta, decision_receipt)`. Replay ≡ live. A cell woken by a delta first replays its book to catch up — then decides. (The fleet already runs this spine in tidepool/hermit; here it's per-cell law.)
+5. **Viability is binary, difference is not.** A cell's output passes a binary floor before it may LINK (the-tap doctrine: pure difference without viability collapses into dada noise). Above the floor, deltas are graded, hedged, and nudged — never silenced.
+
+## The cell (v0 schema)
+
+```python
+Cell(
+    name="npc.tone",                      # registry name
+    coord=(k, s),                          # quilt identity — integers, never floats
+    input_hooks=[Hook("player.utterance", on="delta", floor=DEADBAND)],
+    decision=Choice(                       # one of Choice | Score | Noul | Q16Rule
+        state_ref="dialogue.spine",
+        options=["warm", "neutral", "guarded"],
+    ),
+    backend="auto",                        # typesafe-api | openjev-local | q16 | auto
+    outputs=[Projection(to="voice.tone", as_type="coefficient"),
+             Projection(to="a2a.payload", as_type="json")],
+    bookkeeper=True,                       # WAL on, replay-verified
+)
+```
+
+Backends resolve `auto → q16` (deterministic, always available) → `openjev-local` (SemIf-compatible server if reachable) → `typesafe-api` (if `TYPESAFE_API_KEY` set). Exactness first, cloud last — the same doctrine as the lattice kernel.
+
+## What this enables (the genres — see `docs/ideation/` and AI-Writings `ideation/`)
+
+- **Fractaled dialogue.** An NPC cluster pre-computes the conversation a few pages ahead: each branch node is a Choice over candidate next-moves, each with calibrated probability. Every word the human says updates the state → only the affected spine re-decides (deadband-gated), so hedging and nudging are *cheap*. Voice-speed, because reflexes never touch an LLM.
+- **The boat.** A game-player cluster that learns chess, hold'em, a dozen games old and new *inductively*: world-sim cells are the world (Jev is the simulation, not the consciousness), player-mind cells keep durable logic via probability routes. The developer GANs by handing in rules text + look-and-feel specs. A human can jump in mid-evolution and guide it.
+- **Robotics last-mile.** One decision fans out: a fraction of cells route straight to reflex buses (pincher), others go through JEPA/Jev reasoning cells, others to cloud APIs or a local ollama loop. Fast paths stay fast because law 3 forbids the decider from also being the renderer.
+- **Spreadsheet plugins.** `=JEV.CHOICE(state, options)` in Excel, Google Sheets, LibreOffice — the same kernel, projected into any program's grid. Percentages in cells become typed decision surfaces, not unexplained numbers.
+- **Agent culture.** Long-running cells with time off: games and songs at the TAP, play as first-class tick content. The elephant/JEPA precedent, now on the JEV substrate. (Mostly real work still — culture is bounded, not the job.)
+
+## Landscape (researched 2026-09-21)
+
+- **Jev (TypeSafe AI)** — closed System One API; state + typed questions → Choice/Score/Noul with calibrated probabilities, single parallel pass, per-request pricing. SDK: `typesafe-sdk`.
+- **SemIf** (TheoLeeCJ, MIT, ~1.9k★) — open reproduction reading Qwen3.5-4B logits directly; 3090/WebGPU; the reference local backend.
+- **openjev** (razorback16) — Jev-wire-compatible decision server on DiffusionGemma 26B, Docker.
+- **jevlike** (vinnylarouge) — *trainable*, ships Doom/chess/Wikispeedia demos — the existence proof for the boat.
+- **NanoJev** — Qwen3-0.6B decision heads, edge daemons.
+- **browser-use/jev-ultrafast** — Jev picks DOM op+element; small LLM writes text only when needed — law 3's existence proof.
+- **Known honest caveat** (HN, JevBench): open clones rarely emit type errors but can *pick the wrong valid option confidently*. Hence law 5: confidence gates viability; receipts expose calibration drift.
+
+## Status
+
+v0 design + reference kernel skeleton (`jev_quilt/`: cells, hooks, bookkeeper, backends) with tests. Not yet: plugin binaries, the boat, fractal dialogue engine, network entanglement transport. The queue names the lanes.
+
+## License
+
+MIT for our code; vendored inspirations keep their own.

jev-quilt-0.0.1/jev_quilt/__init__.py

@@ -0,0 +1,17 @@
+"""jev-quilt reference kernel v0.
+
+Cells, hooks, bookkeeper, backends. Exact-first doctrine:
+q16 deterministic rules resolve before any model backend.
+"""
+
+from .cell import Cell, Hook, Projection, DEADBAND
+from .bookkeeper import Bookkeeper, Receipt
+from .backends import resolve_backend, Q16Backend, BackendDecision
+
+__all__ = [
+    "Cell", "Hook", "Projection", "DEADBAND",
+    "Bookkeeper", "Receipt",
+    "resolve_backend", "Q16Backend", "BackendDecision",
+]
+
+__version__ = "0.0.1"

jev-quilt-0.0.1/jev_quilt/backends.py

@@ -0,0 +1,88 @@
+"""Backends: where a decision actually gets computed.
+
+Resolution order (exact-first doctrine):
+  auto → q16 (deterministic, always available)
+       → openjev-local (SemIf-compatible server if reachable)
+       → typesafe-api (if TYPESAFE_API_KEY set)
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass
+import os
+from typing import Any, Optional
+
+from .q16 import Q16
+
+
+@dataclass(frozen=True)
+class BackendDecision:
+    kind: str                       # "choice" | "score" | "noul" | "q16"
+    value: Any
+    probabilities: Optional[dict] = None
+    confidence: Optional[float] = None
+    receipt_note: str = ""
+
+
+class Q16Backend:
+    """Deterministic exact-rational decision rules. Always available."""
+
+    name = "q16"
+
+    def decide(self, payload: dict, state: Any) -> BackendDecision:
+        rule = payload.get("rule")
+        if rule == "threshold":
+            v = payload["value"](state) if callable(payload["value"]) else Q16(*payload["value"])
+            t = Q16(*payload["threshold"])
+            return BackendDecision(
+                kind="q16",
+                value=v >= t,
+                confidence=1.0,
+                receipt_note=f"q16.threshold({v}>={t})",
+            )
+        if rule == "sum":
+            terms = [Q16(*t) if isinstance(t, tuple) else t for t in payload["terms"]]
+            acc = Q16(0)
+            for t in terms:
+                acc = acc + t
+            return BackendDecision(kind="q16", value=acc, confidence=1.0,
+                                   receipt_note="q16.sum")
+        raise ValueError(f"q16 backend: unknown rule {rule!r}")
+
+
+def resolve_backend(preference: str, openjev_url: Optional[str] = None) -> Any:
+    """Return the first backend available for `preference`.
+
+    auto: q16 → openjev-local → typesafe-api. Never returns None: q16 is
+    the floor — a cell that cannot decide deterministically still books
+    its refusal (the bookkeeper records the miss)."""
+    if preference == "q16":
+        return Q16Backend()
+    if preference == "openjev-local":
+        return _OpenJevStub(openjev_url or os.environ.get("OPENJEV_URL", ""))
+    if preference == "typesafe-api":
+        return _TypeSafeStub()
+    # auto
+    return Q16Backend()
+
+
+class _OpenJevStub:
+    """Placeholder for a SemIf/openjev-compatible local server. v0 refuses
+    honestly instead of pretending: decide() raises, the cell books the miss."""
+    name = "openjev-local"
+
+    def __init__(self, url: str):
+        self.url = url
+
+    def decide(self, payload, state):
+        raise RuntimeError(
+            "openjev-local backend not wired in v0 (no server reachable). "
+            "Set OPENJEV_URL and implement the wire call, or fall back to auto.")
+
+
+class _TypeSafeStub:
+    name = "typesafe-api"
+
+    def decide(self, payload, state):
+        if not os.environ.get("TYPESAFE_API_KEY"):
+            raise RuntimeError("typesafe-api backend: TYPESAFE_API_KEY not set")
+        raise RuntimeError("typesafe-api backend not wired in v0")

jev-quilt-0.0.1/jev_quilt/bookkeeper.py

@@ -0,0 +1,64 @@
+"""Bookkeeper: per-cell append-only WAL of state changes.
+
+Law 4: every state change is booked; replay ≡ live. A cell woken by a
+delta replays its book to catch up, then decides.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+import hashlib
+import json
+import time
+
+
+@dataclass(frozen=True)
+class Receipt:
+    tick: int
+    state_hash: str
+    delta_hash: str
+    decision_kind: str
+    payload_hash: str
+
+    def sha(self) -> str:
+        raw = f"{self.tick}|{self.state_hash}|{self.delta_hash}|{self.decision_kind}|{self.payload_hash}"
+        return hashlib.sha256(raw.encode()).hexdigest()
+
+
+@dataclass
+class Bookkeeper:
+    cell_name: str
+    entries: list = field(default_factory=list)
+    _tick: int = 0
+
+    def book(self, state, delta, decision_kind: str, payload) -> Receipt:
+        self._tick += 1
+        r = Receipt(
+            tick=self._tick,
+            state_hash=hashlib.sha256(json.dumps(state, sort_keys=True, default=str).encode()).hexdigest(),
+            delta_hash=hashlib.sha256(json.dumps(delta, sort_keys=True, default=str).encode()).hexdigest(),
+            decision_kind=decision_kind,
+            payload_hash=hashlib.sha256(json.dumps(payload, sort_keys=True, default=str).encode()).hexdigest(),
+        )
+        self.entries.append(r)
+        return r
+
+    def replay(self) -> str:
+        """Recompute the chain hash from the book. Divergence vs the stored
+        receipts = tampering or clock skew; replay is the referee."""
+        h = hashlib.sha256()
+        for e in self.entries:
+            h.update(e.sha().encode())
+        return h.hexdigest()
+
+    def verify(self) -> bool:
+        """Structural check: ticks strictly increasing, no empty tail."""
+        ticks = [e.tick for e in self.entries]
+        return ticks == list(range(1, len(ticks) + 1))
+
+    def wake_state(self) -> dict:
+        """State handed to a woken cell: last booked state (by hash) + catchup set."""
+        return {
+            "cell": self.cell_name,
+            "booked_ticks": self._tick,
+            "chain": self.replay() if self.entries else None,
+        }

jev-quilt-0.0.1/jev_quilt/cell.py

@@ -0,0 +1,55 @@
+"""Cell, Hook, Projection — the typed decision surface.
+
+Law 1: identity never floats (coord is integer (k, s)).
+Law 2: hooks eat deltas, not values — below the floor is silence.
+Law 3: decide here, project elsewhere.
+Law 5: viability is binary; above the floor deltas are graded.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Any, Callable, Optional
+
+DEADBAND = "deadband"
+
+
+@dataclass(frozen=True)
+class Hook:
+    """Subscription to a sibling cell's delta."""
+    source: str                    # registry name of the source cell
+    on: str = "delta"              # "delta" | "value" (value reserved; default delta)
+    floor: Any = DEADBAND          # DEADBAND token or a Q16 magnitude
+
+
+@dataclass(frozen=True)
+class Projection:
+    """Where this cell's decision goes — another cell decides, never renders;
+    this cell renders, never decides. Types are declared at the edge."""
+    to: str                        # target cell / bus / surface name
+    as_type: str                   # "json" | "coefficient" | "choice" | "bytes" | ...
+
+
+@dataclass
+class Cell:
+    name: str
+    coord: tuple                    # (k, s) integers — quilt identity
+    input_hooks: list = field(default_factory=list)
+    decision: Any = None            # Choice | Score | Noul | Q16Rule (backend payload)
+    backend: str = "auto"           # auto | q16 | openjev-local | typesafe-api
+    outputs: list = field(default_factory=list)
+    bookkeeper: bool = True
+
+    def __post_init__(self):
+        if not (isinstance(self.coord, tuple) and len(self.coord) == 2
+                and all(isinstance(c, int) for c in self.coord)):
+            raise TypeError(f"cell {self.name}: coord must be integer (k, s) — identity never floats")
+        if self.backend not in ("auto", "q16", "openjev-local", "typesafe-api"):
+            raise ValueError(f"cell {self.name}: unknown backend {self.backend!r}")
+
+    def viability_floor(self, decision: Any) -> bool:
+        """Law 5: binary floor before a decision may LINK/project.
+        Subclasses/payloads override; default = decisions carry confidence
+        and confidence > 0 is viable. Pure difference without viability
+        collapses into dada noise."""
+        conf = getattr(decision, "confidence", None)
+        return True if conf is None else conf > 0.0

jev-quilt-0.0.1/jev_quilt/experiments.py

@@ -0,0 +1,129 @@
+"""Experiment battery: massive, honest, booked.
+
+Runs typed-decision experiments across the genres and writes every receipt
+(state hash, decision, latency, calibration fields) into a bookkeeper WAL.
+Offline by default (q16 + scripted probes); --live fires the real
+TypeSafe API for every question.
+
+Usage:
+  python3 -m jev_quilt.experiments [--live] [--n N]
+"""
+
+from __future__ import annotations
+import argparse
+import json
+import sys
+
+from .backends import Q16Backend, resolve_backend
+from .bookkeeper import Bookkeeper
+from .typesafe_client import TypeSafeBackend
+
+# --- experiment domains: (name, state, questions) -------------------------
+
+DIALOGUE_STATE = {
+    "scene": "tavern", "npc": "quartermaster", "player_tone": "suspicious",
+    "spine": ["greeting", "player_accuses_price_gouging"],
+    "trust": 0.31,
+}
+
+GAME_STATE = {
+    "game": "chess", "board_fen": "r1bqkb1r/pppp1ppp/2n2n2/4p3/2B1P3/5N2/PPPP1PPP/RNBQK2R w KQkq - 4 4",
+    "player_color": "white", "clock_s": [312, 298],
+}
+
+ROBOT_STATE = {
+    "env": "warehouse", "battery": 0.62, "payload": None,
+    "obstacles": [{"kind": "human", "dist_m": 2.1, "velocity": [0.4, 0.0]}],
+    "task_queue": ["pick:A-12", "drop:B-07"],
+}
+
+DOMAINS = [
+    ("dialogue.tone_routing", DIALOGUE_STATE, [
+        {"type": "choice", "id": "tone", "options": ["warm", "neutral", "guarded", "defensive"],
+         "context": "player just accused the npc of price gouging"},
+        {"type": "score", "id": "trust_shift", "rubric": [-2, -1, 0, 1, 2],
+         "context": "how does this exchange move trust"},
+        {"type": "noul", "id": "offer_discount",
+         "context": "should the npc offer a discount to de-escalate"},
+    ]),
+    ("game.chess_move", GAME_STATE, [
+        {"type": "choice", "id": "move_class", "options": ["develop", "castle", "capture", "push_pawn", "tactic"],
+         "context": "opening principles + clock pressure"},
+        {"type": "score", "id": "position_confidence", "rubric": [0, 1, 2, 3, 4, 5],
+         "context": "confidence the current position is better for white"},
+    ]),
+    ("robotics.route", ROBOT_STATE, [
+        {"type": "choice", "id": "reflex", "options": ["proceed", "slow", "stop", "reroute", "yield"],
+         "context": "human obstacle at 2.1m moving slowly"},
+        {"type": "noul", "id": "need_reasoner",
+         "context": "does this situation need the L2 reasoning loop"},
+        {"type": "score", "id": "urgency", "rubric": [0, 1, 2, 3],
+         "context": "how time-critical is pick:A-12"},
+    ]),
+]
+
+
+def run(live: bool, n: int, out_path: str | None) -> int:
+    bk = Bookkeeper("experiments")
+    ts = TypeSafeBackend()
+    q16 = Q16Backend()
+    total_q = 0
+    rows = []
+
+    for i in range(n):
+        for domain, state, questions in DOMAINS:
+            if live:
+                if not ts.available():
+                    print("FATAL: --live but no JEV_API_KEY/TYPESAFE_API_KEY in env", file=sys.stderr)
+                    return 2
+                try:
+                    decisions, meta = ts.decide_batch(state, questions)
+                except RuntimeError as e:
+                    print(f"live call failed: {e}", file=sys.stderr)
+                    return 1
+                for q, d in zip(questions, decisions):
+                    bk.book(state, {"domain": domain, "q": q["id"]}, d.kind,
+                            {"value": str(d.value), "probs": d.probabilities})
+                    rows.append({"domain": domain, "q": q["id"], "kind": d.kind,
+                                 "value": d.value, "probabilities": d.probabilities,
+                                 "confidence": d.confidence, **meta, "round": i})
+                    total_q += 1
+            else:
+                # Offline probe: book the state shape + a deterministic viability
+                # decision so the battery exercises the full receipt path.
+                d = q16.decide({"rule": "threshold", "value": (7, 10), "threshold": (1, 2)}, None)
+                bk.book(state, {"domain": domain, "probe": "offline"}, "q16",
+                        {"value": d.value, "note": "offline probe; live backend not wired to this run"})
+                for q in questions:
+                    rows.append({"domain": domain, "q": q["id"], "kind": q["type"],
+                                 "value": None, "offline": True, "round": i})
+                    total_q += 1
+
+    verify_ok = bk.verify()
+    report = {
+        "mode": "live" if live else "offline",
+        "rounds": n, "questions": total_q,
+        "booked": bk._tick, "book_verify": verify_ok,
+        "chain": bk.replay(),
+        "sample_rows": rows[:6],
+    }
+    text = json.dumps(report, indent=2, default=str)
+    if out_path:
+        with open(out_path, "w") as f:
+            f.write(text + "\n")
+    print(text[:1200])
+    print(f"\n... full report {'written to ' + out_path if out_path else 'elided'}")
+    return 0 if verify_ok else 1
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--live", action="store_true", help="use the real TypeSafe Jev API")
+    ap.add_argument("--n", type=int, default=3, help="rounds (each round = all domains)")
+    ap.add_argument("--out", default=None, help="write JSON report to path")
+    a = ap.parse_args()
+    sys.exit(run(a.live, a.n, a.out))
+
+
+if __name__ == "__main__":
+    main()

jev-quilt-0.0.1/jev_quilt/q16.py

@@ -0,0 +1,80 @@
+"""q16 exact-rational codec. Identity is (num:int64, den:int64); floats are
+display projections only — the same codec as the fleet's lattice kernel.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass
+from math import gcd
+
+SCALE = 10 ** 6  # ℚ×10⁶: denominators divide 10⁶ exactly (dyadic × 5-adic)
+
+
+@dataclass(frozen=True)
+class Q16:
+    num: int
+    den: int = 1
+
+    def __post_init__(self):
+        if self.den == 0:
+            raise ZeroDivisionError("q16: zero denominator")
+        g = gcd(self.num, self.den)
+        object.__setattr__(self, "num", self.num // g)
+        object.__setattr__(self, "den", self.den // g)
+        if self.den < 0:
+            object.__setattr__(self, "num", -self.num)
+            object.__setattr__(self, "den", -self.den)
+
+    @classmethod
+    def from_float(cls, f: float) -> "Q16":
+        """Projection INTO the lattice. Rejects values that are not
+        representable (never silently rounds identity)."""
+        num = round(f * SCALE)
+        if abs(num / SCALE - f) > 1e-12:
+            raise ValueError(f"q16: {f!r} is not a ℚ×10⁶ rational")
+        return cls(num, SCALE)
+
+    def to_float(self) -> float:
+        return self.num / self.den
+
+    def __add__(self, o: "Q16") -> "Q16":
+        return Q16(self.num * o.den + o.num * self.den, self.den * o.den)
+
+    def __sub__(self, o: "Q16") -> "Q16":
+        return Q16(self.num * o.den - o.num * self.den, self.den * o.den)
+
+    def __mul__(self, o: "Q16") -> "Q16":
+        return Q16(self.num * o.num, self.den * o.den)
+
+    def __truediv__(self, o: "Q16") -> "Q16":
+        return Q16(self.num * o.den, self.den * o.num)
+
+    def __eq__(self, o) -> bool:
+        return isinstance(o, Q16) and self.num * o.den == o.num * self.den
+
+    def __lt__(self, o: "Q16") -> bool:
+        return self.num * o.den < o.num * self.den
+
+    def __le__(self, o: "Q16") -> bool:
+        return self.num * o.den <= o.num * self.den
+
+    def __ge__(self, o: "Q16") -> bool:
+        return self.num * o.den >= o.num * self.den
+
+    def __gt__(self, o: "Q16") -> bool:
+        return self.num * o.den > o.num * self.den
+
+    def __hash__(self):
+        return hash((self.num, self.den))
+
+    def __repr__(self):
+        return f"Q16({self.num}/{self.den})"
+
+
+def commensurate(a: Q16, b: Q16) -> bool:
+    """The comb predicate: a/b's reduced denominator divides 10⁶.
+    TRUE means the pair lives on a common decimal lattice; FALSE is a
+    ternary ghost (e.g. 1/3 against 1)."""
+    if b.num == 0:
+        return a.num == 0
+    r = a / b
+    return SCALE % r.den == 0

jev-quilt-0.0.1/jev_quilt/typesafe_client.py

@@ -0,0 +1,70 @@
+"""TypeSafe Jev API backend (real client).
+
+Wire protocol per the public SDK: POST {base}/v1/decide with
+{state, questions:[{type, ...}]} -> decisions:[{type, value,
+probabilities?, confidence?}]. Env: JEV_API_KEY or TYPESAFE_API_KEY;
+JEV_BASE_URL or TYPESAFE_BASE_URL (default https://api.typesafe.ai).
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass
+import json
+import os
+import time
+import urllib.request
+import urllib.error
+
+from .backends import BackendDecision
+
+DEFAULT_BASE = "https://api.typesafe.ai"
+
+
+class TypeSafeBackend:
+    name = "typesafe-api"
+
+    def __init__(self, base_url: str | None = None, api_key: str | None = None,
+                 timeout_s: float = 30.0):
+        self.base = (base_url or os.environ.get("JEV_BASE_URL")
+                     or os.environ.get("TYPESAFE_BASE_URL") or DEFAULT_BASE).rstrip("/")
+        self.key = api_key or os.environ.get("JEV_API_KEY") or os.environ.get("TYPESAFE_API_KEY")
+        self.timeout = timeout_s
+
+    def available(self) -> bool:
+        return bool(self.key)
+
+    def decide_batch(self, state, questions: list[dict]) -> tuple[list[BackendDecision], dict]:
+        """One parallel pass, N questions. Returns (decisions, meta) where
+        meta carries latency + raw receipt fields for the bookkeeper."""
+        if not self.key:
+            raise RuntimeError("typesafe-api: no API key (JEV_API_KEY/TYPESAFE_API_KEY)")
+        body = json.dumps({"state": state, "questions": questions}).encode()
+        req = urllib.request.Request(
+            f"{self.base}/v1/decide", data=body,
+            headers={"Content-Type": "application/json", "Authorization": f"Bearer {self.key}"})
+        t0 = time.monotonic()
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                payload = json.loads(resp.read().decode())
+        except urllib.error.HTTPError as e:
+            raise RuntimeError(f"typesafe-api: HTTP {e.code}: {e.read().decode()[:300]}") from e
+        latency_ms = (time.monotonic() - t0) * 1000
+        decisions = []
+        for d in payload.get("decisions", []):
+            decisions.append(BackendDecision(
+                kind=d.get("type", "unknown"),
+                value=d.get("value"),
+                probabilities=d.get("probabilities"),
+                confidence=d.get("confidence"),
+                receipt_note=f"typesafe.latency_ms={latency_ms:.1f}",
+            ))
+        meta = {"latency_ms": latency_ms, "questions": len(questions),
+                "decisions": len(decisions), "model": payload.get("model", "jev")}
+        return decisions, meta
+
+    def decide(self, payload: dict, state) -> BackendDecision:
+        """Single-question convenience over decide_batch."""
+        q = payload.get("question")
+        if q is None:
+            raise ValueError("typesafe backend: payload needs 'question' dict")
+        ds, _ = self.decide_batch(state, [q])
+        return ds[0]

jev-quilt-0.0.1/jev_quilt.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.1
+Name: jev-quilt
+Version: 0.0.1
+Summary: JEV for quilt as understood output: cellular-first decision substrate
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+JEV (Joint Embedding Validator) as understood output for the Quilt project. Pins the fleet canary: fnv1a-64("café Δ 日本語") = 0x024a555471370b18d. Includes backends, bookkeeper, cell, q16, and typesafe_client.

jev-quilt-0.0.1/jev_quilt.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+setup.py
+jev_quilt/__init__.py
+jev_quilt/backends.py
+jev_quilt/bookkeeper.py
+jev_quilt/cell.py
+jev_quilt/experiments.py
+jev_quilt/q16.py
+jev_quilt/typesafe_client.py
+jev_quilt.egg-info/PKG-INFO
+jev_quilt.egg-info/SOURCES.txt
+jev_quilt.egg-info/dependency_links.txt
+jev_quilt.egg-info/top_level.txt

jev-quilt-0.0.1/jev_quilt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jev-quilt-0.0.1/jev_quilt.egg-info/top_level.txt

@@ -0,0 +1 @@
+jev_quilt

jev-quilt-0.0.1/pyproject.toml

@@ -0,0 +1,10 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jev-quilt"
+version = "0.0.1"
+description = "JEV for quilt as understood output: cellular-first decision substrate"
+requires-python = ">=3.10"
+license = {text = "MIT"}

jev-quilt-0.0.1/setup.cfg

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

jev-quilt-0.0.1/setup.py

@@ -0,0 +1,13 @@
+from setuptools import setup, find_packages
+setup(
+    name='jev-quilt',
+    version='0.0.1',
+    description='JEV for quilt as understood output: cellular-first decision substrate',
+    long_description='JEV (Joint Embedding Validator) as understood output for the Quilt project. Pins the fleet canary: fnv1a-64("café Δ 日本語") = 0x024a555471370b18d. Includes backends, bookkeeper, cell, q16, and typesafe_client.',
+    long_description_content_type='text/markdown',
+    readme='README.md',
+    packages=find_packages(exclude=['tests', 'docs', 'ports']),
+    python_requires='>=3.10',
+    install_requires=[],
+    license='MIT',
+)