v63: restore factual chat, stable live dashboard, bounded Windows CPU and gated n-gram memory

Separate live snapshots from ledger audits and guest SSH. Read existing ledgers without writer locks. Enforce idle priority, two CPU affinity slots and host pressure/media cancellation for owned Windows jobs; keep RTX disabled after the reported hang. Preserve goals, checkpoints and independent promotion gates. Add causal hashed n-gram candidate with host-scored ablation and honest financial receipts.

Validation: 1134 tests passed, 65 skipped; Ruff and Bash checks passed. No Windows/CUDA execution or verified income claim.

Author: Mantiee

SYNTA_NGRAM_MEMORY.md

@@ -0,0 +1,35 @@
+# Synta conditional-memory pilot
+
+Primary research: https://arxiv.org/abs/2601.07372 and
+https://github.com/deepseek-ai/Engram. Published results use trained
+Engram-equipped models and host-memory prefetching; they do not establish that
+memory inserted into an existing Gemma GGUF improves a financial goal.
+
+`rlm/v100/ngram_memory.py` implements an original smaller Engram-inspired
+candidate: causal rolling byte n-gram addresses, bounded hashed embeddings,
+contextual gates and a zero-initialized value projection. It does not reproduce
+DeepSeek's tokenizer compression, multi-head hashing, convolution or distributed
+prefetching implementation.
+
+`propose_ngram_memory` accepts width 16-64, 1-2 GRU layers, 256-8192 power-of-two
+memory slots and orders 2-4. The conservative total pilot parameter limit is two
+million. Float32 tables occupy at most 6 MiB. Large disk mapping is not justified
+for this pilot: NVMe stores checkpoints, not extra GPU compute or a measured RAM
+expansion. The operator's Windows disk type and bandwidth have not been measured.
+
+`test_submodel` uses the existing isolated CPU trial with 2 threads and bounded
+time, memory and parameters. The host repeats prediction with memory disabled on
+the same trained weights and fixed cases, retains both logs, scores them without
+revealing gold answers to the worker, and verifies the weights checksum between
+evaluations. `quality.json.memory_ablation` records scores and time. This measures
+a component's contribution, not an independently trained equal-capacity baseline.
+
+Scratch-master promotion refuses candidates without measured development
+ablation improvement. Existing independent goal, retention, fresh and public
+gates still apply. Main GGUF weights are untouched. The Windows RTX helper is
+not started or enabled; the operator shutdown remains authoritative. No actual
+goal improvement, profitability or RTX hardware acceptance is claimed.
+
+Regressions cover future-token isolation, initial unchanged logits, actual
+gradient updates, safetensors round-trip, dimension rejection before allocation
+and host scoring with memory on/off on frozen weights.

SYNTA_RECOVERY.md

@@ -154,3 +154,76 @@ serving readiness failure, not a failed income experiment.
 This release does not certify fees unavailable from the actual retrieved page,
 income, demand, novelty, CUDA utilization or browser behavior on the operator's
 machines. The existing Windows CPU limit and disabled RTX preference are retained.
