v64: deliver chat replies, preserve actionable financial visibility and add private remote access

Author: Mantiee

SYNTA_RECOVERY.md

@@ -195,6 +195,40 @@ Runtime evidence is stored under research/market-research, research/backtests,
 research/income-policy-history and research/architecture-candidates. Code tests do
 not assert operator-browser, Windows/CUDA runtime acceptance or actual income.
 
+## v64: delivered replies, independent financial visibility and remote access
+
+- Financial questions including the operator's `zarobiles` wording read measured
+  historical/ledger facts directly. They do not substitute a no-real-orders
+  explanation for an unprofitable simulation. Explicit `assume capital` commands
+  update hypothetical-capital policy without authorizing spending. The upgrade
+  applies the current operator's explicit paper-capital authorization.
+- Read-only financial/status questions can bypass the GPU work queue. Terminal
+  chat monitors requests still pending after its wait window, delivers eventual
+  saved results and errors, and offers `/results` and `/pending`. Real commands
+  retain their bounded queue and tool receipts.
+- Completed research cycles, last entered loop stage, admitted data, optimizer
+  steps and accepted weights are separate. The loop records preparation,
+  research, memory work, data admission, waits and candidate trials. A checkpoint
+  no longer runs a synchronous full financial audit inside the controller.
+- Dashboard inference/readiness HTTP polling uses already-collected events;
+  browser requests have eight-second deadlines and one in-flight request per
+  endpoint. The action archive uses live-document delegated events and a retained
+  DOM container, preserving expanded records across updates and on errors.
+- Stored historical tests load independently of the aggregate report. A separate
+  bounded read checks the current paper state and its last event, exposing equity,
+  positions, quote/fee blockers and original timestamps. It is visibly distinct
+  from a full-history audit; it does not invent fill counts. Saved paper reports
+  retain their own period/time rather than pretending to be live or current-run
+  training evidence. Negative results remain negative.
+- `install-synta-remote.sh` prepares owner-only Tailscale HTTPS dashboard/chat and
+  existing SSH access, without port forwarding. It requires actual operator
+  login/HTTPS authorization and the same account on mobile/laptop. See
+  SYNTA_REMOTE_ACCESS.md for boundaries and shutdown. Windows RTX stays disabled;
+  the existing conservative Windows CPU worker is unchanged.
+
+The finite code tests do not prove a profitable strategy, continuous optimizer
+updates, a successful phone login, or runtime performance on the operator's GPUs.
+
 ## v63: independent live refresh and conservative Windows CPU
 
 - Live file snapshots refresh every five seconds without running `mission-report`

SYNTA_REMOTE_ACCESS.md

