[fix] Give Ollama a real context window (root cause); deterministic weak-check

Root cause of the 'assessment acts like a chatbot / refuses' behavior: Ollama
loaded the model with its default ~4096-token context, which silently TRUNCATED
the assessment prompt (system + facts + injected guideline/country tool results)
and dropped the instructions — so the model drifted to a greeting. Fix the cause:

- agent/loop.py passes options.num_ctx (env NUM_CTX, default 16384) on every chat.
- deploy/modal_app.py loads the model with OLLAMA_CONTEXT_LENGTH=NUM_CTX so the
server matches the client (no reload on first request).
With 16k context lfm2.5:8b now produces a correct, structured assessment on its
own (verified over Modal: refugee · sexual-orientation PSG · high · 3 cards).

Per feedback, replace the brittle prose phrase-matching weak-detector with a
DETERMINISTIC signal: the answer is weak only when the model produced no
structured output (case_type/grounds/countries) or almost no text — no guessing
at non-deterministic wording. The interview-grounded fallback then rarely fires.

Co-authored-by: Codex <noreply@openai.com>

agent/loop.py

@@ -94,6 +94,11 @@ class AgentLoop:
         self.model_id = model_id or os.getenv("MODEL_ID", DEFAULT_MODEL_ID)
         self.provider = os.getenv("MODEL_PROVIDER", "ollama")
         self._host = host or os.getenv("OLLAMA_HOST")
+        # Context window for Ollama. Its default is small (~4096); the assessment
+        # prompt (system + facts + injected guideline/country tool results) easily
+        # overflows that, which silently truncates the instructions and makes the
+        # model drift (e.g. answer as a chatbot). Give it real headroom.
+        self.num_ctx = int(os.getenv("NUM_CTX", "16384"))
         self._client = None  # lazily created so import never needs a server
         # Not all models accept the `think` parameter (e.g. qwen2.5:7b). We
         # optimistically try it, then disable it for this session on first
@@ -152,6 +157,7 @@ class AgentLoop:
                     tools=tool_schemas,
                     stream=True,
                     think=attempt_think,
+                    options={"num_ctx": self.num_ctx},
                 )
                 async for chunk in stream:
                     produced = True

app/phases/assessment.py

@@ -161,29 +161,18 @@ _GROUND_MAP = {
 }
 
 
-# Phrases that mark a non-answer from the model — either a refusal / "need more
-# info", or a conversational greeting that ignores the facts already collected and
-# asks the person for input. Either way, replace it with the deterministic,
-# interview-grounded analysis (the facts are all in hand already).
-_WEAK_MARKERS = (
-    # refusals / "need more information"
-    "cannot determine", "could not determine", "can't determine", "unable to determine",
-    "need more", "more information", "additional details", "additional information",
-    "not enough information", "insufficient information", "unable to assess",
-    "cannot assess", "i cannot provide", "no specific case",
-    # conversational greetings / requests for info it already has
-    "could you tell me", "can you tell me", "please tell me", "please share",
-    "please provide", "when you're ready", "when you are ready", "i'm here to help",
-    "i am here to help", "here to help you", "preferred language", "which language",
-    "navigate your options", "let me know", "feel free to", "happy to help",
-)
-
-
-def _is_weak_reasoning(text: str) -> bool:
-    t = (text or "").strip().lower()
-    if len(t) < 120:
+def _is_weak_reasoning(text: str, result) -> bool:
+    """Deterministic test for a non-answer — no brittle prose pattern-matching.
+
+    The assessment is required to end with a structured block (case_type / grounds
+    / countries). The model is weak/off-task when it produced **none** of that
+    structure, or barely any narration. When that happens (e.g. it drifted into a
+    chatbot greeting because the context window truncated its instructions), the
+    interview-grounded analysis takes over. With an adequate context window this
+    rarely fires."""
+    if len((text or "").strip()) < 120:
         return True
-    return any(m in t for m in _WEAK_MARKERS)
+    return not (result.case_type or result.grounds or result.countries)
 
 
 def _derive_case(session: SessionState) -> tuple[str, list[str], str]:
@@ -402,7 +391,7 @@ async def stream_assessment(session: SessionState, loop):
     # narration is *weak* (a refusal / "I cannot determine …" / barely anything),
     # the interview-derived read takes over so the person never sees a non-answer.
     case_d, grounds_d, risk_d = _derive_case(session)
