v67: answer current questions, recover incomplete chat without actions and verify private HTTPS readiness

Author: Mantiee

SYNTA_V67.md

@@ -0,0 +1,38 @@
+# Synta v67
+
+Current-activity questions such as "to co dokładnie robisz, szczegóły, teraz"
+read recorded jobs, their complete assignments, record age, plans and recent
+action receipts directly. They do not enter a model work loop or change plans.
+Loss complaints return financial evidence without inventing a market cause.
+Replay reproducibility is distinct from independent price validation.
+
+A standalone work request no longer inherits three previous conversations.
+Only an explicit "do it" follow-up can carry the previous exchange. The current
+request takes priority. Long prose ending mid-sentence is rejected even when a
+JSON grammar reports stop. One bounded, concise recovery may summarize genuine
+receipts, without rerunning tools or applying proposed control actions. Unknown
+finish reasons cannot authorize tool execution. This is a targeted validation
+rule, not a guarantee that every plausible complete answer is factually correct.
+
+Upgrade archives old informational questions that created short/mid plans,
+restores a plan only if that exact version is still current, and requeues the
+question through the repaired route. Later operator plans and goals are retained.
+Previously executed tools cannot be undone by changing a response record.
+
+Remote setup now distinguishes configured URLs from ready routing. A phone
+sign-in is insufficient: Tailscale HTTPS/Serve must be approved by the owner.
+The installer checks the gateway, exact private proxy, DNS origin and existing
+LAN dashboard before reporting readiness. It retains owner-only authentication
+and refuses public Funnel. Local checks do not prove the iPhone can reach it.
+
+Adaptive GPU status includes the request source, actor, request ID, model and
+start/end timestamps. It separates Debian requests from Windows local/startup
+checks. These are transport receipts, not evidence of training or useful output.
+Existing CPU/RTX admission controls remain: browsers allowed, one inference,
+65/35/20 percent active-time targets, host load/temperature/RAM/VRAM/observed
+power checks. No global hardware limits or clocks are changed.
+
+Validation includes question routing, recovery without tool duplication, exact
+plan restoration, standalone context isolation, missing Serve readiness and
+GPU proxy receipts. Full regression and lint results accompany publication.
+Actual Windows tasks, phone access and thermals cannot be tested on this host.

pyproject.toml

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

rlm/v100/agent.py

@@ -101,6 +101,10 @@ def native_turn(
                 max_tokens=payload["max_tokens"],
                 total_completion_tokens=completion_tokens,
             )
+        if choice.get("finish_reason") not in ("stop", "eos", "tool_calls", "length"):
+            raise ValueError(
+                "Model response has an unconfirmed finish reason; no answer or tool action accepted"
+            )
         if choice.get("finish_reason") != "length":
             return choice["message"]
         if attempts >= 3 or payload["max_tokens"] >= ceiling:

rlm/v100/chat_facts.py

@@ -20,7 +20,7 @@ def language(message: str) -> str:
 def requested(message: str) -> bool:
     return bool(
         re.search(
-            r"zarab|zarob|strateg|income|profit|backtest|minus|paper|opportunit|candidate|brier|kandydat|drawdown|obsunie|odchylen|glitch",
+            r"zarab|zarob|tracisz|przegrywasz|strateg|income|profit|backtest|minus|paper|opportunit|candidate|brier|kandydat|drawdown|obsunie|odchylen|glitch",
             normalized(message),
         )
     )
@@ -75,6 +75,11 @@ def response(root: Path, message: str) -> dict:
             )
     else:
         lines.append("Audit: unavailable; no source integrity claim accepted")
+    lines.append(
+        "Powtarzalność obliczeń nie potwierdza prawdziwości cen u niezależnego dostawcy ani przyczyny strat. Nie mam podstaw, aby przypisać je konkretnemu trendowi bez analizy śladu transakcji. Ta odpowiedź nie zmienia strategii ani planu."
+        if pl
+        else "Replay reproducibility does not establish independent price accuracy or a cause of losses. A causal explanation needs execution-trace analysis. This answer changes no strategy or plan."
+    )
     for row in value.get("recent_exploratory_backtests", []):
         net = row.get("development_test", {}).get("net_return")
         lines.append(

rlm/v100/chat_progress.py

@@ -2,6 +2,7 @@
 
 import json
 import re
+import time
 from pathlib import Path
 
 from rlm.v100.chat_goals import normalized
@@ -11,7 +12,7 @@ def requested(message: str) -> bool:
     text = normalized(message)
     return bool(
         re.search(
-            r"co (?:teraz |aktualnie )?robisz|jaki (?:jest )?(?:postep|progres)|czego sie nauczyl|czy .*uczysz sie|czy uczysz sie|learn.*continuously|what have you learned|what are you doing",
+            r"co (?:(?:teraz|aktualnie|dokladnie|konkretnie|obecnie) )*robisz|co .*robicie|jaki (?:jest )?(?:postep|progres)|czego sie nauczyl|czy .*uczysz sie|czy uczysz sie|learn.*continuously|what have you learned|what (?:exactly )?are you doing",
             text,
         )
     ) and not re.search(r"\b(?:zmien|dodaj|napraw|zrob|wdroz|zaimplementuj)\b", text)
@@ -118,10 +119,72 @@ def metric(value):
                     + str(error)[:200]
                 )
     lines.append(wording("Przebieg: ", "Run: ") + str(evidence["run"]))
