v65: audit historical metrics, preserve dashboard reading position and adapt bounded compute

Author: Mantiee

SYNTA_RECOVERY.md

@@ -261,3 +261,47 @@ the reported black-screen hang, this preset uses Windows CPU and leaves RTX off;
 it does not promise to diagnose hardware or prevent all crashes. The V100
 remains the main model/GPU. N-gram memory runs as a bounded experimental candidate
 with paired host-scored ablation and existing independent promotion gates.
+
+## v65: metric integrity, field anchoring and measured resource headroom
+
+- The legacy `Odchylenie` header is corrected to maximum drawdown. This is the
+  largest sampled equity decline from a preceding peak, not standard deviation.
+  Double-cost net return has a separate label. The simulator uses full available
+  cash and fees/slippage on each buy/sell leg, which can make frequent trading
+  expensive even with constant prices. Audit receipts include that illustration.
+- `audit_backtests` checks recent archived hashes, valid OHLCV ranges and timing,
+  reruns selected historical simulations and reconstructs net return/drawdown
+  from the equity trace. Changed, malformed, gapped or extreme-jump archives are
+  excluded from retrospective training; original files remain untouched. Every
+  postmortem training example repeats admission checks. These examples explicitly
+  deny future-profit and negative-return-means-corruption claims. Vendor accuracy,
+  intrabar drawdown and unobserved liquidity are not certified by this replay.
+- Upgrade records an audit and gives Synta the metric/parameter contract. The
+  existing tool selects past-only lookbacks 5/10/20 and exposes no Z-score input
+  or lookback 100. Historical losses stay rejected. There is no test-until-profit
+  loop and no admission of backtests as future directional/profit labels.
+- Refresh anchors the visible field inside the centered dashboard rather than the entire parent section. Internal scrolling panels compensate inside their own scroll container, without moving the page.
+  Open disclosures win over draft defaults; live token panes no longer open
+  automatically. The timeline runs chronologically, retaining expanded events
+  that leave the bounded recent window. Reading cards retain their panel while
+  expanded. The action archive keeps its own DOM and pagination.
+- Local CPU/network drone admission scales from two to one or zero slots with
+  measured CPU/RAM headroom. Windows children use one or two affinity slots
+  within the previous two-thread ceiling, idle priority, one job and monitored
+  four-GiB RSS limit. Existing 40% host CPU, six-GiB free RAM and foreground media
+  guards remain. Access-denied foreground inspection yields instead of crashing.
+  Transient SMB failures report blocked/retry state. No clocks, board power or
+  unrelated applications change; Windows RTX remains disabled by the operator.
+- The visible Windows console tails bounded new bytes from stdout, stderr and
+  autostart logs. Failed launches show their error instead of only startup
+  banners; retry pacing backs off. Startup banners alone do not prove a running
+  worker. `idle/ready` means no admitted job, not performed training.
+- `remote_connect` prints this signed-in device's actual HTTPS dashboard/chat and
+  SSH addresses, gateway/Serve configuration and upstream check. Login by itself
+  does not install the private web gateway. The installer can be rerun after
+  login and checks the final configuration without resetting other services.
+
+Code tests use deterministic fixtures and DOM simulation. No Windows host,
+operator browser, actual market archive or phone session is available here;
+installation performs the real archive audit, while phone and runtime acceptance
+remain observable operator-device checks. No profitable strategy is claimed.

SYNTA_REMOTE_ACCESS.md

@@ -11,3 +11,17 @@ Browser chat keeps actual saved request states and replies visible across reconn
 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).
+
+After login, rerun the pinned installer if its earlier terminal was closed. It
+skips login for an already-running Tailscale session and completes the gateway.
+To print actual connection addresses and blockers without changing services:
+
+```bash
+"$HOME/ai-v100/venvs/v100-continual/bin/python" -m rlm.v100.remote_connect --root "$HOME/ai-v100"
+```
+
+On phone/laptop, enable Tailscale under the same account and open the printed
+HTTPS `dashboard` or `chat` URL. For SSH use the printed command and existing
+Debian credentials. No LAN address or router forwarding is needed for these
+services. A configured Serve route is not proof of a successful remote browser
+session; its status is separate from the upstream HTTP check.

pyproject.toml

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

rlm/v100/backtest_audit.py

@@ -0,0 +1,65 @@
+"""Bounded reproducibility audit; never confuse a losing strategy with bad data."""
+
+import hashlib
+import json
+import time
+from pathlib import Path
+
+from rlm.v100.common import atomic_json
+
+
+def inspect_report(path: Path) -> dict:
+    from rlm.v100.backtest_learning import verified
+
+    result = {
+        "report": str(path),
+        "state": "quarantined",
+        "postmortem_training_admitted": False,
+        "forecast_training_admitted": False,
+        "scope": "Archived source checksums, chronology, OHLCV ranges and simulator replay. This cannot certify vendor accuracy, causality or a future edge.",
+    }
+    try:
+        record = verified(path)
+        stored = json.loads(path.read_text())
+        fee = stored["parameters"]["fee_bps"] / 10000
+        slip = stored["parameters"]["slippage_bps"] / 10000
+        pairs = stored["development_test"]["fills"] / 2
+        flat_return = (((1 - fee) * (1 - slip)) / ((1 + fee) * (1 + slip))) ** pairs - 1
+        result.update(
+            state="reproduced",
+            report_sha256=hashlib.sha256(path.read_bytes()).hexdigest(),
+            postmortem_training_admitted=True,
+            verified_sample=json.loads(record["messages"][-1]["content"]),
+            flat_price_cost_only_return=flat_return,
+            cost_explanation="Illustration for the reported number of full-capital buy/sell pairs at constant prices. Actual return also depends on price changes. Fee and slippage apply to each leg; these remain assumptions, not certified fees.",
+        )
+    except (ValueError, OSError, KeyError, TypeError, IndexError, ZeroDivisionError) as error:
+        result["reason"] = str(error)[:400]
+    return result
+
+
+def run(root: Path, limit: int = 20) -> dict:
+    if type(limit) is not int or not 1 <= limit <= 20:
+        raise ValueError("Audit 1-20 recent stored reports")
+    paths = sorted(
+        (root / "research/backtests").glob("run-*/report.json"),
+        key=lambda path: path.stat().st_mtime_ns,
+        reverse=True,
+    )[:limit]
+    result = {
+        "updated": time.time(),
+        "reports": [inspect_report(path) for path in paths],
+        "metric_correction": "max_sampled_drawdown is peak-to-trough equity loss, not standard deviation. Double-cost net return is a different metric. Loss alone is not evidence of a data glitch.",
+        "originals": "retained unchanged",
+        "scope": "Recent reports only; every historical training record is checked again at admission. Unverified reports are excluded, including profitable ones.",
+    }
+    atomic_json(root / "research/backtests/audit-status.json", result)
+    return result
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--root", type=Path, required=True)
+    print(json.dumps(run(parser.parse_args().root), indent=2))

rlm/v100/backtest_learning.py

@@ -4,19 +4,27 @@
 import json
 from pathlib import Path
 
-from rlm.v100.backtesting import bars_from_source, simulate
+from rlm.v100.backtesting import bars_from_source, simulate, source_quality
 from rlm.v100.paper import sha, timestamp
 
 
 def verified(path: Path) -> dict:
+    if path.is_symlink() or path.stat().st_size > 2 * 2**20:
+        raise ValueError("Unsafe or oversized historical report")
     report = json.loads(path.read_text())
     bodies = []
     for index, source in enumerate(report["sources"]):
-        body = (path.parent / f"source-{index}.json").read_text()
+        archive = path.parent / f"source-{index}.json"
+        if archive.is_symlink() or archive.stat().st_size > 2 * 2**20:
+            raise ValueError("Unsafe or oversized archived source")
+        body = archive.read_text()
         if hashlib.sha256(body.encode()).hexdigest() != source["sha256"]:
             raise ValueError("Backtest archived source changed")
         bodies.append(body)
     bars = bars_from_source(report["sources"][0]["url"], bodies[0], timestamp(report["fetched_at"]))
+    quality = source_quality(bars)
+    if quality["gaps"] or quality["large_opening_jumps"]:
+        raise ValueError("Archived bars require source review; excluded from postmortem training")
     events = None
     if len(bodies) > 1:
         events = []
@@ -65,19 +73,36 @@ def verified(path: Path) -> dict:
         bars, split, len(bars), "buy_hold", chosen, arguments["fee_bps"], arguments["slippage_bps"]
     )
     if (
-        report["selected_lookback_on_training_only"] != chosen
+        report["bars"] != len(bars)
+        or report["split_index"] != split
+        or report["selected_lookback_on_training_only"] != chosen
         or report["development_test"] != test
         or report.get("double_cost_stress") != stress
         or report.get("buy_hold_baseline") != baseline
     ):
         raise ValueError("Historical report differs from independently rerun simulator")
     outcome = test["net_return"]
+    for value in (test, stress, baseline):
+        peak, drawdown = 1.0, 0.0
+        for point in value["trace"]:
+            equity = point["marked_equity"]
+            if point["signal_available_at"] > point["fill_at"]:
+                raise ValueError("Future information in historical trace")
+            peak = max(peak, equity)
+            drawdown = max(drawdown, 1 - equity / peak)
+        if (
+            abs(value["net_return"] - (value["trace"][-1]["marked_equity"] - 1)) > 1e-10
+            or abs(value["max_sampled_drawdown"] - drawdown) > 1e-10
+        ):
+            raise ValueError("Historical equity trace does not reproduce reported metrics")
     label = {
         "sample_result": "profit" if outcome > 0 else "loss" if outcome < 0 else "flat",
         "beats_cash_in_sample": outcome > 0,
         "beats_buy_hold_in_sample": outcome > baseline["net_return"],
         "positive_at_double_assumed_cost": stress["net_return"] > 0,
         "repeatable_income_established": False,
+        "drawdown_is_standard_deviation": False,
+        "negative_return_proves_data_corruption": False,
         "next_evidence": "independent forward paper observations with documented costs",
     }
 
@@ -111,7 +136,7 @@ def records(root: Path) -> list[dict]:
     for path in sorted((root / "research/backtests").glob("run-*/report.json")):
         try:
             row = verified(path)
-        except (ValueError, KeyError, OSError, TypeError):
+        except (ValueError, KeyError, OSError, TypeError, IndexError, ZeroDivisionError):
             continue  # Older reports without complete artifacts are not training evidence.
         result.append(row)
     return result

rlm/v100/backtesting.py

@@ -32,6 +32,17 @@ def bars_from_source(url: str, body: str, fetched_at: datetime) -> list[dict]:
                 float(row[3]),
                 float(row[4]),
             )
