alloc-context 0.2.6__tar.gz → 0.2.7__tar.gz

{alloc_context-0.2.6 → alloc_context-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alloc-context
-Version: 0.2.6
+Version: 0.2.7
 Summary: Portfolio-aware crypto context — CEX or wallet holdings, holdings-scoped market, optional allocation analysis
 License: Elastic-2.0
 Project-URL: Homepage, https://mcp.alloc-context.com/llms.txt

{alloc_context-0.2.6 → alloc_context-0.2.7}/alloc_context.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alloc-context
-Version: 0.2.6
+Version: 0.2.7
 Summary: Portfolio-aware crypto context — CEX or wallet holdings, holdings-scoped market, optional allocation analysis
 License: Elastic-2.0
 Project-URL: Homepage, https://mcp.alloc-context.com/llms.txt

{alloc_context-0.2.6 → alloc_context-0.2.7}/alloc_context.egg-info/SOURCES.txt

@@ -70,7 +70,6 @@ alloccontext/mcp/bazaar.py
 alloccontext/mcp/bridge.py
 alloccontext/mcp/bridge_portfolio.py
 alloccontext/mcp/contracts.py
-alloccontext/mcp/glama.py
 alloccontext/mcp/handlers.py
 alloccontext/mcp/http.py
 alloccontext/mcp/instructions.py
@@ -98,6 +97,7 @@ alloccontext/rollup/comparison.py
 alloccontext/rollup/context.py
 alloccontext/rollup/delta.py
 alloccontext/rollup/etf.py
+alloccontext/rollup/expectation_review.py
 alloccontext/rollup/fear_greed.py
 alloccontext/rollup/macro.py
 alloccontext/rollup/portfolio.py
@@ -127,9 +127,9 @@ tests/test_deploy.py
 tests/test_dev_stack.py
 tests/test_etf.py
 tests/test_exchanges_config.py
+tests/test_expectation_review.py
 tests/test_fear_greed.py
 tests/test_fred.py
-tests/test_glama_well_known.py
 tests/test_holdings_scoped_delta_regime.py
 tests/test_holdings_scoped_market.py
 tests/test_horizon.py

{alloc_context-0.2.6 → alloc_context-0.2.7}/alloccontext/__init__.py

@@ -1,3 +1,3 @@
 """AllocContext — portfolio-aware crypto context for agents (MCP)."""
 
-__version__ = "0.2.6"
+__version__ = "0.2.7"

{alloc_context-0.2.6 → alloc_context-0.2.7}/alloccontext/mcp/bazaar.py

@@ -25,7 +25,8 @@ USE_DOCS_PATH = "docs/USE.md"
 
 PRIVACY_COMPACT_COPY = (
     "Privacy: nothing stored. One-time read-only fetch. Pass-through only — "
-    "your keys, wallet address, and portfolio never persist on our servers."
+    "your keys, wallet address, theses, and portfolio never persist on our "
+    "servers."
 )
 
 PRIVACY_PILLAR_MARKERS = (

{alloc_context-0.2.6 → alloc_context-0.2.7}/alloccontext/mcp/bridge.py

@@ -5,6 +5,7 @@ from typing import Any
 from alloccontext.mcp import handlers
 from alloccontext.mcp.bridge_portfolio import (
     attach_assets_scope,
+    attach_bridge_expectation_review,
     bridge_upstream_ready,
     build_upstream_context_args,
     default_bridge_app_config,
@@ -14,7 +15,7 @@ from alloccontext.mcp.bridge_portfolio import (
     resolve_bridge_assets,
     strip_upstream_allocation_regime,
 )
-from alloccontext.mcp.setup import allocation_not_configured
+from alloccontext.mcp.setup import allocation_not_configured, upstream_payment_required
 from alloccontext.mcp.upstream import call_upstream_tool
 from alloccontext.user_config import (
     UserConfig,
@@ -46,6 +47,27 @@ def _effective_band(user: UserConfig, band: float | None) -> float | None:
     return user.band
 
 
+def _effective_theses(
+    user: UserConfig,
+    theses: list[dict[str, Any]] | None,
+) -> list[dict[str, Any]] | None:
+    if theses is not None:
+        return theses
+    return user.theses
+
+
+def _fetch_upstream_baseline(user: UserConfig, *, scope: str, recorded_at: str) -> dict[str, Any]:
+    return call_upstream_tool(
+        user,
+        "get_context_at",
+        {
+            "scope": scope,
+            "as_of": recorded_at,
+            "match": "at_or_before",
+        },
+    )
+
+
 def _bridge_tool_meta(tool_name: str) -> dict[str, Any]:
     return {
         "name": tool_name,
@@ -111,10 +133,13 @@ def create_bridge_server(user: UserConfig):
         assets: list[str] | None = None,
         target_pct: dict[str, float] | None = None,
         band: float | None = None,
+        theses: list[dict[str, Any]] | None = None,
     ) -> dict[str, Any]:
         validated_scope = handlers.validate_scope(scope)
         validated_freshness = handlers.validate_freshness(freshness)
         if not bridge_upstream_ready(user):
+            if _effective_theses(user, theses):
+                return upstream_payment_required()
             effective_assets, _assets_scope = resolve_bridge_assets(
                 user,
                 bridge_config,
@@ -156,6 +181,19 @@ def create_bridge_server(user: UserConfig):
         merged = merge_portfolio_into_bundle(bundle, portfolio)
         merged = strip_upstream_allocation_regime(merged)
         merged = merge_assets_omitted(merged, portfolio)
+        merged = attach_bridge_expectation_review(
+            user=user,
+            bundle=merged,
+            scope=validated_scope,
+            theses=_effective_theses(user, theses),
+            target_pct=_effective_target_pct(user, target_pct),
+            band=_effective_band(user, band),
+            fetch_baseline=lambda **kwargs: _fetch_upstream_baseline(
+                user,
+                scope=kwargs["scope"],
+                recorded_at=kwargs["recorded_at"],
+            ),
+        )
         return attach_assets_scope(merged, assets_scope)
 
     @mcp.tool(**_bridge_tool_meta("get_portfolio_state"))

{alloc_context-0.2.6 → alloc_context-0.2.7}/alloccontext/mcp/bridge_portfolio.py

@@ -15,6 +15,8 @@ from alloccontext.rollup.portfolio_payload import (
     attach_allocation_analysis_to_payload,
     portfolio_dict_from_snapshot,
 )
+from alloccontext.mcp.validation import validate_band, validate_target_pct, validate_theses
+from alloccontext.rollup.expectation_review import build_expectation_review
 from alloccontext.user_config import UserConfig
 
 AssetsScope = Literal["explicit", "portfolio", "default", "portfolio_unavailable"]
@@ -218,3 +220,55 @@ def strip_upstream_allocation_regime(bundle: dict[str, Any]) -> dict[str, Any]:
     result = dict(bundle)
     result["regime"] = updated
     return result
+
+
+def attach_bridge_expectation_review(
+    *,
+    user: UserConfig,
+    bundle: dict[str, Any],
+    scope: str,
+    theses: list[dict[str, Any]] | None,
+    target_pct: dict[str, float] | None,
+    band: float | None,
+    fetch_baseline,
+) -> dict[str, Any]:
+    """Score local theses on a merged bridge bundle (baselines via upstream)."""
+    effective_theses = theses if theses is not None else user.theses
+    if not effective_theses:
+        return bundle
+
+    validated = validate_theses(effective_theses)
+    if not validated:
+        return bundle
+
+    by_recorded_at: dict[str, dict[str, Any] | None] = {}
+    baseline_bundles: dict[str, dict[str, Any] | None] = {}
+    for thesis in validated:
+        thesis_id = thesis["id"]
+        recorded_at = thesis["recorded_at"]
+        if recorded_at not in by_recorded_at:
+            baseline = fetch_baseline(scope=scope, recorded_at=recorded_at)
+            by_recorded_at[recorded_at] = (
+                baseline
+                if isinstance(baseline, dict) and baseline.get("as_of")
+                else None
+            )
+        baseline_bundles[thesis_id] = by_recorded_at[recorded_at]
+
+    effective_target = target_pct if target_pct is not None else user.target_allocation
+    if effective_target is not None:
+        effective_target = validate_target_pct(effective_target)
+    effective_band = band if band is not None else user.band
+    if effective_band is not None:
+        effective_band = validate_band(effective_band)
+
+    review = build_expectation_review(
+        baseline_bundles=baseline_bundles,
+        current_bundle=bundle,
+        theses=validated,
+        target_pct=effective_target,
+        band=effective_band,
+    )
+    result = dict(bundle)
+    result["expectation_review"] = review
+    return result

{alloc_context-0.2.6 → alloc_context-0.2.7}/alloccontext/mcp/contracts.py

@@ -34,6 +34,22 @@ REGIME_AVAILABLE_KEYS = (
     "allocation",
 )
 
+EXPECTATION_REVIEW_KEYS = (
+    "available",
+    "current_as_of",
+    "supported",
+    "weakened",
+    "unknown",
+    "claims",
+)
+
+EXPECTATION_CLAIM_KEYS = (
+    "thesis_id",
+    "type",
+    "status",
+    "evidence",
+)
+
 MCP_TOOL_NAMES = frozenset(spec["tool_name"] for spec in mcp_tool_specs())
 
 
@@ -121,6 +137,25 @@ def validate_context_bundle(payload: dict[str, Any]) -> None:
         label="regime",
         when_available=REGIME_AVAILABLE_KEYS,
     )
+    review = payload.get("expectation_review")
+    if isinstance(review, dict) and review.get("available"):
+        assert_available_block(
+            review,
+            label="expectation_review",
+            when_available=EXPECTATION_REVIEW_KEYS,
+        )
+        for index, claim in enumerate(review.get("claims") or []):
+            if not isinstance(claim, dict):
+                raise AssertionError(f"expectation_review.claims[{index}] must be object")
+            assert_has_keys(
+                claim,
+                EXPECTATION_CLAIM_KEYS,
+                label=f"expectation_review.claims[{index}]",
+            )
+            if claim.get("status") == "unknown" and not claim.get("reason"):
+                raise AssertionError(
+                    f"expectation_review.claims[{index}] unknown requires reason"
+                )
 
 
 def validate_market_context(payload: dict[str, Any]) -> None:

{alloc_context-0.2.6 → alloc_context-0.2.7}/alloccontext/mcp/handlers.py

@@ -32,6 +32,11 @@ from alloccontext.mcp.validation import (
     validate_band,
     validate_nav_usd,
     validate_target_pct,
+    validate_theses,
+)
+from alloccontext.rollup.expectation_review import (
+    build_expectation_review,
+    theses_need_allocation_fit,
 )
 from alloccontext.rollup.comparison import compare_context_bundles
 from alloccontext.rollup.regime import build_regime_context
@@ -116,6 +121,116 @@ def _band_allocation_pct(portfolio: dict[str, Any]) -> dict[str, float]:
     return band_allocation_pct(portfolio.get("holdings") or [])
 
 
+def _load_baseline_bundle(
+    conn: sqlite3.Connection,
+    *,
+    scope: Scope,
+    recorded_at: str,
+) -> dict[str, Any] | None:
+    try:
+        resolved = resolve_context_snapshot_as_of(
+            conn,
+            scope=scope,
+            as_of=recorded_at,
+            mode="at_or_before",
+        )
+        return load_context_bundle_snapshot(conn, scope=scope, as_of=resolved)
+    except SnapshotNotFoundError:
+        return None
+
+
+def _prepare_baseline_bundle(
+    conn: sqlite3.Connection,
+    config,
+    *,
+    scope: Scope,
+    recorded_at: str,
+) -> dict[str, Any] | None:
+    """Load baseline snapshot and rebuild regime for market-wide claim scoring."""
+    raw = _load_baseline_bundle(conn, scope=scope, recorded_at=recorded_at)
+    if raw is None:
+        return None
+    return _attach_regime(dict(raw), config)
+
+
+def _baseline_bundles_for_theses(
+    conn: sqlite3.Connection,
+    config,
+    *,
+    scope: Scope,
+    theses: list[dict[str, Any]],
+) -> dict[str, dict[str, Any] | None]:
+    by_recorded_at: dict[str, dict[str, Any] | None] = {}
+    result: dict[str, dict[str, Any] | None] = {}
+    for thesis in theses:
+        thesis_id = thesis["id"]
+        recorded_at = thesis.get("recorded_at") or ""
+        if recorded_at not in by_recorded_at:
+            by_recorded_at[recorded_at] = _prepare_baseline_bundle(
+                conn,
+                config,
+                scope=scope,
+                recorded_at=recorded_at,
+            )
+        result[thesis_id] = by_recorded_at[recorded_at]
+    return result
+
+
+def _effective_allocation_inputs(
+    config,
+    *,
+    target_pct: dict[str, float] | None,
+    band: float | None,
+) -> tuple[dict[str, float] | None, float | None]:
+    effective_target = target_pct
+    if effective_target is None and config.portfolio.target_allocations:
+        effective_target = validate_target_pct(dict(config.portfolio.target_allocations))
+    effective_band = band
+    if effective_band is None and config.portfolio.rebalance_band is not None:
+        effective_band = validate_band(config.portfolio.rebalance_band)
+    return effective_target, effective_band
+
+
+def _attach_expectation_review(
+    conn: sqlite3.Connection,
+    config,
+    bundle: dict[str, Any],
+    *,
+    scope: Scope,
+    theses: list[dict[str, Any]] | None,
+    target_pct: dict[str, float] | None,
+    band: float | None,
+) -> dict[str, Any]:
+    if not theses:
+        return bundle
+    validated = validate_theses(theses)
+    if not validated:
+        return bundle
+
+    baseline_bundles = _baseline_bundles_for_theses(
+        conn,
+        config,
+        scope=scope,
+        theses=validated,
+    )
+
+    effective_target, effective_band = _effective_allocation_inputs(
+        config,
+        target_pct=target_pct,
+        band=band,
+    )
+    review = build_expectation_review(
+        baseline_bundles=baseline_bundles,
+        current_bundle=bundle,
+        theses=validated,
+        target_pct=effective_target,
+        band=effective_band,
+    )
+    result = dict(bundle)
+    result["expectation_review"] = review
+    return result
+
+
 def _attach_allocation_analysis(
     bundle: dict[str, Any],
     config,
@@ -389,6 +504,7 @@ def get_context_bundle(
     assets: list[str] | None = None,
     target_pct: dict[str, float] | None = None,
     band: float | None = None,
+    theses: list[dict[str, Any]] | None = None,
 ) -> dict[str, Any]:
     now = (as_of or utc_now()).replace(microsecond=0)
     if now.tzinfo is None:
@@ -426,6 +542,13 @@ def get_context_bundle(
         save_snapshot=False,
         alt_symbols=alt_symbols,
     )
+    validated_theses = validate_theses(theses) if theses else []
+    need_allocation = theses_need_allocation_fit(validated_theses)
+    effective_target, effective_band = _effective_allocation_inputs(
+        config,
+        target_pct=target_pct,
+        band=band,
+    )
     if target_pct is not None or band is not None:
         bundle = _attach_allocation_analysis(
             bundle,
@@ -433,8 +556,24 @@ def get_context_bundle(
             target_pct=target_pct,
             band=band,
         )
+    elif need_allocation and effective_target is not None:
+        bundle = _attach_allocation_analysis(
+            bundle,
+            config,
+            target_pct=effective_target,
+            band=effective_band,
+        )
     bundle = apply_assets_filter_to_bundle(bundle, view_assets)
     bundle = _attach_regime(bundle, config)
+    bundle = _attach_expectation_review(
+        conn,
+        config,
+        bundle,
+        scope=scope,
+        theses=theses,
+        target_pct=target_pct,
+        band=band,
+    )
     if target_pct is not None:
         bundle["target_pct"] = validate_target_pct(target_pct)
     if band is not None:

{alloc_context-0.2.6 → alloc_context-0.2.7}/alloccontext/mcp/http.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import contextlib
-import json
 import os
 from collections.abc import AsyncIterator
 from typing import Any
@@ -17,7 +16,6 @@ from alloccontext.mcp.bazaar import (
     build_well_known_x402,
     resolve_public_base_url,
 )
-from alloccontext.mcp.glama import build_glama_well_known
 from alloccontext.mcp.server import create_server
 from alloccontext.mcp.x402_config import (
     CDP_FACILITATOR_URL,
@@ -131,17 +129,6 @@ def _well_known_mcp_server_card() -> JSONResponse:
     return JSONResponse(build_mcp_server_card(version=__version__))
 
 
-def _well_known_glama() -> JSONResponse:
-    public_base = resolve_public_base_url()
-    if not public_base:
-        return JSONResponse({"error": "discovery metadata unavailable"}, status_code=404)
-    try:
-        payload = build_glama_well_known()
-    except (FileNotFoundError, ValueError, json.JSONDecodeError) as exc:
-        return JSONResponse({"error": str(exc)}, status_code=404)
-    return JSONResponse(payload)
-
-
 def _is_loopback_host(host: str) -> bool:
     normalized = host.strip().lower()
     return normalized in {"127.0.0.1", "localhost", "::1"}
@@ -224,7 +211,6 @@ def build_http_app(
         Route("/llms.txt", lambda req: _llms_txt(settings)),
         Route("/.well-known/x402.json", lambda req: _well_known_x402(settings)),
         Route("/.well-known/mcp/server-card.json", lambda req: _well_known_mcp_server_card()),
-        Route("/.well-known/glama.json", lambda req: _well_known_glama()),
     ]
 
     if not settings.enabled:

{alloc_context-0.2.6 → alloc_context-0.2.7}/alloccontext/mcp/instructions.py

@@ -5,7 +5,9 @@ PRODUCT_INSTRUCTIONS = (
     "keys or a public EVM wallet address (keyless). Default responses include "
     "holdings[], market, sentiment, macro, regime, and delta. Allocation "
     "drift and rebalance are opt-in via target_pct or allocation_analysis. "
-    "Privacy: nothing stored; one-time read-only; pass-through only. "
+    "Optional theses[] attach expectation_review (pass-through beliefs; "
+    "nothing stored). Privacy: nothing stored; one-time read-only; "
+    "pass-through only. "
     "setup objects explain missing config."
 )
 

{alloc_context-0.2.6 → alloc_context-0.2.7}/alloccontext/mcp/server.py

@@ -26,6 +26,7 @@ from alloccontext.mcp.tool_fields import (
     MatchMode,
     NavUsd,
     OptionalTargetPct,
+    OptionalTheses,
     PriorAsOf,
     Scenarios,
     Scope,
@@ -117,6 +118,7 @@ def create_server(
         assets: Assets = None,
         target_pct: OptionalTargetPct = None,
         band: BandOptional = None,
+        theses: OptionalTheses = None,
     ) -> dict[str, Any]:
         """Return the full deterministic context bundle for daily or weekly scope."""
         validated_scope = handlers.validate_scope(scope)
@@ -131,6 +133,7 @@ def create_server(
                 assets=assets,
                 target_pct=target_pct,
                 band=band,
+                theses=theses,
             )
         finally:
             conn.close()

{alloc_context-0.2.6 → alloc_context-0.2.7}/alloccontext/mcp/tool_catalog.py

@@ -118,6 +118,63 @@ BAND_SCHEMA: dict[str, Any] = {
     "description": "Drift band width as a fraction (e.g. 0.15 = 15% outside target).",
 }
 
+THESES_SCHEMA: dict[str, Any] = {
+    "type": "array",
+    "description": (
+        "Optional local thesis entries for expectation_review (pass-through; "
+        "nothing stored). Each entry requires id, recorded_at, and claims[]."
+    ),
+    "items": {
+        "type": "object",
+        "properties": {
+            "id": {
+                "type": "string",
+                "description": "Stable thesis identifier for claim results.",
+            },
+            "recorded_at": {
+                "type": "string",
+                "description": "Thesis anchor ISO timestamp (baseline snapshot).",
+            },
+            "asset": {
+                "type": "string",
+                "description": "Optional context symbol for the thesis (not scored).",
+            },
+            "claims": {
+                "type": "array",
+                "description": "Structured claim objects scored deterministically.",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "type": {
+                            "type": "string",
+                            "description": "Claim type (e.g. RELATIVE_STRENGTH).",
+                        },
+                        "asset": {
+                            "type": "string",
+                            "description": "Held asset symbol for asset-scoped claims.",
+                        },
+                        "benchmark": {
+                            "type": "string",
+                            "description": "Benchmark symbol for RELATIVE_STRENGTH.",
+                        },
+                        "direction": {
+                            "type": "string",
+                            "description": "Expected direction (UP/DOWN, IMPROVING, etc.).",
+                        },
+                    },
+                    "required": ["type"],
+                },
+            },
+            "rationale": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Agent context only — never scored.",
+            },
+        },
+        "required": ["id", "recorded_at", "claims"],
+    },
+}
+
 MATCH_SCHEMA: dict[str, Any] = {
     "type": "string",
     "enum": ["exact", "at_or_before"],
@@ -216,7 +273,9 @@ TOOL_DESCRIPTIONS: dict[str, str] = {
         "snapshot. Use get_market_context for market-only; use get_context_at "
         "for a historical snapshot; use get_context_delta to compare two times. "
         "Optional target_pct and band attach allocation_analysis (opt-in drift "
-        "math). freshness=cached uses the local ingest DB; freshness=live runs "
+        "math). Optional theses[] attaches expectation_review (deterministic "
+        "claim scoring vs recorded_at baseline; pass-through only). "
+        "freshness=cached uses the local ingest DB; freshness=live runs "
         "ingest first (may add latency; needs ingest API keys on the host)."
     ),
     "get_market_context": (
@@ -313,6 +372,7 @@ MCP_TOOL_SPECS: tuple[dict[str, Any], ...] = (
                 "assets": ASSET_FILTER_SCHEMA,
                 "target_pct": TARGET_PCT_SCHEMA,
                 "band": BAND_SCHEMA,
+                "theses": THESES_SCHEMA,
             },
         },
         "example": {

{alloc_context-0.2.6 → alloc_context-0.2.7}/alloccontext/mcp/tool_fields.py

@@ -63,6 +63,16 @@ BandOptional = Annotated[
         ),
     ),
 ]
+OptionalTheses = Annotated[
+    list[dict[str, Any]] | None,
+    Field(
+        description=(
+            "Optional local thesis entries (id, recorded_at, claims[]) for "
+            "deterministic expectation_review scoring. Pass-through only — "
+            "nothing stored."
+        ),
+    ),
+]
 BandDefault = Annotated[
     float,
     Field(