@trac3er/oh-my-god 2.2.2 → 2.3.0

package/registry/bundles/data-lineage.yaml

@@ -1,6 +1,6 @@
 id: data-lineage
 kind: provenance
-version: 2.2.2
+version: 2.3.0
 title: OMG Data Lineage
 description: Provenance and privacy tracking for traces, fixtures, examples, and synthetic artifacts.
 hosts:

package/registry/bundles/delta-classifier.yaml

@@ -1,6 +1,6 @@
 id: delta-classifier
 kind: routing
-version: 2.2.2
+version: 2.3.0
 title: OMG Delta Classifier
 description: Change classifier that attaches risk-aware checks, approvals, and packs.
 hosts:

package/registry/bundles/eval-gate.yaml

@@ -1,6 +1,6 @@
 id: eval-gate
 kind: evaluation
-version: 2.2.2
+version: 2.3.0
 title: OMG Eval Gate
 description: Reproducible evaluation gate that blocks regressions before release.
 hosts:

package/registry/bundles/hash-edit.yaml

@@ -1,6 +1,6 @@
 id: hash-edit
 kind: governance
-version: 2.2.2
+version: 2.3.0
 title: OMG Hash Edit Lane
 description: Governed hash-bound edit lane with signed approvals and evidence routing.
 hosts:

package/registry/bundles/health.yaml

@@ -1,6 +1,6 @@
 id: health
 kind: domain-pack
-version: 2.2.2
+version: 2.3.0
 title: OMG Health Pack
 description: Health-sensitive approvals, provenance, and replay attachments.
 hosts:

package/registry/bundles/hook-governor.yaml

@@ -1,6 +1,6 @@
 id: hook-governor
 kind: governance
-version: 2.2.2
+version: 2.3.0
 title: OMG Hook Governor
 description: Canonical hook ordering, policy reinjection, and protected-path governance.
 hosts:

package/registry/bundles/incident-replay.yaml

@@ -1,6 +1,6 @@
 id: incident-replay
 kind: debugging
-version: 2.2.2
+version: 2.3.0
 title: OMG Incident Replay
 description: Replayable bug packs built from logs, failing tests, traces, and diffs.
 hosts:

package/registry/bundles/lsp-pack.yaml

@@ -1,6 +1,6 @@
 id: lsp-pack
 kind: diagnostics
-version: 2.2.2
+version: 2.3.0
 title: OMG LSP Pack
 description: Optional LSP-backed diagnostics and navigation bundle for production verification.
 hosts:

package/registry/bundles/mcp-fabric.yaml

@@ -1,6 +1,6 @@
 id: mcp-fabric
 kind: mcp
-version: 2.2.2
+version: 2.3.0
 title: OMG MCP Fabric
 description: Tools, prompts, resources, and server instructions for the OMG control plane.
 hosts:

package/registry/bundles/plan-council.yaml

@@ -1,6 +1,6 @@
 id: plan-council
 kind: planning
-version: 2.2.2
+version: 2.3.0
 title: OMG Plan Council
 description: Canonical council-style planning bundle for explicit, evidence-backed deep plans.
 hosts:

package/registry/bundles/preflight.yaml

@@ -1,6 +1,6 @@
 id: preflight
 kind: routing
-version: 2.2.2
+version: 2.3.0
 title: OMG Preflight
 description: Repo-aware route selection based on diff, manifests, and classified risk.
 hosts:

package/registry/bundles/proof-gate.yaml

@@ -1,6 +1,6 @@
 id: proof-gate
 kind: proof
-version: 2.2.2
+version: 2.3.0
 title: OMG Proof Gate
 description: Structured release proof gate that binds claims to required evidence artifacts and trace links.
 hosts:

package/registry/bundles/remote-supervisor.yaml

@@ -1,6 +1,6 @@
 id: remote-supervisor
 kind: orchestration
-version: 2.2.2
+version: 2.3.0
 title: OMG Remote Supervisor
 description: Local-only authenticated supervisor sessions for worker orchestration.
 hosts:

package/registry/bundles/robotics.yaml

@@ -1,6 +1,6 @@
 id: robotics
 kind: domain-pack
-version: 2.2.2
+version: 2.3.0
 title: OMG Robotics Pack
 description: Robotics safety policy, replay, and evaluation attachments.
 hosts:

