cyan-eclipse-book 0.1.0__py3-none-any.whl

bazaar-manifest.json

@@ -0,0 +1,66 @@
+{
+ "bench": {
+  "bench_verdict": "CERTIFIED(local)",
+  "certified": true,
+  "checks": [
+   "criteria edit mid-position: one-word change -> CRITERIA_CHANGED event + receipt; position keeps as-of-entry, flag set",
+   "resolution_verify against a WRONG source refused by name; correct source verifies",
+   "DISPUTED blocks verification until cleared",
+   "fee math recomputed independently (all-in buy AND sell, per-unit + total); event-contract max payout attached",
+   "missing schedule AND stale schedule -> FEE_UNVERIFIED while bid/ask still serve",
+   "probability scan: planted keys in provenance, criteria-object field name, nested trading_window \u2014 never emitted; verbatim carriers refused by name",
+   "UNMAPPED native status preserved verbatim",
+   "order_draft: DRAFT only, NOT_EVALUATED mandate note, receipt ref; off-allowlist type refused",
+   "capability denylist by enumeration: exactly the 17 M0 tools; placement/withdraw/account/advice names refused",
+   "auth enforced",
+   "schema valid",
+   "no network surface (source-level)",
+   "no secret leak",
+   "sane errors",
+   "process health",
+   "audit completeness (receipt chain recomputed independently)",
+   "bench isolation"
+  ],
+  "not_tested": [
+   "Live venue reads inside the shipped build \u2014 M0 contains no network code path; live Kalshi/Polymarket public payloads were verified through the transport seam from the Verity bench seat 2026-11-02 (BENCH-VERITY.md: PASS-WITH-CONDITIONS), but no in-build live adapter ships in v0.1.0.",
+   "Order placement, account reads, and the Wallet mandate gate \u2014 M2/M1 scope, owner-gated (spec 18, decision D3). M0 order_draft records an unsubmitted DRAFT with mandate_pre_eval NOT_EVALUATED; no submission path exists.",
+   "Fee schedules as live data \u2014 shipped schedules are fixture-shaped records with provenance labels saying so; the live fetch + account-specific tier provenance lands with the adapters' live step.",
+   "Kalshi / Polymarket US / Kraken / Binance.US / Alpaca chapters \u2014 specced (suite spec 10-12), not built in M0."
+  ],
+  "scorecard_ref": "test-bench/results/eclipse-book-mcp-2026-10-25.json",
+  "status": "CERTIFIED(local) \u2014 Eclipse Bazaar Test Bench 2026-10-25 (scorecard eclipse-book-mcp-2026-10-25.json): 16 pass / 1 na / 0 fail over 17 checks incl. bench isolation. M0 data-only scope; live venue reads not_tested per the preserved not_tested list."
+ },
+ "category": "Markets / Exchange & Prediction-Market Infrastructure",
+ "created": "2026-10-25",
+ "description": "The Market Core of the Eclipse Markets suite (spec eclipse-markets-suite-spec-20261025): one canonical Instrument / Book / Quote / Order / Position / Resolution model over exchanges and prediction markets, with venue adapters that translate and never improvise. Resolution criteria are stored verbatim and hash-pinned \u2014 a venue criteria edit is a CRITERIA_CHANGED event and positions keep the criteria as of entry. Quotes carry all-in buy/sell cost for a stated size from versioned, provenance-stamped fee schedules; a stale or missing schedule degrades all-in fields to FEE_UNVERIFIED rather than quoting a wrong number. Resolutions move REPORTED -> VERIFIED only against the criteria's own named source (DISPUTED is first-class), and no core output ever carries a probability field \u2014 outputs carry price + liquidity flag + depth + verbatim criteria. M0 is data only: no accounts, no keys, no order submission at any tier; order_draft is an unsubmitted record whose mandate pre-evaluation is honestly NOT_EVALUATED until the owner-gated M2.",
+ "icon": "icon-512.png",
+ "name": "Eclipse Book MCP",
+ "powered_by": "Cyan Eclipse Technologies",
+ "price_model": "Free local v0.1; family pricing TBD per spec",
+ "repo": null,
+ "slug": "eclipse-book-mcp",
+ "status": "Live \u2014 v0.1.0 M0 local build (Market Core, data only; CERTIFIED(local) \u2014 Eclipse Bazaar Test Bench 2026-10-25; Verity bench 2026-11-02 PASS-WITH-CONDITIONS incl. live Kalshi/Polymarket public reads via the transport seam \u2014 see BENCH-VERITY.md)",
+ "tagline": "Market data + venue access layer \u2014 not an exchange: one book, one fee truth, one ledger of record.",
+ "tools": [
+  "instrument_ingest",
+  "instrument_get",
+  "instrument_search",
+  "book_ingest",
+  "quote_get",
+  "fee_schedule_register",
+  "fee_schedule_get",
+  "position_open",
+  "position_list",
+  "position_get",
+  "resolution_report",
+  "resolution_verify",
+  "resolution_get",
+  "order_draft",
+  "order_get",
+  "venue_status",
+  "receipt_list"
+ ],
+ "transport": "MCP over stdio (HTTP transport on roadmap)",
+ "vendor": "Cyan Eclipse Technologies",
+ "x402_ready": false
+}

book_engine.py

