awareness-memory-cloud 2.4.4__tar.gz → 2.6.0__tar.gz

{awareness_memory_cloud-2.4.4 → awareness_memory_cloud-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: awareness-memory-cloud
-Version: 2.4.4
+Version: 2.6.0
 Summary: Python SDK for Awareness Memory Cloud
 Author: Awareness Team
 License:                                  Apache License
@@ -638,3 +638,17 @@ export AWARENESS_OWNER_ID="your-owner-id"
 
 python examples/e2e_langchain_cloud.py
 ```
+
+---
+
+## What makes Awareness different
+
+Most memory systems pick one extraction strategy. Awareness combines them:
+
+- **Hybrid retrieval by default** — BM25 full-text + vector cosine + knowledge-graph 1-hop expansion, fused with Reciprocal Rank Fusion. 95.6% R@5 on LongMemEval, zero LLM calls on the retrieval side.
+- **Salience-aware extraction** — the client's own LLM self-scores every card on `novelty` / `durability` / `specificity`; cards below 0.4 on novelty or durability are dropped server-side. Framework metadata (`Sender (untrusted metadata)`, `turn_brief`) is filtered before extraction runs.
+- **Project isolation** — `X-Awareness-Project-Dir` header scopes memory per project.
+- **Zero-LLM backend** — all extraction runs on your LLM (Claude, GPT-4, Gemini, local Llama). The backend is a coordinator + storage layer; no inference costs pass through to you.
+- **One memory, many clients** — same data reachable via Claude Code, OpenClaw, npm / pip / ClawHub, MCP server.
+
+See [`docs/analysis/MEMPALACE_COMPARISON_2026-04-17.md`](https://github.com/edwin-hao-ai/Awareness/blob/main/docs/analysis/MEMPALACE_COMPARISON_2026-04-17.md) for the honest side-by-side against MemPalace.

{awareness_memory_cloud-2.4.4 → awareness_memory_cloud-2.6.0}/README.md

@@ -389,3 +389,17 @@ export AWARENESS_OWNER_ID="your-owner-id"
 
 python examples/e2e_langchain_cloud.py
 ```
+
+---
+
+## What makes Awareness different
+
+Most memory systems pick one extraction strategy. Awareness combines them:
+
+- **Hybrid retrieval by default** — BM25 full-text + vector cosine + knowledge-graph 1-hop expansion, fused with Reciprocal Rank Fusion. 95.6% R@5 on LongMemEval, zero LLM calls on the retrieval side.
+- **Salience-aware extraction** — the client's own LLM self-scores every card on `novelty` / `durability` / `specificity`; cards below 0.4 on novelty or durability are dropped server-side. Framework metadata (`Sender (untrusted metadata)`, `turn_brief`) is filtered before extraction runs.
+- **Project isolation** — `X-Awareness-Project-Dir` header scopes memory per project.
+- **Zero-LLM backend** — all extraction runs on your LLM (Claude, GPT-4, Gemini, local Llama). The backend is a coordinator + storage layer; no inference costs pass through to you.
+- **One memory, many clients** — same data reachable via Claude Code, OpenClaw, npm / pip / ClawHub, MCP server.
+
+See [`docs/analysis/MEMPALACE_COMPARISON_2026-04-17.md`](https://github.com/edwin-hao-ai/Awareness/blob/main/docs/analysis/MEMPALACE_COMPARISON_2026-04-17.md) for the honest side-by-side against MemPalace.

{awareness_memory_cloud-2.4.4 → awareness_memory_cloud-2.6.0}/awareness_memory_cloud.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: awareness-memory-cloud
-Version: 2.4.4
+Version: 2.6.0
 Summary: Python SDK for Awareness Memory Cloud
 Author: Awareness Team
 License:                                  Apache License
@@ -638,3 +638,17 @@ export AWARENESS_OWNER_ID="your-owner-id"
 
 python examples/e2e_langchain_cloud.py
 ```
+
+---
+
+## What makes Awareness different
+
+Most memory systems pick one extraction strategy. Awareness combines them:
+
+- **Hybrid retrieval by default** — BM25 full-text + vector cosine + knowledge-graph 1-hop expansion, fused with Reciprocal Rank Fusion. 95.6% R@5 on LongMemEval, zero LLM calls on the retrieval side.
+- **Salience-aware extraction** — the client's own LLM self-scores every card on `novelty` / `durability` / `specificity`; cards below 0.4 on novelty or durability are dropped server-side. Framework metadata (`Sender (untrusted metadata)`, `turn_brief`) is filtered before extraction runs.
+- **Project isolation** — `X-Awareness-Project-Dir` header scopes memory per project.
+- **Zero-LLM backend** — all extraction runs on your LLM (Claude, GPT-4, Gemini, local Llama). The backend is a coordinator + storage layer; no inference costs pass through to you.
+- **One memory, many clients** — same data reachable via Claude Code, OpenClaw, npm / pip / ClawHub, MCP server.
+
+See [`docs/analysis/MEMPALACE_COMPARISON_2026-04-17.md`](https://github.com/edwin-hao-ai/Awareness/blob/main/docs/analysis/MEMPALACE_COMPARISON_2026-04-17.md) for the honest side-by-side against MemPalace.

{awareness_memory_cloud-2.4.4 → awareness_memory_cloud-2.6.0}/awareness_memory_cloud.egg-info/SOURCES.txt

@@ -28,8 +28,10 @@ tests/test_client_tasks_agents_users.py
 tests/test_client_upload_export_keys.py
 tests/test_ecosystem_smoke.py
 tests/test_export_reader.py
+tests/test_hyde.py
 tests/test_integrations.py
 tests/test_interceptor_response_format_fallback.py
 tests/test_interceptor_wrap.py
 tests/test_quickstart.py
-tests/test_sdk_functional.py
+tests/test_sdk_functional.py
+tests/test_skill_types.py

{awareness_memory_cloud-2.4.4 → awareness_memory_cloud-2.6.0}/memory_cloud/client.py

@@ -333,6 +333,7 @@ class MemoryCloudClient:
         include_installed: bool = True,
         detail: Optional[str] = None,
         ids: Optional[List[str]] = None,
+        hyde_hint: Optional[str] = None,
         trace_id: Optional[str] = None,
     ) -> Dict[str, Any]:
         """Retrieve from memory using the specified recall mode.
@@ -419,24 +420,42 @@ class MemoryCloudClient:
             body["detail"] = detail
         if ids is not None:
             body["ids"] = ids
+        if hyde_hint and hyde_hint.strip():
+            body["hyde_hint"] = hyde_hint.strip()
 
         # Local daemon bridge: route through awareness_recall MCP tool.
+        # F-053 single-parameter surface — pass only `query` and let the daemon
+        # auto-route (query-type classifier + recency channel + budget-tier
+        # shaping). Legacy fields are still forwarded for backwards-compat with
+        # pre-F-053 daemons but marked explicitly so server-side deprecation
+        # logging can trace who's still sending them.
         if self._should_use_daemon():
             daemon_args: Dict[str, Any] = {
-                "semantic_query": query,
+                "query": query,
                 "limit": limit,
-                "detail": detail or "summary",
             }
-            if effective_keyword:
+            # Token budget drives bucket shaping (raw-heavy / mixed / card-only).
+            # Callers can override via custom_kwargs["token_budget"].
+            token_budget = (custom_kwargs or {}).get("token_budget")
+            if token_budget is not None:
+                daemon_args["token_budget"] = int(token_budget)
+            if agent_role:
+                daemon_args["agent_role"] = agent_role
+            # Legacy fields — only forwarded if caller explicitly passed them.
+            # Daemon will log [deprecated param used] for these.
+            if effective_keyword and keyword_query is not None:
                 daemon_args["keyword_query"] = effective_keyword
             if scope:
                 daemon_args["scope"] = scope
-            if recall_mode:
+            if recall_mode and recall_mode != "precise":
+                # "precise" is the SDK default — don't forward it as legacy.
                 daemon_args["recall_mode"] = recall_mode
-            if agent_role:
-                daemon_args["agent_role"] = agent_role
+            if detail is not None:
+                daemon_args["detail"] = detail
             if ids:
                 daemon_args["ids"] = ids
+            if hyde_hint and hyde_hint.strip():
+                daemon_args["hyde_hint"] = hyde_hint.strip()
             daemon_result = self.call_local_daemon("awareness_recall", daemon_args)
             items = daemon_result.get("items") or daemon_result.get("results") or []
             return {"results": items}
@@ -449,6 +468,50 @@ class MemoryCloudClient:
         )
         return self._attach_trace(payload, resolved_trace_id)
 
+    def retrieve_with_hyde(
+        self,
+        memory_id: str,
+        query: str,
+        llm_complete: Callable[[str], str],
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        """Retrieve with a user-supplied LLM generating a HyDE
+        (Hypothetical Document Embeddings) hint.
+
+        The caller passes a ``llm_complete`` callable that wraps their own
+        LLM provider (OpenAI, Anthropic, ollama, etc.). If the LLM call
+        fails or returns a too-short string, this method falls back to a
+        plain ``retrieve()`` with no ``hyde_hint`` — HyDE is always an
+        optional boost, never required.
+
+        :param memory_id: Target memory id.
+        :param query: The raw user query.
+        :param llm_complete: Sync callable taking a prompt string and
+            returning a completion string. Any raised exception is
+            swallowed and causes fallback to plain retrieve.
+        :param kwargs: Forwarded verbatim to ``retrieve()`` (e.g.
+            ``limit``, ``recall_mode``, ``user_id`` …). Do not pass
+            ``hyde_hint`` here — it is generated by this helper.
+        """
+        hyde_prompt = (
+            "Write a single paragraph (100-200 characters) hypothetical "
+            "answer to this question, as if it were already in a knowledge "
+            "base. No preamble, no markdown.\n\n"
+            f"Question: {query}"
+        )
+        hyde_hint: Optional[str] = None
+        try:
+            generated = llm_complete(hyde_prompt)
+            if generated and len(generated.strip()) >= 20:
+                hyde_hint = generated.strip()[:400]
+        except Exception:
+            # Any LLM error → fall back to raw retrieve (no hyde_hint)
+            pass
+        # Strip a caller-supplied hyde_hint to avoid duplicate-kwarg TypeError
+        # if they passed one accidentally; the helper's generated value wins.
+        kwargs.pop("hyde_hint", None)
+        return self.retrieve(memory_id, query, hyde_hint=hyde_hint, **kwargs)
+
     def write(
         self,
         memory_id: str,
@@ -690,6 +753,10 @@ class MemoryCloudClient:
                 result["events_sent"] = len(capped)
                 if ingest_result.get("trace_id"):
                     result["trace_id"] = ingest_result["trace_id"]
+                # Hoist extraction_request to top-level so callers can see that
+                # extraction was scheduled without reaching into result["ingest"].
+                if ingest_result.get("extraction_request") is not None:
+                    result["extraction_request"] = ingest_result["extraction_request"]
 
         # --- Submit insights directly ---
         if insights is not None:
@@ -1521,22 +1588,30 @@ class MemoryCloudClient:
         self,
         memory_id: str,
         skill_id: str,
+        outcome: Optional[str] = "success",
         trace_id: Optional[str] = None,
     ) -> Dict[str, Any]:
         """
-        Mark a skill as used, resetting its decay timer.
+        Mark a skill as used with outcome feedback.
 
         Args:
             memory_id: Target memory id.
             skill_id: The skill to mark as used.
+            outcome: "success" (default), "partial", or "failed".
+                     Failed outcomes decrease confidence; 3+ consecutive
+                     failures auto-flag the skill for review.
             trace_id: Optional trace id.
 
         Returns:
             Updated skill data.
         """
+        body = None
+        if outcome and outcome != "success":
+            body = {"outcome": outcome}
         data, resolved_trace = self._request(
             method="POST",
             path=f"/memories/{memory_id}/skills/{skill_id}/use",
+            json_payload=body,
             trace_id=trace_id,
         )
         return self._attach_trace(data, resolved_trace)

{awareness_memory_cloud-2.4.4 → awareness_memory_cloud-2.6.0}/memory_cloud/types.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional, TypedDict
+from typing import Any, Dict, List, Literal, Optional, TypedDict
 
 
 class RetrieveResult(TypedDict, total=False):
@@ -423,7 +423,12 @@ class Skill(TypedDict, total=False):
     trigger_conditions: List[SkillTrigger]
     tags: List[str]
     source_card_ids: List[str]
-    growth_stage: str       # seedling | budding | evergreen
+    # Lifecycle stage. Kept as plain str for legacy rows, but the typed union
+    # is exposed via `GrowthStage` for call sites that want narrower typing.
+    growth_stage: Literal["seedling", "budding", "evergreen"]
+    # F-059 — known failure modes + post-run checks. Optional for back-compat.
+    pitfalls: List[str]
+    verification: List[str]
     usage_count: int
     decay_score: float
     pinned: bool
@@ -434,6 +439,10 @@ class Skill(TypedDict, total=False):
     last_used_at: str
 
 
+#: Exposed for consumers that want to type-narrow growth_stage.
+GrowthStage = Literal["seedling", "budding", "evergreen"]
+
+
 class SkillListResult(TypedDict, total=False):
     skills: List[Skill]
     total: int

{awareness_memory_cloud-2.4.4 → awareness_memory_cloud-2.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "awareness-memory-cloud"
-version = "2.4.4"
+version = "2.6.0"
 description = "Python SDK for Awareness Memory Cloud"
 readme = "README.md"
 license = { file = "LICENSE" }

{awareness_memory_cloud-2.4.4 → awareness_memory_cloud-2.6.0}/tests/test_export_reader.py

@@ -40,10 +40,13 @@ def test_mcp_helper_session_and_history_parse():
     second = client._begin_memory_session(memory_id="m1", source="python-sdk")
     assert first["session_id"] != second["session_id"]
 
-    backfilled = client._coerce_history_to_events(
-        history="User: hi\nAssistant: done",
+    # v2.0.0 removed _coerce_history_to_events; equivalent behaviour is now
+    # `_build_record_events` accepting a list of transcript lines.
+    backfilled = client._build_record_events(
+        ["User: hi", "Assistant: done"],
         source="python-sdk",
         session_id=second["session_id"],
+        scope="timeline",
     )
     assert len(backfilled) == 2
     assert backfilled[0]["session_id"] == second["session_id"]

awareness_memory_cloud-2.6.0/tests/test_hyde.py

@@ -0,0 +1,200 @@
+"""Tests for ``retrieve_with_hyde`` helper on the Python SDK.
+
+Covers the four behaviours we care about:
+  1. Happy path: LLM returns a sensible hypothetical answer → it is
+     trimmed, clamped to 400 chars, and forwarded to ``retrieve`` as the
+     ``hyde_hint`` kwarg.
+  2. Fallback: ``llm_complete`` raises → the helper swallows the error
+     and calls ``retrieve`` with ``hyde_hint=None``.
+  3. Too-short output (<20 chars after strip) is dropped.
+  4. Plain ``retrieve(hyde_hint="…")`` wires the value into the POST
+     body so the new backend parameter is actually on the wire.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+import pytest
+
+from memory_cloud.client import MemoryCloudClient
+
+
+def _make_client() -> MemoryCloudClient:
+    return MemoryCloudClient(
+        base_url="http://localhost:8000/api/v1",
+        api_key="test-key",
+    )
+
+
+def test_retrieve_with_hyde_forwards_generated_hint() -> None:
+    client = _make_client()
+
+    captured: Dict[str, Any] = {}
+    prompt_seen: Dict[str, str] = {}
+
+    def llm_complete(prompt: str) -> str:
+        prompt_seen["value"] = prompt
+        return (
+            "JWT refresh tokens live for 30 days, rotate on every use, "
+            "and are stored hashed in users.refresh_token_hash."
+        )
+
+    def fake_retrieve(*args: Any, **kwargs: Any) -> Dict[str, Any]:
+        # Support either positional or keyword passthrough
+        if args:
+            kwargs.setdefault("memory_id", args[0] if len(args) > 0 else None)
+            kwargs.setdefault("query", args[1] if len(args) > 1 else None)
+        captured.update(kwargs)
+        return {"results": [{"content": "hit"}]}
+
+    client.retrieve = fake_retrieve  # type: ignore[method-assign]
+
+    out = client.retrieve_with_hyde(
+        "memory-1",
+        "How long do refresh tokens live?",
+        llm_complete,
+        limit=5,
+    )
+
+    assert out["results"] == [{"content": "hit"}]
+    assert captured["memory_id"] == "memory-1"
+    assert captured["query"] == "How long do refresh tokens live?"
+    assert captured["limit"] == 5
+    assert isinstance(captured["hyde_hint"], str)
+    assert captured["hyde_hint"].startswith("JWT refresh tokens live")
+    assert "hypothetical answer" in prompt_seen["value"]
+    assert "How long do refresh tokens live?" in prompt_seen["value"]
+
+
+def test_retrieve_with_hyde_falls_back_when_llm_raises() -> None:
+    client = _make_client()
+    captured: Dict[str, Any] = {}
+
+    def llm_complete(_prompt: str) -> str:
+        raise RuntimeError("LLM provider down")
+
+    def fake_retrieve(*args: Any, **kwargs: Any) -> Dict[str, Any]:
+        if args:
+            kwargs.setdefault("memory_id", args[0] if len(args) > 0 else None)
+            kwargs.setdefault("query", args[1] if len(args) > 1 else None)
+        captured.update(kwargs)
+        return {"results": []}
+
+    client.retrieve = fake_retrieve  # type: ignore[method-assign]
+
+    client.retrieve_with_hyde(
+        "memory-2",
+        "fallback query",
+        llm_complete,
+    )
+
+    assert captured["query"] == "fallback query"
+    assert captured["hyde_hint"] is None, (
+        "When the user's LLM raises, we must fall back to plain retrieve "
+        "with hyde_hint=None, not crash or silently send a partial hint."
+    )
+
+
+def test_retrieve_with_hyde_drops_too_short_output() -> None:
+    client = _make_client()
+    captured: Dict[str, Any] = {}
+
+    def llm_complete(_prompt: str) -> str:
+        return "too short"  # 9 chars < 20 threshold
+
+    def fake_retrieve(*args: Any, **kwargs: Any) -> Dict[str, Any]:
+        if args:
+            kwargs.setdefault("memory_id", args[0] if len(args) > 0 else None)
+            kwargs.setdefault("query", args[1] if len(args) > 1 else None)
+        captured.update(kwargs)
+        return {"results": []}
+
+    client.retrieve = fake_retrieve  # type: ignore[method-assign]
+
+    client.retrieve_with_hyde("memory-3", "short-output q", llm_complete)
+
+    assert captured["hyde_hint"] is None
+
+
+def test_retrieve_with_hyde_clamps_long_output() -> None:
+    client = _make_client()
+    captured: Dict[str, Any] = {}
+
+    def llm_complete(_prompt: str) -> str:
+        return "A" * 1200
+
+    def fake_retrieve(*args: Any, **kwargs: Any) -> Dict[str, Any]:
+        if args:
+            kwargs.setdefault("memory_id", args[0] if len(args) > 0 else None)
+            kwargs.setdefault("query", args[1] if len(args) > 1 else None)
+        captured.update(kwargs)
+        return {"results": []}
+
+    client.retrieve = fake_retrieve  # type: ignore[method-assign]
+
+    client.retrieve_with_hyde("memory-4", "clamp check", llm_complete)
+
+    assert isinstance(captured["hyde_hint"], str)
+    assert len(captured["hyde_hint"]) == 400
+
+
+def test_retrieve_wires_hyde_hint_into_post_body() -> None:
+    """Direct retrieve(hyde_hint=…) must forward the field on the wire."""
+    client = _make_client()
+    captured: Dict[str, Any] = {}
+
+    def fake_request(
+        *,
+        method: str,
+        path: str,
+        json_payload: Any = None,
+        trace_id: Any = None,
+        **_: Any,
+    ):
+        captured["method"] = method
+        captured["path"] = path
+        captured["body"] = json_payload
+        return ({"results": []}, trace_id or "trace-x")
+
+    client._request = fake_request  # type: ignore[method-assign]
+
+    client.retrieve(
+        "memory-5",
+        "explicit hint",
+        hyde_hint="  A pre-computed hypothetical passage for the query.  ",
+    )
+
+    assert captured["method"] == "POST"
+    assert captured["path"] == "/memories/memory-5/retrieve"
+    assert (
+        captured["body"]["hyde_hint"]
+        == "A pre-computed hypothetical passage for the query."
+    ), "Explicit hyde_hint must be trimmed and sent on the wire"
+
+
+def test_retrieve_omits_hyde_hint_when_not_set() -> None:
+    """Backward compat: callers who do not pass hyde_hint see no new field."""
+    client = _make_client()
+    captured: Dict[str, Any] = {}
+
+    def fake_request(
+        *,
+        method: str,
+        path: str,
+        json_payload: Any = None,
+        trace_id: Any = None,
+        **_: Any,
+    ):
+        captured["body"] = json_payload
+        return ({"results": []}, trace_id or "trace-y")
+
+    client._request = fake_request  # type: ignore[method-assign]
+
+    client.retrieve("memory-6", "no hint here")
+
+    assert "hyde_hint" not in captured["body"]
+
+
+if __name__ == "__main__":  # pragma: no cover
+    pytest.main([__file__, "-v"])

awareness_memory_cloud-2.6.0/tests/test_skill_types.py

@@ -0,0 +1,86 @@
+"""Unit tests for `Skill` TypedDict shape (F-059 additions).
+
+Ensures that `pitfalls`, `verification`, and `growth_stage` can be populated
+without tripping type errors and that the TypedDict can round-trip through
+JSON serialization unchanged — the SDK treats these as passthrough fields
+between the backend/daemon and the caller.
+"""
+
+import json
+
+import pytest
+
+from memory_cloud.types import GrowthStage, Skill
+
+
+def _base_skill() -> Skill:
+    return Skill(
+        id="skill-1",
+        memory_id="mem-1",
+        name="Deploy with Docker Compose",
+        summary="Rebuild backend image and restart dependent services.",
+        methods=[{"step": 1, "description": "docker compose build backend"}],
+        trigger_conditions=[{"pattern": "deploy", "weight": 1.0}],
+        tags=["deployment"],
+        source_card_ids=["card-a", "card-b"],
+        growth_stage="budding",
+        usage_count=3,
+        decay_score=0.72,
+        pinned=False,
+        status="active",
+        created_at="2026-04-19T00:00:00Z",
+        updated_at="2026-04-19T00:00:00Z",
+    )
+
+
+@pytest.mark.unit
+def test_skill_accepts_f059_optional_fields() -> None:
+    skill: Skill = _base_skill()
+    skill["pitfalls"] = [
+        "Do not rebuild postgres — resets scram-sha-256 hash",
+        "Avoid `docker compose up` without --env-file .env.prod",
+    ]
+    skill["verification"] = [
+        "curl https://awareness.market/health returns 200",
+        "docker compose ps shows all services healthy",
+    ]
+
+    assert skill["pitfalls"][0].startswith("Do not rebuild")
+    assert len(skill["verification"]) == 2
+
+
+@pytest.mark.unit
+def test_skill_round_trips_through_json_with_new_fields() -> None:
+    skill: Skill = _base_skill()
+    skill["pitfalls"] = ["p1", "p2"]
+    skill["verification"] = ["v1"]
+
+    encoded = json.dumps(skill)
+    decoded = json.loads(encoded)
+
+    assert decoded["pitfalls"] == ["p1", "p2"]
+    assert decoded["verification"] == ["v1"]
+    assert decoded["growth_stage"] == "budding"
+
+
+@pytest.mark.unit
+def test_growth_stage_union_accepts_valid_values() -> None:
+    # Literal values — these should all be accepted by type-checkers.
+    for stage in ("seedling", "budding", "evergreen"):
+        value: GrowthStage = stage  # type: ignore[assignment]
+        skill: Skill = _base_skill()
+        skill["growth_stage"] = value
+        assert skill["growth_stage"] == stage
+
+
+@pytest.mark.unit
+def test_skill_without_f059_fields_is_still_valid() -> None:
+    """Back-compat: skills created before F-059 must still parse cleanly."""
+    skill: Skill = _base_skill()
+    # No `pitfalls` / `verification` keys present.
+    assert "pitfalls" not in skill
+    assert "verification" not in skill
+    # Round-trip still works.
+    decoded = json.loads(json.dumps(skill))
+    assert "pitfalls" not in decoded
+    assert "verification" not in decoded