package/registry/bundles/secure-worktree-pipeline.yaml

@@ -1,6 +1,6 @@
 id: secure-worktree-pipeline
 kind: runtime
-version: 2.2.2
+version: 2.3.0
 title: OMG Secure Worktree Pipeline
 description: Ephemeral worktree execution and supervisor-safe worker dispatch for production jobs.
 hosts:

package/registry/bundles/security-check.yaml

@@ -1,6 +1,6 @@
 id: security-check
 kind: security
-version: 2.2.2
+version: 2.3.0
 title: OMG Security Check
 description: Canonical security audit bundle with provenance, trust scoring, and deterministic evidence.
 hosts:

package/registry/bundles/terminal-lane.yaml

@@ -1,6 +1,6 @@
 id: terminal-lane
 kind: governance
-version: 2.2.2
+version: 2.3.0
 title: OMG Terminal Lane
 description: Highest-risk governed terminal execution lane with strict approval and attestation.
 hosts:

package/registry/bundles/test-intent-lock.yaml

@@ -1,6 +1,6 @@
 id: test-intent-lock
 kind: proof
-version: 2.2.2
+version: 2.3.0
 title: OMG Test Intent Lock
 description: Structured test-delta guard that blocks weakened tests unless explicit override evidence is present.
 hosts:

package/registry/bundles/tracebank.yaml

@@ -1,6 +1,6 @@
 id: tracebank
 kind: evidence
-version: 2.2.2
+version: 2.3.0
 title: OMG Tracebank
 description: Structured plan-to-patch-to-verify trace capture for OMG routes.
 hosts:

package/registry/bundles/vision.yaml

@@ -1,6 +1,6 @@
 id: vision
 kind: domain-pack
-version: 2.2.2
+version: 2.3.0
 title: OMG Vision Pack
 description: Vision-specific OCR, comparison, lineage, drift, and replay attachments.
 hosts:

package/registry/omg-capability.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://github.com/trac3er00/OMG/registry/omg-capability.schema.json",
   "title": "OMG Capability Bundle",