+
+## v63 rebuilt recovery
+
+The interrupted publication did not reach the remote branch. The local workspace
+was subsequently restored from the exact public v62 tree before these fixes were
+rebuilt. Old test counts are not acceptance evidence for this rebuilt release.
+
+- Financial read-only questions use current host reports without waiting for a
+  model, modifying plans or inventing ROI. Historical losses, scoring metrics,
+  zero forward paper fills, hypotheses and verified actual income are separate.
+  An uninitialized paper ledger reports unknown fills rather than fabricated zero.
+- Explicit test-now/history requests execute a transparent BTC hourly commissioning
+  comparison with one shared source acquisition, two predetermined rules and
+  documented assumed costs. Cash, buy-and-hold, doubled costs and chronological
+  windows reject weak candidates. This is not broad autonomous strategy discovery.
+  A comparison is reused for one hour with report digest checks; source failures
+  have their own blocked receipt and no invented ROI. Actual income remains unknown.
+- Hypothetical-capital research is an archived operator policy, distinct from
+  spending/account/outreach/order authorization. Existing explicit goals remain
+  literal. Research jobs are goal-bound, deduplicated and bounded. Windows RTX
+  remains disabled and the bounded CPU mailbox is retained.
+- Native serving readiness waits have durable SQLite timing and a limit of 600
+  seconds or 20 checks. Other requests can complete during the wait. Actual model
+  generation timeouts stay terminal. A plan, inspection or queued job cannot prove
+  implementation. Receipts distinguish failures, reads, queues and publication.
+- Full admitted drone assignments replace the old 300-character SQL preview.
+  Backend finish_reason and measured tokens are separate; length marks an
+  incomplete response. Archive previews remain bounded and labelled.
+- Internal generation instructions and built-in UI labels use English. Chat follows
+  the current operator language. Archived evidence and literal goals stay verbatim.
+- Layout publication cannot reload the reading page automatically. A manual button
+  loads a new layout when the reader is ready. Existing keyed DOM and disclosure
+  preservation remain; viewport anchoring is expanded. Reload once after upgrade
+  to replace already-loaded old JavaScript.
+- The separate n-gram memory pilot is documented in SYNTA_NGRAM_MEMORY.md. It is
+  not a modified Gemma GGUF and cannot activate without measured gates.
+
+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.
+
+## v63: independent live refresh and conservative Windows CPU
+
+- Live file snapshots refresh every five seconds without running `mission-report`
+  in that loop. A separate serial collector performs the aggregate audit with its
+  existing 20-second bound. Delayed audits have their own state and timestamp;
+  GPU/activity/mission reads continue. Guest SSH layout polling is a third loop,
+  so its timeout cannot stop live data. Historical aggregate values stay scoped
+  to the same run and visibly stale; unavailable values are never invented.
+- Financial questions in chat read stored same-run evidence and its original
+  timestamp without launching another aggregate audit. Missing fills and
+  blockers remain unknown. Old-run counters are discarded.
+- Paper and competition reports open existing SQLite ledgers read-only with a
+  one-second lock wait. They no longer request WAL/schema writer locks just to
+  display a report. Paper hash-chain validation is retained.
+- `install-synta-low-load.ps1` replaces only the isolated owned CPU worker, retains
+  its authenticated mailbox, sets autostart, and opens a visible log console.
+  It retires the isolated RTX helper without changing board power, clocks,
+  unrelated processes, firewall rules or desktop applications.
+- Windows children get idle priority and at most two CPU affinity slots, plus
+  two-thread BLAS/Torch limits. One job runs at a time. The worker checks host
+  CPU, free RAM and foreground browser/media/game every two seconds and kills
+  its owned experiment when CPU exceeds 40%, free RAM falls below 6 GiB, or
+  foreground activity needs the computer. Child RSS is sampled against 4 GiB;
+  this is a monitored cutoff, not a Windows kernel allocation quota.
+- The earlier code noticed CPU pressure but ignored it during running jobs.
+  This is fixed and tested with an owned child cancellation receipt.
+
+Per-process duty cycles cannot bound a 3090's instantaneous board power. After
+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.

SYNTA_REQUIREMENTS_AUDIT.md

@@ -116,3 +116,33 @@ Final v62 verification: 1098 tests passed, 65 skipped, one existing PEFT warning
 no deselections. Ruff for Python/scripts/tests excluding the unchanged notebook,
 upgrade shell syntax and diff whitespace checks pass. No Windows, CUDA or
 operator-browser runtime acceptance is asserted by this result.
