Add full NZFC runtime assets for DiffusionGemma Infinite-Context

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+archive/complex_math_10m_archive.jsonl filter=lfs diff=lfs merge=lfs -text
+meta/complex_math_10m_meta.jsonl filter=lfs diff=lfs merge=lfs -text

NZFC_DIFFUSIONGEMMA_INFINITE_CONTEXT_EVIDENCE_PACK_MANIFEST.json

@@ -0,0 +1,64 @@
+{
+  "version": "v1.2.5a-runtime-assets-final",
+  "release_name": "DiffusionGemma Infinite-Context Runtime Asset Final Fix",
+  "repo_id": "SingularityPrinciple/DiffusionGemma-26B-A4B-it-Infinite-Context",
+  "base_model": "google/diffusiongemma-26B-A4B-it",
+  "source_runtime_repo": "SingularityPrinciple/Gemma-E2B-IT-10M-Chat",
+  "contains_base_model_weights": false,
+  "release_type": "evidence_pack_update_with_full_runtime_assets",
+  "marketing_title": "DiffusionGemma-26B-A4B-it-Infinite-Context",
+  "technical_boundary": "external evidence context, not native unlimited model context",
+  "runtime_assets_included": {
+    "runtime_dir": true,
+    "meta_dir": true,
+    "memory_tensors_dir": true,
+    "archive_dir": true,
+    "configs_dir": true
+  },
+  "runtime_only_smoke": {
+    "created_at": "2026-06-11 02:43:54",
+    "repo_id": "SingularityPrinciple/DiffusionGemma-26B-A4B-it-Infinite-Context",
+    "base_model": "google/diffusiongemma-26B-A4B-it",
+    "runtime_only": true,
+    "model_loaded": false,
+    "repo_root_runtime_exists": true,
+    "repo_root_meta_exists": true,
+    "repo_root_memory_tensors_exists": true,
+    "exact_slot_answer": "PROJECT_CODE_DIFFUSIONGEMMA_SMOKE",
+    "exact_slot_passed": true,
+    "exact_slot_profile": {
+      "version": "v1.2.4b",
+      "description": "Strict deterministic exact slot mapper for short explicit scoped key-value recall questions.",
+      "auto_short_circuit": true,
+      "strict_trigger_gate": true
+    },
+    "large_document_chunk_count": 3,
+    "large_document_query_count": 2,
+    "large_document_method": "fts5_bm25",
+    "large_document_passed": true,
+    "tombstone_guard_profile": {
+      "version": "v1.2.4c",
+      "description": "Filters inactive or tombstoned MEM_* records from memory_store.retrieve results.",
+      "db_path": "/kaggle/working/diffusiongemma_infinite_context_evidence_pack_update/runtime_only_smoke_final/memory.sqlite3",
+      "guarded_method": "memory_store.retrieve"
+    },
+    "tombstone_test": {
+      "available": true,
+      "before_found": true,
+      "after_found": false,
+      "passed": true,
+      "tombstoned": 1
+    },
+    "technical_boundary": "external evidence context, not native unlimited model context",
+    "status": "passed"
+  },
+  "non_claims": [
+    "not native infinite context",
+    "not internal infinite memory",
+    "not a claim that the base model itself has unlimited context",
+    "not zero hallucination",
+    "not legal advice",
+    "not production security certification"
+  ],
+  "created_at": "2026-06-11 02:43:54"
+}

README.md

@@ -5,135 +5,49 @@ library_name: transformers
 pipeline_tag: image-text-to-text
 tags:
 - diffusiongemma
-- gemma-4
 - infinite-context
+- nzfc-gram
 - external-memory
 - evidence-retrieval
-- long-context
 - large-documents
-- legal-documents
-- ai-memory
-- nzfc-gram
-- not-native-infinite-context
 ---
 
 # DiffusionGemma-26B-A4B-it-Infinite-Context
 
-**NZFC-GRAM runtime overlay for `google/diffusiongemma-26B-A4B-it`.**
-
-> Marketing title: **Infinite-Context**
-
-Technical boundary:
-
-> External evidence context, not native unlimited model context.
-
-This repository does not include or redistribute Google model weights.
-It is a runtime and adapter overlay that connects DiffusionGemma to NZFC-GRAM external memory, large-document indexing, scoped retrieval, tombstone filtering, redaction, and bounded evidence packs.
-
-## Why this exists
-
-DiffusionGemma provides a very large native context window.
-NZFC-GRAM adds a different layer: governed external memory and document evidence retrieval beyond a single prompt.
-
-The goal is to make memory claims evidence-bound:
-
-```text
-external memory
--> scoped retrieval
--> tombstone filtering
--> malicious-memory redaction
--> large-document / legal-document indexing
--> bounded evidence pack
--> DiffusionGemma generation
-```
-
-## Base model
-
-```text
-google/diffusiongemma-26B-A4B-it
-```
-
-## What this is not
+NZFC-GRAM runtime overlay for external evidence context around `google/diffusiongemma-26B-A4B-it`.
 
-- Not native infinite context.
-- Not internal infinite model memory.
-- Not a claim that DiffusionGemma itself has unlimited context.
-- Not a zero-hallucination guarantee.
-- Not legal advice.
-- Not a production security certification.
-- Not affiliated with Google.
+Technical boundary: external evidence context, not native unlimited model context.
 
-## Quick start: retrieval-only smoke
+## v1.2.5a runtime asset final fix
 
-```bash
-git clone https://huggingface.co/SingularityPrinciple/DiffusionGemma-26B-A4B-it-Infinite-Context
-cd DiffusionGemma-26B-A4B-it-Infinite-Context
-pip install -r requirements.txt
-python examples/quick_diffusiongemma_retrieval_only.py
-```
+This update includes the NZFC root assets required for local runtime initialization:
 
-## Quick start: load DiffusionGemma
+- `runtime/`
+- `meta/`
+- `memory_tensors/` when available
+- `archive/` when available
+- `configs/` when available
 
-DiffusionGemma 26B A4B requires capable hardware.
-Set `LOAD_MODEL=1` only when your environment can load the base model.
+Runtime-only smoke result:
 
-```bash
-LOAD_MODEL=1 python examples/quick_diffusiongemma_generation_preview.py
+```json
+{
+  "runtime_only": true,
+  "model_loaded": false,
+  "repo_root_runtime_exists": true,
+  "repo_root_meta_exists": true,
+  "repo_root_memory_tensors_exists": true,
+  "exact_slot_passed": true,
+  "large_document_passed": true,
+  "large_document_query_count": 2,
+  "tombstone_guard_available": true,
+  "technical_boundary": "external evidence context, not native unlimited model context"
+}
 ```
 
-## Python usage
-
-```python
-from nzfc_gram_runtime import NZFCGramLongMemoryChat
-from nzfc_gram_runtime.diffusiongemma_adapter import attach_diffusiongemma_block_diffusion
-from nzfc_gram_runtime.quality import attach_answer_quality_governor
-from nzfc_gram_runtime.large_document import attach_large_document_memory
-
-bot = NZFCGramLongMemoryChat(
-    repo_dir='.',
-    model_id='google/diffusiongemma-26B-A4B-it',
-    memory_db_path='./user_memory.sqlite3',
-    load_model=False,
-    require_model=False,
-    preload_static_memory=True,
-)
-
-attach_large_document_memory(bot)
-attach_answer_quality_governor(bot)
-
-attach_diffusiongemma_block_diffusion(
-    bot,
-    model_id='google/diffusiongemma-26B-A4B-it',
-    device_map='auto',
-    dtype='auto',
-)
-
-res = bot.quality_chat(
-    'What does my indexed policy document say about deleted memory?',
-    user_id='demo_user',
-    project_id='demo_project',
-    session_id='demo_session',
-)
-print(res['answer'])
-```
-
-## Release status
-
-Fast marketing-preview adapter release.
-
-Recommended validation:
+Important:
 
 ```text