@@ -0,0 +1,13 @@
+# Private remote Synta
+
+Run `tools/install-synta-remote.sh` as the existing Debian operator after updating Synta. It installs Tailscale from its official signed Debian repository if absent. Login is an operator step: open the printed link, then use the same account on the phone/laptop. If HTTPS needs enabling, Tailscale Serve prints its authorization link.
+
+The script prints the private dashboard, `/chat` and SSH address. Tailscale provides connections outside the LAN without router port forwarding. SSH uses the existing Debian SSH credentials. Install Tailscale separately on another home computer to access that computer; this installer does not expose the whole LAN or enable Windows RDP.
+
+The web gateway binds only `127.0.0.1:8786`. Tailscale Serve terminates HTTPS and supplies verified identity headers. Every route requires the configured owner login. Chat writes require the exact HTTPS Origin and a per-process CSRF token; only the existing bounded mission queue is writable. Dashboard proxy routes and body sizes are restricted. There is no public Funnel, arbitrary URL proxy, browser terminal or unauthenticated command endpoint. Existing Serve and Funnel configuration conflicts are preserved and reported.
+
+Browser chat keeps actual saved request states and replies visible across reconnects. It supports the same goal and work commands as the terminal. A submitted command is not a completed action. `/status` is read from host evidence by the mission service. Authentication, ACLs, HTTPS authorization and the first real phone connection must be completed/verified on the operator's devices.
+
+Disable the gateway with `systemctl --user disable --now synta-remote.service`. Disable only its Serve listener with `sudo tailscale serve --https=443 off`; do not reset other Tailscale services.
+
+Official references: [Serve and identity headers](https://tailscale.com/docs/features/tailscale-serve), [packages](https://pkgs.tailscale.com/stable/), [SSH access](https://tailscale.com/docs/features/tailscale-ssh).

SYNTA_REQUIREMENTS_AUDIT.md

@@ -146,3 +146,24 @@ accepted weight updates have not been demonstrated in this workspace.
 Final v63 validation: 1134 passed, 65 skipped, one existing PEFT warning.
 Ruff, formatting, shell syntax and whitespace checks pass. PowerShell has
 static contract tests; this Linux workspace does not execute Windows APIs.
+
+## v64 final verification
+
+The terminal and authenticated mobile gateway return financial/status facts without
+waiting for GPU jobs. Eventual queued replies remain available and are delivered
+by the terminal monitor. Regression coverage includes the exact uploaded Polish
+question, assume-capital authorization, language-specific learning facts, queue
+persistence, CSRF/owner checks, bounded proxy routes and conflicting remote setup.
+
+Dashboard HTTP inference/readiness reads use cached events. Executed JavaScript
+tests click archive controls, expand a record, run repeated rendering updates and
+click again, checking DOM identity, disclosure state and deduplication. Full
+controller checkpoints no longer call the full report audit. Financial display
+tests read while a ledger writer holds a transaction, refuse checksum tampering,
+and show historical losses without inventing missing fill counts or timestamps.
+
+Final test run: **1159 passed, 65 skipped**, one existing PEFT warning; no
+deselections. Ruff, shell syntax and diff checks passed. The real operator phone
+login, Tailscale policy/HTTPS approval, Windows APIs and V100/CUDA performance
+remain deployment checks. No profitable strategy or accepted production weight
+update is inferred from passing these code tests.

pyproject.toml

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

rlm/v100/chat_facts.py

@@ -10,7 +10,7 @@ def language(message: str) -> str:
     return (
         "Polish"
         if re.search(
-            r"\b(?:co|czemu|jak|czy|kiedy|gdzie|zarab|zarabianiem|zrob|zmien|przetestuj|poszukaj|zbieraj|hej|czesc|odpowiedz)\w*\b",
+            r"\b(?:co|czego|czemu|jak|czy|kiedy|gdzie|uczy|naucz|zarab|zarob|znalaz|zrob|zmien|przetestuj|poszukaj|zbieraj|hej|czesc|odpowiedz)\w*\b",
             normalized(message),
         )
         else "English"
@@ -20,7 +20,7 @@ def language(message: str) -> str:
 def requested(message: str) -> bool:
     return bool(
         re.search(
-            r"zarab|income|profit|backtest|minus|paper|opportunit|candidate|brier|kandydat",
+            r"zarab|zarob|strateg|income|profit|backtest|minus|paper|opportunit|candidate|brier|kandydat",
             normalized(message),
         )
     )
@@ -35,9 +35,9 @@ def response(root: Path, message: str) -> dict:
     pl = language(message) == "Polish"
     paper = value.get("paper", {})
     lines = [
-        "Brak potwierdzonego rzeczywistego dochodu. Nie ma wiarygodnej daty pierwszego zarobku."
+        "Oceniam wyniki symulacji i strategii, przy założeniu hipotetycznego kapitału. Brak realnych zleceń nie wyjaśnia strat w paper."
         if pl
-        else "No actual income verified. There is no verified date of first income.",
+        else "I assess simulated capital growth and strategy results. No real orders does not explain paper losses.",
         ("Faza: " if pl else "Phase: ") + str(value.get("phase")),
         ("Wykonania paper: " if pl else "Paper fills: ")
         + str(paper.get("executed_fills", "unknown")),

rlm/v100/chat_progress.py

@@ -1,5 +1,6 @@
 """Direct read-only progress replies, independent of model conversation drift."""
 
+import json
 import re
 from pathlib import Path
 
@@ -10,7 +11,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",
+            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",
             text,
         )
     ) and not re.search(r"\b(?:zmien|dodaj|napraw|zrob|wdroz|zaimplementuj)\b", text)
@@ -25,42 +26,98 @@ def continue_requested(message: str) -> bool:
     )
 
 
-def respond(root: Path) -> dict:
+def respond(root: Path, message: str | None = None) -> dict:
+    from rlm.v100.chat_facts import language
     from rlm.v100.mission_evidence import collect
 
     evidence = collect(root)
     learning = evidence["learning"]
     official = evidence.get("official_benchmark", {})
+    pl = message is None or language(message) == "Polish"
+
+    def wording(polish: str, english: str) -> str:
+        return polish if pl else english
 
     def metric(value):
