v60: launch native GPU serving directly and track concrete income research receipts

Author: Mantiee

SYNTA_RECOVERY.md

@@ -1,4 +1,4 @@
-# Synta recovery, v59
+# Synta recovery, v60
 
 This fixes the uploaded dashboard snapshot's demonstrated failures, not a claim
 that every strategy is profitable or every candidate must be accepted.
@@ -32,3 +32,42 @@ that every strategy is profitable or every candidate must be accepted.
 No change executes real orders, purchases, paid APIs or account creation. It does
 not certify the historical placeholder scalping/arbitrage scripts. Production
 execution and measured progress must be checked after installation on Debian.
+
+## v60: native startup and concrete income research
+
+- Managed native serving executes llama-server directly, with the original argv
+  and library environment. CUDA loading overlaps artifact hashing; the protected
+  receipt is bound to the actual child PID/start identity and unchanged files.
+  Protected evaluation still waits for hashes and health. Native health startup
+  is bounded to at most 180 seconds; failed children are retired. Hash I/O itself
+  is visible but not interruptible by that deadline. No second inference CLI is
+  launched. This removes a redundant startup path; the user's precise stalled
+  stack was not supplied, so a successful V100 start remains a hardware check.
+- `mission-status.server_startup` and dashboard show startup stage/PID/error.
+  Isolated/remote transports are labelled separately, not claimed as native GPU.
+- Operator helper duty percent is preserved by research policy. The old policy
+  silently capped 50% at 30%; no hard utilization or board power cap is claimed.
+- UI-dominated and known previous commissioning income plans are archived and
+  replaced with evidence-backed opportunities/tests across domains. Automatic
+  financial plans cannot smuggle UI work in by mentioning income/forecasts.
+  The long-term goal and explicit operator authority stay unchanged.
+- One bounded, deduplicated RTX research assignment runs every ten minutes
+  independently of the V100 training phase when income research is enabled.
+  Queue failures are recorded. Allocation alone is not discovery or success.
+- `income_opportunities` and `register_income_opportunity` expose fresh
+  host-archived source IDs, conservative gross/net estimates before personal
+  tax, labor, first-income delay, eligibility, blockers and falsification.
+  Zero upfront spend is mandatory. Estimates cannot become actual revenue,
+  training labels or accepted master weights. Earlier versions are retained;
+  repeated titles/domain update a candidate instead of multiplying it.
+- Actual public fetch counters distinguish distinct URLs/content and unchanged
+  rereads. Event/source IDs, checksums and acquisition times are separate from
+  the shared journal filename. Historical finished jobs are labelled. Old local
+  stream fragments are cleared when a new inference starts. Counters cover only
+  instrumented calls, not unseen OS/network activity.
+- Dashboard adds opportunity/test and source-acquisition panels through the
+  existing transactional renderer; no guest script permission is expanded.
+
+No payment ledger is connected. Nothing here guarantees an undiscovered edge,
+fast large income, validated strategy, automatic sale or universal continual
+learning. Prepared useful work, actual outcomes and payment remain distinct.

SYNTA_REQUIREMENTS_AUDIT.md

@@ -1,4 +1,4 @@
-# Synta: requirement and verification audit, v59
+# Synta: requirement and verification audit, v60
 
 This audits the visible conversation. "Implemented" means code exists and the
 listed checks pass, not that it has run successfully on the operator's computers.
@@ -70,3 +70,17 @@ See `SYNTA_RECOVERY.md`: same-run stale-report preservation, independent verifie
 goal reads, read-only goal-status SQLite, actual process/forecast receipts, archived
 UI-plan recovery and independent forward-only financial reference labels. These
 labels commission supervised task data, not model skill or profitable strategies.
+
+## v60 recovery additions
+
+Native startup now bypasses a second controller CLI and reports stages with a
+child-bound protected receipt. Research respects the operator's 50% pacing.
+Income candidates/tests have their own bounded, versioned evidence ledger and
+periodic RTX allocation, including non-market mechanisms. UI work cannot replace
+automatic financial plans. Public-source counters distinguish rereads and fresh
+content; event evidence is separate from a shared journal path.
+
+Validation includes a real child HTTP server standing in for the native binary,
+actual SQLite/host source archives with mocked network, concurrent fetch-counter
+updates, invalid/stale evidence rejection and explicit unknown payment. It does
+not test V100 CUDA, profitability, actual demand or the operator's Windows run.

pyproject.toml

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

rlm/v100/background_observer.py

