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}