-  "version": "2.2.2",
+  "version": "2.3.0",
   "type": "object",
   "required": [
     "id",

package/runtime/adoption.py

@@ -13,12 +13,12 @@ CANONICAL_REPO_URL = "https://github.com/trac3er00/OMG"
 CANONICAL_PACKAGE_NAME = "@trac3er/oh-my-god"
 CANONICAL_PLUGIN_ID = "omg"
 CANONICAL_MARKETPLACE_ID = "omg"
-CANONICAL_VERSION = "2.2.2"
+CANONICAL_VERSION = "2.3.0"
 
 VALID_ADOPTION_MODES = ("omg-only", "coexist")
 CANONICAL_MODE_NAMES = ("chill", "focused", "exploratory")
 
-PRESET_ORDER: tuple[str, ...] = ("safe", "balanced", "interop", "labs", "buffet")
+PRESET_ORDER: tuple[str, ...] = ("safe", "balanced", "interop", "labs", "buffet", "production")
 VALID_PRESETS = PRESET_ORDER
 PRESET_LEVEL: dict[str, int] = {p: i for i, p in enumerate(PRESET_ORDER)}
 
@@ -96,6 +96,7 @@ PRESET_FEATURES: dict[str, dict[str, bool]] = {
         **{f: False for f in _BUFFET_ONLY_FLAGS},
     },
     "buffet": {flag: True for flag in MANAGED_PRESET_FLAGS},
+    "production": {flag: True for flag in MANAGED_PRESET_FLAGS},
 }
 
 _SUPERPOWERS_SENTINELS = (

package/runtime/background_verification.py

@@ -73,7 +73,9 @@ def should_skip_validation(evidence_profile: str | None, stage: str) -> bool:
 
     Rules:
     - ``release`` and ``security-audit`` profiles NEVER skip any stage.
-    - ``None``, empty, or unknown profiles fall back to FULL_REQUIREMENTS (no skip).
+    - ``None`` or empty profiles use FULL_REQUIREMENTS (no skip).
+    - Unknown profiles fail closed (no skip) — the error is surfaced by
+      :func:`resolve_evidence_profile` instead.
     - For other profiles, a stage is skipped when it is NOT in that profile's
       requirement list.
     """
@@ -85,10 +87,50 @@ def should_skip_validation(evidence_profile: str | None, stage: str) -> bool:
     if profile in _NEVER_SKIP_PROFILES:
         return False
 
-    required = requirements_for_profile(profile if profile else None)
+    try:
+        required = requirements_for_profile(profile if profile else None)
+    except ValueError:
+        # Unknown profile: fail closed — don't skip any validation
+        return False
     return stage not in required
 
 
+def resolve_evidence_profile(evidence_profile: str | None) -> dict[str, Any]:
+    """Resolve an evidence profile with strict validation.
+
+    Returns a structured dict:
+    - Success: ``{"status": "ok", "profile": <canonical>, "requirements": [...]}``
+    - Failure: ``{"status": "error", "reason": "unknown_profile", "profile": <raw>}``
+    """
+    from runtime.evidence_requirements import (
+        FULL_REQUIREMENTS,
+        resolve_profile,
+        requirements_for_profile,
+    )
+
+    raw = (evidence_profile or "").strip()
+    if not raw:
+        return {
+            "status": "ok",
+            "profile": None,
+            "requirements": list(FULL_REQUIREMENTS),
+        }
+
+    try:
+        canonical = resolve_profile(raw)
+        return {
+            "status": "ok",
+            "profile": canonical,
+            "requirements": requirements_for_profile(raw),
+        }
+    except ValueError:
+        return {
+            "status": "error",
+            "reason": "unknown_profile",
+            "profile": raw,
+        }
+
+
 def skipped_stages_for_profile(evidence_profile: str | None) -> list[str]:
     """Return the list of stages that WOULD be skipped for a given profile.
 

package/runtime/canonical_surface.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Final
 
-from runtime.evidence_requirements import EVIDENCE_REQUIREMENTS_BY_PROFILE
+from runtime.evidence_requirements import EVIDENCE_REQUIREMENTS_BY_PROFILE, normalize_profile
 
 CANONICAL_PARITY_HOSTS: Final[list[str]] = ["claude", "codex", "gemini", "kimi"]
 COMPATIBILITY_ONLY_HOSTS: Final[list[str]] = ["opencode"]
@@ -13,8 +13,9 @@ DOMAIN_DEFAULTS: Final[dict[str, tuple[str, ...]]] = {
 }
 
 def _release_evidence_profile_labels() -> dict[str, str]:
+    """Generate release labels synchronized with the normalized profile registry."""
     return {
-        profile.replace("-", "_"): profile
+        normalize_profile(profile).replace("-", "_"): profile
         for profile in EVIDENCE_REQUIREMENTS_BY_PROFILE
     }
 

package/runtime/claim_judge.py

@@ -9,7 +9,7 @@ from registry.verify_artifact import verify_artifact_statement
 from runtime import artifact_parsers
 from runtime.context_engine import load_profile_digest
 from runtime.evidence_query import get_evidence_pack
-from runtime.evidence_requirements import FULL_REQUIREMENTS, requirements_for_profile
+from runtime.evidence_requirements import FULL_REQUIREMENTS, normalize_profile, resolve_profile, requirements_for_profile
 
 
 def judge_claims(project_dir: str, claims: list[dict[str, Any]]) -> dict[str, Any]:
@@ -133,13 +133,16 @@ def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
     excluded_failures = _as_non_empty_list(normalized_claim.get("excluded_failures"))
     excluded_failures_waiver_path = str(normalized_claim.get("excluded_failures_waiver_path", "")).strip()
     evidence_profile = str(normalized_claim.get("evidence_profile", "")).strip()
-    evidence_requirements = requirements_for_profile(evidence_profile)
+    evidence_requirements, evidence_profile_error = _resolve_evidence_requirements(evidence_profile)
     requirement_set = {str(item).strip() for item in evidence_requirements if str(item).strip()}
     causal_chain = _as_dict(normalized_claim.get("causal_chain"))
 
     reasons: list[dict[str, Any]] = []
     advisories: list[str] = []
 
+    if evidence_profile_error:
+        reasons.append(evidence_profile_error)
+
     if "tests" in requirement_set and not artifacts:
         reasons.append(
             {
@@ -300,10 +303,41 @@ def _normalize_claim(claim: dict[str, Any]) -> dict[str, Any]:
         "excluded_failures": excluded_failures,
         "excluded_failures_waiver_path": excluded_failures_waiver_path,
         "causal_chain": causal_chain,
-        "evidence_profile": str(claim.get("evidence_profile", evidence.get("evidence_profile", ""))).strip(),
+        "evidence_profile": normalize_profile(str(claim.get("evidence_profile", evidence.get("evidence_profile", ""))).strip()),
     }
 
 
+def _resolve_evidence_requirements(evidence_profile: str) -> tuple[list[str], dict[str, Any] | None]:
+    raw_profile = str(evidence_profile or "").strip()
+    normalized = normalize_profile(raw_profile) if raw_profile else ""
+
+    try:
+        canonical = resolve_profile(normalized or None)
+        return requirements_for_profile(canonical), None
+    except ValueError as exc:
+        payload = _parse_profile_error(exc)
+        reason = {
+            "code": "unknown_evidence_profile",
+            "message": str(payload.get("reason", "unknown_profile")),
+            "field": "evidence_profile",
+            "profile": str(payload.get("profile", raw_profile)).strip(),
+        }
+        return list(FULL_REQUIREMENTS), reason
+
+
+def _parse_profile_error(exc: ValueError) -> dict[str, Any]:
+    raw = str(exc).strip()
+    if not raw:
+        return {}
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError:
+        return {}
+    if isinstance(payload, dict):
+        return payload
+    return {}
+
+
 def _validate_excluded_failures_policy(
     *,
     project_dir: str,

package/runtime/compliance_governor.py

@@ -7,6 +7,8 @@ from typing import Any
 from registry.approval_artifact import load_approval_artifact_from_path, verify_approval_artifact
 from registry.verify_artifact import verify_artifact, verify_tool_attestation
 from runtime.claim_judge import evaluate_claims_for_release
+from runtime.proof_gate import production_gate as evaluate_production_gate
+from runtime.proof_gate import required_production_primitives
 from runtime.runtime_contracts import read_run_state
 
 
@@ -34,7 +36,7 @@ _EXTERNAL_BASH_PATTERNS = (
     re.compile(r"\bgit\s+(clone|fetch|pull)\b"),
 )
 _MUTATION_BASH_PATTERNS = (
-    r"\b(git\s+(add|commit|push|rebase|cherry-pick|merge|tag))\b",
+    r"\b(git\s+(add|commit|push|rebase|cherry-pick|merge|tag(?!\s+(-l|--list)\b)))\b",
     r"\b(rm|mv|cp|tee|touch|mkdir|rmdir|ln)\b",
     r"\b(sed\s+-i|perl\s+-pi)\b",
     r"\b(chmod|chown)\b",
@@ -153,6 +155,30 @@ def evaluate_release_compliance(
                 "reason": str(claim_decision.get("reason", "claim_judge_verdict=unknown")),
                 "claim_judge_verdict": str(claim_decision.get("claim_judge_verdict", "")),
             }
+    else:
+        claim_decision = release_evidence.get("claim_judge") if isinstance(release_evidence.get("claim_judge"), dict) else {
+            "status": "blocked",
+            "claim_judge_verdict": "missing",
+            "reason": "claim_judge_missing_claims",
+        }
+
+    release_gate = production_gate(
+        {
+            **release_evidence,
+            "claim_judge": claim_decision,
+        }
+    )
+    if release_gate.get("status") == "blocked":
+        blockers = release_gate.get("blockers")
+        blocker_list = blockers if isinstance(blockers, list) else []
+        return {
+            "status": "blocked",
+            "authority": "production_gate",
+            "reason": "production_gate_blocked",
+            "blockers": blocker_list,
+            "required_primitives": list(required_production_primitives()),
+            **artifact_audit,
+        }
 
     return {
         "status": "allowed",
@@ -162,6 +188,35 @@ def evaluate_release_compliance(
     }
 
 
+def production_gate(evidence: dict[str, Any]) -> dict[str, Any]:
+    payload = evidence if isinstance(evidence, dict) else {}
+    try:
+        gate_result = evaluate_production_gate(payload)
+    except Exception:
+        return {
+            "status": "blocked",
+            "blockers": ["production_gate_internal_error"],
+            "required_primitives": list(required_production_primitives()),
+        }
+
+    status = str(gate_result.get("status", "")).strip().lower()
+    blockers = gate_result.get("blockers")
+    blocker_list = blockers if isinstance(blockers, list) else []
+    if status != "ok":
+        if not blocker_list:
+            blocker_list = ["production_gate_unknown_blocker"]
+        return {
+            "status": "blocked",
+            "blockers": blocker_list,
+            "required_primitives": list(required_production_primitives()),
+        }
+
+    return {
+        "status": "ok",
+        "required_primitives": list(required_production_primitives()),
+    }
+
+
 def evaluate_governed_tool_request(
     *,
     project_dir: str,
@@ -375,8 +430,34 @@ def _is_mutation_capable_bash(command: str) -> bool:
     for pattern in _MUTATION_BASH_PATTERNS:
         if re.search(pattern, lowered):
             return True
+    # File-write redirection: only classify as mutation if the command itself
+    # is NOT a known read-only program.  `python3 script.py > out.json` is a
+    # read-only computation that merely saves output; the actual mutation
+    # patterns (git commit, rm, mv, etc.) are already caught above.
     if _FILE_WRITE_REDIRECTION_PATTERN.search(lowered):
-        return True
+        if not _is_read_only_program_with_redirect(normalized_command):
+            return True
+    return False
+
+
+def _is_read_only_program_with_redirect(command: str) -> bool:
+    """Return True when the command before any > redirect is a read-only program."""
+    cmd_portion = re.split(r"(?<!\d)\s*>>?\s+\S+", command)[0].strip()
+    if not cmd_portion:
+        return False
+    lowered = cmd_portion.lower()
+    _read_only_prefixes = (
+        "python", "python3", "node", "ruby", "perl",
+        "jq", "yq",
+        "git log", "git diff", "git status", "git show", "git branch",
+        "gh pr", "gh run", "gh api",
+        "ls", "find", "grep", "rg", "ag", "wc", "sort", "uniq",
+        "head", "tail", "less", "more", "file", "stat", "du", "df",
+        "env", "printenv", "uname", "whoami", "hostname", "date",
+    )
+    for prefix in _read_only_prefixes:
+        if lowered.startswith(prefix):
+            return True
     return False
 
 

package/runtime/context_compiler.py

@@ -0,0 +1,131 @@
+"""Bounded context packet compiler.
+
+Reads the live context_engine_packet.json and emits provenance-only, bounded
+summaries for each canonical host.  Raw transcript and session bodies are never
+written to compiled output.
+"""
+from __future__ import annotations
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+_PACKET_REL_PATH = Path(".omg") / "state" / "context_engine_packet.json"
+_ALLOWED_PACKET_KEYS = frozenset({
+    "packet_version", "summary", "artifact_pointers", "provenance_pointers",
+    "artifact_handles", "clarification_status", "ambiguity_state",
+    "provenance_only", "governance", "release_metadata", "coordinator_run_id",
+    "profile_digest", "budget", "delta_only", "run_id",
+    "deterministic_contract",
+})
+
+
+def _resolve_root(root_dir) -> Path:
+    return Path(root_dir).resolve() if root_dir else Path.cwd()
+
+
+def _resolve_output_root(root: Path, output_root) -> Path:
+    if output_root:
+        out = Path(output_root).resolve()
+        out.mkdir(parents=True, exist_ok=True)
+        return out
+    return root
+
+
+def _load_packet(root: Path) -> dict[str, Any]:
+    packet_path = root / _PACKET_REL_PATH
+    if packet_path.exists():
+        try:
+            raw = json.loads(packet_path.read_text(encoding="utf-8"))
+            if isinstance(raw, dict):
+                return {k: v for k, v in raw.items() if k in _ALLOWED_PACKET_KEYS}
+        except Exception:
+            pass
+    return {
+        "packet_version": "1.0",
+        "summary": "no active context signals",
+        "artifact_pointers": [],
+        "provenance_pointers": [],
+        "artifact_handles": [],
+        "provenance_only": True,
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+    }
+
+
+def _write_json(path: Path, data: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+
+
+def compile_context_packets(
+    *,
+    root_dir=None,
+    output_root=None,
+    hosts=None,
+) -> dict[str, Any]:
+    root = _resolve_root(root_dir)
+    output = _resolve_output_root(root, output_root)
+    selected_hosts = list(hosts or ["claude", "codex", "gemini", "kimi"])
+    packet = _load_packet(root)
+    issued_at = datetime.now(timezone.utc).isoformat()
+
+    packet["context_compile_issued_at"] = issued_at
+    packet["hosts"] = selected_hosts
+
+    packet_path = output / _PACKET_REL_PATH
+    _write_json(packet_path, packet)
+    emitted: list[str] = [str(packet_path.relative_to(output))]
+
+    if "codex" in selected_hosts:
+        frag_src = root / ".agents" / "skills" / "omg" / "AGENTS.fragment.md"
+        frag_dst = output / ".agents" / "skills" / "omg" / "AGENTS.fragment.md"
+        frag_dst.parent.mkdir(parents=True, exist_ok=True)
+        if frag_src.exists():
+            frag_dst.write_bytes(frag_src.read_bytes())
+        else:
+            frag_dst.write_text("# OMG Codex Context\n\n_No context signals available._\n", encoding="utf-8")
+        emitted.append(str(frag_dst.relative_to(output)))
+
+    if "gemini" in selected_hosts:
+        gemini_src = root / ".gemini" / "settings.json"
+        gemini_dst = output / ".gemini" / "settings.json"
+        gemini_dst.parent.mkdir(parents=True, exist_ok=True)
+        if gemini_src.exists():
+            try:
+                gemini_data = json.loads(gemini_src.read_text(encoding="utf-8"))
+            except Exception:
+                gemini_data = {}
+        else:
+            gemini_data = {}
+        gemini_data.setdefault("_omg", {})["context_packet"] = {
+            "summary": packet.get("summary", ""),
+            "issued_at": issued_at,
+        }
+        _write_json(gemini_dst, gemini_data)
+        emitted.append(str(gemini_dst.relative_to(output)))
+
+    if "kimi" in selected_hosts:
+        kimi_src = root / ".kimi" / "mcp.json"
+        kimi_dst = output / ".kimi" / "mcp.json"
+        kimi_dst.parent.mkdir(parents=True, exist_ok=True)
+        if kimi_src.exists():
+            try:
+                kimi_data = json.loads(kimi_src.read_text(encoding="utf-8"))
+            except Exception:
+                kimi_data = {}
+        else:
+            kimi_data = {}
+        kimi_data.setdefault("_omg", {})["context_packet"] = {
+            "summary": packet.get("summary", ""),
+            "issued_at": issued_at,
+        }
+        _write_json(kimi_dst, kimi_data)
+        emitted.append(str(kimi_dst.relative_to(output)))
+
+    return {
+        "schema": "OmgContextCompileResult",
+        "status": "ok",
+        "hosts": selected_hosts,
+        "artifacts": emitted,
+        "packet": str(packet_path.relative_to(output)),
+    }

package/runtime/context_limits.py

@@ -320,15 +320,27 @@ def get_model_limits(model_id: str) -> ContextLimitEntry:
 
     # 1. Exact match
     if normalized in _REGISTRY:
-        return _REGISTRY[normalized]
+        return _clone_entry(_REGISTRY[normalized])
 
     # 2. Prefix match (longest prefix first via _PREFIX_TABLE ordering)
     for prefix, registry_key in _PREFIX_TABLE:
         if normalized.startswith(prefix.lower()):
-            return _REGISTRY[registry_key]
+            return _clone_entry(_REGISTRY[registry_key])
 
     # 3. Fallback
-    return _FALLBACK
+    return _clone_entry(_FALLBACK)
+
+
+def _clone_entry(entry: ContextLimitEntry) -> ContextLimitEntry:
+    return {
+        "context_tokens": int(entry["context_tokens"]),
+        "output_reserve_tokens": int(entry["output_reserve_tokens"]),
+        "class_label": str(entry["class_label"]),
+        "preflight_counting": bool(entry["preflight_counting"]),
+        "native_compaction": bool(entry["native_compaction"]),
+        "compaction_trigger_default": int(entry["compaction_trigger_default"]),
+        "notes": str(entry["notes"]),
+    }
 
 
 def is_1m_class(model_id: str) -> bool: