context-engineering-core 0.12.1__tar.gz → 0.14.0__tar.gz

{context_engineering_core-0.12.1 → context_engineering_core-0.14.0}/CHANGELOG.md

@@ -3,7 +3,42 @@
 Earlier versions (0.1.0–0.9.6) are documented in `docs/C01_REPORT.md` through
 `docs/C10_STORAGE_ACL_REPORT.md` and preserved as wheels under `archives/`.
 
-## 0.12.1 — 2026-10-31 (unreleased)
+## 0.14.0 — 2026-10-31 (unreleased)
+
+### Added
+- Optional hybrid retrieval: `assemble_context(..., embedder=, semantic_weight=0.7)`
+  (also via `MemoryStore.assemble`) ranks chunks by 0.7 x meaning + 0.3 x keyword
+  score. `context_engine.embeddings`: `Embedder` protocol, `Model2VecEmbedder`
+  (default model pinned: `minishlab/potion-base-8M@bf8b0566`, extra `[semantic]`),
+  `FastEmbedEmbedder` (extra `[fastembed]`), `FunctionEmbedder`. Bounded vector cache.
+- `strategy-eval --semantic` (adds `retrieval_semantic`, `combined_semantic`) and
+  `context-engine-mcp --semantic`.
+- Reworded questions: default retention 3/31 → 21/31 with the embedder; original
+  questions stay 31/31. Bake-off evidence in `output/embedding-bakeoff-001/`.
+
+### Changed
+- `numpy` is now a declared dependency (it was already installed via `rank-bm25`).
+- Missing optional extras give an install hint instead of a traceback.
+
+### Unchanged
+- Without an embedder, all 310 strategy-benchmark assemblies are byte-identical to
+  0.13.0 (archived in `archives/c14-semantic-0140/`).
+
+## 0.13.0 — 2026-10-31 (unreleased)
+
+### Added
+- Reworded-question stress test: `strategy-eval --questions paraphrased` and
+  `compare_strategies(..., questions="paraphrased")`. 31 questions share no content
+  word (or 4-letter start of a 5+ letter word) with their evidence, enforced by
+  `paraphrase_overlaps`. Result: default retention falls from 31/31 to 3/31 at 900
+  and 3000 tokens (retrieval alone: 6/31 and 7/31). README updated.
+- `assemble_strategy(..., question=...)` to assemble a strategy for any question.
+
+### Unchanged
+- Engine behavior and defaults. 0.12.1 wheel/freeze archived in
+  `archives/c13-paraphrase-0130/`.
+
+## 0.12.1 — 2026-10-31 (PyPI)
 
 ### Changed (performance only; output identical)
 - Budget fit checks compute only the request's estimated token count

{context_engineering_core-0.12.1 → context_engineering_core-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: context-engineering-core
-Version: 0.12.1
+Version: 0.14.0
 Summary: Provider-independent context layers, source contracts, and token budget accounting
 Project-URL: Homepage, https://github.com/Nandu1729/Context-Engine
 Project-URL: Repository, https://github.com/Nandu1729/Context-Engine
@@ -18,15 +18,20 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
+Requires-Dist: numpy>=1.26
 Requires-Dist: pywin32==311; sys_platform == 'win32'
 Requires-Dist: rank-bm25<0.3,>=0.2.2
 Requires-Dist: tiktoken<0.15,>=0.14
+Provides-Extra: fastembed
+Requires-Dist: fastembed<0.10,>=0.9; extra == 'fastembed'
 Provides-Extra: langchain
 Requires-Dist: langchain-core<2,>=1.0; extra == 'langchain'
 Provides-Extra: provider
 Requires-Dist: httpx<0.29,>=0.28; extra == 'provider'
 Provides-Extra: reports
 Requires-Dist: matplotlib<3.12,>=3.11; extra == 'reports'
+Provides-Extra: semantic
+Requires-Dist: model2vec<0.11,>=0.10; extra == 'semantic'
 Provides-Extra: service
 Requires-Dist: fastapi<0.136,>=0.135; extra == 'service'
 Requires-Dist: httpx<0.29,>=0.28; extra == 'service'
@@ -45,7 +50,7 @@ that fits the budget. Those messages keep the recent turns, the facts you pinned
 and the older evidence that matches the question. It never calls a model by
 itself, so you send the messages to any provider you like.
 
-> **Status: alpha (0.12.0).** Good for developers to try locally. It is not yet
+> **Status: alpha (0.14.0).** Good for developers to try locally. It is not yet
 > proven on real-world data, and there is no hosted service. See
 > [What is not proven yet](#what-is-not-proven-yet).
 
@@ -106,6 +111,23 @@ chat_model.invoke(langchain_messages(result))  # pip install 'context-engineerin
 history = turns_from_openai(existing_openai_messages, scope)  # reuse a chat history you already have
 ```
 
+### Better recall for reworded questions (optional)
+
+Keyword search needs the question to reuse the fact's words. Add a small local
+embedding model so meaning matches too ("retailer" finds "merchant"):
+
+```python
+# pip install 'context-engineering-core[semantic]'   (~30 MB model, downloaded once)
+from context_engine.embeddings import Model2VecEmbedder
+
+embedder = Model2VecEmbedder()   # pinned minishlab/potion-base-8M; loads only when you create it
+result = assemble_context(history, question, pins, budget, system=system, embedder=embedder)
+```
+
+Ranking becomes 0.7 x meaning score + 0.3 x keyword score. Prefer accuracy over
+speed? `FastEmbedEmbedder("BAAI/bge-small-en-v1.5")` (extra `[fastembed]`). Or wrap
+your own embedding function or API with `FunctionEmbedder`.
+
 ### Use it from an MCP client
 
 `context-engine-mcp --data-dir ./context-memory` runs a local MCP server (stdio) with
@@ -154,11 +176,15 @@ These are enforced in code and covered by about 1,400 tests:
 - **Answer quality.** Tests measure whether the needed facts *reach* the model's
   context, not whether the model then answers correctly. On the built-in
   benchmark, the default settings keep 31 of 31 planted facts at 900 and 3000
-  tokens. But that benchmark is one synthetic conversation written alongside
-  the engine.
-- **Real-world data.** There are no results yet on real user conversations or
-  on questions phrased differently from the source text. Retrieval is
-  keyword-based (BM25), so heavily reworded questions may miss evidence.
+  tokens, and a live model run answered 31 of 31 correctly at 900 tokens. But
+  that benchmark is one synthetic conversation written alongside the engine.
+- **Reworded questions.** By default, retrieval is keyword-based (BM25). When we
+  reword the 31 benchmark questions so they share no words with the stored facts,
+  the default settings keep only 3 of 31 facts. With the optional embedder (see
+  above) they keep 21 of 31 (retrieval alone: 24–25 of 31), with no loss on the
+  original questions. Run it yourself:
+  `context-engine strategy-eval --questions paraphrased --semantic`.
+- **Real-world data.** There are no results yet on real user conversations.
 - **Exact provider token counts.** Budgets use a local tokenizer estimate.
   Providers may count differently. On small requests, provider counts were up
   to 1.78× the local estimate in past tests, so leave headroom or calibrate.

{context_engineering_core-0.12.1 → context_engineering_core-0.14.0}/README.md

@@ -9,7 +9,7 @@ that fits the budget. Those messages keep the recent turns, the facts you pinned
 and the older evidence that matches the question. It never calls a model by
 itself, so you send the messages to any provider you like.
 
-> **Status: alpha (0.12.0).** Good for developers to try locally. It is not yet
+> **Status: alpha (0.14.0).** Good for developers to try locally. It is not yet
 > proven on real-world data, and there is no hosted service. See
 > [What is not proven yet](#what-is-not-proven-yet).
 
@@ -70,6 +70,23 @@ chat_model.invoke(langchain_messages(result))  # pip install 'context-engineerin
 history = turns_from_openai(existing_openai_messages, scope)  # reuse a chat history you already have
 ```
 
+### Better recall for reworded questions (optional)
+
+Keyword search needs the question to reuse the fact's words. Add a small local
+embedding model so meaning matches too ("retailer" finds "merchant"):
+
+```python
+# pip install 'context-engineering-core[semantic]'   (~30 MB model, downloaded once)
+from context_engine.embeddings import Model2VecEmbedder
+
+embedder = Model2VecEmbedder()   # pinned minishlab/potion-base-8M; loads only when you create it
+result = assemble_context(history, question, pins, budget, system=system, embedder=embedder)
+```
+
+Ranking becomes 0.7 x meaning score + 0.3 x keyword score. Prefer accuracy over
+speed? `FastEmbedEmbedder("BAAI/bge-small-en-v1.5")` (extra `[fastembed]`). Or wrap
+your own embedding function or API with `FunctionEmbedder`.
+
 ### Use it from an MCP client
 
 `context-engine-mcp --data-dir ./context-memory` runs a local MCP server (stdio) with
@@ -118,11 +135,15 @@ These are enforced in code and covered by about 1,400 tests:
 - **Answer quality.** Tests measure whether the needed facts *reach* the model's
   context, not whether the model then answers correctly. On the built-in
   benchmark, the default settings keep 31 of 31 planted facts at 900 and 3000
-  tokens. But that benchmark is one synthetic conversation written alongside
-  the engine.
-- **Real-world data.** There are no results yet on real user conversations or
-  on questions phrased differently from the source text. Retrieval is
-  keyword-based (BM25), so heavily reworded questions may miss evidence.
+  tokens, and a live model run answered 31 of 31 correctly at 900 tokens. But
+  that benchmark is one synthetic conversation written alongside the engine.
+- **Reworded questions.** By default, retrieval is keyword-based (BM25). When we
+  reword the 31 benchmark questions so they share no words with the stored facts,
+  the default settings keep only 3 of 31 facts. With the optional embedder (see
+  above) they keep 21 of 31 (retrieval alone: 24–25 of 31), with no loss on the
+  original questions. Run it yourself:
+  `context-engine strategy-eval --questions paraphrased --semantic`.
+- **Real-world data.** There are no results yet on real user conversations.
 - **Exact provider token counts.** Budgets use a local tokenizer estimate.
   Providers may count differently. On small requests, provider counts were up
   to 1.78× the local estimate in past tests, so leave headroom or calibrate.

{context_engineering_core-0.12.1 → context_engineering_core-0.14.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "context-engineering-core"
-version = "0.12.1"
+version = "0.14.0"
 description = "Provider-independent context layers, source contracts, and token budget accounting"
 readme = "README.md"
 license = "Apache-2.0"
@@ -21,11 +21,13 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Typing :: Typed",
 ]
-dependencies = ["tiktoken>=0.14,<0.15", "rank-bm25>=0.2.2,<0.3", "pywin32==311; sys_platform == 'win32'"]
+dependencies = ["tiktoken>=0.14,<0.15", "rank-bm25>=0.2.2,<0.3", "numpy>=1.26", "pywin32==311; sys_platform == 'win32'"]
 
 [project.optional-dependencies]
 provider = ["httpx>=0.28,<0.29"]
 langchain = ["langchain-core>=1.0,<2"]
+semantic = ["model2vec>=0.10,<0.11"]
+fastembed = ["fastembed>=0.9,<0.10"]
 reports = ["matplotlib>=3.11,<3.12"]
 service = ["fastapi>=0.135,<0.136", "uvicorn>=0.41,<0.42", "PyJWT[crypto]>=2.12,<3", "httpx>=0.28,<0.29"]
 

{context_engineering_core-0.12.1 → context_engineering_core-0.14.0}/src/context_engine/__init__.py

@@ -1,6 +1,6 @@
 """Core contracts. Importing this package performs no configuration or network I/O."""
 
-__version__ = "0.12.1"
+__version__ = "0.14.0"
 
 
 def __getattr__(name):

{context_engineering_core-0.12.1 → context_engineering_core-0.14.0}/src/context_engine/cli.py

@@ -81,6 +81,17 @@ def main(argv: list[str] | None = None) -> int:
         "--budget", type=int, action="append", help="Input allowance; repeatable"
     )
     strategies.add_argument("--probes", action="store_true", help="Include per-fact results")
+    strategies.add_argument(
+        "--questions",
+        choices=("original", "paraphrased"),
+        default="original",
+        help="paraphrased: reworded questions with no shared words (lexical stress test)",
+    )
+    strategies.add_argument(
+        "--semantic",
+        action="store_true",
+        help="Also run hybrid strategies with the default embedder (needs the [semantic] extra)",
+    )
     strategies.add_argument("--data-dir", type=Path)
     strategies.add_argument("--output", type=Path, help="Save JSON to a new file; never overwrite")
     planned = commands.add_parser(
@@ -136,7 +147,18 @@ def main(argv: list[str] | None = None) -> int:
             budgets = None if args.budget is None else tuple(args.budget)
             if budgets is not None and any(b <= 0 for b in budgets):
                 raise ContextEngineError("Budgets must be positive integers")
-            result = compare_strategies(bundle, budgets, include_probes=args.probes)
+            embedder = None
+            if args.semantic:
+                from .embeddings import Model2VecEmbedder
+
+                embedder = Model2VecEmbedder()
+            result = compare_strategies(
+                bundle,
+                budgets,
+                include_probes=args.probes,
+                questions=args.questions,
+                embedder=embedder,
+            )
             if args.output is not None:
                 save_inspection(args.output, result)
             print(json.dumps(result, indent=2, ensure_ascii=False))
@@ -216,6 +238,9 @@ def main(argv: list[str] | None = None) -> int:
     except ContextEngineError as error:
         print(json.dumps(error.to_dict()), file=sys.stderr)
         return 1
+    except ImportError as error:  # An optional extra (e.g. [semantic]) is missing.
+        print(json.dumps({"code": "missing_extra", "message": str(error)}), file=sys.stderr)
+        return 2
 
 
 if __name__ == "__main__":

context_engineering_core-0.14.0/src/context_engine/embeddings.py

@@ -0,0 +1,189 @@
+"""Optional semantic retrieval: a small embedder interface and ready-made adapters.
+
+Keyword (BM25) retrieval needs the question to reuse the evidence's words. An
+embedder maps text to meaning vectors so "retailer" can find "merchant". Pass one to
+`assemble_context(..., embedder=...)` (or `MemoryStore.assemble`) to rank chunks by
+`semantic_weight` x meaning score + (1 - weight) x keyword score.
+
+Models load only when you construct an embedder; assembly never downloads anything.
+
+    from context_engine.embeddings import Model2VecEmbedder
+    embedder = Model2VecEmbedder()          # pip install 'context-engineering-core[semantic]'
+"""
+
+from collections import OrderedDict
+from collections.abc import Callable, Sequence
+from pathlib import Path
+from typing import Protocol, runtime_checkable
+
+import numpy as np
+
+from .errors import ContractError
+
+# minishlab/potion-base-8M (MIT): chosen by measurement on the reworded-question
+# benchmark (docs/BENCHMARK_REPORT.md). Pinned for reproducible vectors.
+DEFAULT_MODEL = "minishlab/potion-base-8M"
+DEFAULT_REVISION = "bf8b056651a2c21b8d2565580b8569da283cab23"
+DEFAULT_SEMANTIC_WEIGHT = 0.7
+_CACHE_SIZE = 16384
+_MAX_TEXT = 100_000
+
+
+@runtime_checkable
+class Embedder(Protocol):
+    """`name` must change whenever vectors would change (model, revision, settings)."""
+
+    name: str
+
+    def embed_documents(self, texts: Sequence[str]) -> Sequence[Sequence[float]]: ...
+
+    def embed_query(self, text: str) -> Sequence[float]: ...
+
+
+class FunctionEmbedder:
+    """Wrap your own functions, e.g. a hosted embedding API you call and pay for."""
+
+    def __init__(
+        self,
+        name: str,
+        documents: Callable[[list[str]], Sequence[Sequence[float]]],
+        query: Callable[[str], Sequence[float]] | None = None,
+    ):
+        if not isinstance(name, str) or not name.strip():
+            raise ContractError("Embedder name is required")
+        self.name = name
+        self._documents = documents
+        self._query = query or (lambda text: documents([text])[0])
+
+    def embed_documents(self, texts):
+        return self._documents(list(texts))
+
+    def embed_query(self, text):
+        return self._query(text)
+
+
+class Model2VecEmbedder:
+    """Static embeddings (Model2Vec); ~30 MB model, fast on CPU, no ONNX runtime."""
+
+    def __init__(self, model: str = DEFAULT_MODEL, *, revision: str | None = DEFAULT_REVISION):
+        """Downloads (once, then cached) the pinned model revision; a local path also works."""
+        try:
+            from huggingface_hub import snapshot_download
+            from model2vec import StaticModel
+        except ImportError:
+            raise ImportError(
+                "Model2VecEmbedder needs model2vec: "
+                "pip install 'context-engineering-core[semantic]'"
+            ) from None
+        local = Path(model).is_dir()
+        self.name = f"model2vec:{model}@{'local' if local else revision or 'latest'}"
+        path = (
+            model
+            if local
+            else snapshot_download(
+                model, revision=revision, allow_patterns=["*.json", "*.safetensors"]
+            )
+        )
+        self._model = StaticModel.from_pretrained(path, force_download=False)
+
+    def embed_documents(self, texts):
+        return self._model.encode(list(texts))
+
+    def embed_query(self, text):
+        return self._model.encode([text])[0]
+
+
+class FastEmbedEmbedder:
+    """ONNX transformer embeddings via fastembed (e.g. BAAI/bge-small-en-v1.5).
+
+    More accurate on the reworded benchmark but much slower to index than the default.
+    """
+
+    def __init__(self, model: str = "BAAI/bge-small-en-v1.5", **options):
+        try:
+            from fastembed import TextEmbedding
+        except ImportError:
+            raise ImportError(
+                "FastEmbedEmbedder needs fastembed: "
+                "pip install 'context-engineering-core[fastembed]'"
+            ) from None
+        self.name = f"fastembed:{model}"
+        self._model = TextEmbedding(model, **options)
+
+    def embed_documents(self, texts):
+        return list(self._model.passage_embed(list(texts)))
+
+    def embed_query(self, text):
+        return next(iter(self._model.query_embed([text])))
+
+
+def _unit(vectors, dimension: int | None = None) -> np.ndarray:
+    array = np.asarray(vectors, dtype=np.float32)
+    if array.ndim != 2 or array.shape[1] == 0 or not np.all(np.isfinite(array)):
+        raise ContractError("Embedder returned invalid vectors")
+    if dimension is not None and array.shape[1] != dimension:
+        raise ContractError("Embedder vector dimensions differ")
+    norms = np.linalg.norm(array, axis=1, keepdims=True)
+    return np.divide(array, norms, out=np.zeros_like(array), where=norms > 0)
+
+
+# Process-wide cache of unit document vectors keyed by (embedder name, text): a chat
+# loop re-embeds the same history on every call otherwise.
+_VECTORS: OrderedDict[tuple[str, str], np.ndarray] = OrderedDict()
+
+
+def document_vectors(embedder: Embedder, texts: Sequence[str]) -> np.ndarray:
+    keys = [(embedder.name, text) for text in texts]
+    missing = list(dict.fromkeys(t for k, t in zip(keys, texts, strict=True) if k not in _VECTORS))
+    if missing:
+        if any(len(t) > _MAX_TEXT for t in missing):
+            raise ContractError("Text too long to embed")
+        fresh = _unit(embedder.embed_documents(missing))
+        if len(fresh) != len(missing):
+            raise ContractError("Embedder returned the wrong number of vectors")
+        for text, vector in zip(missing, fresh, strict=True):
+            _VECTORS[(embedder.name, text)] = vector
+            _VECTORS.move_to_end((embedder.name, text))
+    result = np.stack([_VECTORS[k] for k in keys]) if keys else np.zeros((0, 1), np.float32)
+    for key in keys:
+        _VECTORS.move_to_end(key)
+    while len(_VECTORS) > _CACHE_SIZE:
+        _VECTORS.popitem(last=False)
+    return result
+
+
+def query_vector(embedder: Embedder, text: str, dimension: int) -> np.ndarray:
+    return _unit([embedder.embed_query(text)], dimension)[0]
+
+
+def _scaled(values: np.ndarray) -> np.ndarray:
+    low, high = float(values.min()), float(values.max())
+    return np.zeros_like(values) if high <= low else (values - low) / (high - low)
+
+
+def hybrid_scores(
+    semantic: np.ndarray, lexical: np.ndarray, weight: float = DEFAULT_SEMANTIC_WEIGHT
+) -> np.ndarray:
+    """Per-query min-max scaled fusion: weight x meaning + (1 - weight) x keyword."""
+    return weight * _scaled(np.asarray(semantic, np.float64)) + (1 - weight) * _scaled(
+        np.asarray(lexical, np.float64)
+    )
+
+
+def validate_semantic(embedder, weight) -> None:
+    if not isinstance(embedder, Embedder) or not isinstance(getattr(embedder, "name", None), str):
+        raise ContractError("embedder must provide name, embed_documents and embed_query")
+    if type(weight) not in (int, float) or not 0 <= weight <= 1:
+        raise ContractError("semantic_weight must be between 0 and 1")
+
+
+__all__ = [
+    "DEFAULT_MODEL",
+    "DEFAULT_REVISION",
+    "DEFAULT_SEMANTIC_WEIGHT",
+    "Embedder",
+    "FastEmbedEmbedder",
+    "FunctionEmbedder",
+    "Model2VecEmbedder",
+    "hybrid_scores",
+]

{context_engineering_core-0.12.1 → context_engineering_core-0.14.0}/src/context_engine/evaluation/data/freeze.json

@@ -7,7 +7,7 @@
     "summary_fixture": "b3c1b76bb330b52493e5150647747bad77d5de3a55d05d032bb5703be1c70196"
   },
   "runtime": {
-    "code_hash": "c3d4bfbdad58327eb09a763ae398fd97277e33339ce00cfb5395b2615f2d269f",
+    "code_hash": "9a6b1e2584db1f98a58011dc680ea7dc00f7a06d648831d1d39c46de32735976",
     "dependencies": {
       "certifi": "2026.10.23",
       "charset-normalizer": "3.5.1",
@@ -19,7 +19,7 @@
       "tiktoken": "0.14.0",
       "urllib3": "2.8.0"
     },
-    "package_version": "0.12.1",
+    "package_version": "0.14.0",
     "python": "3.12.13"
   },
   "schema_version": 1

context_engineering_core-0.14.0/src/context_engine/evaluation/data/paraphrases.json

@@ -0,0 +1,38 @@
+{
+  "schema_version": 1,
+  "scenario_id": "incident-100-v1",
+  "rule": "Each question asks for the same fact as the original but shares no content word (and, for words of 5+ letters, no 4-letter word start) with the fact's evidence sentence or answer value. Written by the engine author; not independently reviewed.",
+  "questions": {
+    "merchant": "Which retailer or seller took part?",
+    "ticket": "What case number was opened for this outage?",
+    "service": "Which component directed card purchases to processors?",
+    "owner": "Which group was responsible for fixing the problem?",
+    "database": "Where were purchase records persisted?",
+    "queue": "Which channel transported the clearing notifications?",
+    "rollback": "Which version did they revert to?",
+    "runbook": "Which written procedure did the on-call staff follow?",
+    "cluster": "On which group of machines did the job run?",
+    "bucket": "Where were the compliance downloads kept in object storage?",
+    "region": "In which geographic location did the impacted rollout run?",
+    "canary": "Which early-warning probe spotted the performance drop?",
+    "dashboard": "Which monitoring screen showed response delay?",
+    "certificate": "Which TLS credential needed to be swapped out?",
+    "feature": "Which toggle got switched off?",
+    "cache": "Which in-memory store got cleared?",
+    "trace": "What correlation ID tied the broken calls together?",
+    "replica": "Which copy of the data returned outdated results?",
+    "schema": "Which data-model revision caused the incompatibility?",
+    "retries": "How many repeat attempts were set up?",
+    "timeout": "What wait limit was used before giving up?",
+    "region_backup": "Which location was kept on standby for disaster scenarios?",
+    "policy": "Which permission rule got changed?",
+    "namespace": "Which isolation scope held the background jobs?",
+    "endpoint": "Where was the rerouted load sent?",
+    "checksum": "Which hash confirmed the restored backup was intact?",
+    "shard": "Which data segment was found to be at fault?",
+    "batch": "Which group of jobs was run again once things were restored?",
+    "approval": "Which sign-off permitted rebooting the system?",
+    "handoff": "Which transfer note wrapped up the inquiry?",
+    "archive": "Where was the last proof kept long-term?"
+  }
+}