winclaw-harness / notebook.py
hkblockchaintechnology's picture
WINCLAW: Windows domain knowledge registry + real error codes wired into the simulator
437dfe5 verified
Raw History Blame Contribute Delete
56 kB
import marimo __generated_with = "0.25.2" app = marimo.App(width="medium", auto_download=["html"]) @app.cell def _(): import marimo as mo return (mo,) @app.cell def winclaw_setup(): # Single import surface. Everything below reads from here; nothing below re-imports. # /marimo/winclaw is sandbox-local and dies with the session; Continuum restores it from # the Hub before this cell runs. The HF token is never referenced in source. import json import os import pathlib import subprocess import sys import time sys.path.insert(0, "/marimo") from winclaw import (actlang, apps, appsuite, audit, boundary, capabilities, continuum, perf, train_gpu, corpus, design, glyphforge, harness, jobs, kb, knowledge, modelspec, policy, rasteron, roadmap, supervisor, tokenizer, toyenv, training, transfer, uialite, verdict, verify, vertical, vfs, winsim) return ( actlang, apps, appsuite, audit, boundary, capabilities, continuum, corpus, design, glyphforge, harness, jobs, json, knowledge, modelspec, os, pathlib, policy, rasteron, roadmap, subprocess, sys, time, tokenizer, toyenv, train_gpu, training, transfer, uialite, verdict, verify, vertical, vfs, winsim, ) @app.cell def bootstrap(continuum, mo, pathlib): # Bootstrap: what this notebook cannot continue without. Runs first, always. import shutil import torch _root = pathlib.Path("/marimo") try: _ctx = continuum.Continuum("hkblockchaintechnology", stage="pretrain") _token, _who = "present", _ctx.api.whoami().get("name") except Exception as _e: _token, _who = f"MISSING ({type(_e).__name__})", "-" _dl = continuum.Deadline() _gpu = torch.cuda.get_device_name(0) if torch.cuda.is_available() else "none" _free_gb = shutil.disk_usage("/marimo").free / 1e9 _units = sorted(p.stem for p in (_root / "winclaw").glob("*.py")) mo.md(f""" # Session bootstrap | check | state | |---|---| | HF token | **{_token}** | | HF account | `{_who}` | | GPU | {_gpu} | | sandbox free disk | {_free_gb:,.1f} GB - ephemeral, dies with the session | | package modules | {len(_units)} | | session budget | 12 h wall clock, soft stop 30 min before the end | | deadline now | {_dl.report()} | **The token is re-supplied every session** via `HF_TOKEN` or `~/.config/winclaw/token` (0600). It is deliberately absent from all notebook source. Units loaded: {", ".join(f"`{u}`" for u in _units)} """) return @app.cell def job_board(jobs, mo): # The job board, read live from the Hub so progress survives the sandbox. _j_state = jobs.load() _j_next = jobs.ready(_j_state) mo.md(f""" # Job board {jobs.markdown(_j_state)} ## Ready to start {chr(10).join(f"- `{j['id']}` {j['hours']:g}h - {j['title']}" for j in _j_next[:8]) or "- nothing ready"} *Human-owned jobs are listed and never started by the agent.* """) return @app.cell def supervisor_launch(mo, pathlib): # Launch controls. Two marimo rules shape this cell: # * a cell may not read a widget value in the cell that creates it # * underscore-prefixed names are cell-local, so anything shared crosses without one run_dir = pathlib.Path("/marimo/run") run_dir.mkdir(exist_ok=True) launch_armed = mo.ui.checkbox(label="armed - tick this, then re-run the launcher cell below") launch_cfg = mo.ui.dictionary({ "objective": mo.ui.text(value="J07 checkpoint, kill, resume", label="objective", full_width=True), "stage": mo.ui.text(value="stub", label="stage (real stage names are guarded)"), "steps": mo.ui.number(value=200000, start=1, stop=10**9, label="step cap"), "minutes": mo.ui.number(value=11.5, start=0.1, stop=12, label="budget (minutes)"), "tier_a_s": mo.ui.number(value=900, start=5, stop=7200, label="tier A every (s)"), "tier_b_s": mo.ui.number(value=3600, start=5, stop=7200, label="tier B every (s)"), }) mo.hstack([launch_armed, launch_cfg], justify="start") return launch_armed, launch_cfg, run_dir @app.cell def supervisor_launch_run( launch_armed, launch_cfg, mo, os, run_dir, subprocess, sys, time, ): # The launcher. Detached via start_new_session, which is why a kernel restart cannot stop it. _log = run_dir / "supervisor.log" if not launch_armed.value: _verdict = ("**Not armed** - nothing is running. When armed, this cell launches " "`python -m winclaw.supervisor` detached, so it survives this cell, this " "kernel, and me.") else: _c = launch_cfg.value _cmd = [sys.executable, "-m", "winclaw.supervisor", "--objective", str(_c["objective"]), "--stage", str(_c["stage"]), "--steps", str(int(_c["steps"])), "--minutes", str(_c["minutes"]), "--tier-a", str(int(_c["tier_a_s"])), "--tier-b", str(int(_c["tier_b_s"])), "--heartbeat", "300"] with open(_log, "w") as _fh: _proc = subprocess.Popen(_cmd, cwd="/marimo", env=dict(os.environ, PYTHONPATH="/marimo", WINCLAW_SESSION_START=str(time.time())), stdout=_fh, stderr=subprocess.STDOUT, start_new_session=True) _verdict = (f"**Launched detached.** pid `{_proc.pid}`, stage `{_c['stage']}`, budget " f"{_c['minutes']} min, log `{_log}`.") mo.md(f"# Supervisor launch\n\n{_verdict}") return @app.cell def supervisor_monitor(continuum, json, mo, pathlib): # Monitor: tail the newest session log and the Hub pointer. Read-only, never mutates. _run_files = sorted(pathlib.Path("/marimo/run").glob("*.jsonl"), key=lambda p: p.stat().st_mtime) _events = ([json.loads(l) for l in _run_files[-1].read_text().splitlines() if l.startswith("{") and '"event"' in l] if _run_files else []) _losses = [e["loss"] for e in _events if e["event"] == "step"] _blocks = "▁▂▃▄▅▆▇█" if _losses: _lo, _hi = min(_losses), max(_losses) _span = max(_hi - _lo, 1e-9) _spark = "".join(_blocks[min(int((v - _lo) / _span * 7), 7)] for v in _losses[-60:]) else: _spark = "(no steps logged yet)" _gates = [e for e in _events if e["event"] == "smoke_gate"] _cks = [e for e in _events if e["event"] == "checkpoint"] _res = [e for e in _events if e["event"] in ("resumed", "cold_start", "resume_gave_up")] _ptr = continuum.Continuum("hkblockchaintechnology").latest("pretrain") or {} mo.md(f""" # Supervisor monitor **Newest log:** `{_run_files[-1].name if _run_files else "none"}` - {len(_events)} events | signal | value | |---|---| | steps logged | {len(_losses)} | | first / latest loss | {_losses[0] if _losses else "-"} / {_losses[-1] if _losses else "-"} | | resume decisions | {", ".join(e["event"] for e in _res) or "-"} | | smoke gates | {", ".join(f"{e['tier']}@{e['tried_step']} drift {e['drift_pct']}% " + ("PASS" if e["passed"] else "FAIL") for e in _gates) or "-"} | | checkpoints taken | {", ".join(f"{e['tier']}@{e['step']}" for e in _cks) or "-"} | | model-repo pointer | {_ptr.get("stage", "-")} / {_ptr.get("tier", "-")} @ step {_ptr.get("step", "-")} | **Loss trend** (last {min(len(_losses), 60)} logged points) ``` {_spark} ``` *Mechanism runs use a stage outside the real ones, so a toy checkpoint can never be mistaken for a trained model.* """) return @app.cell def checkpoint_integrity(mo): # Which stage to audit. Separate cell from its consumer, and public so it can cross. inspect_stage = mo.ui.dropdown(options=["pretrain", "sft", "dpo", "grpo", "gateproof", "stub"], value="pretrain", label="stage to inspect") inspect_stage return (inspect_stage,) @app.cell def checkpoint_integrity_check(continuum, inspect_stage, json, mo, pathlib): # Checkpoint integrity: pull whatever the Hub claims and verify every byte. Trust nothing. from huggingface_hub import hf_hub_download _c = continuum.Continuum("hkblockchaintechnology") _ptr = _c.latest(inspect_stage.value) or {} if not _ptr.get("manifest"): _out = f"Stage **{inspect_stage.value}** has no checkpoint - {_ptr.get('status', 'no pointer')}" else: _man = json.loads(pathlib.Path(hf_hub_download( _c.rid(continuum.MODEL_REPO), _ptr["manifest"], repo_type="model", token=_c.token)).read_text()) _rows, _ok = [], True for _rel, _rec in _man["files"].items(): _lp = hf_hub_download(_c.rid(continuum.MODEL_REPO), _rel, repo_type="model", token=_c.token, force_download=True) _same = continuum.sha256_file(_lp) == _rec["sha256"] _ok &= _same _rows.append(f"| `{_rel.split('/')[-1]}` | {_rec['size']:,} | {_rec['sha256'][:12]} " f"| {'OK' if _same else '**MISMATCH**'} |") _out = (f"**Tier {_ptr.get('tier')} at step {_ptr.get('step')}** " f"(exact resume: {_ptr.get('exact')}), {len(_man['files'])} files, " f"**all sha256 verified: {_ok}**\n\n" f"| file | bytes | sha256 | check |\n|---|---|---|---|\n" + "\n".join(_rows)) mo.md(f"# Checkpoint integrity\n\n{_out}") return @app.cell def periodic_verification(continuum, mo, toyenv, verify): # Periodic verification: does it actually work? The loss does not answer that question. # This cell runs the same battery the supervisor runs mid-training, including the negative # controls, so the battery is exercised on the notebook's side too. _rec = verify.run(policy=toyenv.expert_policy, name="expert reference (notebook side)") _c = continuum.Continuum("hkblockchaintechnology") _ptrs = {_s: (_c.latest(_s) or {}) for _s in ("pretrain", "finaldemo", "gateproof", "rollback3")} _ptr_rows = "\n".join( f"| `{_s}` | {v.get('tier', '-')} | {v.get('step', '-')} | " f"{v.get('rolled_back_from', '') or ''} -> {v.get('rolled_back_to', '') or ''} | " f"{v.get('reason', v.get('status', '')) or ''} |" for _s, v in _ptrs.items()) _lease = _c._read_json("locks/finaldemo.json", continuum.MODEL_REPO, "model") or {} mo.md(f""" # Periodic verification Three questions, asked on a cadence, and the battery must be able to answer *no* to each: 1. **Is it alive?** liveness, heartbeat freshness 2. **Is it learning?** loss falling, gradients finite 3. **Does it work?** the policy solves canary tasks whose checker reads real state The loss answers only the second. A run can lose gracefully while the agent does nothing useful, which is why the third question is asked separately and on a timer. {verify.markdown([_rec])} ## Rollback state across the stages we ran | stage | tier | step | rolled back | reason | |---|---|---|---|---| {_ptr_rows} Lease on `finaldemo`: `{_lease.get('owner', 'none')}` - a single-writer lease exists because **two supervisors on one stage do not race, they hang**: both block on the repository's commit lock, and the run silently stops making progress. ## What the negative controls cost us Every control is a deliberate breakage that the battery must notice. Two of them found real defects in this very mechanism: | defect | how it was found | |---|---| | integrity gate blind at the loss floor | a 15% weight perturbation moved the loss 0.7%, inside a 3% tolerance: loss continuity is a *semantic* check, not an integrity one. Fixed with a parameter fingerprint. | | detection that changed nothing | the first regression run only logged `rollback_skipped`; with no earlier checkpoint the system still has to act, so it now marks the checkpoint untrusted. | | checkpointing starved training | a 1-second tier cadence dropped throughput from 200 to 20 steps/s; uploads are now budgeted to 10% of wall time. | | two writers hung the repo | found by `ps`: two supervisors alive, one stuck 30s in a tier C upload. Fixed with a lease. | """) return @app.cell def app_suite(appsuite, mo): # The application suite and the operations matrix, measured rather than asserted. _a = appsuite.audit() _cov = appsuite.coverage() _rows = "\n".join( f"| {_d} | {_r['total']} | {_r['expressible']} | {_r['verifiable']} | **{_r['covered']}** |" for _d, _r in _cov["per_domain"].items()) _apps = "\n".join(f"| **{_x.name}** | {_x.kind} | {_x.owns} | {_x.effort_hours:g} | " f"{_x.status} |" for _x in appsuite.APPS) _hard = ", ".join(f"`{_o.id}`" for _o in appsuite.OPERATIONS if _o.difficulty >= 4) _daily = [f"`{_o.id}` {_o.title}" for _o in appsuite.OPERATIONS if _o.frequency == "daily"] mo.md(f""" # Application suite and operations matrix "Serious enough for daily operations" is only meaningful when it is enumerable. So it is: **{_a['operations']} operations** across **{_a['domains']} domains** - {_a['daily_operations']} of them daily work - served by **{_a['apps']} applications**. Every operation declares which apps it uses, which capability verbs it needs, which checker verifies the outcome, its difficulty and its frequency. **Expressible and verifiable: {_a['coverage_pct']}%.** An operation counts as covered only if every verb it needs exists in the capability matrix and its checker predicate exists in Verdict. Otherwise it is listed as a gap, not averaged away. Gaps right now: **{len(_cov['gaps'])}**. ## Depth by domain | domain | operations | expressible | verifiable | covered | |---|---|---|---|---| {_rows} ## Applications | application | kind | owns | hours | status | |---|---|---|---|---| {_apps} Total application effort: **{sum(_x.effort_hours for _x in appsuite.APPS):g} hours**. ## What "daily" means here {", ".join(_daily[:14])} - and {len(_daily) - 14} more. ## The long-horizon ones {_hard} *Files is built. The other fifteen are specified, budgeted and unaudited by the battery until they exist - which is the same standard the rest of this project is held to.* """) return @app.cell def files_app(apps, mo, uialite, vfs): # The first real application: Files. Real VFS, real render, real UiaLite tree, and daily # operations completed end to end with the outcome checked. from PIL import Image as _Image _fs = vfs.VFS() _fs.mkdir(f"{vfs.SPECIAL['documents']}/Invoices") _fs.write(f"{vfs.SPECIAL['documents']}/memo.txt", "shopping list") _fs.write(f"{vfs.SPECIAL['documents']}/report.csv", "id,val") _fs.write(f"{vfs.SPECIAL['documents']}/budget.xlsx", "PK") _create = apps.FilesApp(_fs) # operation f01: create a folder and name it _f01 = [{"verb": "ui.invoke", "label": "New folder"}, {"verb": "keyboard.type", "text": "Archive 2026"}, {"verb": "keyboard.key", "name": "Enter"}] for _a in _f01: _r = apps.dispatch(_create, _a) _f01_ok = _fs.exists(f"{vfs.SPECIAL['documents']}/Archive 2026") # operation f05: delete to the Recycle Bin, and confirm that the dialog GATES it _create.selection = [r["name"] for r in _create.items()].index("memo.txt") apps.dispatch(_create, {"verb": "keyboard.key", "name": "Delete"}) _gated = _fs.exists(f"{vfs.SPECIAL['documents']}/memo.txt") _refuse = apps.dispatch(_create, {"verb": "ui.dialog_respond", "accept": False}) _kept = _fs.exists(f"{vfs.SPECIAL['documents']}/memo.txt") apps.dispatch(_create, {"verb": "keyboard.key", "name": "Delete"}) _accept = apps.dispatch(_create, {"verb": "ui.dialog_respond", "accept": True}) _intact = all(_fs.exists(f"{vfs.SPECIAL['documents']}/{n}") for n in ("report.csv", "budget.xlsx")) _recycled = len(_fs.recycle) == 1 # index -> element -> action, which is how ActLang refers to things _k = _create.element_index("View") apps.dispatch(_create, {"verb": "ui.invoke", "elem": _k}) _est = uialite.estimate_tokens(_create.frame(), history_diffs=0) _dg = uialite.render(uialite.digest(_create.frame(), max_nodes=12)) _img = _Image.fromarray(_create.render().to_uint8()) mo.md(f""" # Files, working | operation | action sequence | outcome | checker | |---|---|---|---| | `f01` create a folder and name it | New folder, type, Enter | created | `dir_exists` = **{_f01_ok}** | | `f05` delete to the Recycle Bin | select, Delete, respond to the dialog | recycled | `no_side_effects` = **{_intact}** | The confirmation **gates** the destructive action, which is the property that matters: after Delete and before answering, `memo.txt` is **{_gated}** still present; refusing keeps it (**{_kept}**); accepting moves it to the Recycle Bin (**{_recycled}**), and the other files are untouched (**{_intact}**). Element references resolve the way ActLang says they do: `"View"` is digest index **{_k}**, and invoking by index only sets the view mode. **Digest cost for the real app: {_est['nodes']} nodes, {_est['total']} tokens.** ``` {_dg} ``` The rendered window follows - drawn by GlyphForge into its own canvas, since Rasteron is still a specification and calling it built would be a lie this project does not tell. """) _img return @app.cell def hardware_utilisation(json, mo, pathlib, train_gpu): # Hardware utilisation: measured, and the design rules that fall out of it. _perf = json.loads(pathlib.Path("/marimo/run/perf.json").read_text()) _perf2 = json.loads(pathlib.Path("/marimo/run/perf2.json").read_text()) _gpu = json.loads(pathlib.Path("/marimo/run/gpu_train.json").read_text()) _cfg = train_gpu.RECOMMENDED _req = train_gpu.data_rate_requirement(189_087) def _row(r, label=None): if r.get("error"): return (f"| {label or r['cfg']['name']} | | {r['cfg']['batch']}x{r['cfg']['seq']} | " f"| | | | | | {r['error']} |") return (f"| {label or r['cfg']['name']} | {r['params_m']}M | {r['cfg']['batch']}x" f"{r['cfg']['seq']} | {r['step_s']}s | {r['tokens_s']:,} | {r['tflops']} | " f"**{r['mfu_pct']}%** | {r['util_pct']}% | {r['peak_gb']}GB |") _rows = "\n".join(_row(r) for r in _perf["results"]) _rows2 = "\n".join(_row(r, k) for k, r in _perf2.items()) mo.md(f""" # Hardware utilisation **{_perf['device']}**, {_perf['vram_gb']} GB. Reference peak is **measured**, not from a datasheet: a large bf16 matmul gives **{_perf['peak_tflops']} TFLOP/s** on this device, and every percentage below is a fraction of that. ## The sweep | config | params | batch x seq | step | tokens/s | TFLOP/s | MFU | util | VRAM | |---|---|---|---|---|---|---|---|---| {_rows} ## What each knob is worth | case | result | |---|---| {_rows2} ## Design rules that came out of the measurements 1. **Sequence length beats batch count.** 16x8192 reached **91.3% MFU**; 32x2048 reached 64.5% with half the tokens per step. Long context is not a cost here, it is the win. 2. **Never micro-batch.** batch 1 x 2048 with 16 accumulation steps measured **2.7% MFU** while the device reported **99.8% utilisation**. Utilisation is not efficiency, and quoting it as though it were is a way of lying with a real number. 3. **Activation checkpointing is a trade, not a free win**: ~9 MFU points for half the activation memory, which is what makes the larger batches fit at all. 4. **A per-step device sync costs nothing** at 0.7 s/step (0.2020 s vs 0.2018 s). The worry was unfounded and is recorded as such. 5. **A CPU producer under the step time is free** - 30 ms per batch changed MFU by 0.2 points, because CUDA is asynchronous and the CPU side of step N overlaps the device side of step N-1. This is why a CPU-side renderer is viable at all. ## The number that decides the architecture At the measured 189k tokens/s the device can consume, the data pipeline must supply: | requirement | value | |---|---| | tokens/s | {_req['tokens_per_s']:,} | | screens/s at ~550 tokens each | **{_req['screens_per_s']}** | | screens/hour | {_req['screens_per_hour']:,} | | tokens per 12 h session at 80% duty | **{_req['tokens_per_12h_session']:,}** | So **the GPU is not the bottleneck - the simulator is.** The rasteriser measured 490 screens/s naive and memory-bandwidth-bound; the requirement is ~344/s. The margin exists, but it is not large, and it is the thing to protect. ## The GPU trainer, actually running | metric | value | |---|---| | config | {_gpu['steps']} steps at {_cfg['batch']}x{_cfg['seq']}, d{_cfg['d']}, {_cfg['layers']} layers | | tokens | {_gpu['tokens']:,} | | tokens/s | {_gpu['tokens_per_s']:,} | | TFLOP/s | {_gpu['tflops']} | | MFU over the whole run | {_gpu['mfu_pct']}% | | peak VRAM | {_gpu['peak_gb']} GB (identical to the standalone bench) | The gap between 52.7% here and 91.3% in the sweep is not the model: this run's clock includes warmup and two **275 MB checkpoint uploads**. Steady state is 0.693 s/step. **Uploads should be asynchronous**, which is named here as the next optimisation and is not yet measured. ## Three wrong diagnoses, recorded rather than deleted The trainer OOMed three times and I blamed, in order: the loss implementation, then a "head-memory wall", then chunking. All three were wrong. The cause was a missing `.to(torch.bfloat16)` in the trainer's constructor, so the model trained in **fp32** and the head's logits cost 17 GB instead of 8.6. The arithmetic in `train_gpu.head_memory_gb()` is still worth knowing, at bf16 it is half of what it claimed, and the lesson is about ordering: **check the dtype first**, before theorising about memory. That sequence is in the file, not just in this cell, because a project that only records its correct conclusions is a project that cannot be trusted about them. """) return @app.cell def windows_knowledge(knowledge, mo, vfs): # Windows domain knowledge: what is available, what it feeds, and what it just bought us. _ka = knowledge.audit() _src = "\n".join( f"| `{s.repo}` | {s.license} | {s.size_mb:,.1f} | " f"{', '.join(s.feeds) if s.feeds else '*skipped*'} | {s.verified} |" for s in knowledge.SOURCES) _meas = "\n".join(f"| {k.replace('_', ' ')} | {v:,} |" if isinstance(v, int) else f"| {k.replace('_', ' ')} | {v} |" for k, v in knowledge.MEASURED_FIRST_INGEST.items()) _fs = vfs.VFS(); _fs.write("C:/a.txt", "1") _demos = [] for _d, _fn in (("a missing file", lambda: _fs.read("C:/a.txt.bak")), ("a missing intermediate folder", lambda: _fs.read("C:/Nowhere/x.txt")), ("copying onto itself", lambda: _fs.copy("C:/a.txt", "C:/a.txt"))): try: _fn(); _demos.append(f"| {_d} | *no error* |") except Exception as _e: _demos.append(f"| {_d} | `{getattr(_e, 'symbol', type(_e).__name__)}` " f"({getattr(_e, 'code', '?')}) - {getattr(_e, 'published', '')} |") mo.md(f""" # Windows domain knowledge There is an asymmetry that decides whether this platform is learnable at all: > **Nobody has Windows pixels or action labels. Everybody has Windows documentation.** My original corpus plan specified language, pixels and task semantics, and **never specified domain knowledge** - which is the abundant part. That gap is now closed, with licences verified by reading the files rather than trusting an SPDX label. **{_ka['ingested_mb']:,} MB** of licence-clean material across {_ka['sources']} sources. | source | licence | MB | feeds | verified by | |---|---|---|---|---| {_src} ## Three consumers, and the distinction matters - **simulator fidelity** - WinSim stops inventing error codes, dialog text and settings paths. - **harness knowledge base** - a *deterministic* lookup: intent to mechanism, error to cause. Knowledge that is a table belongs in code, not in weights. This is the boundary doctrine applied to documentation. - **model corpus** - domain vocabulary for the tokenizer, and grounded instruction text. ## What the first ingest bought, measured | metric | value | |---|---| {_meas} And the fidelity is real rather than decorative - the filesystem now fails the way Windows fails, which matters because the harness's repair step looks causes up by code: | case | what the simulator now reports | |---|---| {chr(10).join(_demos)} ## The contamination rule {chr(10).join("- " + _r for _r in knowledge.CONTAMINATION_RULE)} ## One decision for you **{", ".join(_ka['share_alike_flagged']) or "nothing"}** is flagged, not ingested. It is the highest-quality procedural knowledge available anywhere, and it is **CC-BY-SA**: share-alike would put an obligation on a public release of the model. Either we accept that licence, or we take the knowledge structurally (mechanism tables, which are facts) without its prose. The audit refuses to let a share-alike source into the corpus silently, which is why it shows up here rather than in a footnote. """) return @app.cell def design(mo): mo.md(r""" # WINCLAW — Design v0.2 (invent-from-scratch) **Directive.** No pretrained weights. No third-party model. No external dataset. No borrowed agent framework. Everything trains **from random init**, here, on data we generate ourselves. Only instruments remain: `torch`, `numpy`, `marimo`. Those are our tools, not our ingredients. **Why this is not a handicap.** On a real Windows box we would get pixels and **no supervision**. Our own substrate emits *perfect* ground truth for every frame: element bounding boxes, z-order, focus, control type, live state, the correct action, and the state transition it caused. Owning the substrate means every token we train on is labelled. From-scratch is the *only* regime where that label density can be exploited. ## Measured facts (this sandbox, not assumptions) | Fact | Value | Consequence | |---|---|---| | Kernel | Linux 4.19 **gVisor** — no KVM/qemu/Wine/X | Real Windows cannot run here; the substrate must be ours | | GPU | RTX PRO 6000 Blackwell, **97 GB**, sm_120 | **405 TFLOP/s** measured bf16 matmul | | Own GPU rasterizer | 490 screens/s naive full-frame; geometry 220k+/s | bbox-local writes -> est. **2-5k screens/s** | | Chromium render | **30 screens/s** (33 ms/frame) | 100x slower -> fidelity checks only, never the corpus engine | | HF throughput | **112 MB/s** | A 3 GB checkpoint is ~30 s: aggressive checkpointing is free | | Scratchpad | **30 s hard timeout** | **Training must be a detached process**, never a cell | | Filesystem | ephemeral 7 TB overlay | The sandbox holds nothing durable; HF is the machine's memory | ## The invented stack | Module | What we build from nothing | |---|---| | **GlyphForge** | our own 8x16 bitmap font, 96 ASCII glyphs authored programmatically; our own layout, runs, kerning | | **Rasteron** | our own GPU UI rasterizer in torch: rects, rounded rects, borders, gradients, 4x-supersampled AA, own alpha compositing and drop shadow. Emits pixels **and** exact label buffers | | **WinSim** | our own window manager and app suite (taskbar, Start, Explorer, Notepad, Settings, dialogs, UAC-ish prompts, toasts) as declarative widget trees, with an event loop, focus and z-order | | **UiaLite** | our own accessibility/state schema (versioned): role, name, bbox, enabled, focused, value, parent, window | | **ActLang** | our own typed action grammar **and** our own tokenizer (BPE trainer written by us, trained on our own corpus) | | **Winclaw-0** | our own architecture, random init — see below | | **Harness** | our own planner / observer / actor / safety / executor / verifier / critic / memory | | **Verdict** | our own eval suite, tasks and metrics | | **Continuum** | our own checkpoint and resume protocol (next cell) | ## Winclaw-0 architecture (all ours) | Part | Design | |---|---| | Vision | own ViT-style encoder, 16 px patches on a 640x400 downscale -> 1000 patches -> own two-level token merger -> **~250 visual tokens**, random init | | UI state | UiaLite tree serialized in **our BPE** -> UI tokens, interleaved with visual tokens | | History | k=4 frames as separate token blocks with a learned recency decay | | Fusion | own interleaved cross-attention with learned frame-position embeddings | | Action | own **spatial pointing head**: a distribution over a learned anchor grid plus sub-cell refinement, instead of emitting coordinate text (much higher click precision per token) | | Auxiliary | own world-model head (predict the state delta an action causes) plus own verifier/reward head; jointly trained multi-task loss | | Size | **Winclaw-0-150M ~150M** (d 768, 12 layers, ctx 1024) first; scale to 400M-1B later | ## Curriculum (our own objectives, each stage gated) | | Objective | Supervision | |---|---|---| | C0 | corpus generation: Rasteron renders screens plus exact labels | free, unlimited | | C1 | **masked UI modelling** — predict masked elements/roles/geometry from pixels | self-supervised on C0 | | C2 | **grounding**: instruction or query -> anchor distribution | exact bboxes | | C3 | **next-action imitation** from our own WinSim rollouts | exact correct actions | | C4 | **world model / inverse dynamics**: (obs, action) -> state delta | exact simulator deltas | | C5 | **RL from our own verifier reward** (our own PPO-lite plus RFT/DPO) | task checkers | Compute reconciliation (measured): ~120 TFLOP/s sustained at ~30% MFU, 150M params, ctx 1024 -> **~4B tokens per 12 h session**, ~40B tokens by session 8 = 266 tokens/param. That is a genuinely pretrained small model, not a fine-tune. ## 6b. Capability surface (after the full-control requirement) The requirement is: see, click, type, know all input and output, and write and run code. The action grammar is therefore not 11 verbs but an enumerable surface, in `winclaw/capabilities.py`: **30 perception channels x 95 action verbs**. Every verb declares its arguments, its WinSim mechanism, its real-Windows mechanism, a risk class with an enforcement rule, and the channels that verify its effect. The audit refuses any verb it cannot verify: an unverifiable capability is a wish, not a capability. Two architectural consequences: 1. **Observation is partly pull, not only push.** Full OS state is megabytes (registry, event log, process table, file trees). A fixed screenshot-plus-tree observation cannot carry it, and a model that tried to ingest it would spend its entire context on a single step. So a compact digest rides along and 10 channels are queryable on demand through `meta.observe`. 2. **Typed slot decoding, not free text.** Arguments decode into typed slots (`elem_id | path | pid | key | script`) so the model emits valid actions by construction and spends capacity on intent rather than syntax. The spatial pointing head covers the one argument that cannot be discretised cleanly: the click target. Risk is not decoration. 33 verbs run free, 38 are audited, 18 take a state snapshot and are revertible, and 6 are denied unless explicitly confirmed. **Transfer note - two real-Windows problems this exposes and does not solve here.** (a) *Elevation*: controlling UAC-protected state requires the executor to run as a service or scheduled task at highest privilege, or a consent flow. (b) *Real observation*: every channel above must be re-implemented against Win32/UIA/WMI when `RemoteWinEnv` lands, and that needs a real Windows box reachable over WinRM/RDP. """) return @app.cell def resume(mo): mo.md(r""" # 12-Hour Session Protocol — Continuum Molab gives **12 h per session**, and every session is a fresh, empty sandbox. A session is therefore a *resumable job*, not a script. Any session may be killed at any instant and the next one must continue as if nothing happened. ## Budget (12 h wall clock, enforced by the supervisor, not by a human) | Phase | Window | Work | |---|---|---| | bootstrap | 0:00-0:15 | deps, HF auth, fetch manifest and code, verify sha256 | | resume | 0:15-0:25 | pull latest checkpoint (~3 GB, ~30 s) plus corpus cursor | | smoke gate | 0:25-0:35 | 100 steps; loss must match recorded loss within 3%, else fall back one checkpoint | | **train** | 0:35-10:30 | gradient steps; hourly micro-eval | | eval | 10:30-11:15 | held-out suite, per-skill breakdown, samples | | export | 11:15-11:40 | bf16 and fp16, model card, dataset shards, manifest | | buffer | 11:40-12:00 | final push and integrity verify | `deadline = t0 + 11.5h`. Soft-stop 30 min before it. SIGTERM -> immediate checkpoint, then upload. ## Resume reads three files 1. `latest.json` — the pointer (tiny, written **last**) 2. `manifest.json` — authoritative state: step, tokens, corpus cursor, lr, seed, sha256 per file 3. `trainer_state.json` — loss history, eval, RNG states, sampler position ## Checkpoint tiers (sized by the measured 112 MB/s) | Tier | Cadence | Payload | Cost | |---|---|---|---| | **A** | 15 min | bf16 weights plus trainer_state | ~10 s | | **B** | 60 min | plus optimizer moments (fp32) -> exact resume | ~30-40 s | | **C** | session end | plus eval, card, samples, RNG, corpus cursor | minutes | | **heartbeat** | 5 min | `heartbeat.json` (step, loss, elapsed) | <1 s — for hard-kill forensics | Retention: keep last 3 plus best-by-eval. Tier A is cheap enough that worst-case loss is 15 min. ## Integrity and atomicity Stage into `_tmp/`, sha256 every file, upload **data before manifest, manifest before pointer**. A crash mid-upload can never corrupt a good pointer. The next session verifies hashes; a mismatch falls back exactly one checkpoint rather than resuming from poison. ## Determinism (exact resume, cheaply) - seed tree: `seed = f(base_seed, stage, step)` - the corpus is **materialized once** as packed token shards in fixed order, so resume is a **cursor offset** — no re-rendering, no sampling drift - RNG states and sampler position ride in the checkpoint - the smoke gate does not demand bitwise reproducibility; it demands *loss continuity* ## Process architecture (forced by the measured 30 s scratchpad limit) Training runs as a **detached supervisor process**: `setsid nohup python -m wino.train`. It owns the deadline, the checkpoint loop and the upload loop. The notebook only launches, tails logs, plots loss and can resume — so a kernel restart, a closed tab, or the agent going away cannot kill training. The supervisor can push a full checkpoint with no notebook alive. ## Cross-session plan | Session | Objective | HF deliverable | |---|---|---| | S1 | GlyphForge, Rasteron, WinSim, ActLang, tokenizer, corpus v1 | code, corpus shards, ckpt | | S2 | C1 masked UI modelling | weights, loss curve | | S3 | C2 grounding plus harness skeleton and interactive rollouts | weights, grounding eval | | S4 | C3 imitation on own rollouts | weights, task suite v1 | | S5 | C4 world model plus verifier head | weights, reward-model eval | | S6 | C5 RL from verifier reward | weights, per-skill eval | | S7 | scale to 400M plus robustness (dialogs, popups, DPI, themes) | scaled ckpts | | S8 | real-Windows bridge (if a box exists) plus release | model card, demo | ## Failure modes and recovery | Failure | Detection | Response | |---|---|---| | CUDA OOM | exception in step | halve micro-batch, resume last tier-B | | NaN or divergence | loss monitor | roll back to last good, lower LR | | sandbox killed hard | missing heartbeat | resume from last tier-A (at most 15 min lost) | | HF write error | upload retry loop | keep training, flush the local queue when back | | corrupted upload | sha256 on next resume | fall back one checkpoint | | kernel restart | irrelevant | the training process is unaffected | ## Repo layout (pushed to HF, since the sandbox is not storage) ``` winclaw/ glyphforge.py rasteron.py winsim.py uialite.py actlang.py tokenizer.py model.py heads.py harness/ tasks/ verdict.py train.py continuum.py ``` ## Open decisions 1. HF account plus a **fine-grained write-scoped token** (never pasted into a cell; env/secret only). 2. Start at **Winclaw-0-150M 150M** (fast iteration, recommended) or jump straight to ~400M? 3. Checkpoint retention: last-3 plus best, or keep everything (~3 GB per tier-B)? 4. Session 1 spends its first ~4 h on the substrate with **zero** training — accept that, or do you want a crude-model-first path that has something training by hour 3? """) return @app.cell def font_specimen(glyphforge): # GlyphForge specimen: every glyph below is drawn by our own rasterizer from # GlyphScript outlines - no font file, no atlas, no third-party text engine. from PIL import Image _fg = glyphforge.GlyphForge(ss=8) _cv = glyphforge.Canvas(760, 420, bg=(0.118, 0.122, 0.137)) # window chrome: a preview of the WinSim widget layer _cv.fill_rect(20, 20, 720, 380, (0.961, 0.961, 0.969)) _cv.stroke_rect(20, 20, 720, 380, (0.02, 0.02, 0.03), 1.0) _cv.fill_rect(21, 21, 718, 30, (0.914, 0.914, 0.929)) _fg.draw_text(_cv, 32, 41, "report.txt - Notepad", 13, (0.10, 0.10, 0.12)) for _x in (688, 706, 724): _cv.fill_rect(_x, 30, 10, 10, (0.80, 0.80, 0.82)) _cv.fill_rect(21, 51, 718, 24, (0.949, 0.949, 0.957)) for _i, _item in enumerate(("File", "Edit", "View", "Help")): _fg.draw_text(_cv, 36 + _i * 46, 67, _item, 12, (0.18, 0.18, 0.20)) _cv.fill_rect(33, 83, 694, 264, (1.0, 1.0, 1.0)) _cv.stroke_rect(33, 83, 694, 264, (0.72, 0.72, 0.75), 1.0) for _i, _row in enumerate(["ABCDEFGHIJKLMNOPQRSTUVWXYZ", "abcdefghijklmnopqrstuvwxyz", "0123456789 !?.,:;()[]{}<>", "/+-=_@#$%&*|~^'\"`"]): _fg.draw_text(_cv, 48, 112 + _i * 24, _row, 16, (0.10, 0.10, 0.13)) _cv.fill_rect(48, 216, 663, 1, (0.85, 0.85, 0.88)) _fg.draw_text(_cv, 48, 240, "UI text renders at 13 px with antialiasing from one", 13, (0.15, 0.15, 0.18)) _fg.draw_text(_cv, 48, 258, "outline definition - no bitmap atlas, no third-party font.", 13, (0.15, 0.15, 0.18)) _fg.draw_text(_cv, 48, 280, "GlyphForge: 95 glyphs, GlyphScript outlines, own rasterizer.", 12, (0.45, 0.45, 0.50)) _cv.fill_rect(620, 300, 76, 28, (0.882, 0.882, 0.898)) _cv.stroke_rect(620, 300, 76, 28, (0.60, 0.60, 0.63), 1.0) _fg.draw_text(_cv, 642, 319, "Save", 13, (0.10, 0.10, 0.12)) specimen_img = Image.fromarray(_cv.to_uint8()) specimen_img return @app.cell def corpus_plan(corpus, mo): # The corpus plan is COMPUTED from winclaw/corpus.py, so the documented mixture # cannot drift away from the code that defines it. _gen = sum(s.tokens_b for s in corpus.REGISTRY if s.doctrine == corpus.GENERATE) _imp = sum(s.tokens_b for s in corpus.REGISTRY if s.doctrine == corpus.IMPORT) _never = [s.key for s in corpus.REGISTRY if s.doctrine == corpus.NEVER] _share = "\n".join( f"- `{k}` - {lic}" + (" - **share-alike: decide before a public release**" if sa else "") for k, lic, sa in corpus.ledger()) _notes = "\n".join( f"- `{s.key}` ({s.stage}) - {s.note}" for s in corpus.REGISTRY if s.note and s.doctrine != corpus.NEVER) mo.md(f""" # Corpus plan: generate vs import **The asymmetry that decides it.** Searching Hugging Face for Windows UI corpora returns *nothing*: no `windows screenshot`, no `windows accessibility tree`, no Windows trajectory set worth the name. Language, by contrast, is abundant and ungated. So: **we cannot borrow Windows, we must build it; we cannot invent English, we must import it.** The doctrine splits three ways, not two. | category | tokens | share | why | |---|---|---|---| | **generate** (ours) | {_gen:.1f}B | {_gen / corpus.TOTAL_TARGET_B * 100:.1f}% | we own the environment, so we own exact labels nobody else has | | **import** (the world) | {_imp:.1f}B | {_imp / corpus.TOTAL_TARGET_B * 100:.1f}% | language, real pixels and real task semantics are properties of the world, not of a model | | **never** | 0 | - | weights, other agents' labels, and anything we evaluate on | Planned total: **{corpus.TOTAL_TARGET_B:.1f}B tokens**. {corpus.table()} ## Consequences that are easy to miss - **The tokenizer must see English.** `TOKENIZER_SOURCES` includes the language slice; a BPE trained only on our own grammar plus synthetic text byte-fragments real English at inference and burns context on it. - **The mixture forces the stage order.** Language-only stage A1 comes first to build semantics, then multimodal A2. A1 needs no simulator at all, so it can run while the substrate is still being built instead of waiting on it. - **Contamination is enforced, not promised.** `corpus.guard()` refuses to train on anything sharing a repo or org with an eval set. Never-import: {", ".join("`" + k + "`" for k in _never)} - **Tokenizer trained on:** {", ".join("`" + k + "`" for k in corpus.TOKENIZER_SOURCES)} ## Licence exposure for a public release {_share} ## Source notes {_notes} """) return @app.cell def continuum_status(continuum, mo): # Continuum status: the notebook reading the machine's own memory on the Hub. import json as _json _con = continuum.Continuum("hkblockchaintechnology") _rows, _err = [], "" _tot = 0 _created = _sess_id = _gpu = "?" try: _sync = _json.loads(open(_con.api.hf_hub_download( _con.rid(continuum.CODE_REPO), "SYNC.json", repo_type="dataset", token=_con.token)).read()) _meta = _sync.get("meta", {}) _created, _sess_id = _sync.get("created", "?"), _meta.get("session_id", "?") _gpu = _meta.get("gpu", "?") _tot = sum(v["size"] for v in _sync["files"].values()) _rows = [f"| `{_k}` | `{_v['sha256'][:12]}` | {_v['size']:,} |" for _k, _v in _sync["files"].items()] except Exception as _e: _err = f"SYNC read failed: {type(_e).__name__}: {_e}" _stage_rows = [] for _st in ("pretrain", "sft", "dpo", "grpo", "gguf"): _ptr = _con.latest(_st) or {} _stage_rows.append(f"| `{_st}/` | {_ptr.get('status', 'empty - no checkpoint yet')} |") _sess_log = "\n".join(f"- `{_f}`" for _f in _con.tree(continuum.CODE_REPO) if _f.startswith("sessions/")) mo.md(f""" # WINCLAW - Continuum status **Last pushed session:** `{_sess_id}` \u00b7 **written:** {_created} \u00b7 **host GPU:** `{_gpu}` | repository | kind | link | |---|---|---| | `winclaw-harness` | dataset | https://huggingface.co/datasets/hkblockchaintechnology/winclaw-harness | | `winclaw-0-150m` | model | https://huggingface.co/hkblockchaintechnology/winclaw-0-150m | | `winclaw-corpus` | dataset | https://huggingface.co/datasets/hkblockchaintechnology/winclaw-corpus | | `winclaw-tasks` | dataset | https://huggingface.co/datasets/hkblockchaintechnology/winclaw-tasks | ## Last verified sync {_tot:,} bytes across {len(_rows)} files, each with its own sha256. The resume gate re-verifies every hash before training is allowed to continue. | file | sha256 | bytes | |---|---|---| {chr(10).join(_rows)} ## Model stage pointers | stage | latest.json | |---|---| {chr(10).join(_stage_rows)} ## Session log on the Hub {_sess_log or "- none yet"} ## The one manual step, every session The token. Re-supplied per session via `HF_TOKEN` or `~/.config/winclaw/token` (0600). It is deliberately absent from all notebook source, because Molab persists cell source and a shared notebook would leak it. {f"**ERROR:** {_err}" if _err else ""} """) return @app.cell def capabilities(capabilities, mo): # The capability surface. Every number below is counted from # winclaw/capabilities.py, not asserted in prose. _aud = capabilities.audit() _claims = capabilities.requirements_markdown() _matrix = capabilities.markdown() _bad = ("\n".join("- " + p for p in _aud["problems"])) if _aud["problems"] else "none - every channel has a mechanism, every verb is verifiable" mo.md(f""" # WINCLAW - capability surface The purpose stated: **see, click, type, know all input and output, and write and run code.** That is a specification, so it is enumerable. It is not 11 action verbs, it is **{_aud['channels']} perception channels x {_aud['verbs']} action verbs** = {_aud['channels'] * _aud['verbs']:,} possible channel-verb interactions. ## Requirements, resolved against the matrix {_claims} ## Integrity audit | check | result | |---|---| | channel mechanisms declared | {len(capabilities.CHANNELS)} / {len(capabilities.CHANNELS)} | | verb mechanisms declared | {len(capabilities.VERBS)} / {len(capabilities.VERBS)} | | verbs with no verifying channel | **0** - the audit rejects them | | audit problems | {_bad} | Rule the audit enforces: *a capability whose effect we cannot observe is not a capability, it is a hope.* Every verb declares the channels that confirm it worked, which is also exactly the reward path. ## Risk enforcement {_aud['risk_histogram']['none']} verbs run free, {_aud['risk_histogram']['low']} are audited, {_aud['risk_histogram']['high']} take a state snapshot and are revertible, and {_aud['risk_histogram']['critical']} are denied unless explicitly confirmed. ## Full matrix {_matrix} """) return @app.cell def the_bet(boundary, mo): # The inversion, made explicit and testable. _b = boundary.audit() _true = "\n".join(f"- {_x}" for _x in boundary.CLAIM["why_it_could_be_true"]) _false = "\n".join(f"- {_x}" for _x in boundary.CLAIM["why_it_could_be_false"]) _test = "\n".join(f"{_i + 1}. {_x}" for _i, _x in enumerate(boundary.CLAIM["how_we_test_it"])) _learn = "\n".join(f"- {_x}" for _x in boundary.CLAIM["what_we_learn_either_way"]) mo.md(f""" # The bet People train a general multi-function model and then put it inside an agentic harness. WINCLAW is the inverse: **the harness interface is fixed first, and the model is trained from random init against it.** The model is therefore not a component inside a harness - it is the harness core. That difference is engineering, not branding, and it has four consequences. ## What the inversion buys - **No interface tax.** The observation format and the action space *are* the model's pretraining distribution. A general model must translate between its internal representation and whatever the harness speaks, and that translation is loss. - **Labels instead of rubrics.** Every training token carries an exact label from the simulator. Adapting a general model means prompts and judge models. Learning-signal quality is the scarce resource, and here we own it outright. - **Architecture matched to the action space.** Spatial pointing for click targets, typed slots for arguments - rather than asking a text model to emit coordinates as characters and hoping. - **Small becomes viable.** Because it does one thing, 150M has a real chance against something several times larger. That is a testable claim, not a slogan. ## What it costs {_false} Honest framing: the conventional approach optimises for *model generality* and pays at the interface. Ours optimises for *interface fidelity* and pays in *generalisation*. Both are bets. Ours is only the right bet because we own the labels. ## The boundary that makes a small model viable {boundary.markdown()} Audit: {_b["counts"]["model"]} decisions to the model, {_b["counts"]["harness"]} to the harness, {_b["counts"]["shared"]} shared - **{'PASS' if _b["ok"] else 'FAIL'}**. The rule is enforced in code: deterministic work is never assigned to weights. ## The falsifiable claim > {boundary.CLAIM["statement"]} **Why it could be true** {_true} **How it gets tested** {_test} **What we learn either way** {_learn} ## Precedent, stated fairly {boundary.CLAIM["honest_precedent"]} ## Still unresolved {boundary.CLAIM["baseline_decision"]} """) return @app.cell def design_register( actlang, audit, boundary, capabilities, design, harness, mo, modelspec, policy, rasteron, roadmap, tokenizer, training, transfer, uialite, verdict, vertical, winsim, ): # "Complete" as a checklist rather than a feeling. This register is the authority; the # earlier prose design cell is superseded by it. Two different things are tracked, and # conflating them is how a design lies to itself: # design_complete - every item is specified, with a done-criterion and dependencies # blockers_cleared - a blocker is only cleared when a VERIFIED item claims it _c = design.completeness() _st = design.status(audit.audit()["blockers"]) _res = design.resolutions(audit.audit()["blockers"]) _specs = (("uialite", uialite), ("actlang", actlang), ("modelspec", modelspec), ("rasteron", rasteron), ("winsim", winsim), ("harness", harness), ("verdict", verdict), ("policy", policy), ("tokenizer", tokenizer), ("training", training), ("vertical", vertical), ("roadmap", roadmap), ("transfer", transfer), ("capabilities", capabilities), ("boundary", boundary), ("audit", audit)) _rows, _n, _pass = [], 0, 0 for _name, _mod in _specs: if not hasattr(_mod, "audit"): continue _n += 1 try: _a = _mod.audit() _ok = _a.get("ok", True) _pass += _ok _rows.append(f"| `{_name}` | **{'PASS' if _ok else 'FAIL'}** | " f"{'; '.join(_a.get('problems') or []) or '-'} |") except Exception as _e: _rows.append(f"| `{_name}` | **ERROR** | {type(_e).__name__}: {_e} |") _res_rows = "\n".join( f"| `{_r['blocker']}` | {', '.join(_r['claimed_by'])} | " f"{', '.join(_r['cleared_by']) or '**none**'} | {'yes' if _r['cleared'] else '**no**'} |" for _r in _res) _status = "\n".join(f"| {_i.id} | {_i.title} | **{_i.status}** | " f"{', '.join(_i.depends_on) or '-'} |" for _i in design.REGISTER) mo.md(f""" # WINCLAW design register ## Design: {_st['percent']}% specified. Blockers cleared: {_st['blockers_cleared']} of {_st['blockers_total']}. > **The register is complete and nothing is built.** All {_c['total']} items are specified > ({_c['by_status']['specified']} specified, {_c['by_status']['verified']} verified), and > {_pass}/{_n} spec audits pass. But a blocker is only *claimed* by a design item - it is > *cleared* only when that item is verified by execution. On that measure the project is at > **{_st['blockers_cleared']} of {_st['blockers_total']}**. ## Open blockers | blocker | claimed by | cleared by | cleared | |---|---|---|---| {_res_rows} ## Spec audit board | spec | audit | problems | |---|---|---| {chr(10).join(_rows)} ## Register | id | item | status | depends on | |---|---|---|---| {_status} """) return @app.cell def design_core(actlang, mo, modelspec, uialite): # The three foundational specs. Everything else consumes these: WinSim emits UiaLite, # the model reads UiaLite and emits ActLang, and both are sized against the ledger. mo.md(f""" # Core specs ## UiaLite - observation schema {uialite.markdown()} ## ActLang - action language {actlang.markdown()} ## Modelspec - parameter ledger and context budget {modelspec.markdown()} """) return @app.cell def design_runtime(harness, mo, rasteron, winsim): mo.md(f""" # Runtime specs ## Rasteron - the rasteriser, and its determinism contract {rasteron.markdown()} ## WinSim - the substrate {winsim.markdown()} ## Harness - the control loop {harness.markdown()} """) return @app.cell def design_program( mo, policy, roadmap, tokenizer, training, transfer, verdict, vertical, ): mo.md(f""" # Programme specs ## The vertical slice {vertical.markdown()} ## Roadmap in sessions {roadmap.markdown()} ## Training plan {training.markdown()} ## Verdict - checkers, metrics and the pre-registered claim {verdict.markdown()} ## Safety policy {policy.markdown()} ## Tokenizer {tokenizer.markdown()} ## Real Windows bridge {transfer.markdown()} """) return @app.cell def design_audit(audit, mo): # The design auditing itself. Findings marked [proved] were demonstrated by running # the code, not by reading it. _a = audit.audit() _trust = "\n".join(f"- {_x}" for _x in audit.VERDICT["trustworthy_now"]) _mistrust = "\n".join(f"- {_x}" for _x in audit.VERDICT["not_trustworthy"]) _fix = "\n".join(f"{_i + 1}. {_x}" for _i, _x in enumerate(audit.VERDICT["top_five_changes"])) mo.md(f""" # Design audit - WINCLAW against itself **Verdict: the design is NOT finished.** {_a["total"]} findings - **{_a["by_severity"]["blocker"]} blockers, {_a["by_severity"]["major"]} major, {_a["by_severity"]["minor"]} minor** - of which {_a["proved_by_running"]} were proved by running the code rather than reading it. The blockers: {chr(10).join("- `" + _k + "`" for _k in _a["blockers"])} > {audit.VERDICT["ratio"]} ## What I trust right now {_trust} ## What I do not trust {_mistrust} ## The five changes this audit requires {_fix} ## Full findings {audit.markdown()} """) return if __name__ == "__main__": app.run()
import marimo
__generated_with = "0.25.2"
app = marimo.App(width="medium", auto_download=["html"])
@app.cell
def _():
import marimo as mo
return (mo,)
@app.cell
def winclaw_setup():
# Single import surface. Everything below reads from here; nothing below re-imports.
# /marimo/winclaw is sandbox-local and dies with the session; Continuum restores it from
# the Hub before this cell runs. The HF token is never referenced in source.
import json
import os
import pathlib
import subprocess
import sys
import time
sys.path.insert(0, "/marimo")
from winclaw import (actlang, apps, appsuite, audit, boundary, capabilities, continuum,
perf, train_gpu,
corpus, design, glyphforge, harness, jobs, kb, knowledge, modelspec, policy, rasteron,
roadmap, supervisor, tokenizer, toyenv, training, transfer, uialite,
verdict, verify, vertical, vfs, winsim)
return (
actlang,
apps,
appsuite,
audit,
boundary,
capabilities,
continuum,
corpus,
design,
glyphforge,
harness,
jobs,
json,
knowledge,
modelspec,
os,
pathlib,
policy,
rasteron,
roadmap,
subprocess,
sys,
time,
tokenizer,
toyenv,
train_gpu,
training,
transfer,
uialite,
verdict,
verify,
vertical,
vfs,
winsim,
)
@app.cell
def bootstrap(continuum, mo, pathlib):
# Bootstrap: what this notebook cannot continue without. Runs first, always.
import shutil
import torch
_root = pathlib.Path("/marimo")
try:
_ctx = continuum.Continuum("hkblockchaintechnology", stage="pretrain")
_token, _who = "present", _ctx.api.whoami().get("name")
except Exception as _e:
_token, _who = f"MISSING ({type(_e).__name__})", "-"
_dl = continuum.Deadline()
_gpu = torch.cuda.get_device_name(0) if torch.cuda.is_available() else "none"
_free_gb = shutil.disk_usage("/marimo").free / 1e9
_units = sorted(p.stem for p in (_root / "winclaw").glob("*.py"))
mo.md(f"""
# Session bootstrap
| check | state |
|---|---|
| HF token | **{_token}** |
| HF account | `{_who}` |
| GPU | {_gpu} |
| sandbox free disk | {_free_gb:,.1f} GB - ephemeral, dies with the session |
| package modules | {len(_units)} |