+
+## v63 rebuilt verification
+
+After interrupted publication and workspace rollback, the exact public v62 tree
+was restored and this release was rebuilt. Final rebuilt test run: 1125 passed,
+65 skipped, one existing PEFT warning, 68.64 seconds. These results supersede the
+pre-interruption v63 test count. The causal n-gram memory pilot adds real gradient,
+checkpoint and paired host-ablation regressions. All network transports are test
+fixtures; no V100/Windows/browser hardware acceptance or verified income is claimed.
+See SYNTA_RECOVERY.md and SYNTA_NGRAM_MEMORY.md for scope and admission limits.
+
+## v63 final collection and Windows limits
+
+Aggregate auditing and guest SSH synchronization no longer block the five-second
+live collector. Existing ledgers are read without writer/schema locks. Delayed
+aggregate audits remain explicitly labeled rather than masquerading as live
+financial data. Tests include a deliberately blocked collector and a concurrent
+SQLite writer.
+
+Windows now has a dedicated conservative installer with verified isolated
+process replacement, CPU pressure cancellation, idle priority, two affinity
+slots, monitored four-GiB child RSS, six-GiB host reserve and foreground
+browser/media yielding. GPU power is not changed globally; the RTX helper stays
+off after the reported hang. This uses Windows CPU for admitted jobs, not pooled
+RAM/VRAM or guaranteed GPU safety. Actual Windows execution and V100 profit or
+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.

pyproject.toml

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

rlm/v100/architectures.py

