asked its context window, eli dumped a code map and then said the evidence did not specify it: n_ctx was 12192 and in the startup snapshot, but EXPLAIN_COGNITION_RUNTIME described the architecture and carried no inference parameters at all — and the router's diagnostic_focus=inference_runtime was ignored by both producers

Author: ShadowESC95

eli/execution/executor_enhanced.py

@@ -1688,7 +1688,20 @@ def _explain_cognition_runtime_report() -> Dict[str, Any]:
 def _format_cognition_runtime(report: Dict[str, Any]) -> str:
     if not report.get('ok'):
         return str(report.get('error') or 'Cognition runtime report failed')
-    lines = [
+    lines = []
+    # The live INFERENCE parameters go first. Asked "what is your current context
+    # window?", this report answered with module paths, grep line numbers and
+    # SQLite table counts — and the synthesis on top of it then said "the
+    # provided evidence does not specify the current context window size". It
+    # did not: n_ctx was 12192, written to runtime_snapshot.json at startup, and
+    # this report — named for the runtime — had no field for it.
+    try:
+        from eli.runtime.deterministic_grounding_gate import _inference_runtime_lines
+        lines.append(_inference_runtime_lines())
+        lines.append("")
+    except Exception:
+        log.debug("[EXECUTOR] inference runtime block unavailable", exc_info=True)
+    lines += [
         f"Cognition runtime: {report.get('path')}",
         f"Memory module: {report.get('memory_path')}",
         f"Router module: {report.get('router_path')}",

eli/runtime/deterministic_grounding_gate.py

@@ -955,8 +955,63 @@ def table_block(title: str, db: _EliPath, counts: dict[str, int]) -> list[str]:
     return "\n".join(lines)
 
 
-def _eli_cognition_pipeline_v2() -> str:
-    return """Cognition pipeline, input to output:
+def _inference_runtime_lines() -> str:
+    """The live inference parameters, as plain lines of evidence.
+
+    Asked "what is your current context window?", ELI answered "The provided
+    evidence does not specify the current context window size." It was running
+    at n_ctx=12192 and had written that number to runtime_snapshot.json at
+    startup — the evidence bundle for EXPLAIN_COGNITION_RUNTIME simply had no
+    field for it. The action is named for the runtime and described only the
+    architecture: module paths, line numbers and table counts.
+
+    Requested and effective are BOTH reported, because they diverge and the
+    difference is the answer to most questions in this area: on that session the
+    user asked for 99 GPU layers and got 8, which is why replies took minutes.
+    """
+    snap = _runtime_snapshot() or {}
+    req = snap.get("requested") or {}
+    eff = snap.get("effective") or {}
+
+    def pick(key, fallback_top=True):
+        for src in (eff, snap if fallback_top else {}):
+            if src.get(key) not in (None, ""):
+                return src.get(key)
+        return "unknown"
+
+    lines = ["Inference runtime (live, from the loaded model):"]
+    model = snap.get("model_name") or snap.get("model_path") or "unknown"
+    lines.append(f"- model: {model}")
+    lines.append(f"- provider: {snap.get('provider', 'unknown')}")
+    lines.append(f"- context window (n_ctx): {pick('n_ctx')}")
+    if req.get("n_ctx") not in (None, "") and req.get("n_ctx") != eff.get("n_ctx"):
+        lines.append(f"  (requested {req.get('n_ctx')}, reduced to fit VRAM)")
+    lines.append(f"- GPU layers offloaded: {pick('n_gpu_layers')}")
+    if req.get("n_gpu_layers") not in (None, "") and req.get("n_gpu_layers") != eff.get("n_gpu_layers"):
+        lines.append(f"  (requested {req.get('n_gpu_layers')} — the rest run on CPU, which is the "
+                     f"dominant cost of a slow reply)")
+    lines.append(f"- batch: {pick('n_batch')}   threads: {pick('n_threads')}")
+    lines.append(f"- load mode: {snap.get('load_mode', 'unknown')}")
+    return "\n".join(lines)
+
+
+def _eli_cognition_pipeline_v2(focus: str = "") -> str:
+    runtime_block = ""
+    try:
+        runtime_block = _inference_runtime_lines()
+    except Exception:
+        log.debug("inference runtime block unavailable", exc_info=True)
+
+    # A question about the inference runtime gets the NUMBERS, not a code map.
+    # The router already classifies this (diagnostic_focus=inference_runtime) and
+    # the answer ignored it, returning the architecture description regardless.
+    if runtime_block and str(focus or "").strip().lower() == "inference_runtime":
+        return runtime_block + "\n\n" + _COGNITION_PIPELINE_TEXT
+
+    return ((runtime_block + "\n\n") if runtime_block else "") + _COGNITION_PIPELINE_TEXT
+
+
+_COGNITION_PIPELINE_TEXT = """Cognition pipeline, input to output:
 
 1. GUI / voice capture
 - Text input enters through eli/gui/eli_pro_audio_gui_v2_0.py.
@@ -1102,7 +1157,10 @@ def render_action(action: str, args: _EliMapping[str, _EliAny] | None = None, us
         return _eli_runtime_audit_v2()
 
     if a == "EXPLAIN_COGNITION_RUNTIME":
-        return _eli_cognition_pipeline_v2()
+        # The router already decides this ("diagnostic_focus": "inference_runtime"
+        # for a question about the context window / model / GPU) — pass it through
+        # instead of returning the same architecture text for every question.
+        return _eli_cognition_pipeline_v2(str((args or {}).get("diagnostic_focus") or ""))
 
     if a in {"EXPLAIN_MEMORY_RUNTIME", "MEMORY_STATUS", "PERSONAL_MEMORY_DEEP_EXPLAIN"}:
         if _eli_wants_personal_memory_v2(text):

tests/test_runtime_question_gets_runtime.py

@@ -0,0 +1,125 @@
+"""Locks on "what is your context window?" being answered with the number.
+
+Live at 2.2.0, running a 30B model with 8 of 99 layers on GPU:
+
+    user> What is your current context window? You should have a reasonably
+          high context window, no?
+    ELI > Cognition runtime: /…/engine.py
+          Memory module: /…/memory.py
+          - gguf: lines [67, 69, 1712, 3775, …]      <- 60 grep line numbers
+          - active_db: capability_proposals(0), conversation_turns(672), …
+    user> What is your current context window?
+    ELI > The provided evidence does not specify the current context window size.
+
+It did not — and n_ctx was 12192, written to runtime_snapshot.json at startup
+and printed six times in the same log. EXPLAIN_COGNITION_RUNTIME, the action
+named for the runtime, described the ARCHITECTURE: module paths, grep hits and
+SQLite table counts, with no field anywhere for the inference parameters.
+
+The router had already worked it out — it routed with
+``diagnostic_focus: "inference_runtime"`` — and both evidence producers ignored
+that argument and returned the same text for every question.
+
+Requested and effective are both reported because their divergence is usually
+the real answer: that session asked for 99 GPU layers and got 8, which is why
+single replies took 136 seconds.
+"""
+import json
+
+import pytest
+
+from eli.runtime import deterministic_grounding_gate as G
+
+SNAPSHOT = {
+    "provider": "gguf",
+    "model_name": "NVIDIA-Nemotron-3-Nano-Omni-30B-A3B-Reasoning-UD-Q4_K_XL.gguf",
+    "n_ctx": 12192, "n_gpu_layers": 8, "n_batch": 128, "load_mode": "GPU",
+    "requested": {"n_ctx": 12192, "n_gpu_layers": 99, "n_threads": 10, "n_batch": 128},
+    "effective": {"n_ctx": 12192, "n_gpu_layers": 8, "n_threads": 10, "n_batch": 128},
+}
+
+
+@pytest.fixture
+def live_snapshot(monkeypatch):
+    monkeypatch.setattr(G, "_runtime_snapshot", lambda: dict(SNAPSHOT))
+
+
+# ── the question must be answerable from the evidence ───────────────────────
+def test_the_context_window_is_in_the_evidence(live_snapshot):
+    assert "12192" in G._inference_runtime_lines()
+
+
+def test_the_model_is_named(live_snapshot):
+    assert "Nemotron" in G._inference_runtime_lines()
+
+
+def test_requested_and_effective_gpu_layers_are_both_shown(live_snapshot):
+    """8 of a requested 99 is the reason a reply took over two minutes. Showing
+    only the effective number hides the cause; only the requested one lies."""
+    out = G._inference_runtime_lines()
+    assert "8" in out and "99" in out
+
+
+def test_a_divergence_is_explained_not_just_printed(live_snapshot):
+    out = G._inference_runtime_lines()
+    assert "CPU" in out, "the reason the missing layers cost time is not stated"
+
+
+def test_no_divergence_means_no_noise(monkeypatch):
+    """When requested == effective there is nothing to explain."""
+    snap = dict(SNAPSHOT)
+    snap["requested"] = dict(snap["effective"])
+    monkeypatch.setattr(G, "_runtime_snapshot", lambda: snap)
+    assert "requested" not in G._inference_runtime_lines()
+
+
+# ── the focus the router already computed must be honoured ──────────────────
+def test_an_inference_question_leads_with_the_numbers(live_snapshot):
+    out = G._eli_cognition_pipeline_v2("inference_runtime")
+    assert out.index("12192") < out.index("Cognition pipeline"), \
+        "still leading with the architecture description"
+
+
+def test_the_architecture_description_is_not_lost(live_snapshot):
+    """Someone asking how ELI works still needs the pipeline text."""
+    out = G._eli_cognition_pipeline_v2("inference_runtime")
+    assert "Cognition pipeline" in out
+    assert "Router" in out
+
+
+def test_the_runtime_is_present_even_without_a_focus(live_snapshot):
+    """A report named for the runtime should carry it regardless."""
+    assert "12192" in G._eli_cognition_pipeline_v2("")
+
+
+# ── the executor's copy of the report, which is what the user saw ──────────
+def test_the_executor_report_also_leads_with_the_runtime(live_snapshot):
+    from eli.execution.executor_enhanced import _format_cognition_runtime
+    out = _format_cognition_runtime({
+        "ok": True, "path": "engine.py", "memory_path": "memory.py",
+        "router_path": "router.py", "executor_path": "executor.py", "checks": {},
+    })
+    assert "12192" in out
+    assert out.index("12192") < out.index("Cognition runtime:")
+
+
+# ── failure modes ──────────────────────────────────────────────────────────
+def test_a_missing_snapshot_does_not_break_the_report(monkeypatch):
+    monkeypatch.setattr(G, "_runtime_snapshot", lambda: {})
+    out = G._eli_cognition_pipeline_v2("inference_runtime")
+    assert "Cognition pipeline" in out, "lost the whole report over a missing snapshot"
+    assert "unknown" in out
+
+
+def test_a_raising_snapshot_does_not_break_the_report(monkeypatch):
+    def boom():
+        raise RuntimeError("snapshot unreadable")
+    monkeypatch.setattr(G, "_runtime_snapshot", boom)
+    out = G._eli_cognition_pipeline_v2("inference_runtime")
+    assert "Cognition pipeline" in out
+
+
+def test_the_pipeline_text_is_a_constant_not_rebuilt_per_call():
+    """It is static prose; only the runtime block is live."""
+    assert isinstance(G._COGNITION_PIPELINE_TEXT, str)
+    assert "Cognition pipeline" in G._COGNITION_PIPELINE_TEXT