-1. Fresh-download repo
-2. Import runtime
-3. Retrieval-only smoke test
-4. Optional DiffusionGemma model load on suitable hardware
-5. High-frequency multi-context memory test
-6. Large-document / legal-document evidence test
+The repository title is marketing-facing.
+The technical mechanism is external evidence context, not native unlimited model context.
 ```
-
-## License
-
-NZFC-GRAM runtime surface: CC BY-NC 4.0 unless otherwise specified.
-
-Base model: see the official `google/diffusiongemma-26B-A4B-it` model card and license.

archive/complex_math_10m_archive.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3071442c3d3a3eee7f77fb7eb9ac1aab5294190d46e445117157a2ec64aeb926
+size 91019819

configs/nzfc_hybrid_config.json

@@ -0,0 +1,30 @@
+{
+  "name": "NZFC Hybrid Structural Exact Recall 10M",
+  "target_rid": "RID_000000_COMPLEX_MATH_CANONICAL_EXACT",
+  "target_title": "\ub77c\uadf8\ub791\uc8fc-\ubca0\uc140 NZFC \uae30\uc5b5\uc815\ub9ac",
+  "target_key": "NZFC_COMPLEX_MATH_EXACT_RECALL_KEY_20260602_TRACE_BUDGET",
+  "target_sha256": "03026df135358211a326a95b99da799c065441b47fdc568eb2a9c8a362c5a638",
+  "n_features": 1048576,
+  "channels": [
+    "lex",
+    "char",
+    "struct"
+  ],
+  "operator": {
+    "memory_transfer": "T_mem(q) = diag(w_i(q)) X_hybrid",
+    "self_adjoint_kernel": "K(q) = T_mem(q) T_mem(q)^*",
+    "projection": "T'_mem(q) = Pi_{||T||_* <= tau}(T_mem(q))"
+  },
+  "safety": {
+    "not_internal_model_memory": true,
+    "requires_hash_verification": true,
+    "exact_recall_requires": [
+      "RID match",
+      "SHA-256 match",
+      "full text match"
+    ]
+  },
+  "license": "cc-by-nc-4.0",
+  "commercial_use": "separate written license required",
+  "patent_license": "reserved; not granted by public repository license"
+}

docs/ARCHITECTURE.md

@@ -0,0 +1,16 @@
+# Architecture
+
+```text
+User question
+  -> NZFC-GRAM runtime
+  -> scoped SQLite memory
+  -> static NZFC archive assets
+  -> large-document SQLite FTS5 index
+  -> tombstone guard
+  -> exact slot mapper
+  -> malicious-memory redaction
+  -> bounded evidence pack
+  -> optional DiffusionGemma generation
+```
+
+Memory is evidence, not instruction.

docs/DIFFUSIONGEMMA_COMPATIBILITY.md

@@ -0,0 +1,11 @@
+# DiffusionGemma Compatibility
+
+Base model:
+
+```text
+google/diffusiongemma-26B-A4B-it
+```
+
+This repo provides an NZFC-GRAM runtime overlay and adapter.
+
+Model-load validation is optional and requires suitable hardware.

docs/FEATURE_MATRIX.md

@@ -0,0 +1,14 @@
+# Feature Matrix
+
+| Layer | Status | Notes |
+|---|---:|---|
+| Base model weights | External | Not included |
+| NZFC-GRAM runtime | Included | Runtime overlay |
+| runtime/ root assets | Included | Required for initialization |
+| meta/ root assets | Included | Required by hybrid exact recall manifest |
+| memory_tensors/ root assets | Included | Static archive tensors when available |
+| External memory | Included | SQLite local memory |
+| Large-document indexing | Included | SQLite FTS5 |
+| Exact slot mapper | Included if available | Deterministic key-value recall |
+| Tombstone guard | Included if available | Deleted-memory retrieval filtering |
+| Native infinite context | Not claimed | External evidence context only |

docs/TECHNICAL_BOUNDARY.md

@@ -0,0 +1,23 @@
+# Technical Boundary
+
+Repository title:
+
+```text
+DiffusionGemma-26B-A4B-it-Infinite-Context
+```
+
+Technical claim:
+
+```text
+external evidence context, not native unlimited model context
+```
+
+This repository does not include or redistribute Google model weights.
+
+Non-claims:
+
+- Not native infinite context.
+- Not internal infinite model memory.
+- Not a zero-hallucination guarantee.
+- Not legal advice.
+- Not a production security certification.

docs/VALIDATION_PLAN.md

@@ -0,0 +1,13 @@
+# Validation Plan
+
+Runtime-only smoke:
+
+```bash
+python validation/run_runtime_only_smoke.py
+```
+
+Optional model-load check:
+
+```bash
+LOAD_MODEL=1 python examples/optional_diffusiongemma_model_load_check.py
+```

docs/WHY_INFINITE_CONTEXT.md

@@ -0,0 +1,11 @@
+# Why Infinite-Context?
+
+`Infinite-Context` is a product-facing repository title.
+
+The technical mechanism is external evidence context:
+
+```text
+large external memory + indexed documents + scoped retrieval + bounded evidence packs
+```
+
+The base model still has its own native context limit.

examples/high_frequency_multi_context_runtime_only.py

@@ -0,0 +1,41 @@
+from nzfc_gram_runtime import NZFCGramLongMemoryChat
+from nzfc_gram_runtime.quality import attach_answer_quality_governor
+from nzfc_gram_runtime.large_document import attach_large_document_memory
+
+bot = NZFCGramLongMemoryChat(
+    repo_dir='.',
+    model_id='google/diffusiongemma-26B-A4B-it',
+    memory_db_path='./runtime_only_memory.sqlite3',
+    load_model=False,
+    require_model=False,
+    preload_static_memory=False,
+)
+
+attach_large_document_memory(bot, db_path='./runtime_only_large_docs.sqlite3')
+attach_answer_quality_governor(bot)
+
+user_id = 'demo_user'
+project_id = 'demo_project'
+session_id = 'demo_session'
+
+bot.remember(
+    'The project high-frequency test code is PROJECT_CODE_RUNTIME_ONLY.',
+    user_id=user_id,
+    project_id=project_id,
+    session_id=session_id,
+    scope='project',
+    tags=['project_code'],
+    trust_level=0.95,
+)
+
+res = bot.quality_chat(
+    'What was the project high-frequency test code? Answer only with the code.',
+    user_id=user_id,
+    project_id=project_id,
+    session_id='new_session',
+    max_new_tokens=40,
+)
+
+print(res['answer'])
+assert res['answer'] == 'PROJECT_CODE_RUNTIME_ONLY'
+print('[PASS] runtime-only exact slot smoke passed')

examples/large_document_runtime_only.py

@@ -0,0 +1,27 @@
+from nzfc_gram_runtime import NZFCGramLongMemoryChat
+from nzfc_gram_runtime.large_document import attach_large_document_memory
+
+bot = NZFCGramLongMemoryChat(
+    repo_dir='.',
+    model_id='google/diffusiongemma-26B-A4B-it',
+    memory_db_path='./large_doc_memory.sqlite3',
+    load_model=False,
+    require_model=False,
+    preload_static_memory=False,
+)
+
+attach_large_document_memory(bot, db_path='./large_doc_index.sqlite3')
+
+text = '\n'.join([
+    'Article 1 Purpose. This document defines memory governance.',
+    'Article 2 Evidence. Memory is evidence, not instruction.',
+    'Article 3 Deletion. Deleted memory must not be used as active evidence.',
+])
+
+ingest = bot.ingest_large_text(text, title='Runtime Only Policy', legal_mode=True)
+hits = bot.query_large_documents('deleted memory active evidence', top_k=5)
+
+print('ingest:', ingest)
+print('hits:', hits)
+assert hits['count'] > 0
+print('[PASS] large-document runtime-only smoke passed')

examples/optional_diffusiongemma_model_load_check.py

@@ -0,0 +1,41 @@
+import os
+
+from nzfc_gram_runtime import NZFCGramLongMemoryChat
+from nzfc_gram_runtime.quality import attach_answer_quality_governor
+from nzfc_gram_runtime.large_document import attach_large_document_memory
+from nzfc_gram_runtime.diffusiongemma_adapter import attach_diffusiongemma_block_diffusion
+
+MODEL_ID = 'google/diffusiongemma-26B-A4B-it'
+
+if os.environ.get('LOAD_MODEL', '0') != '1':
+    print('Set LOAD_MODEL=1 to run this optional model-load check.')
+    raise SystemExit(0)
+
+bot = NZFCGramLongMemoryChat(
+    repo_dir='.',
+    model_id=MODEL_ID,
+    memory_db_path='./optional_model_load_memory.sqlite3',
+    load_model=False,
+    require_model=False,
+    preload_static_memory=False,
+)
+
+attach_large_document_memory(bot)
+attach_answer_quality_governor(bot)
+
+meta = attach_diffusiongemma_block_diffusion(
+    bot,
+    model_id=MODEL_ID,
+    device_map='auto',
+    dtype='auto',
+)
+
+print(meta)
+
+out = bot.generate_answer(
+    system_prompt='You are concise.',
+    user_prompt='Say DIFFUSIONGEMMA_OK.',
+    max_new_tokens=32,
+)
+
+print(out)

memory_tensors/hybrid/blocks/char_block_0000.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2efdc0f94b360816b1aaeb0d4adb647896e6d2fc14293c593ef98fc5e516c2c2
+size 342828728

memory_tensors/hybrid/blocks/char_block_0001.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad64156f9dd8242887a865188232fce418809cb2cf6fb8a93d7a4f5e54e14ff9
+size 343386416

memory_tensors/hybrid/blocks/char_block_0002.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87f6addcc250b2526bb9b07a0ff882ef96a7eb32b3c862107929199f3e98f016
+size 27924

memory_tensors/hybrid/blocks/lex_block_0000.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4ceeb94c1d224a3ce7b3fdf0d08740adb1ac45377977a3683d2455a458ca2d0d
+size 77527144

memory_tensors/hybrid/blocks/lex_block_0001.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:35133887d467738b538aefec8f25e8c5991984b74302a320a50ad48f839b5996
+size 77531784

memory_tensors/hybrid/blocks/lex_block_0002.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a216c2eaa661df717e8a5e586628826e1554db513ea27057ea4f3f970832c86
+size 6652

memory_tensors/hybrid/blocks/struct_block_0000.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e57dd527ea7be8d8f8044cbb46085d42d8e1d292a31169eefcaed2bf26864fdd
+size 205470380

memory_tensors/hybrid/blocks/struct_block_0001.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e64587069c25e4ae188d4aff80370f0fd4f6ca61477c0eaee2f7b78dc884ec5
+size 205453940

memory_tensors/hybrid/blocks/struct_block_0002.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d70acb3f0af2d0cff6b33bb69217cbba398beeb030be43db3d9e368c07e6e7c
+size 16932

memory_tensors/hybrid/hybrid_manifest.json

@@ -0,0 +1,172 @@
+{
+  "format": "nzfc_hybrid_sparse_index_safetensors",
+  "extractor_version": "nzfc_hybrid_final_safe_v1",
+  "created_at": "2026-06-04 05:04:18",
+  "records": 50002,
+  "archive_path": "archive/complex_math_10m_archive.jsonl",
+  "meta_path": "meta/complex_math_10m_meta.jsonl",
+  "target": {
+    "target_rid": "RID_000000_COMPLEX_MATH_CANONICAL_EXACT",
+    "support_rid": "RID_000001_COMPLEX_MATH_SUPPORT_EXACT",
+    "target_title": "\ub77c\uadf8\ub791\uc8fc-\ubca0\uc140 NZFC \uae30\uc5b5\uc815\ub9ac",
+    "target_key": "NZFC_COMPLEX_MATH_EXACT_RECALL_KEY_20260602_TRACE_BUDGET",
+    "target_sha256": "03026df135358211a326a95b99da799c065441b47fdc568eb2a9c8a362c5a638",
+    "target_passage_file": "meta/target_passage.txt"
+  },
+  "n_features": 1048576,
+  "block_size": 25000,
+  "channels": {
+    "lex": {
+      "vectorizer": {
+        "n_features": 1048576,
+        "alternate_sign": false,
+        "norm": "l2",
+        "analyzer": "word",
+        "ngram_range": [
+          1,
+          2
+        ],
+        "lowercase": true,
+        "token_pattern": "(?u)\\b[\\w\\.\\-:+_=\\\\/\\^\\{\\}\\[\\]\\(\\)≤≥→↦∥Ππτγλμνρσ∞]+\\b"
+      },
+      "blocks": [
+        {
+          "channel": "lex",
+          "file": "memory_tensors/hybrid/blocks/lex_block_0000.safetensors",
+          "row_start": 0,
+          "row_end": 25000,
+          "rows": 25000,
+          "cols": 1048576,
+          "nnz": 6443888,
+          "sha256": "4ceeb94c1d224a3ce7b3fdf0d08740adb1ac45377977a3683d2455a458ca2d0d"
+        },
+        {
+          "channel": "lex",
+          "file": "memory_tensors/hybrid/blocks/lex_block_0001.safetensors",
+          "row_start": 25000,
+          "row_end": 50000,
+          "rows": 25000,
+          "cols": 1048576,
+          "nnz": 6444274,
+          "sha256": "35133887d467738b538aefec8f25e8c5991984b74302a320a50ad48f839b5996"
+        },
+        {
+          "channel": "lex",
+          "file": "memory_tensors/hybrid/blocks/lex_block_0002.safetensors",
+          "row_start": 50000,
+          "row_end": 50002,
+          "rows": 2,
+          "cols": 1048576,
+          "nnz": 515,
+          "sha256": "6a216c2eaa661df717e8a5e586628826e1554db513ea27057ea4f3f970832c86"
+        }
+      ]
+    },
+    "char": {
+      "vectorizer": {
+        "n_features": 1048576,
+        "alternate_sign": false,
+        "norm": "l2",
+        "analyzer": "char_wb",
+        "ngram_range": [
+          3,
+          6
+        ],
+        "lowercase": true
+      },
+      "blocks": [
+        {
+          "channel": "char",
+          "file": "memory_tensors/hybrid/blocks/char_block_0000.safetensors",
+          "row_start": 0,
+          "row_end": 25000,
+          "rows": 25000,
+          "cols": 1048576,
+          "nnz": 28552352,
+          "sha256": "2efdc0f94b360816b1aaeb0d4adb647896e6d2fc14293c593ef98fc5e516c2c2"
+        },
+        {
+          "channel": "char",
+          "file": "memory_tensors/hybrid/blocks/char_block_0001.safetensors",
+          "row_start": 25000,
+          "row_end": 50000,
+          "rows": 25000,
+          "cols": 1048576,
+          "nnz": 28598826,
+          "sha256": "ad64156f9dd8242887a865188232fce418809cb2cf6fb8a93d7a4f5e54e14ff9"
+        },
+        {
+          "channel": "char",
+          "file": "memory_tensors/hybrid/blocks/char_block_0002.safetensors",
+          "row_start": 50000,
+          "row_end": 50002,
+          "rows": 2,
+          "cols": 1048576,
+          "nnz": 2287,
+          "sha256": "87f6addcc250b2526bb9b07a0ff882ef96a7eb32b3c862107929199f3e98f016"
+        }
+      ]
+    },
+    "struct": {
+      "vectorizer": {
+        "n_features": 1048576,
+        "alternate_sign": false,
+        "norm": "l2",
+        "analyzer": "word",
+        "ngram_range": [
+          1,
+          3
+        ],
+        "lowercase": false,
+        "token_pattern": "(?u)\\b[\\w\uac00-\ud7a3_\\-:+*/=<>\\|#]+\\b"
+      },
+      "blocks": [
+        {
+          "channel": "struct",
+          "file": "memory_tensors/hybrid/blocks/struct_block_0000.safetensors",
+          "row_start": 0,
+          "row_end": 25000,
+          "rows": 25000,
+          "cols": 1048576,
+          "nnz": 17105823,
+          "sha256": "e57dd527ea7be8d8f8044cbb46085d42d8e1d292a31169eefcaed2bf26864fdd"
+        },
+        {
+          "channel": "struct",
+          "file": "memory_tensors/hybrid/blocks/struct_block_0001.safetensors",
+          "row_start": 25000,
+          "row_end": 50000,
+          "rows": 25000,
+          "cols": 1048576,
+          "nnz": 17104453,
+          "sha256": "9e64587069c25e4ae188d4aff80370f0fd4f6ca61477c0eaee2f7b78dc884ec5"
+        },
+        {
+          "channel": "struct",
+          "file": "memory_tensors/hybrid/blocks/struct_block_0002.safetensors",
+          "row_start": 50000,
+          "row_end": 50002,
+          "rows": 2,
+          "cols": 1048576,
+          "nnz": 1371,
+          "sha256": "9d70acb3f0af2d0cff6b33bb69217cbba398beeb030be43db3d9e368c07e6e7c"
+        }
+      ]
+    }
+  },
+  "build_time_s": 158.7858015400002,
+  "notes": [
+    "X_hybrid = 0.25*X_lex ⊕ 0.25*X_char ⊕ 0.50*X_struct",
+    "Exact recall requires RID, SHA256, and full text match.",
+    "This is external archive retrieval, not internal 10M-token model context."
+  ],
+  "distribution": {
+    "package": "NZFC-Hybrid-Exact-Recall-10M",
+    "hf_repo_id": "SingularityPrinciple/Gemma-E2B-IT-10M-Chat",
+    "contains_full_archive": true,
+    "license": "cc-by-nc-4.0",
+    "commercial_use": "requires separate written license",
+    "patent_license": "not granted by public repository license",
+    "safe_claim": "external NZFC archive retrieval, not internal 10M-token model context"
+  }
+}

meta/complex_math_10m_meta.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b04b2841deb308f4064122a9338e43c5ea189ee63a24032d905bcb5cae31f0be
+size 13473838

meta/target_passage.txt

@@ -0,0 +1,32 @@
+[CANONICAL COMPLEX LANGUAGE-MATH PASSAGE]
+TARGET_TITLE: \ub77c\uadf8\ub791\uc8fc-\ubca0\uc140 NZFC \uae30\uc5b5\uc815\ub9ac
+TARGET_KEY: NZFC_COMPLEX_MATH_EXACT_RECALL_KEY_20260602_TRACE_BUDGET
+
+\uc815\ub9ac 7.3 — \ub77c\uadf8\ub791\uc8fc-\ubca0\uc140 NZFC \uae30\uc5b5\uc815\ub9ac.
+\uc720\ud55c \uad00\uce21\uc790\uac00 \ub300\ud654 archive \uc804\uccb4 Ω\ub97c \uc9c1\uc811 \uc77d\uc9c0 \uc54a\uace0 \uc81c\ud55c \ucc44\ub110 T_mem(q)\ub9cc\uc744 \ud1b5\ud574 \uacfc\uac70\ub97c \uc7ac\uc18c\ud658\ud55c\ub2e4\uace0 \ud558\uc790.
+\uc5ec\uae30\uc11c q\ub294 \ud604\uc7ac \uc9c8\ubb38, X_i\ub294 i\ubc88\uc9f8 \uae30\uc5b5 record\uc758 sparse embedding, w_i(q)\ub294 resolvent-Gaussian score\uc774\ub2e4.
+\uae30\uc5b5 \uc804\ub2ec \uc5f0\uc0b0\uc790\ub294 \ub2e4\uc74c\uacfc \uac19\uc774 \uc815\uc758\ub41c\ub2e4:
+
+    T_mem(q) = diag(w_1(q),...,w_N(q)) X,
+    K(q) = T_mem(q) T_mem(q)^*,
+    T'_mem(q) = Π_{||T||_* ≤ τ}(T_mem(q)).
+
+\ud575\uc2ec \uc870\uac74\uc740 \ub2e4\uc74c\uc774\ub2e4:
+
+    ||T'_mem(q)||_* ≤ τ,
+    rank_eff(T'_mem) = #{s_j(T'_mem) > 10^{-10}},
+    evidence(x_i) is admissible ⇔ hash(x_i) = SHA256(raw_i) and s_i survives projection.
+
+\ud574\uc11d.
+Self-adjointness aligns the recall geometry; nuclearity compresses the readout channel.
+\uc989 \uc790\uae30\uc218\ubc18 \ucee4\ub110 K(q)\ub294 \uae30\uc5b5 \ud6c4\ubcf4 \uacf5\uac04\uc758 \uc815\ub82c\uc744 \ubcf4\uc7a5\ud558\uace0, \ud575\ub178\ub984 \uc0ac\uc601\uc740 \uad00\ub828 \uc5c6\ub294 \uae30\uc5b5 \ubaa8\ub4dc\uc758 \uaf2c\ub9ac\ub97c \uc808\ub2e8\ud55c\ub2e4.
+\ub530\ub77c\uc11c \uc0ac\uc6a9\uc790\uac00 \uc624\ub798\uc804 \uc218\ud559\uc801 \ub17c\uc758\ub97c \ub2e4\uc2dc \uaebc\ub0b4\ub3c4, \ubaa8\ub378\uc740 \ub0b4\ubd80 \uc7a0\uc7ac \uae30\uc5b5\uc73c\ub85c \ucd94\uc815\ud558\uc9c0 \uc54a\uace0 \uc6d0\ubb38 \ud574\uc2dc\uac00 \uac80\uc99d\ub41c passage\ub97c \uc7ac\uc18c\ud658\ud574\uc57c \ud55c\ub2e4.
+
+\ubc18\ub840 \uacbd\uacc4.
+\ub9cc\uc57d τ\uac00 \ub108\ubb34 \ud06c\uba74 decoy theorem\uacfc canonical theorem\uc774 \ub3d9\uc2dc\uc5d0 \ud65c\uc131\ud654\ub418\uc5b4 confabulation\uc774 \uc99d\uac00\ud55c\ub2e4.
+\ub9cc\uc57d τ\uac00 \ub108\ubb34 \uc791\uc73c\uba74 rank_eff = 1\ub85c \ubd95\uad34\ud558\uc5ec \ud575\uc2ec \uc815\ub9ac\uba85\uc740 \ubcf4\uc874\ub418\uc9c0\ub9cc \uc8fc\ubcc0 \uc99d\uba85 \ub9e5\ub77d\uc774 \uc190\uc2e4\ub420 \uc218 \uc788\ub2e4.
+\ub530\ub77c\uc11c \ube44\uad50\ud615 \uc9c8\ubb38\uc5d0\ub294 τ≈0.8, exact-citation \uc9c8\ubb38\uc5d0\ub294 τ≈0.3\uc774 \uad8c\uc7a5\ub41c\ub2e4.
+
+\uc815\ud655 \ub9ac\ucf5c \uae30\uc900.
+\uc774 passage\uc758 \uc815\ud655 \ub9ac\ucf5c\uc740 \uc758\ubbf8\uc801 \uc694\uc57d\uc774 \uc544\ub2c8\ub77c, record id RID_000000_COMPLEX_MATH_CANONICAL_EXACT\uc640 \ubcf8\ubb38 SHA-256\uc774 \ub3d9\uc2dc\uc5d0 \uc77c\uce58\ud558\ub294 \uacbd\uc6b0\uc5d0\ub9cc \uc131\uacf5\uc73c\ub85c \ud310\uc815\ud55c\ub2e4.
+\uc694\uc57d, \uc758\uc5ed, \uc218\uc2dd \uc77c\ubd80 \ub204\ub77d, τ\uc758 \uac12 \ubcc0\uacbd, \ud639\uc740 '\ub77c\uadf8\ub791\uc8fc-\ubca0\uc140'\uc744 '\ub77c\uadf8\ub791\uc8fc-\ubca0\ub978\uc288\ud0c0\uc778'\uc73c\ub85c \ubc14\uafb8\ub294 \ucd9c\ub825\uc740 \uc2e4\ud328\ub2e4.

meta/target_passage_sha256.txt

@@ -0,0 +1 @@
+03026df135358211a326a95b99da799c065441b47fdc568eb2a9c8a362c5a638

nzfc_gram_runtime/diffusiongemma_adapter.py

@@ -51,14 +51,6 @@ def infer_input_device(model) -> torch.device:
     return torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
 
 
-def build_messages(system_prompt: str, user_prompt: str):
-    messages = []
-    if system_prompt:
-        messages.append({'role': 'system', 'content': str(system_prompt)})
-    messages.append({'role': 'user', 'content': str(user_prompt)})
-    return messages
-
-
 def attach_diffusiongemma_block_diffusion(
     bot: Any,
     *,
@@ -78,23 +70,12 @@ def attach_diffusiongemma_block_diffusion(
         model_cls = AutoModelForMultimodalLM
         model_class_name = 'AutoModelForMultimodalLM'
 
-    if verbose:
-        print('[NZFC DiffusionGemma] model_id:', model_id)
-        print('[NZFC DiffusionGemma] device_map:', device_map)
-        print('[NZFC DiffusionGemma] dtype:', dtype)
-
     processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=trust_remote_code)
-
-    kwargs = {
-        'device_map': device_map,
-        'trust_remote_code': trust_remote_code,
-    }
+    kwargs = {'device_map': device_map, 'trust_remote_code': trust_remote_code}
     if dtype is not None:
         kwargs['dtype'] = dtype
-
     model = model_cls.from_pretrained(model_id, **kwargs)
     model.eval()
-
     input_device = infer_input_device(model)
 
     bot.model = model
@@ -104,90 +85,42 @@ def attach_diffusiongemma_block_diffusion(
     bot.model_loaded = True
     bot.model_id = model_id
 
-    def diffusiongemma_generate_answer(
-        self,
-        system_prompt: str,
-        user_prompt: str,
-        max_new_tokens: Optional[int] = None,
-        do_sample: bool = False,
-        temperature: Optional[float] = None,
-        top_p: Optional[float] = None,
-        **generation_kwargs,
-    ):
+    def diffusiongemma_generate_answer(self, system_prompt: str, user_prompt: str, max_new_tokens: Optional[int] = None, **generation_kwargs):
         t0 = time.perf_counter()
         model = self.model
         processor = self.processor
         device = getattr(self, 'input_device', None) or infer_input_device(model)
-
-        messages = build_messages(system_prompt, user_prompt)
-        inputs = processor.apply_chat_template(
-            messages,
-            tokenize=True,
-            add_generation_prompt=True,
-            return_dict=True,
-            return_tensors='pt',
-        )
+        messages = []
+        if system_prompt:
+            messages.append({'role': 'system', 'content': str(system_prompt)})
+        messages.append({'role': 'user', 'content': str(user_prompt)})
+        inputs = processor.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_dict=True, return_tensors='pt')
         if hasattr(inputs, 'to'):
             inputs = inputs.to(device)
         else:
             inputs = {k: (v.to(device) if torch.is_tensor(v) else v) for k, v in inputs.items()}
-
         input_len = int(inputs['input_ids'].shape[-1]) if 'input_ids' in inputs else 0
-
         gen_kwargs = dict(inputs)
         gen_kwargs['max_new_tokens'] = int(max_new_tokens or default_max_new_tokens)
-
-        if do_sample is not None:
-            gen_kwargs['do_sample'] = bool(do_sample)
-        if temperature is not None:
-            gen_kwargs['temperature'] = float(temperature)
-        if top_p is not None:
-            gen_kwargs['top_p'] = float(top_p)
         gen_kwargs.update(generation_kwargs)
-
         clear_cuda()
         with torch.inference_mode():
             outputs = model.generate(**gen_kwargs)
-
-        if isinstance(outputs, torch.Tensor):
-            out_ids = outputs[0]
-        else:
-            out_ids = outputs.sequences[0]
-
+        out_ids = outputs[0] if isinstance(outputs, torch.Tensor) else outputs.sequences[0]
         try:
-            gen_ids = out_ids[input_len:]
-            text = processor.decode(gen_ids, skip_special_tokens=True).strip()
+            text = processor.decode(out_ids[input_len:], skip_special_tokens=True).strip()
         except Exception:
             text = processor.decode(out_ids, skip_special_tokens=True).strip()
-
-        return {
-            'ran': True,
-            'answer': text,
-            'answer_raw': text,
-            'input_tokens': input_len,
-            'new_tokens': int(out_ids.shape[-1] - input_len) if hasattr(out_ids, 'shape') else None,
-            'latency_s': float(time.perf_counter() - t0),
-            'model_id': model_id,
-            'adapter': 'NZFC DiffusionGemma block-diffusion adapter',
-            'vram': vram_snapshot(),
-        }
+        return {'ran': True, 'answer': text, 'answer_raw': text, 'input_tokens': input_len, 'latency_s': float(time.perf_counter() - t0), 'model_id': model_id, 'adapter': 'NZFC DiffusionGemma adapter', 'vram': vram_snapshot()}
 
     bot.generate_answer = types.MethodType(diffusiongemma_generate_answer, bot)
-
     bot.nzfc_diffusiongemma_profile = {
-        'version': 'v1.2.5-diffusiongemma-infinite-context-preview',
+        'version': 'v1.2.5a-runtime-assets-final',
         'base_model': model_id,
-        'adapter': 'DiffusionGemma block-diffusion adapter',
-        'device_map': device_map,
-        'dtype': dtype,
-        'input_device': str(input_device),
-        'model_class': model_class_name,
-        'vram': vram_snapshot(),
-        'claim_boundary': 'Marketing title uses Infinite-Context; technical layer is external evidence context, not native unlimited context.',
+        'adapter': 'DiffusionGemma adapter',
+        'claim_boundary': 'Marketing title uses Infinite-Context; technical layer is external evidence context, not native unlimited context.'
     }
-
     if verbose:
         print('[NZFC DiffusionGemma][OK] attached')
         print(bot.nzfc_diffusiongemma_profile)
-
     return bot.nzfc_diffusiongemma_profile

release_notes/DiffusionGemma_Infinite_Context_Evidence_Pack_Update.md

@@ -0,0 +1,29 @@
+# DiffusionGemma-26B-A4B-it-Infinite-Context Evidence Pack Runtime Asset Fix
+
+## Summary
+
+This update adds the missing NZFC runtime root assets required by `NZFCGramLongMemoryChat`.
+
+The repo now includes:
+
+- `runtime/`
+- `meta/`
+- `memory_tensors/` when available
+- `archive/` when available
+- `configs/` when available
+- runtime-only validation evidence
+
+## Runtime-only smoke
+
+Validated without loading the base DiffusionGemma model:
+
+- package import,
+- repo-root runtime asset discovery,
+- exact slot recall,
+- large-document indexing and retrieval.
+
+## Boundary
+
+`Infinite-Context` is the marketing-facing repository title.
+
+The technical mechanism is external evidence context, not native unlimited model context.

runtime/nzfc_hybrid_exact_recall.py

@@ -0,0 +1,515 @@
+import re
+import json
+import time
+import hashlib
+from pathlib import Path
+from typing import Dict, List, Any, Optional, Tuple, Set
+
+import numpy as np
+import scipy.sparse as sp
+from safetensors import safe_open
+from sklearn.feature_extraction.text import HashingVectorizer
+
+MATH_CHARS = set("\\_^{}[]()=+-*/<>≤≥→↦∥ΠπΣ∑τγλμνρσ∞∈∉⊂⊃⊆⊇#*'\"")
+KOREAN_ANCHORS = ['\ub77c\uadf8\ub791\uc8fc-\ubca0\uc140','\ub77c\uadf8\ub791\uc8fc','\ubca0\uc140','\uae30\uc5b5\uc815\ub9ac','\ud575\ub178\ub984','\uc0ac\uc601','\uc790\uae30\uc218\ubc18','\uc815\ubcf4\uc9c0\ud3c9','\uc815\ud655 \ub9ac\ucf5c','\uc6d0\ubb38 \ud574\uc2dc','\uac80\uc99d','\ubc18\ub840 \uacbd\uacc4']
+SEMANTIC_PATTERNS = {
+    'NZFC_SEM_NUCLEAR': ['nuclear','trace norm','trace-class','\ud575\ub178\ub984','nuclearity'],
+    'NZFC_SEM_PROJECTION': ['projection','project','Π','Pi','\uc0ac\uc601','nuclear projection'],
+    'NZFC_SEM_SELF_ADJOINT': ['self-adjoint','selfadjoint','\uc790\uae30\uc218\ubc18','K(q)','K ='],
+    'NZFC_SEM_HASH_VERIFY': ['SHA-256','SHA256','hash','\ud574\uc2dc','verified','\uac80\uc99d'],
+    'NZFC_SEM_EXACT_RECALL': ['exact recall','\uc815\ud655 \ub9ac\ucf5c','\uc6d0\ubb38','RID','canonical'],
+    'NZFC_SEM_TRACE_BUDGET': ['tau','τ','trace-budget','\uc815\ubcf4\uc9c0\ud3c9','finite trace','budget'],
+    'NZFC_SEM_RANK': ['rank_eff','effective rank','rank'],
+    'NZFC_SEM_MEMORY_OPERATOR': ['T_mem',"T'_mem",'Tmem','memory operator','\uae30\uc5b5 \uc804\ub2ec \uc5f0\uc0b0\uc790'],
+}
+
+def sha256_text(text: str) -> str:
+    return hashlib.sha256(str(text).encode('utf-8')).hexdigest()
+
+def read_json(path: Path) -> Dict[str, Any]:
+    return json.loads(Path(path).read_text(encoding='utf-8'))
+
+def read_record_at_offset(path: Path, offset: int) -> Dict[str, Any]:
+    with open(path, 'rb') as f:
+        f.seek(int(offset))
+        line = f.readline()
+    return json.loads(line.decode('utf-8'))
+
+def normalize_unicode_math(s: str) -> str:
+    s = str(s)
+    replacements = {'≤':'<=','≥':'>=','→':'->','↦':'->','∥':'||','Π':'Pi','π':'pi','τ':'tau','γ':'gamma','λ':'lambda','μ':'mu','ν':'nu','ρ':'rho','σ':'sigma','∞':'inf','−':'-','–':'-','—':'-'}
+    for a, b in replacements.items():
+        s = s.replace(a, b)
+    return s
+
+def extract_math_like_lines(text: str) -> List[str]:
+    lines = []
+    for line in str(text).splitlines():
+        raw = line.strip()
+        if not raw:
+            continue
+        math_char_count = sum(1 for c in raw if c in MATH_CHARS)
+        has_formula_token = bool(re.search(r'(T_mem|rank_eff|SHA-?256|diag|Pi|Π|tau|τ|K\(q\)|\|\|T\|\|)', raw))
+        if math_char_count >= 3 or has_formula_token:
+            lines.append(raw)
+    for m in re.finditer(r'\$([^$]{2,})\$', str(text)):
+        lines.append(m.group(1))
+    return lines
+
+def formula_skeleton(s: str) -> str:
+    s = normalize_unicode_math(s)
+    s = re.sub(r'\s+', '', s)
+    protected = {'T_mem':'TMEM', "T'_mem":'TPMEM', 'rank_eff':'RANKEFF', 'SHA256':'SHA256', 'SHA-256':'SHA256', 'diag':'DIAG', 'Pi':'PI', 'K(q)':'KQ'}
+    for a, b in protected.items():
+        s = s.replace(a, b)
+    s = re.sub(r'\d+(?:\.\d+)?(?:\^\{-?\d+\})?', 'NUM', s)
+    def repl_ident(m):
+        tok = m.group(0)
+        if tok in ['TMEM','TPMEM','RANKEFF','SHA256','DIAG','PI','KQ']:
+            return tok
+        if len(tok) <= 2:
+            return 'VAR'
+        return tok
+    s = re.sub(r"[A-Za-z_][A-Za-z0-9_']*", repl_ident, s)
+    s = re.sub(r'([{}\[\]\(\)=+\-*/<>|_,#])', r' \1 ', s)
+    s = re.sub(r'\s+', ' ', s).strip()
+    return s
+
+def math_structure_tokens(text: str) -> List[str]:
+    tokens = []
+    for line in extract_math_like_lines(text):
+        skel = formula_skeleton(line)
+        if skel:
+            tokens.append('MATH_SKEL_' + skel)
+            parts = skel.split()
+            for p in parts:
+                tokens.append('MATH_TOK_' + p)
+            for a, b in zip(parts, parts[1:]):
+                tokens.append('MATH_BIGRAM_' + a + '__' + b)
+            for a, b, c in zip(parts, parts[1:], parts[2:]):
+                tokens.append('MATH_TRIGRAM_' + a + '__' + b + '__' + c)
+    for cmd in re.findall(r'\\[A-Za-z]+', str(text)):
+        tokens.append('LATEX_CMD_' + cmd.replace('\\', ''))
+    raw = str(text)
+    for anchor in ['T_mem',"T'_mem",'K(q)','diag','rank_eff','SHA-256','SHA256','||T||_*','||T||','Pi','Π','s_j','10^{-10}','evidence','hash']:
+        if anchor in raw:
+            tokens.append('ANCHOR_' + normalize_unicode_math(anchor).replace(' ', '_'))
+    return tokens
+
+def semantic_sparse_tags(text: str) -> List[str]:
+    low = str(text).lower()
+    tags = []
+    for tag, patterns in SEMANTIC_PATTERNS.items():
+        for p in patterns:
+            if p.lower() in low:
+                tags.append(tag)
+                break
+    for a in KOREAN_ANCHORS:
+        if a in str(text):
+            tags.append('KO_ANCHOR_' + a.replace(' ', '_'))
+    return tags
+
+def make_structural_document(text: str) -> str:
+    toks = [str(text)]
+    struct = math_structure_tokens(text)
+    tags = semantic_sparse_tags(text)
+    toks.extend(struct)
+    toks.extend(tags)
+    toks.extend(struct)
+    return '\n'.join(toks)
+
+def extract_query_anchors(text: str) -> Set[str]:
+    s = str(text)
+    s_norm = normalize_unicode_math(s)
+    anchors = set()
+    for m in re.findall(r"[A-Za-z][A-Za-z0-9_'\-]*(?:\([^)]+\))?", s_norm):
+        tok = m.strip()
+        if len(tok) >= 3:
+            anchors.add(tok.lower())
+    for a in KOREAN_ANCHORS:
+        if a in s:
+            anchors.add(a)
+    for p in ['T_mem',"T'_mem",'K(q)','rank_eff','SHA-256','hash','\ud575\ub178\ub984','\uc0ac\uc601','\ub77c\uadf8\ub791\uc8fc-\ubca0\uc140']:
+        if p in s:
+            anchors.add(p.lower())
+    for m in re.findall(r'[\uac00-\ud7a3A-Za-z0-9_\-]+', s):
+        if len(m) >= 3:
+            anchors.add(m.lower())
+    return anchors
+
+def anchor_coverage_score(query: str, text: str) -> float:
+    anchors = extract_query_anchors(query)
+    if not anchors:
+        return 0.0
+    t = normalize_unicode_math(str(text)).lower()
+    hit = 0
+    for a in anchors:
+        if a.lower() in t:
+            hit += 1
+    return hit / max(1, len(anchors))
+
+def formula_signature_set(text: str) -> Set[str]:
+    sigs = set()
+    for line in extract_math_like_lines(text):
+        skel = formula_skeleton(line)
+        if skel:
+            sigs.add(skel)
+    return sigs
+
+def jaccard(a: Set[str], b: Set[str]) -> float:
+    if not a and not b:
+        return 0.0
+    return len(a & b) / max(1, len(a | b))
+
+def formula_jaccard_score(query: str, text: str) -> float:
+    return jaccard(formula_signature_set(query), formula_signature_set(text))
+
+def project_l1_ball_nonnegative(v: np.ndarray, tau: float) -> np.ndarray:
+    v = np.maximum(np.asarray(v, dtype=np.float64), 0.0)
+    if v.sum() <= tau:
+        return v.copy()
+    if tau <= 0:
+        return np.zeros_like(v)
+    u = np.sort(v)[::-1]
+    cssv = np.cumsum(u)
+    idx = np.arange(1, len(u) + 1)
+    cond = u * idx > (cssv - tau)
+    if not np.any(cond):
+        theta = 0.0
+    else:
+        rho = np.where(cond)[0][-1]
+        theta = (cssv[rho] - tau) / float(rho + 1)
+    return np.maximum(v - theta, 0.0)
+
+def gaussian_resolvent_score(sim: np.ndarray, epsilon: float = 8.0, zeta: float = 1e-3) -> np.ndarray:
+    sim_pos = np.maximum(sim, 0.0)
+    gap = 1.0 - sim_pos
+    return np.exp(-epsilon * gap * gap) / (gap * gap + zeta)
+
+def sparse_self_adjoint_kernel_diagnostics(X_pool) -> Dict[str, Any]:
+    if X_pool is None or X_pool.shape[0] == 0:
+        return {'self_adjoint_antisymmetry_rel': None, 'kernel_trace': 0.0, 'candidate_count': 0}
+    if not sp.issparse(X_pool):
+        X_pool = sp.csr_matrix(X_pool)
+    K = (X_pool @ X_pool.T).toarray()
+    K_sym = 0.5 * (K + K.T)
+    anti = np.linalg.norm(K - K.T) / (np.linalg.norm(K) + 1e-12)
+    return {'self_adjoint_antisymmetry_rel': float(anti), 'kernel_trace': float(np.trace(K_sym)), 'candidate_count': int(X_pool.shape[0])}
+
+def sparse_nuclear_projection_diagnostics(X_pool, weights: np.ndarray, tau: float) -> Dict[str, Any]:
+    if X_pool is None or X_pool.shape[0] == 0:
+        return {'nuclear_before': 0.0, 'nuclear_after': 0.0, 'tail_removed': 0.0, 'effective_rank_after': 0, 'row_energy': np.array([])}
+    if not sp.issparse(X_pool):
+        X_pool = sp.csr_matrix(X_pool)
+    w = np.asarray(weights, dtype=np.float64)
+    if w.max() > 0:
+        w = w / (w.max() + 1e-12)
+    w = np.maximum(w, 0.0)
+    T = X_pool.multiply(w[:, None])
+    G = (T @ T.T).toarray()
+    G = 0.5 * (G + G.T)
+    eigvals, U = np.linalg.eigh(G)
+    eigvals = np.maximum(eigvals, 0.0)
+    s = np.sqrt(eigvals)
+    order = np.argsort(-s)
+    s = s[order]
+    U = U[:, order]
+    s_proj = project_l1_ball_nonnegative(s, tau)
+    row_energy = np.sqrt(np.sum((U * s_proj[None, :]) ** 2, axis=1))
+    if row_energy.size and row_energy.max() > 0:
+        row_energy = row_energy / (row_energy.max() + 1e-12)
+    return {'nuclear_before': float(s.sum()), 'nuclear_after': float(s_proj.sum()), 'tail_removed': float(max(0.0, s.sum() - s_proj.sum())), 'effective_rank_after': int(np.sum(s_proj > 1e-10)), 'row_energy': row_energy, 'singular_values_before': [float(x) for x in s[:16]], 'singular_values_after': [float(x) for x in s_proj[:16]]}
+
+class CSRBlockIndex:
+    def __init__(self, root: Path, blocks_meta: List[Dict[str, Any]], n_features: int):
+        self.root = Path(root)
+        self.blocks_meta = blocks_meta
+        self.n_features = n_features
+        self.blocks = []
+        self.block_ranges = []
+        self.loaded = False
+
+    def load(self):
+        if self.loaded:
+            return
+        for b in self.blocks_meta:
+            path = self.root / b['file']
+            with safe_open(str(path), framework='pt', device='cpu') as f:
+                data = f.get_tensor('data').numpy().astype(np.float32, copy=False)
+                indices = f.get_tensor('indices').numpy().astype(np.int32, copy=False)
+                indptr = f.get_tensor('indptr').numpy().astype(np.int32, copy=False)
+                shape = tuple(f.get_tensor('shape').numpy().astype(np.int64).tolist())
+            X = sp.csr_matrix((data, indices, indptr), shape=shape)
+            self.blocks.append(X)
+            self.block_ranges.append((int(b['row_start']), int(b['row_end'])))
+        self.loaded = True
+
+    def similarity(self, q):
+        self.load()
+        sims = []
+        for X in self.blocks:
+            sims.append((X @ q.T).toarray().ravel().astype(np.float64))
+        return np.concatenate(sims, axis=0) if sims else np.array([], dtype=np.float64)
+
+    def rows(self, indices: np.ndarray):
+        self.load()
+        rows = []
+        for idx in indices:
+            idx = int(idx)
+            for block_i, (start, end) in enumerate(self.block_ranges):
+                if start <= idx < end:
+                    rows.append(self.blocks[block_i][idx - start])
+                    break
+        if not rows:
+            return sp.csr_matrix((0, self.n_features), dtype=np.float32)
+        return sp.vstack(rows, format='csr')
+
+class NZFCHybridExactRecall10M:
+    def __init__(self, repo_dir: str = '.'):
+        self.root = Path(repo_dir)
+        self.manifest = read_json(self.root / 'memory_tensors/hybrid/hybrid_manifest.json')
+        self.n_features = int(self.manifest['n_features'])
+        self.archive_path = self.root / self.manifest['archive_path'] if self.manifest.get('archive_path') else None
+        self.meta_path = self.root / self.manifest['meta_path']
+        self.metas = []
+        with open(self.meta_path, 'rb') as f:
+            for line in f:
+                if line.strip():
+                    self.metas.append(json.loads(line.decode('utf-8')))
+        self.target = self.manifest['target']
+        self.target_passage = (self.root / self.target['target_passage_file']).read_text(encoding='utf-8')
+        self.target_sha256 = self.target['target_sha256']
+        self.lex_vectorizer = self._build_vectorizer(self.manifest['channels']['lex']['vectorizer'])
+        self.char_vectorizer = self._build_vectorizer(self.manifest['channels']['char']['vectorizer'])
+        self.struct_vectorizer = self._build_vectorizer(self.manifest['channels']['struct']['vectorizer'])
+        self.lex_index = CSRBlockIndex(self.root, self.manifest['channels']['lex']['blocks'], self.n_features)
+        self.char_index = CSRBlockIndex(self.root, self.manifest['channels']['char']['blocks'], self.n_features)
+        self.struct_index = CSRBlockIndex(self.root, self.manifest['channels']['struct']['blocks'], self.n_features)
+
+    def _build_vectorizer(self, cfg):
+        kwargs = {'n_features': cfg['n_features'], 'alternate_sign': cfg['alternate_sign'], 'norm': cfg['norm'], 'analyzer': cfg['analyzer'], 'ngram_range': tuple(cfg['ngram_range']), 'lowercase': cfg['lowercase']}
+        if 'token_pattern' in cfg:
+            kwargs['token_pattern'] = cfg['token_pattern']
+        return HashingVectorizer(**kwargs)
+
+    def preload(self):
+        self.lex_index.load()
+        self.char_index.load()
+        self.struct_index.load()
+
+    def verify_meta(self, meta):
+        if self.archive_path is None or not self.archive_path.exists():
+            return {'verified': False, 'raw': None, 'reason': 'archive_not_included'}
+        raw = read_record_at_offset(self.archive_path, int(meta['byte_offset']))
+        ok_rid = raw.get('rid') == meta.get('rid')
+        ok_hash = sha256_text(raw.get('text', '')) == meta.get('text_sha256')
+        return {'verified': bool(ok_rid and ok_hash), 'raw': raw}
+
+    def _positive_normalize(self, a):
+        a = np.maximum(np.asarray(a, dtype=np.float64), 0.0)
+        m = float(a.max()) if a.size else 0.0
+        if m <= 1e-14:
+            return a
+        return a / (m + 1e-12)
+
+    def _hybrid_vectors(self, query):
+        q_lex = self.lex_vectorizer.transform([query])
+        q_char = self.char_vectorizer.transform([query])
+        q_struct = self.struct_vectorizer.transform([make_structural_document(query)])
+        return self.lex_index.similarity(q_lex), self.char_index.similarity(q_char), self.struct_index.similarity(q_struct)
+
+    def _rows_from_hybrid(self, indices):
+        A = self.lex_index.rows(indices).multiply(0.25)
+        B = self.char_index.rows(indices).multiply(0.25)
+        C = self.struct_index.rows(indices).multiply(0.50)
+        return sp.hstack([A, B, C], format='csr')
+
+    def _read_text_by_index(self, global_idx):
+        meta = self.metas[int(global_idx)]
+        if self.archive_path is None or not self.archive_path.exists():
+            return meta.get('text_preview', '')
+        rec = read_record_at_offset(self.archive_path, int(meta['byte_offset']))
+        return rec.get('text', '')
+
+    def query(self, query, tau_trace=0.3, top_pool=512, top_k=16, strict_energy_floor=0.010):
+        t0 = time.perf_counter()
+        sim_lex, sim_char, sim_struct = self._hybrid_vectors(query)
+        nlex = self._positive_normalize(sim_lex)
+        nchar = self._positive_normalize(sim_char)
+        nstruct = self._positive_normalize(sim_struct)
+        base = 0.20 * nlex + 0.25 * nchar + 0.55 * nstruct
+        base = base * gaussian_resolvent_score(base)
+        if float(base.max()) <= 1e-14:
+            base = 0.4 * nstruct + 0.3 * nchar + 0.3 * nlex
+        pool_n = min(int(top_pool), len(self.metas))
+        pool_idx = np.argsort(-base)[:pool_n]
+        anchor_scores = []
+        formula_scores = []
+        penalties = []
+        for global_idx in pool_idx:
+            text = self._read_text_by_index(int(global_idx))
+            kind = str(self.metas[int(global_idx)].get('kind', ''))
+            anchor_scores.append(anchor_coverage_score(query, text))
+            formula_scores.append(formula_jaccard_score(query, text))
+            penalty = 1.0
+            if kind == 'filler':
+                penalty *= 0.55
+            if 'decoy' in kind:
+                penalty *= 0.70
+            penalties.append(penalty)
+        anchor_scores = np.asarray(anchor_scores, dtype=np.float64)
+        formula_scores = np.asarray(formula_scores, dtype=np.float64)
+        penalties = np.asarray(penalties, dtype=np.float64)
+        base_pool = base[pool_idx]
+        base_pool = base_pool * (1.0 + 0.80 * anchor_scores + 0.60 * formula_scores) * penalties
+        weights = base_pool / (base_pool.max() + 1e-12) if base_pool.max() > 0 else base_pool
+        X_pool = self._rows_from_hybrid(pool_idx)
+        kernel_diag = sparse_self_adjoint_kernel_diagnostics(X_pool)
+        nuc = sparse_nuclear_projection_diagnostics(X_pool, weights, tau_trace)
+        row_energy = nuc.pop('row_energy')
+        wnorm = weights / (weights.max() + 1e-12) if weights.max() > 0 else weights
+        enorm = row_energy / (row_energy.max() + 1e-12) if row_energy.size and row_energy.max() > 0 else row_energy
+        final_score = 0.45 * wnorm + 0.35 * enorm + 0.15 * anchor_scores + 0.05 * formula_scores
+        order = np.argsort(-final_score)
+        selected = []
+        for local_rank, j in enumerate(order[:top_k], start=1):
+            global_idx = int(pool_idx[j])
+            meta = self.metas[global_idx]
+            ver = self.verify_meta(meta)
+            raw = ver.get('raw') or {}
+            text = raw.get('text', self._read_text_by_index(global_idx))
+            item = {'rank': local_rank, 'global_index': global_idx, 'rid': meta.get('rid'), 'kind': meta.get('kind'), 'verified': bool(ver.get('verified')), 'sim_lex': float(sim_lex[global_idx]), 'sim_char': float(sim_char[global_idx]), 'sim_struct': float(sim_struct[global_idx]), 'anchor_score': float(anchor_scores[j]), 'formula_score': float(formula_scores[j]), 'trace_projected_energy': float(row_energy[j]) if row_energy.size else 0.0, 'final_score': float(final_score[j]), 'text': text, 'text_sha256': meta.get('text_sha256'), 'exact_target_sha_match': bool(meta.get('text_sha256') == self.target_sha256), 'exact_text_match': bool(text == self.target_passage)}
+            selected.append(item)
+        strict = [x for x in selected if x['verified'] and x['trace_projected_energy'] >= strict_energy_floor]
+        if not strict:
+            strict = [x for x in selected if x['verified']][:1]
+        t1 = time.perf_counter()
+        diag = {'method': 'distributed_nzfc_hybrid_safetensors', 'query_time_s': float(t1 - t0), 'tau_trace': float(tau_trace), 'top_pool': int(top_pool), 'top_k': int(top_k), 'strict_energy_floor': float(strict_energy_floor), 'target_rid': self.target['target_rid'], 'target_title': self.target['target_title'], 'target_key': self.target['target_key'], 'target_sha256': self.target_sha256, **kernel_diag, **nuc}
+        return strict, selected, diag
+
+    def render_pack(self, query, strict, diag, max_chars_per_item=2600):
+        lines = []
+        lines.append('[NZFC HYBRID STRUCTURE-AWARE EXACT RECALL PACK]')
+        lines.append('Query: ' + str(query))
+        lines.append('')
+        lines.append('Memory boundary:')
+        lines.append('- This is external NZFC archive retrieval.')
+        lines.append('- This is not internal 10M-token model context.')
+        lines.append('- Exact recall passes only by RID, SHA-256, and full-text equality.')
+        lines.append('')
+        lines.append('Target identity:')
+        lines.append('- target_rid: ' + str(diag.get('target_rid')))
+        lines.append('- target_title: ' + str(diag.get('target_title')))
+        lines.append('- target_key: ' + str(diag.get('target_key')))
+        lines.append('- target_sha256: ' + str(diag.get('target_sha256')))
+        lines.append('')
+        lines.append('Admissibility diagnostics:')
+        for k, v in diag.items():
+            if k in ['singular_values_before', 'singular_values_after']:
+                lines.append('- ' + k + ': ' + json.dumps(v[:12], ensure_ascii=False))
+            else:
+                lines.append('- ' + k + ': ' + str(v))
+        lines.append('')
+        lines.append('Strict verified evidence items:')
+        for item in strict:
+            preview = str(item['text'])[:max_chars_per_item].replace('\n', '\n  ')
+            lines.append('')
+            lines.append('[' + str(item['rank']) + '] rid=' + str(item['rid']) + ' kind=' + str(item['kind']) + ' verified=' + str(item['verified']) + ' exact_text_match=' + str(item['exact_text_match']))
+            lines.append('score=' + format(item['final_score'], '.6f') + ' trace=' + format(item['trace_projected_energy'], '.6f'))
+            lines.append('text_sha256=' + str(item['text_sha256']))
+            lines.append('exact_target_sha_match=' + str(item['exact_target_sha_match']))
+            lines.append('Evidence excerpt:')
+            lines.append('  ' + preview)
+        lines.append('')
+        lines.append('Answering rule: Use only verified evidence shown here. Never claim internal 10M-token model memory.')
+        return '\n'.join(lines)
+
+class TokenBudget:
+    def __init__(self, tokenizer=None):
+        self.tokenizer = tokenizer
+
+    def count(self, text: str) -> int:
+        text = str(text)
+        if self.tokenizer is not None:
+            try:
+                return len(self.tokenizer(text, add_special_tokens=False)['input_ids'])
+            except Exception:
+                pass
+        return max(1, len(text) // 3)
+
+    def truncate(self, text: str, max_tokens: int) -> str:
+        text = str(text)
+        if max_tokens <= 0:
+            return ''
+        if self.count(text) <= max_tokens:
+            return text
+        if self.tokenizer is not None:
+            try:
+                ids = self.tokenizer(text, add_special_tokens=False)['input_ids'][:max_tokens]
+                return self.tokenizer.decode(ids, skip_special_tokens=True)
+            except Exception:
+                pass
+        return text[:max(100, max_tokens * 3)] + '\n[TRUNCATED_BY_CONTEXT_GOVERNOR]'
+
+    def compact_middle(self, text: str, max_tokens: int) -> str:
+        text = str(text)
+        if self.count(text) <= max_tokens:
+            return text
+        half = max_tokens // 2
+        head = self.truncate(text, half)
+        tail = self.truncate(text[-max(1000, half * 6):], half)
+        return head + '\n[... CONTEXT GOVERNOR OMITTED MIDDLE ...]\n' + tail
+
+class ContextGovernor:
+    def __init__(self, token_budget=None, target_context_tokens=8000, hard_cap_context_tokens=16000, max_memory_pack_tokens=5000, max_cards=4, max_excerpt_tokens_per_card=700, min_excerpt_tokens_per_card=120, max_user_query_tokens=768):
+        self.tb = token_budget or TokenBudget()
+        self.target_context_tokens = int(target_context_tokens)
+        self.hard_cap_context_tokens = int(hard_cap_context_tokens)
+        self.max_memory_pack_tokens = int(max_memory_pack_tokens)
+        self.max_cards = int(max_cards)
+        self.max_excerpt_tokens_per_card = int(max_excerpt_tokens_per_card)
+        self.min_excerpt_tokens_per_card = int(min_excerpt_tokens_per_card)
+        self.max_user_query_tokens = int(max_user_query_tokens)
+
+    def compact_user_query(self, query: str) -> str:
+        return self.tb.compact_middle(str(query), self.max_user_query_tokens)
+
+    def evidence_card(self, item: Dict[str, Any], excerpt_tokens: int) -> str:
+        text = str(item.get('text', ''))
+        excerpt = self.tb.truncate(text, excerpt_tokens)
+        return '\n'.join(['[EVIDENCE_CARD rank=' + str(item.get('rank')) + ']', 'rid: ' + str(item.get('rid')), 'kind: ' + str(item.get('kind')), 'verified: ' + str(item.get('verified')), 'exact_text_match: ' + str(item.get('exact_text_match')), 'exact_target_sha_match: ' + str(item.get('exact_target_sha_match')), 'text_sha256: ' + str(item.get('text_sha256')), 'final_score: ' + str(item.get('final_score')), 'trace_projected_energy: ' + str(item.get('trace_projected_energy')), 'excerpt:', excerpt])
+
+    def build_memory_pack(self, query: str, strict_items: List[Dict[str, Any]], diag: Dict[str, Any], excerpt_tokens_per_card=None, max_cards=None) -> str:
+        excerpt_tokens = int(excerpt_tokens_per_card or self.max_excerpt_tokens_per_card)
+        n_cards = int(max_cards or self.max_cards)
+        selected = strict_items[:n_cards]
+        diag_small = {'method': diag.get('method'), 'tau_trace': diag.get('tau_trace'), 'target_rid': diag.get('target_rid'), 'target_title': diag.get('target_title'), 'target_sha256': diag.get('target_sha256'), 'nuclear_before': diag.get('nuclear_before'), 'nuclear_after': diag.get('nuclear_after'), 'tail_removed': diag.get('tail_removed'), 'effective_rank_after': diag.get('effective_rank_after'), 'candidate_count': diag.get('candidate_count')}
+        def render(cards, ex_tokens):
+            lines = ['[NZFC CONTEXT-GOVERNED MEMORY PACK]', '', 'Memory boundary:', '- This is external NZFC archive retrieval.', '- This is not internal 10M-token model context.', '- The full archive is never inserted into the LLM prompt.', '- Only verified evidence cards below may be used for past-memory claims.', '', 'Query summary:', self.compact_user_query(query), '', 'Admissibility diagnostics:', json.dumps(diag_small, ensure_ascii=False, indent=2), '', 'Verified evidence cards:']
+            for item in cards:
+                lines.append('')
+                lines.append(self.evidence_card(item, ex_tokens))
+            lines.extend(['', 'Answering rules:', '- Use only the verified evidence cards above.', '- If evidence is insufficient, say so explicitly.', '- Never claim that the model internally remembered the 10M-token archive.', '- Distinguish source-verified evidence, current user claim, and inference.', '- Do not copy or infer from archive records not shown in this pack.'])
+            return '\n'.join(lines)
+        pack = render(selected, excerpt_tokens)
+        while self.tb.count(pack) > self.max_memory_pack_tokens:
+            if excerpt_tokens > self.min_excerpt_tokens_per_card:
+                excerpt_tokens = max(self.min_excerpt_tokens_per_card, int(excerpt_tokens * 0.70))
+            elif n_cards > 1:
+                n_cards -= 1
+                selected = strict_items[:n_cards]
+            else:
+                break
+            pack = render(selected, excerpt_tokens)
+        return pack
+
+    def build_prompts(self, query: str, strict_items: List[Dict[str, Any]], diag: Dict[str, Any]):
+        memory_pack = self.build_memory_pack(query, strict_items, diag)
+        system_prompt = '\n'.join(['You are a reasoning model with an NZFC verified external memory layer.', 'The NZFC memory pack is external verified memory, not internal model memory.', 'Use only the evidence cards inside the memory pack for past-memory claims.', 'Never claim that you internally read or remembered the 10M-token archive.', 'If the pack is insufficient, say evidence is insufficient.', 'Answer in Korean unless the user asks otherwise.'])
+        compact_query = self.compact_user_query(query)
+        user_prompt = '\n'.join(['[NZFC MEMORY PACK BEGIN]', memory_pack, '[NZFC MEMORY PACK END]', '', '[CURRENT USER MESSAGE]', compact_query, '', '[TASK]', 'Answer using only verified NZFC evidence when relevant. External archive retrieval, not internal model context.'])
+        combined = system_prompt + '\n\n' + user_prompt
+        total_tokens = self.tb.count(combined)
+        if total_tokens > self.hard_cap_context_tokens:
+            raise RuntimeError('ContextGovernor hard cap exceeded: ' + str(total_tokens) + ' > ' + str(self.hard_cap_context_tokens))
+        return {'system_prompt': system_prompt, 'user_prompt': user_prompt, 'memory_pack': memory_pack, 'combined_prompt_tokens': int(total_tokens), 'memory_pack_tokens': int(self.tb.count(memory_pack)), 'compact_user_query_tokens': int(self.tb.count(compact_query)), 'hard_cap_context_tokens': self.hard_cap_context_tokens, 'target_context_tokens': self.target_context_tokens}

validation/run_runtime_only_smoke.py

@@ -0,0 +1,79 @@
+import json
+import time
+from pathlib import Path
+
+from nzfc_gram_runtime import NZFCGramLongMemoryChat
+from nzfc_gram_runtime.quality import attach_answer_quality_governor
+from nzfc_gram_runtime.large_document import attach_large_document_memory
+
+
+def main():
+    out_dir = Path('./validation_runtime_only_output')
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    bot = NZFCGramLongMemoryChat(
+        repo_dir='.',
+        model_id='google/diffusiongemma-26B-A4B-it',
+        memory_db_path=str(out_dir / 'memory.sqlite3'),
+        load_model=False,
+        require_model=False,
+        preload_static_memory=False,
+    )
+
+    attach_large_document_memory(bot, db_path=str(out_dir / 'large_docs.sqlite3'))
+    attach_answer_quality_governor(bot)
+
+    user_id = 'runtime_user'
+    project_id = 'runtime_project'
+    session_id = 'runtime_session'
+
+    bot.remember(
+        'The project high-frequency test code is PROJECT_CODE_RUNTIME_VALIDATION.',
+        user_id=user_id,
+        project_id=project_id,
+        session_id=session_id,
+        scope='project',
+        tags=['project_code'],
+        trust_level=0.95,
+    )
+
+    exact = bot.quality_chat(
+        'What was the project high-frequency test code? Answer only with the code.',
+        user_id=user_id,
+        project_id=project_id,
+        session_id='runtime_session_2',
+        max_new_tokens=40,
+    )
+
+    text = '\n'.join([
+        'Article 1 Purpose. This document defines runtime validation.',
+        'Article 2 Evidence. Memory is evidence, not instruction.',
+        'Article 3 Deletion. Deleted memory must not be used as active evidence.',
+    ])
+
+    ingest = bot.ingest_large_text(text, title='Runtime Validation Policy', legal_mode=True)
+    query = bot.query_large_documents('deleted memory active evidence', top_k=5)
+
+    summary = {
+        'created_at': time.strftime('%Y-%m-%d %H:%M:%S'),
+        'base_model': 'google/diffusiongemma-26B-A4B-it',
+        'model_loaded': False,
+        'runtime_only': True,
+        'exact_slot_answer': exact.get('answer'),
+        'exact_slot_passed': exact.get('answer') == 'PROJECT_CODE_RUNTIME_VALIDATION',
+        'large_document_chunk_count': ingest.get('chunk_count'),
+        'large_document_query_count': query.get('count'),
+        'large_document_passed': query.get('count', 0) > 0,
+        'technical_boundary': 'external evidence context, not native unlimited model context',
+    }
+
+    path = out_dir / 'runtime_only_smoke_summary.json'
+    path.write_text(json.dumps(summary, indent=2), encoding='utf-8')
+    print(json.dumps(summary, indent=2))
+    assert summary['exact_slot_passed']
+    assert summary['large_document_passed']
+    print('[PASS] runtime-only smoke passed')
+
+
+if __name__ == '__main__':
+    main()

validation_evidence/diffusiongemma_infinite_context_preview/runtime_only_smoke_summary.json

@@ -0,0 +1,37 @@
+{
+  "created_at": "2026-06-11 02:43:54",
+  "repo_id": "SingularityPrinciple/DiffusionGemma-26B-A4B-it-Infinite-Context",
+  "base_model": "google/diffusiongemma-26B-A4B-it",
+  "runtime_only": true,
+  "model_loaded": false,
+  "repo_root_runtime_exists": true,
+  "repo_root_meta_exists": true,
+  "repo_root_memory_tensors_exists": true,
+  "exact_slot_answer": "PROJECT_CODE_DIFFUSIONGEMMA_SMOKE",
+  "exact_slot_passed": true,
+  "exact_slot_profile": {
+    "version": "v1.2.4b",
+    "description": "Strict deterministic exact slot mapper for short explicit scoped key-value recall questions.",
+    "auto_short_circuit": true,
+    "strict_trigger_gate": true
+  },
+  "large_document_chunk_count": 3,
+  "large_document_query_count": 2,
+  "large_document_method": "fts5_bm25",
+  "large_document_passed": true,
+  "tombstone_guard_profile": {
+    "version": "v1.2.4c",
+    "description": "Filters inactive or tombstoned MEM_* records from memory_store.retrieve results.",
+    "db_path": "/kaggle/working/diffusiongemma_infinite_context_evidence_pack_update/runtime_only_smoke_final/memory.sqlite3",
+    "guarded_method": "memory_store.retrieve"
+  },
+  "tombstone_test": {
+    "available": true,
+    "before_found": true,
+    "after_found": false,
+    "passed": true,
+    "tombstoned": 1
+  },
+  "technical_boundary": "external evidence context, not native unlimited model context",
+  "status": "passed"
+}