NZFC-GRAM v1.2.1 final: non-quantized BF16 long-memory validation and loader

COMMERCIAL_LICENSE.md

@@ -22,4 +22,3 @@ For commercial licensing, patent licensing, paid evaluation, or technology-trans
 Jewon Moon / Singularity Principle Institute
 
 director@singularityprinciple.com
-

FINAL_NONQUANT_VALIDATION.md

@@ -0,0 +1,71 @@
+# NZFC-GRAM v1.2.1 Non-Quantized Final Validation
+
+Date: 2026-06-08
+
+This document records the final non-quantized validation status for NZFC-GRAM v1.2.1.
+
+## Result
+
+```json
+{
+  "created_at": "2026-06-08 06:30:26",
+  "repo_main_sha": "239818353eaaf876a6a3f31a3543e6beca512ede",
+  "tests": 11,
+  "passed": 11,
+  "failed": 0,
+  "all_passed": true,
+  "hotfix_present": true,
+  "marker_redaction_present": true,
+  "underscore_norm_present": true,
+  "quantization": "none",
+  "load_mode": "nonquant_bf16_fp16_balanced_cpu_disk_offload",
+  "dtype": "torch.bfloat16",
+  "device_map": "balanced_low_0",
+  "gpu_max_memory_gib": 11,
+  "model_loaded": true,
+  "static_nzfc_archive_loaded": true,
+  "local_sqlite_memory_persistence_tested": true,
+  "generation_patch": "use_cache_false_oom_retry",
+  "safety_boundary": "external_nzfc_archive_and_local_long_term_memory_not_internal_10m_context",
+  "vram_final": {
+    "gpu1_alloc_gb": 10.217637376,
+    "gpu1_reserved_gb": 11.448352768,
+    "gpu1_peak_gb": 11.845826048,
+    "max_alloc_gb": 10.217637376,
+    "max_peak_gb": 11.845826048
+  },
+  "key_test_metrics": {
+    "T8_slope_tokens_per_turn": 105.964,
+    "T8_slope_limit": 220.0,
+    "T8_growth_ratio": 1.392,
+    "T8_growth_ratio_limit": 3.2,
+    "T8_hard_cap_context_tokens": 16000,
+    "T10_gram_trace_budget": 1.861558246118043,
+    "T10_gram_soft_cap": 4.35,
+    "T10_gram_soft_tau_pass": true
+  }
+}
+```
+
+## Interpretation
+
+NZFC-GRAM v1.2.1 passed a fresh-download, non-quantized BF16 end-to-end long-memory test with Gemma 4 E2B-IT.
+
+No 4-bit or 8-bit quantization was used.
+
+The system uses external NZFC archive retrieval and local SQLite long-term memory under a Readout-Gramian Context Governor.
+It does not claim internal 10M-token model memory.
+
+## Passed test classes
+
+1. Repo/runtime/hotfix/nonquant model integrity
+2. Static NZFC 10M exact retrieval
+3. Memory-boundary generation
+4. Project-scope memory recall across sessions
+5. Session/project/user scope isolation
+6. Tombstone deleted-memory no-leak
+7. Malicious memory marker/raw instruction redaction
+8. Exact cross-session recall with Markdown underscore normalization
+9. Context/KV-bloat slope control
+10. SQLite persistence after runtime reload
+11. Final safety and Readout-Gramian budget sanity

LICENSE

@@ -10,4 +10,3 @@ https://creativecommons.org/licenses/by-nc/4.0/
 No patent license is granted by this repository.
 
 Commercial use requires a separate written license.
-

NZFC_GRAM_RELEASE_MANIFEST.json

