v56: use direct bounded conversational inference and finite queue retries

Author: Mantiee

V100_AUDIT.md

@@ -647,3 +647,26 @@ Validation: 1018 passed, 65 skipped, one resource-dependent worker integration
 deselected, one existing PEFT warning. Ruff and upgrade shell checks pass. The
 transaction test executes four refreshes and checks actual object identity for
 reader/text nodes, expanded state and page/card/text scroll offsets.
+
+## v56: direct conversational transport and finite connection retries
+
+Ordinary questions now make one chat-completions generation after a bounded
+accepted-model identity probe. They skip apply-template/tokenize requests, full
+research evidence/context assembly and cold-starting a large CPU chat model.
+The compact prompt contains the recorded goal and current mission state; absent
+profit/training counters remain unknown. Incomplete output is rejected, not
+reported as a model answer. Generation uses a 20-second socket timeout and a
+40-second total deadline. Explicit work keeps its executable tool path and
+separate 60-second transport budget.
+
+Connection failures retry at most once before becoming terminal and releasing
+the next queued request. The console waits up to 200 seconds to cover the existing
+180-second work budget instead of leaving a still-processing request after 120.
+This does not increase the backend work budget. A busy/offline server can still
+fail explicitly; these tests do not certify operation on the user's hardware.
+
+Validation: 1022 passed, 65 skipped, one resource-dependent worker integration
+deselected; one existing PEFT warning. Ruff, diff and upgrade shell checks pass.
+Tests cover the actual question route (one generation, bounded identity check,
+no CPU cold start/tool loop), incomplete output rejection and queue advancement
+after terminal connection failures.

pyproject.toml

@@ -3,7 +3,7 @@ name = "rlms"
 authors = [
     {name = "Alex Zhang", email = "altzhang@mit.edu"},
 ]
-version = "0.1.3+v100.55"
+version = "0.1.3+v100.56"
 description = "Recursive Language Models."
 readme = "README.md"
 license = "MIT"

rlm/v100/mission_chat.py

@@ -243,6 +243,56 @@ def conversation_question(message: str) -> bool:
     )
 
 
+def conversational_response(
+    root: Path, client, message: str, mission: dict, plans: dict, responder: dict
+) -> dict:
+    """One actual model request with bounded factual context and no tool routing."""
+    goal = (plans.get("long") or {}).get("text", "No recorded goal")
+    facts = {
+        "mission_running": mission.get("running"),
+        "phase": mission.get("state", {}).get("phase"),
+        "learning": mission.get("learning"),
+        "goal": goal[:3000],
+    }
+    client.timeout = min(client.timeout, 20)
+    client.request_deadline = min(
+        getattr(client, "request_deadline", time.monotonic() + 40), time.monotonic() + 40
+    )
+    reply = client.request(
+        "/v1/chat/completions",
+        {
+            "model": client.model_name,
+            "messages": [
+                {
+                    "role": "system",
+                    "content": "You are Synta. Answer the user's question directly in Polish, briefly. This is read-only chat: do not claim to execute work or update plans. Only the supplied status is verified. Missing optimizer/profit counters are unknown. Explain how the recorded goal relates to the question, without changing it or promising profit. State missing evidence honestly. Verified current facts: "
+                    + json.dumps(facts, ensure_ascii=False),
+                },
+                {"role": "user", "content": message},
+            ],
+            "max_tokens": 512,
+            "temperature": 0.0,
+            "stream": False,
+            **client.template_args(),
+        },
+    )
+    choice = reply["choices"][0]
+    answer = choice["message"].get("content")
+    if (
+        choice.get("finish_reason") not in ("stop", "eos")
+        or not isinstance(answer, str)
+        or not answer.strip()
+    ):
+        raise ValueError("Conversational model response incomplete; no invented answer accepted")
+    return {
+        "answer": answer.strip(),
+        "actions": [],
+        "applied": [],
+        "responder": responder,
+        "scope": "Single model generation; read-only question, no tool execution or control changes",
+    }
+
+
 def respond(root: Path, directory: Path, request: dict, accepted_cpu=None) -> dict:
     from rlm.v100.agent import native_turn
     from rlm.v100.competition import helper_client
