Space: session limit counts only non-cached answers (cache-only at limit)

app.py

@@ -289,7 +289,14 @@ def _api_url() -> str:
     return str(_CFG["api_url"]).strip()
 
 
-def _session_allow(session_hash: str, timestamps: list[float]) -> tuple[bool, list[float]]:
+# API protocol headers (v2/api/public.py): the response says whether it came from the question cache;
+# at the session limit the Space asks for a cache-only answer, so cached repeats never hit the limit.
+CACHE_HEADER = "X-TheAnswer-Cache"
+CACHE_ONLY_HEADER = "X-TheAnswer-Cache-Only"
+
+
+def _session_room(session_hash: str, timestamps: list[float]) -> tuple[bool, list[float]]:
+    """Whether this session may trigger a new (non-cached) answer now. Records nothing."""
     now = time.monotonic()
     cap = int(_CFG["asks_per_min"])
     window_s = float(_CFG["rate_window_s"])
@@ -306,13 +313,18 @@ def _session_allow(session_hash: str, timestamps: list[float]) -> tuple[bool, li
             for bucket in stale:
                 _SESSION_HITS.pop(bucket, None)
         backup = [stamp for stamp in _SESSION_HITS.get(key, []) if now - stamp < window_s]
-        if cap <= 0 or len(window) >= cap or len(backup) >= cap:
-            _SESSION_HITS[key] = backup
-            return False, window
-        window.append(now)
-        backup.append(now)
         _SESSION_HITS[key] = backup
-        return True, window
+        room = cap > 0 and len(window) < cap and len(backup) < cap
+    return room, window
+
+
+def _session_record(session_hash: str, window: list[float]) -> list[float]:
+    """Count one non-cached answer against this session."""
+    now = time.monotonic()
+    key = session_hash or ""
+    with _SESSION_LOCK:
+        _SESSION_HITS.setdefault(key, []).append(now)
+    return list(window) + [now]
 
 
 def _friendly_http_error(status: int) -> str:
@@ -348,23 +360,28 @@ def ask(
         return render_notice(_msg_too_long()), timestamps or []
 
     session_hash = getattr(request, "session_hash", None) or ""
-    allowed, timestamps = _session_allow(session_hash, timestamps or [])
-    if not allowed:
-        return render_notice(_ui("msg_rate")), timestamps
+    room, timestamps = _session_room(session_hash, timestamps or [])
 
     token = os.environ.get("THEANSWER_API_TOKEN") or ""
     if not token.strip():
         return render_notice(_ui("msg_unconfigured")), timestamps
 
+    headers = {"Authorization": f"Bearer {token}"}
+    if not room:  # at the session limit: only a cached answer may come back (no new Gemini call)
+        headers[CACHE_ONLY_HEADER] = "1"
     try:
         resp = httpx.post(
             _api_url(),
             json={"question": question},
-            headers={"Authorization": f"Bearer {token}"},
+            headers=headers,
             timeout=float(_CFG["http_timeout_s"]),
         )
     except (httpx.TimeoutException, httpx.NetworkError, httpx.HTTPError):
+        if room:
+            timestamps = _session_record(session_hash, timestamps)
         return render_notice(_ui("msg_network")), timestamps
+    if room and resp.headers.get(CACHE_HEADER) != "hit":  # only non-cached answers count
+        timestamps = _session_record(session_hash, timestamps)
 
     if resp.status_code != 200:
         return render_notice(_friendly_http_error(resp.status_code)), timestamps