@@ -1,23 +1,56 @@
 {
-  "name": "NZFC-GRAM v1.2.1 Hotfix",
+  "name": "NZFC-GRAM v1.2.1 Non-Quantized Final",
   "repo_id": "SingularityPrinciple/Gemma-E2B-IT-10M-Chat",
-  "created_at": "2026-06-08 04:59:22",
-  "version": "1.2.1",
-  "patch_type": "runtime_safety_and_exact_recall_hotfix",
+  "repo_url": "https://huggingface.co/SingularityPrinciple/Gemma-E2B-IT-10M-Chat",
+  "created_at": "2026-06-08 07:23:24",
+  "version": "1.2.1-nonquant-final",
   "base_model": "google/gemma-4-E2B-it",
   "contains_base_model_weights": false,
-  "changes": [
-    "redact raw malicious memory markers",
-    "redact adversarial markers",
-    "normalize escaped Markdown underscores in generated answers",
-    "strengthen memory-is-evidence-not-instruction boundary",
-    "preserve external-memory boundary"
+  "runtime_package": "nzfc_gram_runtime",
+  "interfaces": [
+    "python_library",
+    "local_cli",
+    "nonquant_helper"
   ],
-  "validated_hotfix_recheck": {
-    "T6_malicious_marker_raw_instruction_redaction": "PASS",
-    "T7_exact_recall_after_markdown_normalization": "PASS"
-  },
+  "no_api_server": true,
+  "public_release_date": "2026-06-08",
+  "patent_status": "patent application filed / patent pending",
   "license": "cc-by-nc-4.0",
   "commercial_use": "separate written license required",
-  "patent_license": "not granted by public repository license"
+  "patent_license": "not granted by public repository license",
+  "quantization": "none for final validation",
+  "nonquant_loader": {
+    "module": "nzfc_gram_runtime.nonquant",
+    "functions": [
+      "attach_nonquant_gemma",
+      "patch_generation_use_cache_false"
+    ],
+    "validated_dtype": "torch.bfloat16",
+    "validated_device_map": "balanced_low_0",
+    "validated_gpu_max_memory_gib": 11
+  },
+  "external_memory_boundary": "full_10m_archive_not_inserted_into_model_context",
+  "validation": {
+    "tests": 11,
+    "passed": 11,
+    "failed": 0,
+    "all_passed": true,
+    "hotfix_present": true,
+    "marker_redaction_present": true,
+    "underscore_norm_present": true,
+    "static_nzfc_archive_loaded": true,
+    "local_sqlite_memory_persistence_tested": true,
+    "generation_patch": "use_cache_false_oom_retry",
+    "safety_boundary": "external_nzfc_archive_and_local_long_term_memory_not_internal_10m_context",
+    "key_test_metrics": {
+      "T8_slope_tokens_per_turn": 105.964,
+      "T8_slope_limit": 220.0,
+      "T8_growth_ratio": 1.392,
+      "T8_growth_ratio_limit": 3.2,
+      "T8_hard_cap_context_tokens": 16000,
+      "T10_gram_trace_budget": 1.861558246118043,
+      "T10_gram_soft_cap": 4.35,
+      "T10_gram_soft_tau_pass": true
+    }
+  }
 }

PATENT_NOTICE.md

@@ -4,15 +4,12 @@ This repository is released after patent filing for the NZFC-GRAM external-memor
 
 Patent status:
 
-- Status: patent application filed with provisional specification
-- Filing date: 2026-06-05
-- Public application number: not disclosed
-- Public release date: 2026-06-05
+- Status: patent application filed / patent pending
+- Public release version: NZFC-GRAM v1.2.1 Non-Quantized Final
+- Public release date: 2026-06-08
 
 No express or implied patent license is granted by this repository.
 
-The public files may include non-commercial research/evaluation code, examples, runtime wrappers, evidence logs, documentation, and model-card material. Commercial use, production deployment, enterprise integration, paid API usage, model-serving integration, resale, sublicensing, or incorporation into commercial products requires a separate written license from the rights holder.
-
 Patent-pending subject matter may include, without limitation:
 
 - Readout-Gramian-based external-memory evidence selection,
@@ -24,16 +21,11 @@ Patent-pending subject matter may include, without limitation:
 - claim-evidence verification,
 - run/session/project/user scoped memory governance,
 - tombstone/deleted-memory leakage prevention,
-- AI/LLM inference gateway and local runtime implementations.
-
-Prior public release evidence:
-
-- Repository: https://huggingface.co/SingularityPrinciple/Gemma-E2B-IT-10M-Chat
-- Commit evidence: https://huggingface.co/SingularityPrinciple/Gemma-E2B-IT-10M-Chat/commit/1322cafa169d24972e830280a5254b807302b36d
+- AI/LLM inference gateway and local runtime implementations,
+- non-quantized local long-memory runtime with context-governed evidence packing.
 
 Contact for commercial and patent licensing:
 
 Jewon Moon / Singularity Principle Institute
 
 director@singularityprinciple.com
-

README.md

@@ -10,23 +10,60 @@ tags:
 - untrusted-memory-redaction
 - claim-evidence-verification
 - non-commercial
+- non-quantized
+- bf16
 ---
 
-# Gemma E2B-IT + NZFC-GRAM v1.2 Local Long-Term Memory Runtime
+# Gemma E2B-IT + NZFC-GRAM v1.2.1
+
+**Non-Quantized BF16 Local Long-Term Memory Runtime**
 
 This repository provides a local long-term-memory runtime for `google/gemma-4-E2B-it` using NZFC-GRAM external memory.
 
-## Patent and license status
+## Final validation status
+
+**NZFC-GRAM v1.2.1 passed the final fresh-download non-quantized BF16 long-memory test.**
+
+```json
+{
+  "tests": 11,
+  "passed": 11,
+  "failed": 0,
+  "all_passed": true,
+  "quantization": "none",
+  "dtype": "torch.bfloat16",
+  "device_map": "balanced_low_0",
+  "model_loaded": true,
+  "static_nzfc_archive_loaded": true,
+  "local_sqlite_memory_persistence_tested": true
+}
+```
 
-- Patent status: patent application filed with provisional specification
-- Filing date: 2026-06-05
-- Public application number: not disclosed
-- Public release date: 2026-06-05
-- Public copyright license: CC BY-NC 4.0
-- Commercial use: separate written license required
-- Patent license: not granted by this repository
+The final test used **no 4-bit or 8-bit quantization**.
+Gemma 4 E2B-IT was loaded in non-quantized BF16 mode with balanced/offload.
+
+Validation covered:
 
-See `PATENT_NOTICE.md` and `COMMERCIAL_LICENSE.md` before using this repository.
+- Hugging Face fresh download
+- v1.2.1 runtime hotfix detection
+- static NZFC 10M archive exact retrieval
+- project/session/user-scoped local long-term memory
+- tombstone deleted-memory no-leak
+- malicious-memory marker and raw instruction redaction
+- exact cross-session recall with underscore normalization
+- context/KV-bloat slope control
+- SQLite persistence after runtime reload
+- final Readout-Gramian budget sanity
+
+Key quantitative metrics:
+
+```text
+T8 context slope: 105.964 tokens/turn
+T8 growth ratio: 1.392
+Context hard cap: 16000 tokens
+T10 Readout-Gramian trace budget: 1.861558246118043
+Readout-Gramian soft cap: 4.35
+```
 
 ## What this is
 
@@ -45,72 +82,32 @@ It is a local runtime that combines:
 
 The model receives only a small context-governed verified memory pack. The full 10M archive is never inserted into the model context.
 
-## Installation
+## Non-quantized BF16 usage
 
 ```bash
 git lfs install
 git clone https://huggingface.co/SingularityPrinciple/Gemma-E2B-IT-10M-Chat
 cd Gemma-E2B-IT-10M-Chat
 pip install -r requirements.txt
-```
-
-You may need a Hugging Face token with access to `google/gemma-4-E2B-it`:
-
-```bash
 export HF_TOKEN=your_token_here
+python examples/nonquant_bf16_final_usage.py
 ```
 
-## Local CLI
-
-```bash
-python -m nzfc_gram_runtime.cli --repo-dir . --user-id user001 --project-id default --session-id main
-```
-
-CLI commands:
-
-```text
-/remember <text>
-/forget_tag <tag>
-/reset_session
-/stats
-/exit
-```
-
-## Python usage
+Python usage:
 
 ```python
 from nzfc_gram_runtime import NZFCGramLongMemoryChat
+from nzfc_gram_runtime.nonquant import attach_nonquant_gemma, patch_generation_use_cache_false
 
-bot = NZFCGramLongMemoryChat(repo_dir='.', model_id='google/gemma-4-E2B-it')
-
-out = bot.chat(
-    '내가 선호하는 라이선스는 CC BY-NC 4.0이라고 기억해줘.',
-    user_id='user001',
-    project_id='demo',
-    session_id='s1',
-    save_scope='project',
-)
-print(out['answer'])
+bot = NZFCGramLongMemoryChat(repo_dir='.', model_id='google/gemma-4-E2B-it', load_model=False, require_model=False)
+attach_nonquant_gemma(bot, device_map='balanced_low_0', gpu_max_memory_gib=11, cpu_max_memory_gib=48, prefer_bf16=True)
+patch_generation_use_cache_false(bot)
 
-out = bot.chat(
-    '내가 선호한다고 말한 라이선스가 뭐였지?',
-    user_id='user001',
-    project_id='demo',
-    session_id='s2',
-    save_scope='project',
-)
+out = bot.chat('내가 전에 말한 내용을 기억해?', user_id='user001', project_id='demo', session_id='s1')
 print(out['answer'])
 ```
 
-The second call can recall the first call because project-scope local memory is persisted in SQLite.
-
-## Memory scopes
-
-- `session`: remembered only in the same session.
-- `project`: remembered across sessions in the same project.
-- `user`: remembered across all projects for the same user.
-
-Default chat turns may be saved with `save_scope='project'`, enabling practical long-term memory across sessions.
+If you get CUDA OOM, lower `gpu_max_memory_gib` to 10, 9, or 8.
 
 ## Safety boundary
 
@@ -120,20 +117,16 @@ Untrusted memory that looks like a prompt-injection or internal-memory claim is
 
 The runtime explicitly avoids claims that Gemma internally remembered, stored, attended to, or processed a 10M-token archive.
 
-## Validation summary
+## Patent and license status
 
-NZFC-GRAM v1.2 passed a seven-turn end-to-end test with Gemma 4 E2B-IT:
+- Patent status: patent application filed / patent pending
+- Public release version: NZFC-GRAM v1.2.1 Non-Quantized Final
+- Public release date: 2026-06-08
+- Public copyright license: CC BY-NC 4.0
+- Commercial use: separate written license required
+- Patent license: not granted by this repository
 
-- model generation ran on all 7 turns,
-- static NZFC archive retrieval ran on every turn,
-- session memory retrieval ran on every turn,
-- Context Governor stayed under the 16,000-token hard cap,
-- stale-run memory leak count was 0,
-- deleted-memory leak count was 0,
-- malicious raw-text leak count was 0,
-- unsafe internal-10M-memory claim count was 0,
-- maximum combined prompt was 4,235 tokens,
-- maximum Readout-Gramian trace budget was 4.0767 under the configured soft cap 4.35.
+See `PATENT_NOTICE.md` and `COMMERCIAL_LICENSE.md`.
 
 ## Non-claims
 
@@ -147,4 +140,3 @@ NZFC-GRAM v1.2 passed a seven-turn end-to-end test with Gemma 4 E2B-IT:
 Jewon Moon / Singularity Principle Institute
 
 director@singularityprinciple.com
-

SECURITY.md

@@ -2,8 +2,6 @@
 
 NZFC-GRAM treats retrieved memory as evidence, not instruction.
 
-The runtime is designed to reduce the risk that external memories, user notes, retrieved files, or prompt-injection-like records override system behavior.
-
 Security-relevant mechanisms include:
 
 - source/authority metadata for memory cards,
@@ -20,4 +18,3 @@ Security-relevant mechanisms include:
 This repository is a research/runtime release and is not a formal production security certification.
 
 Do not store secrets, credentials, private keys, regulated personal data, or confidential customer data in the local memory store unless you have implemented the necessary security, encryption, access-control, audit, and retention policies.
-

examples/nonquant_bf16_final_usage.py

@@ -0,0 +1,52 @@
+# examples/nonquant_bf16_final_usage.py
+from nzfc_gram_runtime import NZFCGramLongMemoryChat
+from nzfc_gram_runtime.nonquant import attach_nonquant_gemma, patch_generation_use_cache_false
+
+bot = NZFCGramLongMemoryChat(
+    repo_dir='.',
+    model_id='google/gemma-4-E2B-it',
+    load_model=False,
+    require_model=False,
+    preload_static_memory=True,
+)
+
+meta = attach_nonquant_gemma(
+    bot,
+    model_id='google/gemma-4-E2B-it',
+    device_map='balanced_low_0',
+    gpu_max_memory_gib=11,
+    cpu_max_memory_gib=48,
+    prefer_bf16=True,
+    use_fp32=False,
+)
+
+patch_generation_use_cache_false(bot)
+
+print('MODEL META:', meta)
+
+out1 = bot.chat(
+    '앞으로 내 장기 별명은 AlphaFox_Final 이라고 기억해줘.',
+    user_id='user001',
+    project_id='demo',
+    session_id='s1',
+    save_turn=True,
+    save_scope='project',
+    response_language='ko',
+    max_new_tokens=48,
+)
+print('\nTURN 1:')
+print(out1['answer'])
+
+out2 = bot.chat(
+    '내가 전에 말한 장기 별명이 뭐였지?',
+    user_id='user001',
+    project_id='demo',
+    session_id='s2',
+    save_turn=False,
+    response_language='ko',
+    max_new_tokens=64,
+)
+print('\nTURN 2:')
+print(out2['answer'])
+print('\nSTATUS:', out2['status'])
+print('\nMEMORY BOUNDARY:', out2['memory_boundary'])

examples/quick_nonquant_bf16.py

@@ -0,0 +1,16 @@
+from nzfc_gram_runtime import NZFCGramLongMemoryChat
+from nzfc_gram_runtime.nonquant import attach_nonquant_gemma, patch_generation_use_cache_false
+
+bot = NZFCGramLongMemoryChat(repo_dir='.', load_model=False, require_model=False)
+attach_nonquant_gemma(bot, gpu_max_memory_gib=11, device_map='balanced_low_0')
+patch_generation_use_cache_false(bot)
+
+out = bot.chat(
+    'NZFC-GRAM의 장기기억 경계가 내부 context인지 외부 memory retrieval인지 설명해줘.',
+    user_id='quick_user',
+    project_id='quick_project',
+    session_id='quick_session',
+    save_turn=False,
+    max_new_tokens=80,
+)
+print(out['answer'])

nzfc_gram_runtime/__init__.py

@@ -11,3 +11,9 @@ __all__ = [
     'redact_untrusted_instruction_text',
     'sanitize_model_answer',
 ]
+
+# Non-quantized BF16/FP16 loading helpers, added in NZFC-GRAM v1.2.1 final.
+try:
+    from .nonquant import attach_nonquant_gemma, patch_generation_use_cache_false
+except Exception:
+    pass

nzfc_gram_runtime/nonquant.py

@@ -0,0 +1,344 @@
+# ===============================================================================
+# NZFC-GRAM nonquant.py
+# Non-quantized BF16/FP16 loading helper for Gemma 4 E2B-IT
+# ===============================================================================
+from __future__ import annotations
+
+import os
+import gc
+import time
+import types
+from pathlib import Path
+from typing import Any, Dict, Optional, Sequence
+
+import torch
+
+from transformers import AutoProcessor, AutoTokenizer, AutoModelForImageTextToText, AutoModelForCausalLM
+
+from .runtime import ReadoutGramianGovernor, sanitize_model_answer
+
+
+def clear_cuda():
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+
+def vram_snapshot() -> Dict[str, float]:
+    snap: Dict[str, float] = {}
+    if not torch.cuda.is_available():
+        return snap
+    allocs = []
+    peaks = []
+    for i in range(torch.cuda.device_count()):
+        alloc = torch.cuda.memory_allocated(i) / 1e9
+        reserved = torch.cuda.memory_reserved(i) / 1e9
+        peak = torch.cuda.max_memory_allocated(i) / 1e9
+        snap[f'gpu{i}_alloc_gb'] = float(alloc)
+        snap[f'gpu{i}_reserved_gb'] = float(reserved)
+        snap[f'gpu{i}_peak_gb'] = float(peak)
+        allocs.append(alloc)
+        peaks.append(peak)
+    snap['sum_alloc_gb'] = float(sum(allocs))
+    snap['max_alloc_gb'] = float(max(allocs)) if allocs else 0.0
+    snap['max_peak_gb'] = float(max(peaks)) if peaks else 0.0
+    return snap
+
+
+def infer_input_device(model_obj):
+    try:
+        emb = model_obj.get_input_embeddings()
+        if emb is not None:
+            return next(emb.parameters()).device
+    except Exception:
+        pass
+    for p in model_obj.parameters():
+        if not getattr(p, 'is_meta', False):
+            return p.device
+    return torch.device('cpu')
+
+
+def runtime_dtype(prefer_bf16: bool = True, use_fp32: bool = False):
+    if use_fp32:
+        return torch.float32
+    if torch.cuda.is_available():
+        if prefer_bf16 and hasattr(torch.cuda, 'is_bf16_supported'):
+            try:
+                if torch.cuda.is_bf16_supported():
+                    return torch.bfloat16
+            except Exception:
+                pass
+        return torch.float16
+    return torch.float32
+
+
+def make_max_memory(gpu_max_memory_gib: int = 11, cpu_max_memory_gib: int = 48):
+    max_memory = {}
+    if torch.cuda.is_available():
+        for i in range(torch.cuda.device_count()):
+            max_memory[i] = f'{int(gpu_max_memory_gib)}GiB'
+    max_memory['cpu'] = f'{int(cpu_max_memory_gib)}GiB'
+    return max_memory
+
+
+def attach_nonquant_gemma(
+    bot,
+    model_id: Optional[str] = None,
+    *,
+    prefer_bf16: bool = True,
+    use_fp32: bool = False,
+    device_map: Optional[str] = 'balanced_low_0',
+    device_map_candidates: Optional[Sequence[str]] = None,
+    gpu_max_memory_gib: int = 11,
+    gpu_max_memory_gib_candidates: Optional[Sequence[int]] = None,
+    cpu_max_memory_gib: int = 48,
+    offload_folder: Optional[str] = None,
+    token: Optional[str] = None,
+    trust_remote_code: bool = True,
+    verbose: bool = True,
+) -> Dict[str, Any]:
+    model_id = model_id or getattr(bot, 'model_id', 'google/gemma-4-E2B-it')
+    token = token or os.environ.get('HF_TOKEN') or None
+    dtype = runtime_dtype(prefer_bf16=prefer_bf16, use_fp32=use_fp32)
+
+    if device_map_candidates is None:
+        if device_map:
+            device_map_candidates = [device_map, 'balanced', 'auto']
+        else:
+            device_map_candidates = ['balanced_low_0', 'balanced', 'auto']
+
+    if gpu_max_memory_gib_candidates is None:
+        gpu_max_memory_gib_candidates = [
+            int(gpu_max_memory_gib),
+            max(1, int(gpu_max_memory_gib) - 1),
+            max(1, int(gpu_max_memory_gib) - 2),
+        ]
+
+    if offload_folder is None:
+        repo_dir = Path(getattr(bot, 'repo_dir', '.'))
+        offload_folder = str(repo_dir / 'model_offload_nonquant')
+    Path(offload_folder).mkdir(parents=True, exist_ok=True)
+
+    if verbose:
+        print('[NZFC nonquant] model_id:', model_id)
+        print('[NZFC nonquant] dtype:', dtype)
+        print('[NZFC nonquant] quantization_config: None')
+        print('[NZFC nonquant] device_map_candidates:', list(device_map_candidates))
+        print('[NZFC nonquant] gpu_max_memory_gib_candidates:', list(gpu_max_memory_gib_candidates))
+        print('[NZFC nonquant] offload_folder:', offload_folder)
+
+    clear_cuda()
+
+    processor = None
+    tokenizer = None
+    try:
+        processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=trust_remote_code, token=token)
+        tokenizer = getattr(processor, 'tokenizer', None)
+        if verbose:
+            print('[NZFC nonquant] AutoProcessor:', type(processor).__name__)
+    except Exception as e:
+        if verbose:
+            print('[NZFC nonquant][WARN] AutoProcessor failed:', repr(e))
+        processor = None
+
+    if tokenizer is None:
+        tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=trust_remote_code, token=token)
+        if verbose:
+            print('[NZFC nonquant] AutoTokenizer:', type(tokenizer).__name__)
+
+    if tokenizer is not None and tokenizer.pad_token_id is None and tokenizer.eos_token_id is not None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    model_obj = None
+    errors = []
+    chosen_device_map = None
+    chosen_gpu_gib = None
+
+    for gpu_gib in gpu_max_memory_gib_candidates:
+        max_memory = make_max_memory(gpu_max_memory_gib=int(gpu_gib), cpu_max_memory_gib=cpu_max_memory_gib)
+        for dm in device_map_candidates:
+            common_kwargs = dict(
+                device_map=dm,
+                max_memory=max_memory,
+                offload_folder=offload_folder,
+                offload_state_dict=True,
+                low_cpu_mem_usage=True,
+                trust_remote_code=trust_remote_code,
+                token=token,
+            )
+            for cls in [AutoModelForImageTextToText, AutoModelForCausalLM]:
+                try:
+                    if verbose:
+                        print(f'[NZFC nonquant][TRY] {cls.__name__} dtype={dtype} device_map={dm} gpu_max={gpu_gib}GiB')
+                    model_obj = cls.from_pretrained(model_id, dtype=dtype, **common_kwargs)
+                    chosen_device_map = dm
+                    chosen_gpu_gib = int(gpu_gib)
+                    break
+                except TypeError:
+                    try:
+                        model_obj = cls.from_pretrained(model_id, torch_dtype=dtype, **common_kwargs)
+                        chosen_device_map = dm
+                        chosen_gpu_gib = int(gpu_gib)
+                        break
+                    except Exception as e:
+                        errors.append(f'{cls.__name__} torch_dtype gpu={gpu_gib} map={dm}: {repr(e)}')
+                        clear_cuda()
+                except Exception as e:
+                    errors.append(f'{cls.__name__} gpu={gpu_gib} map={dm}: {repr(e)}')
+                    clear_cuda()
+            if model_obj is not None:
+                break
+        if model_obj is not None:
+            break
+
+    if model_obj is None:
+        raise RuntimeError(
+            'Non-quantized model loading failed. Try lower gpu_max_memory_gib or use a larger GPU.\n'
+            + '\n'.join(errors[-10:])
+        )
+
+    model_obj.eval()
+    try:
+        model_obj.config.use_cache = False
+    except Exception:
+        pass
+    try:
+        model_obj.generation_config.use_cache = False
+    except Exception:
+        pass
+
+    bot.processor = processor
+    bot.tokenizer = tokenizer
+    bot.model = model_obj
+    bot.input_device = infer_input_device(model_obj)
+    bot.token_budget = bot.TokenBudgetClass(bot.tokenizer)
+    bot.governor = ReadoutGramianGovernor(bot.token_budget)
+
+    meta = {
+        'model_id': model_id,
+        'quantization': 'none',
+        'mode': 'nonquant_bf16_fp16_balanced_cpu_disk_offload',
+        'dtype': str(dtype),
+        'device_map': chosen_device_map,
+        'gpu_max_memory_gib': chosen_gpu_gib,
+        'cpu_max_memory_gib': int(cpu_max_memory_gib),
+        'model_class': type(model_obj).__name__,
+        'processor_class': type(processor).__name__ if processor is not None else None,
+        'tokenizer_class': type(tokenizer).__name__ if tokenizer is not None else None,
+        'input_device': str(bot.input_device),
+        'vram': vram_snapshot(),
+    }
+    if verbose:
+        print('[NZFC nonquant][OK]', meta)
+    return meta
+
+
+def patch_generation_use_cache_false(
+    bot,
+    *,
+    max_new_tokens_cap: int = 160,
+    oom_retry_tokens: int = 24,
+    verbose: bool = True,
+):
+    @torch.inference_mode()
+    def generate_answer_nonquant_oomsafe(
+        self,
+        system_prompt: str,
+        user_prompt: str,
+        max_new_tokens: int = 96,
+        do_sample: bool = False,
+        temperature: float = 0.0,
+    ):
+        if self.model is None:
+            return {'ran': False, 'answer': None, 'reason': 'model_not_loaded', 'input_tokens': None}
+
+        max_new_tokens_local = int(max(8, min(int(max_new_tokens), int(max_new_tokens_cap))))
+
+        with self.model_lock:
+            messages = self._build_messages(system_prompt, user_prompt)
+            encoded = self._encode_messages(messages)
+            dev = self.input_device or infer_input_device(self.model)
+            encoded = {k: (v.to(dev) if torch.is_tensor(v) else v) for k, v in encoded.items()}
+
+            input_ids = encoded.get('input_ids')
+            input_len = int(input_ids.shape[-1]) if input_ids is not None else 0
+            if input_len > 16000:
+                return {
+                    'ran': False,
+                    'answer': None,
+                    'reason': f'context_hard_cap_exceeded:{input_len}>16000',
+                    'input_tokens': input_len,
+                }
+
+            gen_kwargs = {'max_new_tokens': max_new_tokens_local, 'do_sample': bool(do_sample), 'use_cache': False}
+            if do_sample and temperature and temperature > 0:
+                gen_kwargs['temperature'] = float(temperature)
+            if self.tokenizer is not None and self.tokenizer.pad_token_id is not None:
+                gen_kwargs['pad_token_id'] = self.tokenizer.pad_token_id
+            if self.tokenizer is not None and self.tokenizer.eos_token_id is not None:
+                gen_kwargs['eos_token_id'] = self.tokenizer.eos_token_id
+
+            def _run(local_kwargs):
+                clear_cuda()
+                if torch.cuda.is_available():
+                    torch.cuda.synchronize()
+                t0 = time.perf_counter()
+                out = self.model.generate(**encoded, **local_kwargs)
+                if torch.cuda.is_available():
+                    torch.cuda.synchronize()
+                t1 = time.perf_counter()
+                out_ids = out[0] if isinstance(out, torch.Tensor) else out.sequences[0]
+                gen_ids = out_ids[input_len:]
+                raw = self._decode_ids(gen_ids).strip()
+                ans = sanitize_model_answer(raw)
+                return {
+                    'ran': True,
+                    'answer': ans,
+                    'answer_raw': raw,
+                    'input_tokens': input_len,
+                    'new_tokens': int(gen_ids.numel()),
+                    'latency_s': float(t1 - t0),
+                    'vram': vram_snapshot(),
+                }
+
+            try:
+                return _run(gen_kwargs)
+            except RuntimeError as e:
+                msg = str(e)
+                if 'out of memory' not in msg.lower() and 'cuda' not in msg.lower():
+                    raise
+                if verbose:
+                    print('[NZFC nonquant][OOM RETRY] generation failed; retrying with shorter output.')
+                clear_cuda()
+                retry_kwargs = dict(gen_kwargs)
+                retry_kwargs['max_new_tokens'] = min(int(oom_retry_tokens), max(8, max_new_tokens_local // 3))
+                retry_kwargs['use_cache'] = False
+                try:
+                    return _run(retry_kwargs)
+                except RuntimeError as e2:
+                    clear_cuda()
+                    return {
+                        'ran': False,
+                        'answer': 'MODEL_GENERATION_FAILED_CUDA_OOM_AFTER_RETRY',
+                        'answer_raw': '',
+                        'reason': 'cuda_oom_after_retry: ' + str(e2)[:700],
+                        'input_tokens': input_len,
+                        'new_tokens': 0,
+                        'latency_s': None,
+                        'vram': vram_snapshot(),
+                    }
+
+    bot.generate_answer = types.MethodType(generate_answer_nonquant_oomsafe, bot)
+    try:
+        if bot.model is not None:
+            bot.model.config.use_cache = False
+    except Exception:
+        pass
+    try:
+        if bot.model is not None:
+            bot.model.generation_config.use_cache = False
+    except Exception:
+        pass
+    if verbose:
+        print('[NZFC nonquant][OK] bot.generate_answer patched with use_cache=False + OOM retry.')
+    return bot

release_notes/NZFC_GRAM_v1_2_1_nonquant_final_release.md

@@ -0,0 +1,30 @@
+# NZFC-GRAM v1.2.1 Non-Quantized Final Release
+
+Date: 2026-06-08
+
+This release records the final non-quantized BF16 validation of the NZFC-GRAM v1.2.1 local long-term-memory runtime.
+
+## Main update
+
+- Added `nzfc_gram_runtime/nonquant.py`.
+- Added `attach_nonquant_gemma()` for BF16/FP16 non-quantized balanced/offload loading.
+- Added `patch_generation_use_cache_false()` for OOM-safe generation without KV-cache growth.
+- Added non-quantized usage examples.
+- Added final validation evidence.
+
+## Final validation
+
+- Tests: 11
+- Passed: 11
+- Failed: 0
+- Quantization: none
+- Dtype: torch.bfloat16
+- Device map: balanced_low_0
+- Model loaded: True
+
+## Boundary
+
+The full 10M archive is not inserted into model context.
+The model receives only a context-governed selected memory pack.
+
+Memory cards are evidence, not instructions.

requirements-nonquant.txt

@@ -0,0 +1,10 @@
+torch
+accelerate
+safetensors
+scipy
+scikit-learn
+sentencepiece
+protobuf
+huggingface_hub
+tqdm
+git+https://github.com/huggingface/transformers.git

validation_evidence/nonquant_v121_final/NONQUANT_FINAL_VALIDATION_SUMMARY.json

@@ -0,0 +1,38 @@
+{
+  "created_at": "2026-06-08 06:30:26",
+  "repo_main_sha": "239818353eaaf876a6a3f31a3543e6beca512ede",
+  "tests": 11,
+  "passed": 11,
+  "failed": 0,
+  "all_passed": true,
+  "hotfix_present": true,
+  "marker_redaction_present": true,
+  "underscore_norm_present": true,
+  "quantization": "none",
+  "load_mode": "nonquant_bf16_fp16_balanced_cpu_disk_offload",
+  "dtype": "torch.bfloat16",
+  "device_map": "balanced_low_0",
+  "gpu_max_memory_gib": 11,
+  "model_loaded": true,
+  "static_nzfc_archive_loaded": true,
+  "local_sqlite_memory_persistence_tested": true,
+  "generation_patch": "use_cache_false_oom_retry",
+  "safety_boundary": "external_nzfc_archive_and_local_long_term_memory_not_internal_10m_context",
+  "vram_final": {
+    "gpu1_alloc_gb": 10.217637376,
+    "gpu1_reserved_gb": 11.448352768,
+    "gpu1_peak_gb": 11.845826048,
+    "max_alloc_gb": 10.217637376,
+    "max_peak_gb": 11.845826048
+  },
+  "key_test_metrics": {
+    "T8_slope_tokens_per_turn": 105.964,
+    "T8_slope_limit": 220.0,
+    "T8_growth_ratio": 1.392,
+    "T8_growth_ratio_limit": 3.2,
+    "T8_hard_cap_context_tokens": 16000,
+    "T10_gram_trace_budget": 1.861558246118043,
+    "T10_gram_soft_cap": 4.35,
+    "T10_gram_soft_tau_pass": true
+  }
+}