@@ -12,8 +12,11 @@
 def tick(root: Path) -> None:
     from rlm.v100.goal_compute import tick as compute_tick
     from rlm.v100.goal_learning import tick as goal_tick
+    from rlm.v100.income_opportunities import commission
     from rlm.v100.spot_bootstrap import prepare
 
+    commission(root)
+
     try:
         goal_tick(root)
     except (OSError, ValueError, RuntimeError, requests.RequestException) as error:

rlm/v100/competition.py

@@ -77,11 +77,22 @@ def guard_cpu_process(
 def managed_server(
     profile_path: Path, root: Path, log_path: Path, cancel: threading.Event | None = None
 ):
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    startup_path = log_path.with_suffix(".startup.json")
+
+    def startup(stage: str, **details) -> None:
+        value = {"stage": stage, "updated": time.time(), "log": str(log_path), **details}
+        atomic_json(startup_path, value)
+        print("Server startup:", json.dumps(value), flush=True)
+
+    startup("validating-profile")
     profile = load_profile(profile_path, root)
     from rlm.v100.remote_helper import remote_profile
-    from rlm.v100.scratch_master import is_scratch, verify
 
-    if is_scratch(profile):
+    if profile["runtime"].get("backend") == "isolated-architecture":
+        from rlm.v100.scratch_master import verify
+
+        startup("verifying-isolated-architecture")
         verify(profile)
         log_path.parent.mkdir(parents=True, exist_ok=True)
         with log_path.open("a") as log:
@@ -95,6 +106,7 @@ def managed_server(
         return
 
     if remote_profile(profile):
+        startup("checking-remote-backend", endpoint=profile["runtime"]["base_url"])
         client = helper_client(profile, root)
         from rlm.v100.remote_helper import OllamaResearchClient
 
@@ -125,16 +137,31 @@ def managed_server(
     }
     if cpu:
         environment["CUDA_VISIBLE_DEVICES"] = ""
-    log_path.parent.mkdir(parents=True, exist_ok=True)
+    if profile["server"].get("library_path"):
+        environment["LD_LIBRARY_PATH"] = (
+            profile["server"]["library_path"] + ":" + environment.get("LD_LIBRARY_PATH", "")
+        )
+    from rlm.v100.cli import server_command
+    from rlm.v100.serving import write_receipt
+
+    argv = server_command(profile)
+    for key in ("binary", "model", "draft_model"):
+        value = profile["server"][key]
+        if value and not Path(value).is_file():
+            raise FileNotFoundError(value)
+    startup("launching-native-process")
     with log_path.open("a") as log:
+        log.write("Starting native server directly: " + json.dumps(argv) + "\n")
+        log.flush()
         process = subprocess.Popen(
-            command(root, profile_path, "serve"),
+            argv,
             stdout=log,
             stderr=subprocess.STDOUT,
             env=environment,
         )
         stop_guard = threading.Event()
         guard = None
+        ready = False
         if cpu and profile.get("resources", {}).get("cpu_guard"):
             guard = threading.Thread(
                 target=guard_cpu_process,
@@ -143,9 +170,21 @@ def managed_server(
             )
             guard.start()
         try:
+            deadline = time.monotonic() + min(180, profile["runtime"]["max_timeout"])
+            startup("verifying-artifacts", pid=process.pid)
+            # The native child loads CUDA concurrently with verification. No second
+            # controller CLI import, registry initialization or Python launcher.
+            if process.poll() is not None:
+                raise RuntimeError(f"Native server exited before verification; inspect {log_path}")
+            try:
+                write_receipt(profile, root, pid=process.pid)
+            except ProcessLookupError as error:
+                raise RuntimeError(
+                    f"Native server exited during verification; inspect {log_path}"
+                ) from error
+            startup("waiting-for-health", pid=process.pid)
             if cpu:
                 os.setpriority(os.PRIO_PROCESS, process.pid, 10)
-            deadline = time.monotonic() + profile["runtime"]["max_timeout"]
             with requests.Session() as session:
                 session.trust_env = False
                 while True:
@@ -165,7 +204,12 @@ def managed_server(
                     if response.status_code == 200:
                         break
                     time.sleep(0.25)
+            startup("ready", pid=process.pid)
+            ready = True
             yield profile
+        except Exception as error:
+            startup("failed", pid=process.pid, error=str(error)[:500])
+            raise
         finally:
             stop_guard.set()
             if guard is not None:
@@ -177,6 +221,8 @@ def managed_server(
                 except subprocess.TimeoutExpired:
                     process.kill()
                     process.wait()
+            if ready:
+                startup("stopped", pid=process.pid)
 
 
 @contextmanager