@@ -255,6 +305,14 @@ def respond(root: Path, directory: Path, request: dict, accepted_cpu=None) -> di
     # Authorization comes only from the current authenticated local user message,
     # never from a model-generated action or text retrieved from the internet.
     message = request["message"].strip()
+    quick_question = conversation_question(message) or message.casefold() in (
+        "hej",
+        "cześć",
+        "czesc",
+        "hello",
+        "hi",
+        "odpowiedz",
+    )
     if re.search(
         r"\b(?:co potrafisz|co umiesz|twoje możliwości|twoje mozliwosci|what can you do)\b",
         message.casefold(),
@@ -388,6 +446,9 @@ def respond(root: Path, directory: Path, request: dict, accepted_cpu=None) -> di
     client.activity_actor = "chat"
     # The endpoint is reused for candidate evaluation. Chat waits rather than
     # talking to an unaccepted candidate or opening another GPU server.
+    client.request_deadline = request.get("deadline", time.monotonic() + 180)
+    generation_timeout = min(getattr(client, "timeout", 120), 60)
+    client.timeout = min(generation_timeout, 10)
     delegated = False
     cpu_master = False
     cpu_detail = None
@@ -398,9 +459,14 @@ def respond(root: Path, directory: Path, request: dict, accepted_cpu=None) -> di
     except (requests.RequestException, OSError):
         if not profile.get("resources", {}).get("interactive_lab"):
             raise
-        if accepted_cpu is not None and profile.get("resources", {}).get("accepted_cpu_chat"):
+        if (
+            accepted_cpu is not None
+            and not quick_question
+            and profile.get("resources", {}).get("accepted_cpu_chat")
+        ):
             try:
                 client = accepted_cpu.get(profile)
+                generation_timeout = min(client.timeout, 60)
                 cpu_master = True
             except (ValueError, OSError, RuntimeError, requests.RequestException) as error:
                 cpu_detail = str(error)[:300]
@@ -417,23 +483,39 @@ def respond(root: Path, directory: Path, request: dict, accepted_cpu=None) -> di
                     "Master busy; no independent remote chat helper"
                 ) from None
             client = helper_client(helper, root)
+            client.request_deadline = request.get("deadline", time.monotonic() + 180)
+            generation_timeout = min(client.timeout, 60)
+            client.timeout = min(generation_timeout, 20)
             client.identity()
             client.sampling_args["max_tokens"] = 2048
             client.enable_thinking = False
             client.activity_actor = "chat-delegate"
             delegated = True
     client.request_deadline = request.get("deadline", time.monotonic() + 180)
-    client.timeout = min(client.timeout, 60)
+    client.timeout = generation_timeout
     client.enable_thinking = False
     client.sampling_args = dict(client.sampling_args)
     client.sampling_args["max_tokens"] = min(2048, client.sampling_args.get("max_tokens", 2048))
     client.activity_context = {**client.activity_context, "chat_request_id": request.get("id")}
     from rlm.v100 import chat_resources
 
     resource_request = chat_resources.instruction(message)
-    question_only = conversation_question(message) and not resource_request
+    question_only = quick_question and not resource_request
     if question_only:
-        client.sampling_args["max_tokens"] = min(768, client.sampling_args["max_tokens"])
+        return conversational_response(
+            root,
+            client,
+            message,
+            mission,
+            read_plans(root),
+            {
+                "model": client.model_name,
+                "delegated_while_master_busy": delegated,
+                "accepted_master_on_cpu": cpu_master,
+                "accepted_model_sha256": accepted_cpu.sha256 if cpu_master else None,
+                "cpu_admission_detail": cpu_detail,
+            },
+        )
     with connect(root) as db:
         history = db.execute(
             "SELECT message,response FROM requests WHERE state='completed' ORDER BY rowid DESC LIMIT 3"
@@ -667,7 +749,11 @@ def service_loop(root: Path, directory: Path, stop: threading.Event, accepted_cp
                 "decisions", "user-command-completed", {"id": request["id"], **response}
             )
         except (requests.ConnectionError, requests.Timeout) as error:
-            expired = time.monotonic() >= request["deadline"] or isinstance(error, requests.Timeout)
+            expired = (
+                time.monotonic() >= request["deadline"]
+                or isinstance(error, requests.Timeout)
+                or request["attempts"] >= 1
+            )
             with connect(root) as db:
                 db.execute(
                     "UPDATE requests SET state=?,attempts=attempts+1,error=?,updated=? WHERE id=? AND state='queued'",
@@ -678,6 +764,16 @@ def service_loop(root: Path, directory: Path, stop: threading.Event, accepted_cp
                         request["id"],
                     ),
                 )
+            ActivityLog(root, "controller", "chat").write(
+                "errors",
+                "user-command-failed" if expired else "user-command-retry",
+                {
+                    "id": request["id"],
+                    "error": str(error)[:500],
+                    "attempts": request["attempts"] + 1,
+                    "terminal": expired,
+                },
+            )
         except Exception as error:
             with connect(root) as db:
                 db.execute(
@@ -710,7 +806,7 @@ def alongside(root: Path, directory: Path):
             accepted_cpu.close()
 
 
-def wait_reply(root: Path, identity: str, timeout: float = 120, progress=None) -> dict:
+def wait_reply(root: Path, identity: str, timeout: float = 200, progress=None) -> dict:
     deadline = time.monotonic() + timeout
     next_update = time.monotonic()
     while time.monotonic() < deadline:

tests/test_v100_chat_backend.py

@@ -195,3 +195,110 @@ def test_readonly_question_uses_conversation_route(message):
 )
 def test_explicit_work_keeps_executable_route(message):
     assert not mission_chat.conversation_question(message)
+
+
+def test_conversation_is_one_real_generation_without_template_or_tools(tmp_path):
+    calls = []
+    client = SimpleNamespace(
+        model_name="v100",
+        timeout=180,
+        template_args=lambda: {"chat_template_kwargs": {"enable_thinking": False}},
+        request=lambda endpoint, payload: calls.append((endpoint, payload))
+        or {
+            "choices": [
+                {
+                    "finish_reason": "stop",
+                    "message": {"content": "Cel pozostaje ten sam; nie ma dowodu zysku."},
+                }
+            ]
+        },
+    )
+    result = mission_chat.conversational_response(
+        tmp_path,
+        client,
+        "a co z zarabianiem",
+        {"running": True, "state": {"phase": "income-research"}},
+        {"long": {"text": "Operator goal"}},
+        {"model": "v100"},
+    )
+    assert len(calls) == 1 and calls[0][0] == "/v1/chat/completions"
+    assert calls[0][1]["max_tokens"] == 512
+    assert "tools" not in calls[0][1]
+    assert "Operator goal" in calls[0][1]["messages"][0]["content"]
+    assert result["applied"] == [] and client.timeout == 20
+
+
+def test_conversation_rejects_truncated_generation(tmp_path):
+    client = SimpleNamespace(
+        model_name="v100",
+        timeout=60,
+        template_args=lambda: {},
+        request=lambda *a: {
+            "choices": [{"finish_reason": "length", "message": {"content": "partial"}}]
+        },
+    )
+    with pytest.raises(ValueError, match="incomplete"):
+        mission_chat.conversational_response(tmp_path, client, "hej", {}, {}, {"model": "v100"})
+
+
+def test_question_fast_path_skips_cpu_start_and_research_context(tmp_path, monkeypatch):
+    accepted = profile(tmp_path)
+    atomic_json(tmp_path / "serving-active.json", accepted)
+    monkeypatch.setattr(mission_chat, "load_profile", lambda *a: accepted)
+    monkeypatch.setattr(
+        mission, "status", lambda *a: {"running": True, "state": {}, "learning": {}}
+    )
+    calls = []
+    client = SimpleNamespace(
+        model_name="v100",
+        timeout=120,
+        sampling_args={},
+        activity_context={},
+        template_args=lambda: {},
+    )
+
+    def request(endpoint, payload=None):
+        calls.append((endpoint, client.timeout))
+        if endpoint == "/props":
+            return {"model_path": accepted["server"]["model"]}
+        return {"choices": [{"finish_reason": "stop", "message": {"content": "Odpowiedź modelu"}}]}
+
+    client.request = request
+    monkeypatch.setattr(competition, "helper_client", lambda *a: client)
+
+    def forbidden(*a, **kw):
+        pytest.fail("Question must not start a CPU model or research/tool loop")
+
+    monkeypatch.setattr(research_tools, "research_turn", forbidden)
+    manager = SimpleNamespace(get=forbidden)
+    result = mission_chat.respond(tmp_path, tmp_path, {"message": "a co z zarabianiem"}, manager)
+    assert result["answer"] == "Odpowiedź modelu"
+    assert calls == [("/props", 10), ("/v1/chat/completions", 20)]
+
+
+def test_connection_failures_stop_retrying_and_release_next_request(tmp_path, monkeypatch):
+    import requests
+
+    first = mission_chat.submit(tmp_path, "first")
+    second = mission_chat.submit(tmp_path, "second")
+    with mission_chat.connect(tmp_path) as db:
+        db.execute("UPDATE requests SET attempts=1 WHERE id=?", (first,))
+    seen = []
+
+    def respond(*args):
+        request = args[2]
+        seen.append(request["id"])
+        if request["id"] == first:
+            raise requests.ConnectionError("backend unavailable")
+        return {"answer": "next response", "actions": [], "applied": []}
+
+    monkeypatch.setattr(mission_chat, "respond", respond)
+
+    class Stop:
+        def wait(self, seconds):
+            return len(seen) >= 2
+
+    mission_chat.service_loop(tmp_path, tmp_path, Stop())
+    assert mission_chat.inspect(tmp_path, first)["state"] == "failed"
+    assert mission_chat.inspect(tmp_path, second)["state"] == "completed"
+    assert seen == [first, second]

tests/test_v100_mission_evidence.py

@@ -4,7 +4,7 @@
 
 import pytest
 
-from rlm.v100 import agent, competition, mission, mission_chat, mission_evidence, research_tools
+from rlm.v100 import competition, mission, mission_chat, mission_evidence, research_tools
 from rlm.v100.common import atomic_json
 
 
@@ -147,23 +147,33 @@ def test_ordinary_chat_gets_host_evidence_before_model_can_guess(tmp_path, monke
     monkeypatch.setattr(
         mission_chat, "load_profile", lambda *args: {"runtime": {}, "server": {"model": str(model)}}
     )
+    seen = []
+
+    def reply(endpoint, payload=None):
+        if endpoint == "/props":
+            return {"model_path": str(model)}
+        seen.extend(payload["messages"])
+        return {
+            "choices": [
+                {
+                    "finish_reason": "stop",
+                    "message": {"content": "Counters unavailable; no training claim."},
+                }
+            ]
+        }
+
     client = SimpleNamespace(
-        request=lambda *args: {"model_path": str(model)},
+        request=reply,
+        template_args=lambda: {},
         model_name="v100",
         timeout=120,
         sampling_args={"max_tokens": 2048},
         activity_context={},
     )
     monkeypatch.setattr(competition, "helper_client", lambda *args: client)
-    seen = []
-
-    def reply(client, messages, **kwargs):
-        seen.extend(messages)
-        return {"content": '{"answer":"Counters unavailable; no training claim.","actions":[]}'}
-
-    monkeypatch.setattr(agent, "native_turn", reply)
     result = mission_chat.respond(tmp_path, run, {"message": "Czy trenujesz?"})
-    evidence = json.loads(seen[-1]["content"])["mission_evidence"]
-    assert evidence["optimizer_updates_observed"] is None
-    assert "Never invent a grader error cause" in seen[0]["content"]
+    evidence = json.loads(seen[0]["content"].split("Verified current facts: ", 1)[1])
+    assert evidence["learning"]["completed_cycles"] == 0
+    assert evidence["phase"] == "baseline-before-weight-updates"
+    assert "Missing optimizer/profit counters are unknown" in seen[0]["content"]
     assert result["actions"] == [] and result["applied"] == []

tools/upgrade-v100-retention.sh

@@ -47,7 +47,7 @@ PY
 uv --no-config pip install --python "$PY" --no-deps --reinstall-package rlms \
   "rlms @ git+https://github.com/Mantiee/rlm.git@$REV"
 uv --no-config pip check --python "$PY"
-uv --no-config pip freeze --python "$PY" > "$AI_V100_ROOT/research/requirements.continual.v10055.txt"
+uv --no-config pip freeze --python "$PY" > "$AI_V100_ROOT/research/requirements.continual.v10056.txt"
 
 "$PY" <<'PY'
 import json, os