@@ -406,6 +406,10 @@ def run_candidate(
     if pool.stat().st_size > 8 * 2**20:
         raise ValueError("Architecture corpus exceeds 8 MiB pilot budget")
     train, validation = load_records(pool, root / "research/state/architecture-splits.sqlite3")
+    from rlm.v100.morphology import read_shape
+
+    shape = read_shape(output / "source/model.py")
+    memory_ablation = None
     run = output / "trial"
     with resource_lease(root, budget["device"]):
         run.mkdir(exist_ok=False)
@@ -447,6 +451,29 @@ def run_candidate(
             eval_time = phase(output, run, inputs, budget, "predict")
             if file_hash(weights) != weights_sha:
                 raise ValueError("Architecture changed weights while being evaluated")
+            if shape and shape.get("memory_kind") == "causal-hashed-ngram-v1":
+                shutil.copyfile(run / "predict.log", run / "memory-enabled.log")
+                configuration["ablate_ngram_memory"] = True
+                atomic_json(inputs / "config.json", configuration)
+                ablation_time = phase(output, run, inputs, budget, "predict")
+                if file_hash(weights) != weights_sha:
+                    raise ValueError("Architecture changed weights during memory ablation")
+                shutil.copyfile(run / "predict.log", run / "memory-disabled.log")
+                if (run / "memory-disabled.log").stat().st_size > 2 * 2**20:
+                    raise ValueError("Ablation output exceeds protocol budget")
+                ablation_predictions = [
+                    json.loads(line)
+                    for line in (run / "memory-disabled.log").read_text().splitlines()
+                    if line.startswith('{"id":')
+                ]
+                ablation_cases = score_predictions(rows, ablation_predictions)
+                memory_ablation = {
+                    "disabled_passed_cases": sum(row["passed"] for row in ablation_cases),
+                    "disabled_evaluation_seconds": ablation_time,
+                    "cases": ablation_cases,
+                    "scope": "Same trained weights with memory disabled; feature ablation only, not an independently trained capacity-matched baseline",
+                }
+                shutil.copyfile(run / "memory-enabled.log", run / "predict.log")
         if (run / "predict.log").stat().st_size > 2 * 2**20:
             raise ValueError("Architecture prediction output exceeds its protocol budget")
         predictions = [
@@ -471,6 +498,12 @@ def run_candidate(
             "status": "scored full-weight submodel pilot; main serving model was not replaced",
             "scope": "Finite development suite; sampled resource monitoring is not hardware partitioning or proof against malicious code",
         }
+        if memory_ablation is not None:
+            memory_ablation["enabled_passed_cases"] = report["passed_cases"]
+            memory_ablation["development_improvement"] = (
+                report["passed_cases"] > memory_ablation["disabled_passed_cases"]
+            )
+            report["memory_ablation"] = memory_ablation
         atomic_json(run / "quality.json", report)
         from rlm.v100.experiments import SharedLab
 

rlm/v100/backtesting.py

@@ -113,7 +113,7 @@ def simulate(
     }
 
 
-def run(root: Path, branch: str, arguments: dict) -> dict:
+def run(root: Path, branch: str, arguments: dict, *, source_snapshot: tuple | None = None) -> dict:
     from rlm.v100.research_tools import download_page
 
     if set(arguments) != {"price_url", "event_url", "rule", "fee_bps", "slippage_bps"} or arguments[
@@ -124,7 +124,9 @@ def run(root: Path, branch: str, arguments: dict) -> dict:
         value = arguments[field]
         if type(value) not in (int, float) or not math.isfinite(value) or not 0 <= value <= 1000:
             raise ValueError("Backtest costs must be explicit bounded assumptions")
-    price_url, body = download_page(arguments["price_url"])
+    price_url, body = (
+        source_snapshot if source_snapshot is not None else download_page(arguments["price_url"])
+    )
     now = datetime.now(UTC)
     bars = bars_from_source(price_url, body, now)
     sources = [

rlm/v100/chat_facts.py

@@ -0,0 +1,98 @@
+"""Local factual answers do not depend on model availability or narratives."""
+
+import re
+from pathlib import Path
+
+from rlm.v100.income_policy import normalized
+
+
+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",
+            normalized(message),
+        )
+        else "English"
+    )
+
+
+def requested(message: str) -> bool:
+    return bool(
+        re.search(
+            r"zarab|income|profit|backtest|minus|paper|opportunit|candidate|brier|kandydat",
+            normalized(message),
+        )
+    )
+
+
+def response(root: Path, message: str) -> dict:
+    from rlm.v100.income_opportunities import status
+    from rlm.v100.progress import snapshot
+
+    value = snapshot(root)
+    board = status(root)
+    pl = language(message) == "Polish"
+    paper = value.get("paper", {})
+    lines = [
+        "Brak potwierdzonego rzeczywistego dochodu. Nie ma wiarygodnej daty pierwszego zarobku."
+        if pl
+        else "No actual income verified. There is no verified date of first income.",
+        ("Faza: " if pl else "Phase: ") + str(value.get("phase")),
+        ("Wykonania paper: " if pl else "Paper fills: ")
+        + str(paper.get("executed_fills", "unknown")),
+        "Zero wykonań nie potwierdza strategii. Prognozy nie są transakcjami."
+        if pl
+        else "Zero fills do not validate a strategy. Forecasts are not trades.",
+        ("Blokady: " if pl else "Blockers: ")
+        + (", ".join(value["paper_blockers"]) if "paper_blockers" in value else "unknown"),
+        ("Czas zapisanej kontroli: " if pl else "Stored audit timestamp: ")
+        + str(value.get("updated_at", "unavailable")),
+        ("Zarejestrowane hipotezy dla celu: " if pl else "Registered current-goal hypotheses: ")
+        + str(len(board["candidates"])),
+        "Ujemny zwrot backtestu jest stratą symulacji historycznej. Nie jest wynikiem Brier ani benchmarku."
+        if pl
+        else "A negative backtest return is a historical simulated loss, not a Brier or benchmark score.",
+    ]
+    for row in value.get("recent_exploratory_backtests", []):
+        net = row.get("development_test", {}).get("net_return")
+        lines.append(
+            str(row.get("parameters", {}).get("rule"))
+            + ": "
+            + (f"{net:.2%}" if type(net) in (int, float) else "unknown")
+            + " | "
+            + str(row.get("report"))
+        )
+    return {
+        "answer": "\n".join(lines),
+        "actions": [],
+        "applied": [],
+        "facts": value,
+        "responder": {"model": "controller-financial-evidence"},
+        "scope": "Read-only host evidence; no plan, weight, order or spending changes",
+    }
+
+
+def test_response(root: Path, message: str) -> dict:
+    from rlm.v100.market_research import compare
+
+    value = compare(root)
+    lines = [value["state"], value.get("error", value["scope"])]
+    for row in value["comparisons"]:
+        net = row["development_test"].get("net_return")
+        lines.append(
+            row["parameters"]["rule"]
+            + ": "
+            + (f"{net:.2%}" if type(net) in (int, float) else "unknown")
+            + " | "
+            + row["triage"]["state"]
+            + " | "
+            + row["report"]
+        )
+    return {
+        "answer": "\n".join(lines),
+        "actions": [],
+        "applied": [value],
+        "responder": {"model": "controller-historical-comparison"},
+        "scope": "Historical research executed; no future edge, verified income or orders claimed",
+    }