+    from rlm.v100.drones import inspect
+    from rlm.v100.live_status import recent_events
+    from rlm.v100.planning import read
+
+    jobs = inspect(root)
+    now = time.time()
+    lines.append(wording("Odczyt statusu UTC: ", "Status read UTC: ") + str(now))
+    for row in jobs:
+        if row["state"] not in ("running", "queued"):
+            continue
+        age = max(0, now - row["updated"]) if row["updated"] else None
+        lines.append(
+            f"{row['kind']} / {row['branch']} / {row['id']}: {row['state']} | "
+            + wording("wiek zapisu: ", "record age: ")
+            + (f"{age:.0f}s" if age is not None else "unknown")
+            + "\n"
+            + row["assignment"]
+        )
+    if not any(row["state"] == "running" for row in jobs):
+        lines.append(
+            wording(
+                "Brak dronów oznaczonych jako wykonujące zadanie.", "No drones recorded as running."
+            )
+        )
+    plans = read(root)
+    for horizon in ("short", "mid"):
+        plan = plans.get(horizon) or {}
+        lines.append(
+            f"Plan {horizon} [{plan.get('id', 'unknown')}]: {plan.get('text', 'unavailable')}"
+        )
+    events = recent_events(root, 200)
+    observed = [
+        event
+        for event in events
+        if event.get("kind")
+        in (
+            "inference-start",
+            "inference-finished",
+            "inference-failed",
+            "tool-start",
+            "tool-result",
+        )
+    ][-8:]
+    lines.append(
+        wording(
+            "Ostatnie zapisane akcje (historia, nie dowód bieżącej pracy):",
+            "Latest recorded actions (history, not proof of current work):",
+        )
+    )
+    for event in observed:
+        lines.append(
+            f"{event.get('time')} | {event.get('actor')} | {event.get('kind')} | {event.get('tool', '')} | {event.get('summary', '')}"
+        )
+    if not observed:
+        lines.append(
+            wording(
+                "Brak zarejestrowanych akcji w odczytanym oknie.",
+                "No recorded actions in the read window.",
+            )
+        )
     return {
         "answer": "\n".join(lines),
         "actions": [],
         "applied": [],
         "evidence": evidence,
+        "observed_jobs": jobs,
+        "observed_actions": observed,
         "responder": {"model": "controller-status", "delegated_while_master_busy": False},
     }

rlm/v100/chat_recovery.py

@@ -0,0 +1,72 @@
+"""Upgrade-only repair of plans created while answering an informational question."""
+
+import json
+import re
+from pathlib import Path
+
+from rlm.v100.common import atomic_json
+
+
+def repair(root: Path) -> dict:
+    from rlm.v100.mission import status
+    from rlm.v100.mission_chat import connect, conversation_question
+
+    if status(root)["running"]:
+        raise ValueError("Stop the mission before recovering chat-created plans")
+    directory = root / "research/state/chat-question-repairs"
+    repaired = []
+    with connect(root) as db:
+        rows = db.execute(
+            "SELECT * FROM requests WHERE state='completed' ORDER BY rowid DESC LIMIT 500"
+        ).fetchall()
+        for row in rows:
+            if not conversation_question(row["message"]):
+                continue
+            response = json.loads(row["response"])
+            receipts = [
+                r for r in response.get("applied", []) if r.get("horizon") in ("short", "mid")
+            ]
+            if not receipts:
+                continue
+            if not re.fullmatch(r"[a-f0-9]{32}", row["id"]):
+                raise ValueError("Invalid archived question identity")
+            archive = directory / (row["id"] + ".json")
+            if archive.exists():
+                continue
+            path = root / "research/plans/current.json"
+            plans = json.loads(path.read_text()) if path.exists() else {}
+            restored = []
+            for receipt in receipts:
+                horizon, identity = receipt["horizon"], receipt.get("id", "")
+                if (
+                    not re.fullmatch(r"[a-f0-9]{32}", identity)
+                    or plans.get(horizon, {}).get("id") != identity
+                ):
+                    continue
+                version = json.loads((root / "research/plans" / (identity + ".json")).read_text())
+                previous = version.get("previous") or {}
+                # A later goal change must not resurrect an unrelated earlier goal's plan.
+                if previous.get("goal_id") not in (None, plans[horizon].get("goal_id")):
+                    continue
+                plans[horizon] = previous
+                restored.append(horizon)
+            atomic_json(
+                archive,
+                {
+                    "request": dict(row),
+                    "restored_plans": restored,
+                    "scope": "Question-created plan reverted only if its exact ID is still active; later plans and original evidence retained.",
+                },
+            )
+            if restored:
+                atomic_json(
+                    archive.with_name(row["id"] + "-plans-before.json"),
+                    json.loads(path.read_text()),
+                )
+                atomic_json(path, plans)
+            db.execute(
+                "UPDATE requests SET state='queued',response=NULL,attempts=0,error=NULL,updated=0,wait_started=0 WHERE id=?",
+                (row["id"],),
+            )
+            repaired.append({"id": row["id"], "restored_plans": restored, "archive": str(archive)})
+    return {"requeued_questions": repaired, "long_term_goal_changed": False}

rlm/v100/chat_resources.py

@@ -81,6 +81,8 @@ def status(root: Path) -> dict:
             "active_request_target_percent": client.helper_duty_percent,
             "scope": "Inference/vision helper, request pacing; not a hard GPU utilization/power cap",
         }
+        if profile.get("resources", {}).get("require_adaptive_windows_guard"):
+            value["helper"]["admission"] = client.remote_request("/api/synta-resources")
     except (OSError, ValueError, RuntimeError, requests.RequestException) as error:
         value["helper"] = {"reachable": False, "error": str(error)[:300]}
     return value