+            low, high, volume = float(row[1]), float(row[2]), float(row[5])
+            if (
+                not all(math.isfinite(value) for value in (low, high, volume))
+                or not 0
+                < low
+                <= min(open_price, close_price)
+                <= max(open_price, close_price)
+                <= high
+                or volume < 0
+            ):
+                raise ValueError("Invalid public Coinbase OHLCV price range or volume")
         else:
             opened, closed = (
                 timestamp(row["open_time"]).timestamp(),
@@ -63,6 +74,24 @@ def bars_from_source(url: str, body: str, fetched_at: datetime) -> list[dict]:
     return bars
 
 
+def source_quality(bars: list[dict]) -> dict:
+    gaps = sum(
+        left["available_at"] < right["open_time"]
+        for left, right in zip(bars, bars[1:], strict=False)
+    )
+    jumps = sum(
+        abs(right["open"] / left["close"] - 1) > 0.5
+        for left, right in zip(bars, bars[1:], strict=False)
+    )
+    return {
+        "closed_bars": len(bars),
+        "gaps": gaps,
+        "large_opening_jumps": jumps,
+        "state": "requires source review" if gaps or jumps else "structural checks passed",
+        "scope": "Structural checks only. Large moves are flags, not proof of corrupt prices.",
+    }
+
+
 def simulate(
     bars: list[dict],
     start: int,
@@ -268,6 +297,12 @@ def run(root: Path, branch: str, arguments: dict, *, source_snapshot: tuple | No
             {key: value for key, value in source.items() if key != "body"} for source in sources
         ],
         "bars": len(bars),
+        "source_quality": source_quality(bars),
+        "metric_definitions": {
+            "max_sampled_drawdown": "Largest sampled peak-to-trough equity loss, including assumed exit costs; not standard deviation",
+            "net_return": "Final liquidated equity divided by initial equity, minus one",
+            "double_cost_stress": "Separate simulation with doubled assumed fees and slippage; its net return is not drawdown",
+        },
         "split_index": split,
         "selected_lookback_on_training_only": chosen,
         "development_test": test,

rlm/v100/chat_facts.py

@@ -10,7 +10,7 @@ def language(message: str) -> str:
     return (
         "Polish"
         if re.search(
-            r"\b(?:co|czego|czemu|jak|czy|kiedy|gdzie|uczy|naucz|zarab|zarob|znalaz|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|sprawdz|zbadaj|odchylen|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|zarob|strateg|income|profit|backtest|minus|paper|opportunit|candidate|brier|kandydat",
+            r"zarab|zarob|strateg|income|profit|backtest|minus|paper|opportunit|candidate|brier|kandydat|drawdown|obsunie|odchylen|glitch",
             normalized(message),
         )
     )
@@ -54,6 +54,27 @@ def response(root: Path, message: str) -> dict:
         if pl
         else "A negative backtest return is a historical simulated loss, not a Brier or benchmark score.",
     ]
+    lines.append(
+        "Obsunięcie to największy spadek kapitału od wcześniejszego szczytu, nie odchylenie standardowe. Wynik netto przy podwójnych kosztach to oddzielny zwrot. Sama strata nie dowodzi błędu danych."
+        if pl
+        else "Drawdown is the largest equity decline from a prior peak, not standard deviation. Double-cost net return is a separate return. A loss alone does not prove corrupt data."
+    )
+    audit_path = root / "research/backtests/audit-status.json"
+    if audit_path.exists() and audit_path.stat().st_size <= 2 * 2**20:
+        import json
+
+        audit = json.loads(audit_path.read_text())
+        for row in audit.get("reports", [])[:4]:
+            lines.append(
+                "Audit: "
+                + row["state"]
+                + " | "
+                + row["report"]
+                + " | "
+                + row.get("reason", "archived simulator replay only")
+            )
+    else:
+        lines.append("Audit: unavailable; no source integrity claim accepted")
     for row in value.get("recent_exploratory_backtests", []):
         net = row.get("development_test", {}).get("net_return")
         lines.append(
@@ -96,3 +117,31 @@ def test_response(root: Path, message: str) -> dict:
         "responder": {"model": "controller-historical-comparison"},
         "scope": "Historical research executed; no future edge, verified income or orders claimed",
     }
+
+
+def audit_response(root: Path, message: str) -> dict:
+    from rlm.v100.backtest_audit import run
+
+    value = run(root)
+    rows = [
+        "Audit: "
+        + row["state"]
+        + " | "
+        + row["report"]
+        + " | "
+        + row.get("reason", "archived replay passed")
+        for row in value["reports"]
+    ]
+    return {
+        "answer": (
+            "Obsunięcie to największy spadek kapitału od wcześniejszego szczytu, nie odchylenie standardowe. Zwrot przy podwójnych kosztach jest osobną metryką. Sama strata nie dowodzi błędu cen. Audyt poniżej odtwarza zapisane źródła i obliczenia; nie potwierdza ich u niezależnego dostawcy."
+            if language(message) == "Polish"
+            else value["metric_correction"]
+        )
+        + "\n"
+        + ("\n".join(rows) or "No archived reports to audit"),
+        "actions": [],
+        "applied": [value],
+        "responder": {"model": "controller-backtest-audit"},
+        "scope": value["scope"],
+    }

rlm/v100/chat_resources.py

@@ -56,6 +56,15 @@ def status(root: Path) -> dict:
         "drones": drone_status(root),
         "scope": "Owned job execution only. Windows RAM/disk are worker-local resources, not pooled Debian RAM or shared VRAM. No arbitrary Windows shell is exposed.",
     }
+    from rlm.v100.mission_chat import preferences
+
+    if preferences(root).get("remote_helper_enabled", True) is False:
+        value["helper"] = {
+            "reachable": None,
+            "state": "disabled by operator",
+            "scope": "No Windows GPU probes or jobs. Accepted V100 serves model work; CPU mailbox remains available. Duty cycle cannot cap peak GPU power.",
+        }
+        return value
     try:
         profile = load_profile(selected_helper(root), root)
         if not remote_profile(profile):