-        return str(value) if value is not None else "brak potwierdzonych danych"
+        return (
+            str(value)
+            if value is not None
+            else wording("brak potwierdzonych danych", "no verified data")
+        )
 
     lines = [
-        "Status z plików kontrolera, bez zmiany planów:",
-        "Misja: " + ("działa" if evidence["mission_running"] else "zatrzymana"),
-        "Faza: " + str(evidence.get("phase")),
-        "Cykle uczenia: " + metric(learning.get("completed_cycles")),
-        "Potwierdzone kroki optymalizatora: " + metric(evidence["optimizer_updates_observed"]),
-        "Zaakceptowane aktualizacje wag: " + metric(evidence["accepted_weight_updates_this_run"]),
+        wording(
+            "Pętla badań działa osobno od treningu wag. Trening wymaga nowych zweryfikowanych danych; nie odbywa się przy każdej odpowiedzi.",
+            "Research runs separately from weight training. Training requires new verified data; answering a message is not an optimizer update.",
+        ),
+        wording("Misja: ", "Mission: ")
+        + (
+            wording("działa", "running")
+            if evidence["mission_running"]
+            else wording("zatrzymana", "stopped")
+        ),
+        wording("Faza: ", "Phase: ") + str(evidence.get("phase")),
+        wording("Cykle pętli zakończone: ", "Completed loop cycles: ")
+        + metric(learning.get("completed_cycles")),
+        wording("Potwierdzone kroki optymalizatora: ", "Verified optimizer updates: ")
+        + metric(evidence["optimizer_updates_observed"]),
+        wording("Zaakceptowane aktualizacje wag: ", "Accepted weight updates: ")
+        + metric(evidence["accepted_weight_updates_this_run"]),
     ]
     if official:
         lines += [
-            f"Benchmark oficjalny: {official.get('completed', '?')}/{official.get('total', '?')} | {official.get('state', 'stan nieznany')}",
-            "Raport: " + official["report"],
+            wording("Benchmark oficjalny: ", "Official benchmark: ")
+            + f"{official.get('completed', '?')}/{official.get('total', '?')} | {official.get('state', 'unknown')}",
+            wording("Raport: ", "Report: ") + official["report"],
         ]
         if official.get("current_case"):
-            lines.append("Bieżący przypadek: " + official["current_case"])
+            lines.append(
+                wording("Bieżący przypadek: ", "Current case: ") + official["current_case"]
+            )
     else:
-        lines.append("Benchmark oficjalny: brak licznika potwierdzonego dla bieżącego przebiegu.")
+        lines.append(
+            wording(
+                "Benchmark oficjalny: brak licznika potwierdzonego dla bieżącego przebiegu.",
+                "Official benchmark: no verified current-run counter.",
+            )
+        )
     for report in evidence["reports"]:
         if isinstance(report, dict) and report.get("cases"):
-            lines.append(f"Test bazowy: {report['passed']}/{report['cases']} | {report['path']}")
+            lines.append(
+                wording("Test bazowy: ", "Baseline: ")
+                + f"{report['passed']}/{report['cases']} | {report['path']}"
+            )
     goal = evidence.get("goal_learning", {})
-    lines.append("Zapisane prognozy pod cel: " + str(len(goal.get("forecasts", []))))
-    lines.append("Przebieg: " + str(evidence["run"]))
     lines.append(
-        "Dashboard odświeża renderer hosta; skrypty w edytowalnym HTML mastera nie są potrzebne. Brak licznika nie dowodzi bezczynności."
+        wording("Prognozy w ostatnim oknie statusu: ", "Forecasts in the recent status window: ")
+        + str(len(goal.get("forecasts", [])))
     )
+    if not evidence["accepted_weight_updates_this_run"]:
+        lines.append(
+            wording(
+                "Nie mam potwierdzenia nowych zaakceptowanych wag w tym przebiegu. Zapisanie prognozy lub planu nie jest treningiem.",
+                "No newly accepted weights verified in this run. Recording a forecast or plan is not training.",
+            )
+        )
+    if evidence.get("run"):
+        path = Path(evidence["run"]) / "learning/heartbeat.json"
+        if path.exists() and path.stat().st_size <= 16384:
+            try:
+                activity = json.loads(path.read_text())
+                lines.append(
+                    wording("Ostatni etap pętli: ", "Last loop stage: ")
+                    + str(activity.get("stage"))
+                )
+                if activity.get("reason"):
+                    lines.append(
+                        wording("Powód oczekiwania: ", "Wait reason: ") + activity["reason"]
+                    )
+            except (OSError, ValueError) as error:
+                lines.append(
+                    wording("Status etapu niedostępny: ", "Stage status unavailable: ")
+                    + str(error)[:200]
+                )
+    lines.append(wording("Przebieg: ", "Run: ") + str(evidence["run"]))
     return {
         "answer": "\n".join(lines),
         "actions": [],