@@ -0,0 +1,619 @@
+# Eclipse Book MCP
+# Copyright © 2026 Cyan Eclipse Technologies LLC · cetech.ai
+# Eclipse Book — shared Market Core engine (spec
+
+"""Eclipse Book — shared Market Core engine (spec
+eclipse-markets-suite-spec-20261025 sections 5-7).
+
+This module is the suite law in code: canonical Instrument /
+Book / Quote / Order / Position / Resolution objects, fee truth
+(section 5.3), the resolution-verification discipline (5.4),
+liquidity + probability honesty (5.5), and the append-only
+hash-chained receipt ledger.
+
+Adapters (Forecast, Strike first) import this module from the
+sibling core directory and translate venue-native payloads into
+engine calls against the SHARED suite state, loaded fresh at
+every call. An adapter may never emit a core object it had to
+guess at: missing native fields surface as explicit gaps, and a
+venue status that does not map into the core vocabulary surfaces
+as UNMAPPED with the native string preserved, never coerced
+(section 5.2).
+
+M0 SCOPE: data only. This engine contains no order-submission,
+account, withdrawal, or transfer capability at any tier — the
+Order object exists as a DRAFT record (section 5.6) whose mandate
+pre-evaluation is honestly NOT_EVALUATED in M0. Placement is M2,
+owner-gated (spec section 18, decision D3).
+
+Pure functions over a state dict: load/save are the caller's
+job. Stdlib only. Money math is Decimal end-to-end; prices are
+decimal strings on every surface (section 5.2).
+"""
+import copy
+import hashlib
+import json
+from datetime import datetime, timezone
+from decimal import Decimal
+
+
+class ToolError(Exception):
+    pass
+
+
+KINDS = {"SPOT", "EVENT_CONTRACT", "EQUITY", "PLAY_EVENT_CONTRACT"}
+STATUSES = {"OPEN", "CLOSED", "RESOLVED", "VOIDED"}
+MONEY_CLASSES = {"REAL", "PLAY"}
+BOOK_TYPES = {"CLOB", "AMM", "INDICATIVE"}
+RESOLUTION_STATES = {"NONE", "REPORTED", "VERIFIED", "DISPUTED"}
+ORDER_TYPES = {"MARKET", "LIMIT"}
+ORDER_STATUSES = {"DRAFT", "SUBMITTED", "OPEN", "PARTIAL", "FILLED",
+                  "CANCELLED", "REJECTED", "EXPIRED"}
+
+# Liquidity law (spec 5.5): core-owned thresholds, notional in the
+# instrument's currency at the best ask. Adapters may tighten,
+# never loosen. DEEP >= 10000, THIN < 1000, else FRAGILE.
+LIQUIDITY_DEEP_MIN = Decimal("10000")
+LIQUIDITY_THIN_MAX = Decimal("1000")
+
+DEFAULT_FEE_FRESHNESS_HOURS = 24
+DEFAULT_BOOK_STALE_SECONDS = 86400
+
+
+def now_iso() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+
+def parse_time(value):
+    if value is None:
+        return None
+    text = str(value).strip()
+    if len(text) == 10:
+        text += "T00:00:00+00:00"
+    return datetime.fromisoformat(text.replace("Z", "+00:00"))
+
+
+def sha(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def canon(obj) -> str:
+    return json.dumps(obj, sort_keys=True, separators=(",", ":"))
+
+
+def D(value) -> Decimal:
+    return Decimal(str(value))
+
+
+def ds(value) -> str:
+    """Decimal -> canonical decimal string (no exponent, no
+    trailing-zero noise)."""
+    d = D(value)
+    s = format(d, "f")
+    if "." in s:
+        s = s.rstrip("0").rstrip(".")
+    return s if s not in ("", "-0") else "0"
+
+
+# ---------------------------------------------------------------- receipts
+def emit_receipt(state: dict, rtype: str, detail: dict) -> dict:
+    prev = state["receipts"][-1]["hash"] if state["receipts"] else "GENESIS"
+    entry = {"seq": len(state["receipts"]) + 1, "ts": now_iso(),
+             "type": rtype, "prev_hash": prev, "detail": detail}
+    entry["hash"] = sha(prev + canon(
+        {k: v for k, v in entry.items() if k != "hash"}))
+    state["receipts"].append(entry)
+    return entry
+
+
+def verify_receipt_chain(receipts) -> bool:
+    prev = "GENESIS"
+    for entry in receipts:
+        expect = sha(prev + canon(
+            {k: v for k, v in entry.items() if k != "hash"}))
+        if entry.get("hash") != expect or entry.get("prev_hash") != prev:
+            return False
+        prev = entry["hash"]
+    return True
+
+
+# ------------------------------------------------------- probability law
+def probability_scan(obj, path="$"):
+    """Spec 5.5: the core never emits a probability field.
+    Returns the list of offending key paths (keys only — a price
+    is a price, and no output key may name it anything else)."""
+    hits = []
+    if isinstance(obj, dict):
+        for key, value in obj.items():
+            if "probab" in str(key).lower():
+                hits.append(f"{path}.{key}")
+            hits.extend(probability_scan(value, f"{path}.{key}"))
+    elif isinstance(obj, list):
+        for i, value in enumerate(obj):
+            hits.extend(probability_scan(value, f"{path}[{i}]"))
+    return hits
+
+
+def guard_no_probability(obj):
+    hits = probability_scan(obj)
+    if hits:
+        raise ToolError(
+            "PROBABILITY_FIELD_FORBIDDEN: core outputs carry price + "
+            f"liquidity + criteria, never a probability field ({hits})")
+    return obj
+
+
+# ------------------------------------------------------------------- state
+def empty_state() -> dict:
+    return {"config": {"fee_freshness_hours": DEFAULT_FEE_FRESHNESS_HOURS,
+                       "book_stale_seconds": DEFAULT_BOOK_STALE_SECONDS},
+            "instruments": {}, "books": {}, "fee_schedules": {},
+            "positions": {}, "orders": {}, "receipts": []}
+
+
+def ensure_seeded(state: dict, seed: dict) -> dict:
+    state["config"].update(seed.get("config", {}))
+    for sched in seed.get("fee_schedules", []):
+        if sched["schedule_ref"] not in state["fee_schedules"]:
+            state["fee_schedules"][sched["schedule_ref"]] = sched
+    return state
+
+
+# ------------------------------------------------------------ fee schedules
+def fee_schedule_register(state: dict, args: dict) -> dict:
+    """Fee schedules are versioned data with provenance (5.3):
+    source + fetched_at are required; a schedule without them is
+    not a schedule."""
+    for field in ("venue", "version", "source", "fetched_at",
+                  "taker_fee_bps"):
+        if args.get(field) in (None, ""):
+            raise ToolError(f"FEE_SCHEDULE_PROVENANCE_REQUIRED: {field}")
+    ref = f"{args['venue']}@{args['version']}"
+    sched = {"schedule_ref": ref, "venue": args["venue"],
+             "version": args["version"], "source": args["source"],
+             "fetched_at": args["fetched_at"],
+             "taker_fee_bps": ds(args["taker_fee_bps"]),
+             "maker_fee_bps": ds(args.get("maker_fee_bps", "0")),
+             "settlement_fee_model": args.get(
+                 "settlement_fee_model", {"type": "none"}),
+             "freshness_hours": int(args.get(
+                 "freshness_hours",
+                 state["config"]["fee_freshness_hours"]))}
+    state["fee_schedules"][ref] = sched
+    emit_receipt(state, "fee_schedule_registered",
+                 {"schedule_ref": ref, "venue": sched["venue"],
+                  "fetched_at": sched["fetched_at"]})
+    return {"fee_schedule": sched}
+
+
+def fee_schedule_for(state: dict, venue: str):
+    """Latest registered schedule for a venue, or None."""
+    cands = [s for s in state["fee_schedules"].values()
+             if s["venue"] == venue]
+    if not cands:
+        return None
+    return sorted(cands, key=lambda s: s["fetched_at"])[-1]
+
+
+def fee_freshness(state: dict, venue: str, as_of: str):
+    """-> (schedule, status): FRESH | STALE | NO_SCHEDULE."""
+    sched = fee_schedule_for(state, venue)
+    if sched is None:
+        return None, "NO_SCHEDULE"
+    age_h = (parse_time(as_of) - parse_time(
+        sched["fetched_at"])).total_seconds() / 3600.0
+    if age_h > sched["freshness_hours"]:
+        return sched, "STALE"
+    return sched, "FRESH"
+
+
+# --------------------------------------------------------------- instruments
+def instrument_id_for(venue: str, kind: str, native_id: str) -> str:
+    wing = "B" if kind in ("EVENT_CONTRACT", "PLAY_EVENT_CONTRACT") else "A"
+    return f"{wing}:{venue}:{native_id}"
+
+
+def ingest_instrument(state: dict, spec_in: dict) -> dict:
+    """Register or refresh a canonical Instrument. Resolution
+    criteria are verbatim + hash-pinned at first read (5.4): a
+    later ingest carrying different criteria records a
+    CRITERIA_CHANGED event; the instrument keeps every version,
+    and positions keep the criteria as of their entry."""
+    for field in ("venue", "native_id", "kind", "title"):
+        if not spec_in.get(field):
+            raise ToolError(f"INSTRUMENT_FIELD_REQUIRED: {field}")
+    kind = spec_in["kind"]
+    if kind not in KINDS:
+        raise ToolError(f"INSTRUMENT_KIND_UNKNOWN: {kind}")
+    money_class = spec_in.get("money_class", "REAL")
+    if money_class not in MONEY_CLASSES:
+        raise ToolError(f"MONEY_CLASS_UNKNOWN: {money_class}")
+    if kind == "PLAY_EVENT_CONTRACT" and money_class != "PLAY":
+        raise ToolError("PLAY_INSTRUMENT_REQUIRES_PLAY_MONEY_CLASS")
+    criteria = spec_in.get("resolution_criteria")
+    if kind in ("EVENT_CONTRACT", "PLAY_EVENT_CONTRACT"):
+        if not criteria or not criteria.get("text"):
+            raise ToolError(
+                "RESOLUTION_CRITERIA_REQUIRED: an event contract "
+                "without verbatim criteria is not an instrument")
+        if not spec_in.get("resolution_source"):
+            raise ToolError(
+                "RESOLUTION_SOURCE_REQUIRED: the named resolver is "
+                "part of the instrument (spec 5.4)")
+    native_status = spec_in.get("native_status")
+    mapped = spec_in.get("status_mapped")
+    status = mapped if mapped in STATUSES else "UNMAPPED"
+    iid = instrument_id_for(spec_in["venue"], kind, spec_in["native_id"])
+    existing = state["instruments"].get(iid)
+    event = None
+    if existing is None:
+        inst = {"instrument_id": iid, "venue": spec_in["venue"],
+                "native_id": spec_in["native_id"],
+                "native_symbol": spec_in.get("native_symbol"),
+                "kind": kind, "title": spec_in["title"],
+                "underlying": spec_in.get("underlying"),
+                "outcomes": spec_in.get("outcomes", []),
+                "resolution_source": spec_in.get("resolution_source"),
+                "trading_window": spec_in.get("trading_window", {}),
+                "tick": spec_in.get("tick"),
+                "min_size": spec_in.get("min_size"),
+                "currency": spec_in.get("currency", "USD"),
+                "money_class": money_class, "status": status,
+                "native_status": native_status,
+                "provenance": spec_in.get("provenance", {}),
+                "resolution": {"state": "NONE", "outcome": None,
+                               "source": None, "evidence_ref": None,
+                               "criteria_match": None, "history": []}}
+        if criteria:
+            inst["resolution_criteria"] = criteria["text"]
+            inst["resolution_criteria_source_ref"] = criteria.get(
+                "source_ref")
+            inst["criteria_versions"] = [{
+                "hash": sha(criteria["text"]), "text": criteria["text"],
+                "source_ref": criteria.get("source_ref"),
+                "first_seen": now_iso()}]
+        # Probability guard runs PRE-COMMIT (PP3-H3): a refused
+        # ingest writes nothing — no instrument, no receipt.
+        guard_no_probability(inst)
+        state["instruments"][iid] = inst
+        emit_receipt(state, "instrument_ingested",
+                     {"instrument_id": iid, "venue": inst["venue"],
+                      "kind": kind})
+        return {"instrument": inst, "criteria_changed": None}
+    # Refresh: status/native fields update; criteria are pinned.
+    # Mutations land on a copy and commit only after the
+    # probability guard passes (PP3-H3) — a refused refresh
+    # leaves the stored instrument and receipts untouched.
+    updated = copy.deepcopy(existing)
+    updated["status"] = status
+    updated["native_status"] = native_status
+    if spec_in.get("trading_window"):
+        updated["trading_window"] = spec_in["trading_window"]
+    if criteria:
+        new_hash = sha(criteria["text"])
+        cur_hash = updated["criteria_versions"][-1]["hash"]
+        if new_hash != cur_hash:
+            updated["criteria_versions"].append({
+                "hash": new_hash, "text": criteria["text"],
+                "source_ref": criteria.get("source_ref"),
+                "first_seen": now_iso()})
+            updated["resolution_criteria"] = criteria["text"]
+            updated["resolution_criteria_source_ref"] = criteria.get(
+                "source_ref")
+            event = {"type": "CRITERIA_CHANGED", "instrument_id": iid,
+                     "old_hash": cur_hash, "new_hash": new_hash}
+    guard_no_probability(updated)
+    state["instruments"][iid] = updated
+    if event is not None:
+        emit_receipt(state, "criteria_changed", dict(event))
+    return {"instrument": updated, "criteria_changed": event}
+
+
+def criteria_snapshot(inst: dict):
+    if "criteria_versions" not in inst:
+        return None
+    cur = inst["criteria_versions"][-1]
+    return {"text": cur["text"], "hash": cur["hash"],
+            "source_ref": cur.get("source_ref")}
+
+
+# --------------------------------------------------------------------- books
+def build_book(instrument_id: str, venue: str, book_type: str,
+               bids, asks, as_of: str, tick=None, native_ref=None):
+    """Canonical Book from normalized levels. bids/asks: lists of
+    {price, size} with decimal-string values, any order — the
+    builder sorts (bids desc, asks asc) and preserves venue-native
+    precision by keeping the strings it was given."""
+    if book_type not in BOOK_TYPES:
+        raise ToolError(f"BOOK_TYPE_UNKNOWN: {book_type}")
+    bids_s = sorted(bids, key=lambda lv: D(lv["price"]), reverse=True)
+    asks_s = sorted(asks, key=lambda lv: D(lv["price"]))
+    book = {"instrument_id": instrument_id, "venue": venue,
+            "as_of": as_of, "book_type": book_type,
+            "bids": [{"price": ds(lv["price"]), "size": ds(lv["size"])}
+                     for lv in bids_s],
+            "asks": [{"price": ds(lv["price"]), "size": ds(lv["size"])}
+                     for lv in asks_s],
+            "native_ref": native_ref}
+    book["depth_summary"] = depth_summary(book, tick)
+    if bids_s and asks_s:
+        bid, ask = D(bids_s[0]["price"]), D(asks_s[0]["price"])
+        mid = (bid + ask) / 2
+        book["spread_bps"] = ds((ask - bid) / mid * 10000) if mid else None
+    else:
+        book["spread_bps"] = None
+    return book
+
+
+def depth_summary(book: dict, tick=None) -> dict:
+    bids, asks = book["bids"], book["asks"]
+    out = {"size_at_best_bid": bids[0]["size"] if bids else "0",
+           "size_at_best_ask": asks[0]["size"] if asks else "0",
+           "notional_at_best_ask": "0", "size_within_5_ticks_bid": "0",
+           "size_within_5_ticks_ask": "0"}
+    if asks:
+        out["notional_at_best_ask"] = ds(
+            D(asks[0]["size"]) * D(asks[0]["price"]))
+    if tick:
+        t = D(tick)
+        if bids:
+            floor = D(bids[0]["price"]) - 5 * t
+            out["size_within_5_ticks_bid"] = ds(sum(
+                D(lv["size"]) for lv in bids if D(lv["price"]) >= floor))
+        if asks:
+            cap = D(asks[0]["price"]) + 5 * t
+            out["size_within_5_ticks_ask"] = ds(sum(
+                D(lv["size"]) for lv in asks if D(lv["price"]) <= cap))
+    return out
+
+
+def liquidity_flag(book: dict) -> str:
+    notional = D(book["depth_summary"]["notional_at_best_ask"])
+    if notional >= LIQUIDITY_DEEP_MIN:
+        return "DEEP"
+    if notional < LIQUIDITY_THIN_MAX:
+        return "THIN"
+    return "FRAGILE"
+
+
+def ingest_book(state: dict, book: dict) -> dict:
+    iid = book["instrument_id"]
+    if iid not in state["instruments"]:
+        raise ToolError(f"BOOK_FOR_UNKNOWN_INSTRUMENT: {iid}")
+    outcome = book.get("outcome")
+    key = f"{iid}|{outcome}" if outcome else iid
+    book = dict(book)
+    book["outcome"] = outcome
+    state["books"][key] = book
+    return {"book": book}
+
+
+def get_book(state: dict, instrument_id: str, outcome=None):
+    key = f"{instrument_id}|{outcome}" if outcome else instrument_id
+    book = state["books"].get(key)
+    if book is None and outcome is None:
+        cands = [b for k, b in state["books"].items()
+                 if k.startswith(instrument_id + "|")]
+        if len(cands) == 1:
+            book = cands[0]
+    if book is None:
+        raise ToolError(f"BOOK_NOT_FOUND: {key}")
+    return book
+
+
+# -------------------------------------------------------------------- quotes
+def quote_get(state: dict, instrument_id: str, size,
+              outcome=None, as_of=None) -> dict:
+    """The ONLY price-shaped object consumers may receive (5.1):
+    price + all-in cost for a stated size + fee-truth state +
+    liquidity + (for event contracts) the criteria attached.
+    Never a probability field (5.5)."""
+    inst = state["instruments"].get(instrument_id)
+    if inst is None:
+        raise ToolError(f"INSTRUMENT_NOT_FOUND: {instrument_id}")
+    book = get_book(state, instrument_id, outcome)
+    if not book["bids"] or not book["asks"]:
+        raise ToolError("BOOK_ONE_SIDED: no two-sided book, no quote")
+    as_of = as_of or now_iso()
+    bid = D(book["bids"][0]["price"])
+    ask = D(book["asks"][0]["price"])
+    mid = (bid + ask) / 2
+    n = D(size)
+    sched, fee_status = fee_freshness(state, inst["venue"], as_of)
+    quote = {"instrument_id": instrument_id, "venue": inst["venue"],
+             "outcome": outcome, "as_of": as_of,
+             "book_as_of": book["as_of"], "bid": ds(bid), "ask": ds(ask),
+             "mid": ds(mid), "mid_basis": "computed",
+             "spread_bps": book["spread_bps"],
+             "size": ds(n), "currency": inst["currency"],
+             "money_class": inst["money_class"],
+             "liquidity_flag": liquidity_flag(book),
+             "depth_summary": book["depth_summary"],
+             "fee_status": fee_status,
+             "fee_schedule_ref": sched["schedule_ref"] if sched else None}
+    age = (parse_time(as_of) - parse_time(
+        book["as_of"])).total_seconds()
+    quote["book_stale"] = age > state["config"]["book_stale_seconds"]
+    if fee_status == "FRESH":
+        bps = D(sched["taker_fee_bps"])
+        buy_gross = ask * n
+        buy_fee = buy_gross * bps / 10000
+        sell_gross = bid * n
+        sell_fee = sell_gross * bps / 10000
+        quote["all_in_buy_cost"] = {
+            "total": ds(buy_gross + buy_fee),
+            "per_unit": ds((buy_gross + buy_fee) / n),
+            "fee_amount": ds(buy_fee),
+            "fee_schedule_ref": sched["schedule_ref"]}
+        quote["all_in_sell_value"] = {
+            "total": ds(sell_gross - sell_fee),
+            "per_unit": ds((sell_gross - sell_fee) / n),
+            "fee_amount": ds(sell_fee),
+            "fee_schedule_ref": sched["schedule_ref"]}
+        quote["settlement_fee_model"] = sched["settlement_fee_model"]
+        if inst["kind"] in ("EVENT_CONTRACT", "PLAY_EVENT_CONTRACT"):
+            quote["max_payout_for_size"] = ds(n * D(1))
+    else:
+        # A wrong all-in number is worse than no number (5.3).
+        quote["all_in_buy_cost"] = "FEE_UNVERIFIED"
+        quote["all_in_sell_value"] = "FEE_UNVERIFIED"
+    if inst["kind"] in ("EVENT_CONTRACT", "PLAY_EVENT_CONTRACT"):
+        snap = criteria_snapshot(inst)
+        quote["resolution_criteria"] = snap["text"]
+        quote["resolution_criteria_hash"] = snap["hash"]
+        quote["resolution_source"] = inst["resolution_source"]
+    return guard_no_probability(quote)
+
+
+# ----------------------------------------------------------------- positions
+def position_open(state: dict, args: dict) -> dict:
+    inst = state["instruments"].get(args["instrument_id"])
+    if inst is None:
+        raise ToolError(f"INSTRUMENT_NOT_FOUND: {args['instrument_id']}")
+    pid = f"pos-{len(state['positions']) + 1}"
+    snap = criteria_snapshot(inst)
+    pos = {"position_id": pid, "instrument_id": inst["instrument_id"],
+           "venue": inst["venue"],
+           "account_ref": args.get("account_ref", "owner"),
+           "outcome": args.get("outcome"),
+           "size": ds(args["size"]),
+           "avg_cost": ds(args["entry_price"]),
+           "avg_cost_basis": "all-in per unit, as supplied at entry",
+           "settlement_state": "OPEN",
+           "criteria_as_of_entry": snap,
+           "opened_at": now_iso()}
+    state["positions"][pid] = pos
+    emit_receipt(state, "position_opened",
+                 {"position_id": pid, "instrument_id": inst["instrument_id"],
+                  "criteria_hash": snap["hash"] if snap else None})
+    return {"position": position_view(state, pos)}
+
+
+def position_view(state: dict, pos: dict) -> dict:
+    inst = state["instruments"][pos["instrument_id"]]
+    view = dict(pos)
+    cur = criteria_snapshot(inst)
+    view["criteria_current"] = cur
+    entry = pos.get("criteria_as_of_entry")
+    view["criteria_changed_since_entry"] = bool(
+        entry and cur and entry["hash"] != cur["hash"])
+    view["resolution_state"] = inst["resolution"]["state"]
+    view["money_class"] = inst["money_class"]
+    return guard_no_probability(view)
+
+
+# --------------------------------------------------------------- resolutions
+def resolution_report(state: dict, args: dict) -> dict:
+    """A resolution is a claim until verified (5.4): REPORTED."""
+    inst = state["instruments"].get(args["instrument_id"])
+    if inst is None:
+        raise ToolError(f"INSTRUMENT_NOT_FOUND: {args['instrument_id']}")
+    res = inst["resolution"]
+    if args.get("disputed"):
+        res["state"] = "DISPUTED"
+    elif res["state"] in ("NONE", "DISPUTED"):
+        res["state"] = "REPORTED"
+    res["outcome"] = args["outcome"]
+    res["source"] = args.get("source")
+    res["evidence_ref"] = args.get("evidence_ref")
+    res["history"].append({"state": res["state"], "ts": now_iso(),
+                           "outcome": args["outcome"],
+                           "evidence_ref": args.get("evidence_ref")})
+    emit_receipt(state, "resolution_reported",
+                 {"instrument_id": inst["instrument_id"],
+                  "state": res["state"], "outcome": args["outcome"]})
+    return {"resolution": resolution_view(inst)}
+
+
+def resolution_verify(state: dict, args: dict) -> dict:
+    """VERIFIED only against the criteria's OWN named source
+    (5.4). A verification attempt naming any other source is
+    refused by name; a live dispute keeps the state DISPUTED."""
+    inst = state["instruments"].get(args["instrument_id"])
+    if inst is None:
+        raise ToolError(f"INSTRUMENT_NOT_FOUND: {args['instrument_id']}")
+    res = inst["resolution"]
+    if res["state"] == "NONE":
+        raise ToolError("RESOLUTION_NOT_REPORTED: nothing to verify")
+    named = inst.get("resolution_source")
+    if args.get("verification_source") != named:
+        raise ToolError(
+            f"RESOLUTION_SOURCE_MISMATCH: criteria name '{named}' as "
+            f"the source of truth; '{args.get('verification_source')}' "
+            "cannot verify this resolution")
+    if res["state"] == "DISPUTED" and not args.get("dispute_cleared"):
+        raise ToolError(
+            "RESOLUTION_DISPUTED: dispute is open; verification waits "
+            "for finality (spec 5.4)")
+    res["state"] = "VERIFIED"
+    res["criteria_match"] = bool(args.get("criteria_match", True))
+    res["history"].append({"state": "VERIFIED", "ts": now_iso(),
+                           "verification_source": named,
+                           "criteria_match": res["criteria_match"]})
+    emit_receipt(state, "resolution_verified",
+                 {"instrument_id": inst["instrument_id"],
+                  "outcome": res["outcome"],
+                  "criteria_match": res["criteria_match"]})
+    return {"resolution": resolution_view(inst)}
+
+
+def resolution_view(inst: dict) -> dict:
+    res = inst["resolution"]
+    return guard_no_probability({
+        "instrument_id": inst["instrument_id"],
+        "state": res["state"], "verification": res["state"],
+        "outcome": res["outcome"], "source": res["source"],
+        "named_resolution_source": inst.get("resolution_source"),
+        "evidence_ref": res["evidence_ref"],
+        "criteria_match": res["criteria_match"],
+        "history": res["history"]})
+
+
+# -------------------------------------------------------------------- orders
+def order_draft(state: dict, args: dict) -> dict:
+    """M0: a DRAFT record only. No submission path exists in
+    this build at any tier; the mandate pre-evaluation is
+    honestly NOT_EVALUATED until M2 wires the Wallet gate
+    (spec 5.6 / 7.2)."""
+    inst = state["instruments"].get(args["instrument_id"])
+    if inst is None:
+        raise ToolError(f"INSTRUMENT_NOT_FOUND: {args['instrument_id']}")
+    otype = args.get("type", "LIMIT")
+    if otype not in ORDER_TYPES:
+        raise ToolError(
+            f"ORDER_TYPE_NOT_IN_V1_ALLOWLIST: {otype} (MARKET|LIMIT only)")
+    oid = f"ord-{len(state['orders']) + 1}"
+    order = {"order_id": oid, "venue_order_id": None,
+             "instrument_id": inst["instrument_id"],
+             "venue": inst["venue"], "side": args["side"],
+             "type": otype, "size": ds(args["size"]),
+             "limit_price": ds(args["limit_price"])
+             if args.get("limit_price") is not None else None,
+             "status": "DRAFT", "fills": [],
+             "mandate_ref": None,
+             "mandate_pre_eval": "NOT_EVALUATED_M0_DATA_ONLY",
+             "created_at": now_iso()}
+    state["orders"][oid] = order
+    receipt = emit_receipt(state, "order_drafted",
+                           {"order_id": oid,
+                            "instrument_id": inst["instrument_id"]})
+    order["receipt_ref"] = receipt["hash"]
+    return {"order": order}
+
+
+# ---------------------------------------------------------------- venue status
+def venue_status(state: dict, venue: str, as_of=None) -> dict:
+    as_of = as_of or now_iso()
+    sched, fee_status = fee_freshness(state, venue, as_of)
+    insts = [i for i in state["instruments"].values()
+             if i["venue"] == venue]
+    return {"venue": venue, "as_of": as_of,
+            "capability": "M0_DATA_ONLY",
+            "order_tools": "ABSENT",
+            "account_tools": "ABSENT",
+            "instruments": len(insts),
+            "fee_schedule_ref": sched["schedule_ref"] if sched else None,
+            "fee_status": fee_status,
+            "chain_valid": verify_receipt_chain(state["receipts"])}
+
+# Eclipse Book MCP · © 2026 Cyan Eclipse Technologies LLC · cetech.ai

cyan_eclipse_book-0.1.0.dist-info/METADATA

@@ -0,0 +1,50 @@
+Metadata-Version: 2.5
+Name: cyan-eclipse-book
+Version: 0.1.0
+Summary: Market data + venue access layer — not an exchange: one book, one fee truth, one ledger of record.
+Project-URL: Homepage, https://cetech.ai
+Project-URL: Repository, https://github.com/CYAN-ECLIPSE-TECHNOLOGIES-LLC/eclipse-book-mcp
+Project-URL: Vendor, https://cetech.ai
+Author: Cyan Eclipse Technologies LLC
+License: MIT
+License-File: LICENSE
+Keywords: fees,market-data,mcp,model-context-protocol,venues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# cyan-eclipse-book
+
+mcp-name: io.github.CYAN-ECLIPSE-TECHNOLOGIES-LLC/book
+
+**What this is:** the MCP server for **Eclipse Book MCP** - The Market Core of the Eclipse Markets suite (spec eclipse-markets-suite-spec-20261025): one canonical Instrument / Book / Quote / Order / Position / Resolution model over exchanges and prediction markets, with venue adapters that translate and never improvise. Resolution criteria are stored verbatim and hash-pinned — a venue criteria edit is a CRITERIA_CHANGED event and positions keep the criteria as of entry. Quotes carry all-in buy/sell cost for a stated size from versioned, provenance-stamped fee schedules; a stale or missing schedule degrades all-in fields to FEE_UNVERIFIED rather than quoting a wrong number. Resolutions move REPORTED -> VERIFIED only against the criteria's own named source (DISPUTED is first-class), and no core output ever carries a probability field — outputs carry price + liquidity flag + depth + verbatim criteria. M0 is data only: no accounts, no keys, no order submission at any tier; order_draft is an unsubmitted record whose mandate pre-evaluation is honestly NOT_EVALUATED until the owner-gated M2.
+
+## Run it
+
+```console
+$ pip install cyan-eclipse-book
+$ eclipse-book           # MCP over stdio, Python stdlib only
+```
+
+MCP client config:
+
+```json
+{ "mcpServers": { "cyan-eclipse-book": { "command": "uvx", "args": ["--from", "cyan-eclipse-book", "eclipse-book"] } } }
+```
+
+## Tools (17)
+
+`instrument_ingest` - `instrument_get` - `instrument_search` - `book_ingest` - `quote_get` - `fee_schedule_register` - `fee_schedule_get` - `position_open` - `position_list` - `position_get` - `resolution_report` - `resolution_verify` - `resolution_get` - `order_draft` - `order_get` - `venue_status` - `receipt_list`
+
+## Honest scope
+
+- In development — v0.1.0 M0 local build (Market Core, data only; fixtures behind transport seams; CERTIFIED(local) — Eclipse Bazaar Test Bench 2026-10-25)
+- State and runtime data files ship in the wheel beside `server.py`,
+  at the same relative paths the server reads them from.
+
+Powered by Cyan Eclipse Technologies LLC (cetech.ai) - a Veteran-Owned
+Small Business. MIT licensed.

cyan_eclipse_book-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+bazaar-manifest.json,sha256=oPV-jqsBoreA4iCiYSNmy7uw9WVf6-RgxYe2Apg16Pw,4657
+book_engine.py,sha256=fceXMnZLDbaeI_PV_JeSdN-yHfS3kVKPW-tQudWJdHE,26539
+fixtures.json,sha256=t1d8_AuHUsGiK8cE3DjpwLp4JsJ9VPVZJrsE00Ot7ts,1130
+server.py,sha256=KuPRo9uLtvThnjHIXpI0SQHjwFL3NA-6bYFzfnR-5co,16985
+cyan_eclipse_book-0.1.0.dist-info/METADATA,sha256=ajV_lXtrcs9HS7tfNvVRo1DkjEm-pA4yYwW9F-8MqGI,2981
+cyan_eclipse_book-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+cyan_eclipse_book-0.1.0.dist-info/entry_points.txt,sha256=xjkDyF8zjzh6lAKYcZuQGhZ4X1pDW0dFdpftfxHRltA,45
+cyan_eclipse_book-0.1.0.dist-info/licenses/LICENSE,sha256=J64raxD33SRnnCn8p1F-lRl0rnesurM9Jlkd3auDZvA,1086
+cyan_eclipse_book-0.1.0.dist-info/RECORD,,

cyan_eclipse_book-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cyan_eclipse_book-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+eclipse-book = server:main

cyan_eclipse_book-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cyan Eclipse Technologies LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fixtures.json

@@ -0,0 +1 @@
+{"config":{"book_stale_seconds":86400,"fee_freshness_hours":24},"fee_schedules":[{"fetched_at":"2026-10-25T00:00:00Z","freshness_hours":24,"maker_fee_bps":"0","schedule_ref":"polymarket_global@2026-07-01","settlement_fee_model":{"type":"none"},"source":"fixture: Polymarket fee schedule shape (per-market taker curve, maker zero) — live schedule is a build-time fetch, not_tested in M0","taker_fee_bps":"75","venue":"polymarket_global","version":"2026-07-01"},{"fetched_at":"2026-10-25T12:00:00Z","freshness_hours":72,"maker_fee_bps":"40","schedule_ref":"coinbase@2026-10-25","settlement_fee_model":{"type":"none"},"source":"fixture: Coinbase Advanced Trade public fee schedule shape — account-specific tiers supersede at M1","taker_fee_bps":"60","venue":"coinbase","version":"2026-10-25"},{"fetched_at":"2026-08-01T00:00:00Z","freshness_hours":24,"maker_fee_bps":"40","schedule_ref":"coinbase@2026-08-01-stale","settlement_fee_model":{"type":"none"},"source":"fixture: deliberately stale schedule used to prove FEE_UNVERIFIED degradation","taker_fee_bps":"60","venue":"coinbase_legacy_fixture","version":"2026-08-01-stale"}]}

server.py

@@ -0,0 +1,428 @@
+#!/usr/bin/env python3
+# Eclipse Book MCP
+# Copyright © 2026 Cyan Eclipse Technologies LLC · cetech.ai
+
+"""Eclipse Book MCP — v0.1.0, phase M0 (Market Core, data only).
+
+Powered by Cyan Eclipse Technologies (cetech.ai).
+
+Descriptor (mandatory with the name, spec section 3.1): Eclipse
+Book — market data + venue access layer: exchanges and
+prediction markets, normalized: one book, one fee truth, one
+ledger of record. It is NOT an exchange, not a matching engine,
+and never a bookmaker: it holds no funds, crosses no orders,
+and takes no other side.
+
+This server owns (spec eclipse-markets-suite-spec-20261025
+section 5): the canonical Instrument / Book / Quote / Order /
+Position / Resolution objects; resolution criteria stored
+VERBATIM + hash-pinned (a criteria edit is a CRITERIA_CHANGED
+event; positions keep the criteria as of entry); fee truth
+(all-in cost per stated size from versioned, provenance-stamped
+fee schedules — a stale schedule degrades the quote to
+FEE_UNVERIFIED rather than quoting a wrong number); the
+resolution lifecycle (REPORTED -> VERIFIED only against the
+criteria's own named source; DISPUTED is first-class); and the
+probability law (no core output carries a probability field —
+outputs carry price + liquidity flag + depth + criteria ref).
+
+ADAPTER SEAM (M0 fixture form, stated plainly): adapters import
+book_engine from this directory and evaluate against the SHARED
+suite state file ($ECLIPSE_BOOK_STATE or ./data/state.json
+beside this file), loaded fresh at every call. Adapters own
+translation from venue-native payloads; the core owns objects,
+law, and the ledger.
+
+M0 SCOPE: data only. No accounts, no keys, no order submission
+exists in this build at any tier — order_draft produces an
+unsubmitted DRAFT record whose mandate pre-evaluation is
+honestly NOT_EVALUATED until M2 (owner-gated). No certification
+claimed — bench pending.
+
+Transport: MCP over stdio (newline-delimited JSON-RPC 2.0),
+stdlib only. State: $ECLIPSE_BOOK_STATE or ./data/state.json,
+seeded from fixtures.json.
+"""
+import json
+import os
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).parent
+sys.path.insert(0, str(HERE))
+
+import book_engine as eng  # noqa: E402
+from book_engine import ToolError  # noqa: E402
+
+STATE_PATH = Path(os.environ.get(
+    "ECLIPSE_BOOK_STATE", HERE / "data" / "state.json"))
+FIXTURES_PATH = HERE / "fixtures.json"
+
+
+def load_state() -> dict:
+    if STATE_PATH.exists():
+        return json.loads(STATE_PATH.read_text())
+    state = eng.empty_state()
+    seed = json.loads(FIXTURES_PATH.read_text())
+    eng.ensure_seeded(state, seed)
+    save_state(state)
+    return state
+
+
+def save_state(state: dict) -> None:
+    STATE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    STATE_PATH.write_text(json.dumps(state, indent=1))
+
+
+# ------------------------------------------------------------------- tools
+def t_instrument_ingest(state, args):
+    return eng.ingest_instrument(state, args)
+
+
+def t_instrument_get(state, args):
+    inst = state["instruments"].get(args["instrument_id"])
+    if inst is None:
+        raise ToolError(f"INSTRUMENT_NOT_FOUND: {args['instrument_id']}")
+    return {"instrument": eng.guard_no_probability(inst)}
+
+
+def t_instrument_search(state, args):
+    query = (args.get("query") or "").lower()
+    venue = args.get("venue")
+    out = []
+    for inst in state["instruments"].values():
+        if venue and inst["venue"] != venue:
+            continue
+        if query and query not in inst["title"].lower() \
+                and query not in inst["instrument_id"].lower():
+            continue
+        out.append({"instrument_id": inst["instrument_id"],
+                    "venue": inst["venue"], "kind": inst["kind"],
+                    "title": inst["title"], "status": inst["status"],
+                    "native_status": inst["native_status"],
+                    "money_class": inst["money_class"]})
+    return {"instruments": out, "count": len(out)}
+
+
+def t_book_ingest(state, args):
+    book = eng.build_book(
+        args["instrument_id"], args["venue"],
+        args.get("book_type", "CLOB"), args["bids"], args["asks"],
+        args["as_of"], tick=args.get("tick"),
+        native_ref=args.get("native_ref"))
+    book["outcome"] = args.get("outcome")
+    return eng.ingest_book(state, book)
+
+
+def t_quote_get(state, args):
+    return {"quote": eng.quote_get(
+        state, args["instrument_id"], args["size"],
+        outcome=args.get("outcome"), as_of=args.get("as_of"))}
+
+
+def t_fee_schedule_register(state, args):
+    return eng.fee_schedule_register(state, args)
+
+
+def t_fee_schedule_get(state, args):
+    sched, status = eng.fee_freshness(
+        state, args["venue"], args.get("as_of") or eng.now_iso())
+    if sched is None:
+        raise ToolError(f"FEE_SCHEDULE_NOT_FOUND: {args['venue']}")
+    return {"fee_schedule": sched, "fee_status": status}
+
+
+def t_position_open(state, args):
+    return eng.position_open(state, args)
+
+
+def t_position_list(state, args):
+    return {"positions": [eng.position_view(state, p)
+                          for p in state["positions"].values()],
+            "count": len(state["positions"])}
+
+
+def t_position_get(state, args):
+    pos = state["positions"].get(args["position_id"])
+    if pos is None:
+        raise ToolError(f"POSITION_NOT_FOUND: {args['position_id']}")
+    return {"position": eng.position_view(state, pos)}
+
+
+def t_resolution_report(state, args):
+    return eng.resolution_report(state, args)
+
+
+def t_resolution_verify(state, args):
+    return eng.resolution_verify(state, args)
+
+
+def t_resolution_get(state, args):
+    inst = state["instruments"].get(args["instrument_id"])
+    if inst is None:
+        raise ToolError(f"INSTRUMENT_NOT_FOUND: {args['instrument_id']}")
+    return {"resolution": eng.resolution_view(inst)}
+
+
+def t_order_draft(state, args):
+    return eng.order_draft(state, args)
+
+
+def t_order_get(state, args):
+    order = state["orders"].get(args["order_id"])
+    if order is None:
+        raise ToolError(f"ORDER_NOT_FOUND: {args['order_id']}")
+    return {"order": order}
+
+
+def t_venue_status(state, args):
+    return eng.venue_status(state, args["venue"],
+                            as_of=args.get("as_of"))
+
+
+def t_receipt_list(state, args):
+    limit = args.get("limit")
+    receipts = state["receipts"]
+    if limit is not None:
+        receipts = receipts[-int(limit):]
+    return {"receipts": receipts, "count": len(state["receipts"]),
+            "chain_valid": eng.verify_receipt_chain(state["receipts"])}
+
+
+TOOLS = {
+    "instrument_ingest": (
+        t_instrument_ingest,
+        "T1 (core-local). Register or refresh a canonical "
+        "Instrument from an adapter-normalized spec. Event "
+        "contracts REQUIRE verbatim resolution criteria + a "
+        "named resolution source; criteria are hash-pinned and a "
+        "later change is a CRITERIA_CHANGED event (spec 5.4). "
+        "Unmapped venue statuses surface as UNMAPPED, never "
+        "coerced (5.2).",
+        {"venue": {"type": "string"}, "native_id": {"type": "string"},
+         "native_symbol": {"type": "string"},
+         "kind": {"type": "string"}, "title": {"type": "string"},
+         "underlying": {"type": "string"},
+         "outcomes": {"type": "array", "items": {"type": "string"}},
+         "resolution_criteria": {"type": "object"},
+         "resolution_source": {"type": "string"},
+         "trading_window": {"type": "object"},
+         "tick": {"type": "string"}, "min_size": {"type": "string"},
+         "currency": {"type": "string"},
+         "money_class": {"type": "string"},
+         "native_status": {"type": "string"},
+         "status_mapped": {"type": "string"},
+         "provenance": {"type": "object"}},
+        ["venue", "native_id", "kind", "title"]),
+    "instrument_get": (
+        t_instrument_get,
+        "T0. One canonical Instrument by core id, criteria "
+        "versions and resolution state included.",
+        {"instrument_id": {"type": "string"}}, ["instrument_id"]),
+    "instrument_search": (
+        t_instrument_search,
+        "T0. Search instruments by title/id substring, optional "
+        "venue filter.",
+        {"query": {"type": "string"}, "venue": {"type": "string"}}, []),
+    "book_ingest": (
+        t_book_ingest,
+        "T1 (core-local). Store a canonical Book snapshot built "
+        "from normalized levels for an ingested instrument "
+        "(per outcome for event contracts).",
+        {"instrument_id": {"type": "string"},
+         "venue": {"type": "string"}, "book_type": {"type": "string"},
+         "bids": {"type": "array", "items": {"type": "object"}},
+         "asks": {"type": "array", "items": {"type": "object"}},
+         "as_of": {"type": "string"}, "tick": {"type": "string"},
+         "outcome": {"type": "string"},
+         "native_ref": {"type": "string"}},
+        ["instrument_id", "venue", "bids", "asks", "as_of"]),
+    "quote_get": (
+        t_quote_get,
+        "T0. The only price-shaped object (spec 5.1): bid/ask/"
+        "computed mid, ALL-IN buy/sell cost for the stated size "
+        "from the venue's dated fee schedule, liquidity flag + "
+        "depth, and — for event contracts — the verbatim "
+        "resolution criteria. A stale or missing fee schedule "
+        "degrades all-in fields to FEE_UNVERIFIED (5.3). Never "
+        "a probability field (5.5).",
+        {"instrument_id": {"type": "string"},
+         "size": {"type": "string"}, "outcome": {"type": "string"},
+         "as_of": {"type": "string"}},
+        ["instrument_id", "size"]),
+    "fee_schedule_register": (
+        t_fee_schedule_register,
+        "T1 (core-local). Register a versioned fee schedule. "
+        "Provenance (source + fetched_at) is REQUIRED — a "
+        "schedule without it is not a schedule (5.3).",
+        {"venue": {"type": "string"}, "version": {"type": "string"},
+         "source": {"type": "string"},
+         "fetched_at": {"type": "string"},
+         "taker_fee_bps": {"type": "string"},
+         "maker_fee_bps": {"type": "string"},
+         "settlement_fee_model": {"type": "object"},
+         "freshness_hours": {"type": "integer"}},
+        ["venue", "version", "source", "fetched_at", "taker_fee_bps"]),
+    "fee_schedule_get": (
+        t_fee_schedule_get,
+        "T0. The venue's current fee schedule + its freshness "
+        "state (FRESH | STALE | NO_SCHEDULE).",
+        {"venue": {"type": "string"}, "as_of": {"type": "string"}},
+        ["venue"]),
+    "position_open": (
+        t_position_open,
+        "T1 (core-local record). Record a position with the "
+        "resolution criteria snapshotted AS OF ENTRY (5.4). A "
+        "record, not an execution: M0 places nothing.",
+        {"instrument_id": {"type": "string"},
+         "size": {"type": "string"},
+         "entry_price": {"type": "string"},
+         "outcome": {"type": "string"},
+         "account_ref": {"type": "string"}},
+        ["instrument_id", "size", "entry_price"]),
+    "position_list": (
+        t_position_list,
+        "T0/T1. All recorded positions, each carrying its "
+        "criteria-as-of-entry beside the current criteria and a "
+        "criteria_changed_since_entry flag.",
+        {}, []),
+    "position_get": (
+        t_position_get,
+        "T0/T1. One recorded position by id.",
+        {"position_id": {"type": "string"}}, ["position_id"]),
+    "resolution_report": (
+        t_resolution_report,
+        "T1 (core-local). Record a venue-reported resolution "
+        "(REPORTED) or mark a dispute (DISPUTED, first-class, "
+        "spec 5.4). A report is a claim, not a fact.",
+        {"instrument_id": {"type": "string"},
+         "outcome": {"type": "string"}, "source": {"type": "string"},
+         "evidence_ref": {"type": "string"},
+         "disputed": {"type": "boolean"}},
+        ["instrument_id", "outcome"]),
+    "resolution_verify": (
+        t_resolution_verify,
+        "T1 (core-local). Promote REPORTED -> VERIFIED, only "
+        "against the criteria's OWN named source of truth; any "
+        "other source is refused by name, and an open dispute "
+        "blocks verification until cleared (5.4).",
+        {"instrument_id": {"type": "string"},
+         "verification_source": {"type": "string"},
+         "criteria_match": {"type": "boolean"},
+         "dispute_cleared": {"type": "boolean"}},
+        ["instrument_id", "verification_source"]),
+    "resolution_get": (
+        t_resolution_get,
+        "T0. The Resolution record for an instrument: state "
+        "(NONE|REPORTED|VERIFIED|DISPUTED), outcome, sources, "
+        "history. Unverified is data, not fact (5.4).",
+        {"instrument_id": {"type": "string"}}, ["instrument_id"]),
+    "order_draft": (
+        t_order_draft,
+        "T1. Build an UNSUBMITTED Order in DRAFT (MARKET|LIMIT "
+        "only) with its receipt. M0 has no submission path at "
+        "any tier; mandate pre-evaluation reads "
+        "NOT_EVALUATED_M0_DATA_ONLY (spec 5.6, 7.2).",
+        {"instrument_id": {"type": "string"},
+         "side": {"type": "string"}, "type": {"type": "string"},
+         "size": {"type": "string"},
+         "limit_price": {"type": "string"}},
+        ["instrument_id", "side", "size"]),
+    "order_get": (
+        t_order_get,
+        "T0/T1. One Order record with lifecycle + fills + fee "
+        "reconciliation fields.",
+        {"order_id": {"type": "string"}}, ["order_id"]),
+    "venue_status": (
+        t_venue_status,
+        "T0. Adapter health for a venue: capability record "
+        "(M0 = DATA ONLY), instrument count, fee-schedule "
+        "freshness, ledger chain state.",
+        {"venue": {"type": "string"}, "as_of": {"type": "string"}},
+        ["venue"]),
+    "receipt_list": (
+        t_receipt_list,
+        "T0. The suite ledger: append-only, hash-chained "
+        "receipts; verifies the chain.",
+        {"limit": {"type": "integer"}}, []),
+}
+
+# Capability denylist, stated in code (spec 7/8): M0 is data
+# only — no placement, no accounts, no withdrawals, no advice.
+FORBIDDEN_TOOL_NAMES = {
+    "order_place", "order_submit", "place_order", "submit_order",
+    "trade_execute", "buy", "sell", "withdraw", "withdraw_funds",
+    "transfer_funds", "account_get", "account_summary",
+    "create_api_key", "margin_open", "leverage_set",
+    "recommend", "signal_get", "probability_get",
+}
+
+
+def tool_list():
+    return [{"name": name, "description": description,
+             "inputSchema": {"type": "object", "properties": props,
+                             "required": required}}
+            for name, (_, description, props, required) in TOOLS.items()]
+
+
+def handle(req: dict):
+    method, rid = req.get("method", ""), req.get("id")
+    if method == "initialize":
+        return {"jsonrpc": "2.0", "id": rid, "result": {
+            "protocolVersion": req.get("params", {}).get(
+                "protocolVersion", "2025-03-26"),
+            "capabilities": {"tools": {}},
+            "serverInfo": {"name": "eclipse-book",
+                           "version": "0.1.0"}}}
+    if method == "ping":
+        return {"jsonrpc": "2.0", "id": rid, "result": {}}
+    if method == "tools/list":
+        return {"jsonrpc": "2.0", "id": rid,
+                "result": {"tools": tool_list()}}
+    if method == "tools/call":
+        name = req["params"]["name"]
+        args = req["params"].get("arguments", {})
+        if name in FORBIDDEN_TOOL_NAMES or name not in TOOLS:
+            return {"jsonrpc": "2.0", "id": rid, "error": {
+                "code": -32602,
+                "message": f"unknown or line-forbidden tool {name}"}}
+        state = load_state()
+        receipts_before = len(state["receipts"])
+        try:
+            out = TOOLS[name][0](state, args)
+            save_state(state)
+            return {"jsonrpc": "2.0", "id": rid, "result": {
+                "content": [{"type": "text",
+                             "text": json.dumps(out, indent=1)}]}}
+        except ToolError as exc:
+            if len(state["receipts"]) > receipts_before:
+                save_state(state)
+            return {"jsonrpc": "2.0", "id": rid, "result": {
+                "content": [{"type": "text",
+                             "text": json.dumps({"error": str(exc)})}],
+                "isError": True}}
+    if rid is not None:
+        return {"jsonrpc": "2.0", "id": rid, "error": {
+            "code": -32601, "message": f"method not found: {method}"}}
+    return None
+
+
+def main():
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            response = handle(json.loads(line))
+        except Exception as exc:  # never crash the transport
+            response = {"jsonrpc": "2.0", "id": None, "error": {
+                "code": -32603, "message": str(exc)}}
+        if response is not None:
+            sys.stdout.write(json.dumps(response) + "\n")
+            sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    main()
+
+# Eclipse Book MCP · © 2026 Cyan Eclipse Technologies LLC · cetech.ai