-    weak = _is_weak_reasoning(visible)
+    weak = _is_weak_reasoning(visible, result)
     case_type = case_d if weak else (result.case_type or case_d)
     grounds_final = grounds_d if weak else (result.grounds or grounds_d)
     risk_final = risk_d if weak else (result.risk or risk_d)

deploy/modal_app.py

@@ -37,6 +37,10 @@ MODELS = [LLM_MODEL, EMBED_MODEL]
 
 GPU = os.environ.get("MODAL_GPU", "L4")                 # L4 (cheapest) | A10G | A100
 MIN_CONTAINERS = int(os.environ.get("MODAL_MIN_CONTAINERS", "0"))  # 1 = keep warm
+# Context window. Ollama's default (~4096) truncates our assessment prompt; load
+# the model at this size so it (and the app's per-request num_ctx) match -> no
+# reload on the first request. Must match the app's NUM_CTX.
+NUM_CTX = os.environ.get("NUM_CTX", "16384")
 OLLAMA_DIR = "/root/.ollama"                            # model cache (Volume mount)
 PORT = 11434
 
@@ -57,7 +61,7 @@ def _start_ollama(bind: str = "0.0.0.0", keep_alive: str | None = None) -> None:
 
     ``keep_alive="-1"`` tells Ollama never to unload the model from GPU while the
     container is warm, so a kept-warm endpoint answers in ~1s with no reload."""
-    env = {**os.environ, "OLLAMA_HOST": f"{bind}:{PORT}"}
+    env = {**os.environ, "OLLAMA_HOST": f"{bind}:{PORT}", "OLLAMA_CONTEXT_LENGTH": NUM_CTX}
     if keep_alive is not None:
         env["OLLAMA_KEEP_ALIVE"] = keep_alive
     subprocess.Popen(["ollama", "serve"], env=env)

tests/unit/test_assessment_logic.py

@@ -1,27 +1,34 @@
 """tests/unit/test_assessment_logic.py — deterministic assessment fallbacks."""
 
+from app.assessment_parse import AssessmentResult
 from app.phases.assessment import _derive_case, _is_weak_reasoning
 from app.state.session import SessionState
 
+_EMPTY = AssessmentResult()
+_FULL = AssessmentResult(case_type="refugee", grounds=["political opinion"],
+                         risk="high", countries=["Sweden"])
 
-def test_weak_reasoning_detected():
-    # refusals / non-answers
-    assert _is_weak_reasoning("Based on the information provided, I cannot determine a case type.")
-    assert _is_weak_reasoning("Additional details about your situation are needed to proceed.")
-    assert _is_weak_reasoning("too short")
-    # a conversational greeting that ignores the collected facts
-    assert _is_weak_reasoning(
-        "Hello! I'm here to help you navigate your options. Could you tell me your "
-        "preferred language? If you have documents, please share them when you're ready."
-    )
-    # a substantive analysis is NOT weak
+
+def test_weak_reasoning_is_deterministic():
+    # Weak = no structured output, regardless of how the prose reads. A refusal or
+    # a chatbot greeting both produce no @@ASSESSMENT block, so both are weak —
+    # without pattern-matching the wording.
+    refusal = "Based on the information provided, I cannot determine a case type at this time, sorry."
+    greeting = ("Hello! I'm here to help you navigate your options. Could you tell me your "
+                "preferred language? If you have documents, please share them when ready.")
+    assert _is_weak_reasoning(refusal, _EMPTY)
+    assert _is_weak_reasoning(greeting, _EMPTY)
+    assert _is_weak_reasoning("too short", _EMPTY)        # length floor
+    # A substantive analysis WITH structured output is not weak…
     good = (
         "Based on what you shared, you face a well-founded fear of persecution on "
         "political grounds. Under the 1951 Convention this is a refugee claim, and "
-        "because you remain in your country you must seek protection abroad. "
-        "Sweden, France and Italy all run active asylum procedures."
+        "because you remain in your country you must seek protection abroad."
     )
-    assert not _is_weak_reasoning(good)
+    assert not _is_weak_reasoning(good, _FULL)
+    # …and the SAME good prose with no structured output is treated as weak
+    # (the model skipped the required block).
+    assert _is_weak_reasoning(good, _EMPTY)
 
 
 def _seed(types, danger):